refactor: collapse patch barrel into patch/index.ts

packages/opencode/src/patch/index.ts

@@ -1 +1,680 @@
-export * as Patch from "./patch"
+import z from "zod"
+import * as path from "path"
+import * as fs from "fs/promises"
+import { readFileSync } from "fs"
+import { Log } from "../util"
+
+const log = Log.create({ service: "patch" })
+
+// Schema definitions
+export const PatchSchema = z.object({
+  patchText: z.string().describe("The full patch text that describes all changes to be made"),
+})
+
+export type PatchParams = z.infer<typeof PatchSchema>
+
+// Core types matching the Rust implementation
+export interface ApplyPatchArgs {
+  patch: string
+  hunks: Hunk[]
+  workdir?: string
+}
+
+export type Hunk =
+  | { type: "add"; path: string; contents: string }
+  | { type: "delete"; path: string }
+  | { type: "update"; path: string; move_path?: string; chunks: UpdateFileChunk[] }
+
+export interface UpdateFileChunk {
+  old_lines: string[]
+  new_lines: string[]
+  change_context?: string
+  is_end_of_file?: boolean
+}
+
+export interface ApplyPatchAction {
+  changes: Map<string, ApplyPatchFileChange>
+  patch: string
+  cwd: string
+}
+
+export type ApplyPatchFileChange =
+  | { type: "add"; content: string }
+  | { type: "delete"; content: string }
+  | { type: "update"; unified_diff: string; move_path?: string; new_content: string }
+
+export interface AffectedPaths {
+  added: string[]
+  modified: string[]
+  deleted: string[]
+}
+
+export enum ApplyPatchError {
+  ParseError = "ParseError",
+  IoError = "IoError",
+  ComputeReplacements = "ComputeReplacements",
+  ImplicitInvocation = "ImplicitInvocation",
+}
+
+export enum MaybeApplyPatch {
+  Body = "Body",
+  ShellParseError = "ShellParseError",
+  PatchParseError = "PatchParseError",
+  NotApplyPatch = "NotApplyPatch",
+}
+
+export enum MaybeApplyPatchVerified {
+  Body = "Body",
+  ShellParseError = "ShellParseError",
+  CorrectnessError = "CorrectnessError",
+  NotApplyPatch = "NotApplyPatch",
+}
+
+// Parser implementation
+function parsePatchHeader(
+  lines: string[],
+  startIdx: number,
+): { filePath: string; movePath?: string; nextIdx: number } | null {
+  const line = lines[startIdx]
+
+  if (line.startsWith("*** Add File:")) {
+    const filePath = line.slice("*** Add File:".length).trim()
+    return filePath ? { filePath, nextIdx: startIdx + 1 } : null
+  }
+
+  if (line.startsWith("*** Delete File:")) {
+    const filePath = line.slice("*** Delete File:".length).trim()
+    return filePath ? { filePath, nextIdx: startIdx + 1 } : null
+  }
+
+  if (line.startsWith("*** Update File:")) {
+    const filePath = line.slice("*** Update File:".length).trim()
+    let movePath: string | undefined
+    let nextIdx = startIdx + 1
+
+    // Check for move directive
+    if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
+      movePath = lines[nextIdx].slice("*** Move to:".length).trim()
+      nextIdx++
+    }
+
+    return filePath ? { filePath, movePath, nextIdx } : null
+  }
+
+  return null
+}
+
+function parseUpdateFileChunks(lines: string[], startIdx: number): { chunks: UpdateFileChunk[]; nextIdx: number } {
+  const chunks: UpdateFileChunk[] = []
+  let i = startIdx
+
+  while (i < lines.length && !lines[i].startsWith("***")) {
+    if (lines[i].startsWith("@@")) {
+      // Parse context line
+      const contextLine = lines[i].substring(2).trim()
+      i++
+
+      const oldLines: string[] = []
+      const newLines: string[] = []
+      let isEndOfFile = false
+
+      // Parse change lines
+      while (i < lines.length && !lines[i].startsWith("@@") && !lines[i].startsWith("***")) {
+        const changeLine = lines[i]
+
+        if (changeLine === "*** End of File") {
+          isEndOfFile = true
+          i++
+          break
+        }
+
+        if (changeLine.startsWith(" ")) {
+          // Keep line - appears in both old and new
+          const content = changeLine.substring(1)
+          oldLines.push(content)
+          newLines.push(content)
+        } else if (changeLine.startsWith("-")) {
+          // Remove line - only in old
+          oldLines.push(changeLine.substring(1))
+        } else if (changeLine.startsWith("+")) {
+          // Add line - only in new
+          newLines.push(changeLine.substring(1))
+        }
+
+        i++
+      }
+
+      chunks.push({
+        old_lines: oldLines,
+        new_lines: newLines,
+        change_context: contextLine || undefined,
+        is_end_of_file: isEndOfFile || undefined,
+      })
+    } else {
+      i++
+    }
+  }
+
+  return { chunks, nextIdx: i }
+}
+
+function parseAddFileContent(lines: string[], startIdx: number): { content: string; nextIdx: number } {
+  let content = ""
+  let i = startIdx
+
+  while (i < lines.length && !lines[i].startsWith("***")) {
+    if (lines[i].startsWith("+")) {
+      content += lines[i].substring(1) + "\n"
+    }
+    i++
+  }
+
+  // Remove trailing newline
+  if (content.endsWith("\n")) {
+    content = content.slice(0, -1)
+  }
+
+  return { content, nextIdx: i }
+}
+
+function stripHeredoc(input: string): string {
+  // Match heredoc patterns like: cat <<'EOF'\n...\nEOF or <<EOF\n...\nEOF
+  const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/)
+  if (heredocMatch) {
+    return heredocMatch[2]
+  }
+  return input
+}
+
+export function parsePatch(patchText: string): { hunks: Hunk[] } {
+  const cleaned = stripHeredoc(patchText.trim())
+  const lines = cleaned.split("\n")
+  const hunks: Hunk[] = []
+  let i = 0
+
+  // Look for Begin/End patch markers
+  const beginMarker = "*** Begin Patch"
+  const endMarker = "*** End Patch"
+
+  const beginIdx = lines.findIndex((line) => line.trim() === beginMarker)
+  const endIdx = lines.findIndex((line) => line.trim() === endMarker)
+
+  if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+    throw new Error("Invalid patch format: missing Begin/End markers")
+  }
+
+  // Parse content between markers
+  i = beginIdx + 1
+
+  while (i < endIdx) {
+    const header = parsePatchHeader(lines, i)
+    if (!header) {
+      i++
+      continue
+    }
+
+    if (lines[i].startsWith("*** Add File:")) {
+      const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx)
+      hunks.push({
+        type: "add",
+        path: header.filePath,
+        contents: content,
+      })
+      i = nextIdx
+    } else if (lines[i].startsWith("*** Delete File:")) {
+      hunks.push({
+        type: "delete",
+        path: header.filePath,
+      })
+      i = header.nextIdx
+    } else if (lines[i].startsWith("*** Update File:")) {
+      const { chunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx)
+      hunks.push({
+        type: "update",
+        path: header.filePath,
+        move_path: header.movePath,
+        chunks,
+      })
+      i = nextIdx
+    } else {
+      i++
+    }
+  }
+
+  return { hunks }
+}
+
+// Apply patch functionality
+export function maybeParseApplyPatch(
+  argv: string[],
+):
+  | { type: MaybeApplyPatch.Body; args: ApplyPatchArgs }
+  | { type: MaybeApplyPatch.PatchParseError; error: Error }
+  | { type: MaybeApplyPatch.NotApplyPatch } {
+  const APPLY_PATCH_COMMANDS = ["apply_patch", "applypatch"]
+
+  // Direct invocation: apply_patch <patch>
+  if (argv.length === 2 && APPLY_PATCH_COMMANDS.includes(argv[0])) {
+    try {
+      const { hunks } = parsePatch(argv[1])
+      return {
+        type: MaybeApplyPatch.Body,
+        args: {
+          patch: argv[1],
+          hunks,
+        },
+      }
+    } catch (error) {
+      return {
+        type: MaybeApplyPatch.PatchParseError,
+        error: error as Error,
+      }
+    }
+  }
+
+  // Bash heredoc form: bash -lc 'apply_patch <<"EOF" ...'
+  if (argv.length === 3 && argv[0] === "bash" && argv[1] === "-lc") {
+    // Simple extraction - in real implementation would need proper bash parsing
+    const script = argv[2]
+    const heredocMatch = script.match(/apply_patch\s*<<['"](\w+)['"]\s*\n([\s\S]*?)\n\1/)
+
+    if (heredocMatch) {
+      const patchContent = heredocMatch[2]
+      try {
+        const { hunks } = parsePatch(patchContent)
+        return {
+          type: MaybeApplyPatch.Body,
+          args: {
+            patch: patchContent,
+            hunks,
+          },
+        }
+      } catch (error) {
+        return {
+          type: MaybeApplyPatch.PatchParseError,
+          error: error as Error,
+        }
+      }
+    }
+  }
+
+  return { type: MaybeApplyPatch.NotApplyPatch }
+}
+
+// File content manipulation
+interface ApplyPatchFileUpdate {
+  unified_diff: string
+  content: string
+}
+
+export function deriveNewContentsFromChunks(filePath: string, chunks: UpdateFileChunk[]): ApplyPatchFileUpdate {
+  // Read original file content
+  let originalContent: string
+  try {
+    originalContent = readFileSync(filePath, "utf-8")
+  } catch (error) {
+    throw new Error(`Failed to read file ${filePath}: ${error}`, { cause: error })
+  }
+
+  let originalLines = originalContent.split("\n")
+
+  // Drop trailing empty element for consistent line counting
+  if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+    originalLines.pop()
+  }
+
+  const replacements = computeReplacements(originalLines, filePath, chunks)
+  let newLines = applyReplacements(originalLines, replacements)
+
+  // Ensure trailing newline
+  if (newLines.length === 0 || newLines[newLines.length - 1] !== "") {
+    newLines.push("")
+  }
+
+  const newContent = newLines.join("\n")
+
+  // Generate unified diff
+  const unifiedDiff = generateUnifiedDiff(originalContent, newContent)
+
+  return {
+    unified_diff: unifiedDiff,
+    content: newContent,
+  }
+}
+
+function computeReplacements(
+  originalLines: string[],
+  filePath: string,
+  chunks: UpdateFileChunk[],
+): Array<[number, number, string[]]> {
+  const replacements: Array<[number, number, string[]]> = []
+  let lineIndex = 0
+
+  for (const chunk of chunks) {
+    // Handle context-based seeking
+    if (chunk.change_context) {
+      const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex)
+      if (contextIdx === -1) {
+        throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`)
+      }
+      lineIndex = contextIdx + 1
+    }
+
+    // Handle pure addition (no old lines)
+    if (chunk.old_lines.length === 0) {
+      const insertionIdx =
+        originalLines.length > 0 && originalLines[originalLines.length - 1] === ""
+          ? originalLines.length - 1
+          : originalLines.length
+      replacements.push([insertionIdx, 0, chunk.new_lines])
+      continue
+    }
+
+    // Try to match old lines in the file
+    let pattern = chunk.old_lines
+    let newSlice = chunk.new_lines
+    let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file)
+
+    // Retry without trailing empty line if not found
+    if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+      pattern = pattern.slice(0, -1)
+      if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
+        newSlice = newSlice.slice(0, -1)
+      }
+      found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file)
+    }
+
+    if (found !== -1) {
+      replacements.push([found, pattern.length, newSlice])
+      lineIndex = found + pattern.length
+    } else {
+      throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.old_lines.join("\n")}`)
+    }
+  }
+
+  // Sort replacements by index to apply in order
+  replacements.sort((a, b) => a[0] - b[0])
+
+  return replacements
+}
+
+function applyReplacements(lines: string[], replacements: Array<[number, number, string[]]>): string[] {
+  // Apply replacements in reverse order to avoid index shifting
+  const result = [...lines]
+
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const [startIdx, oldLen, newSegment] = replacements[i]
+
+    // Remove old lines
+    result.splice(startIdx, oldLen)
+
+    // Insert new lines
+    for (let j = 0; j < newSegment.length; j++) {
+      result.splice(startIdx + j, 0, newSegment[j])
+    }
+  }
+
+  return result
+}
+
+// Normalize Unicode punctuation to ASCII equivalents (like Rust's normalize_unicode)
+function normalizeUnicode(str: string): string {
+  return str
+    .replace(/[\u2018\u2019\u201A\u201B]/g, "'") // single quotes
+    .replace(/[\u201C\u201D\u201E\u201F]/g, '"') // double quotes
+    .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, "-") // dashes
+    .replace(/\u2026/g, "...") // ellipsis
+    .replace(/\u00A0/g, " ") // non-breaking space
+}
+
+type Comparator = (a: string, b: string) => boolean
+
+function tryMatch(lines: string[], pattern: string[], startIndex: number, compare: Comparator, eof: boolean): number {
+  // If EOF anchor, try matching from end of file first
+  if (eof) {
+    const fromEnd = lines.length - pattern.length
+    if (fromEnd >= startIndex) {
+      let matches = true
+      for (let j = 0; j < pattern.length; j++) {
+        if (!compare(lines[fromEnd + j], pattern[j])) {
+          matches = false
+          break
+        }
+      }
+      if (matches) return fromEnd
+    }
+  }
+
+  // Forward search from startIndex
+  for (let i = startIndex; i <= lines.length - pattern.length; i++) {
+    let matches = true
+    for (let j = 0; j < pattern.length; j++) {
+      if (!compare(lines[i + j], pattern[j])) {
+        matches = false
+        break
+      }
+    }
+    if (matches) return i
+  }
+
+  return -1
+}
+
+function seekSequence(lines: string[], pattern: string[], startIndex: number, eof = false): number {
+  if (pattern.length === 0) return -1
+
+  // Pass 1: exact match
+  const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof)
+  if (exact !== -1) return exact
+
+  // Pass 2: rstrip (trim trailing whitespace)
+  const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof)
+  if (rstrip !== -1) return rstrip
+
+  // Pass 3: trim (both ends)
+  const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof)
+  if (trim !== -1) return trim
+
+  // Pass 4: normalized (Unicode punctuation to ASCII)
+  const normalized = tryMatch(
+    lines,
+    pattern,
+    startIndex,
+    (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()),
+    eof,
+  )
+  return normalized
+}
+
+function generateUnifiedDiff(oldContent: string, newContent: string): string {
+  const oldLines = oldContent.split("\n")
+  const newLines = newContent.split("\n")
+
+  // Simple diff generation - in a real implementation you'd use a proper diff algorithm
+  let diff = "@@ -1 +1 @@\n"
+
+  // Find changes (simplified approach)
+  const maxLen = Math.max(oldLines.length, newLines.length)
+  let hasChanges = false
+
+  for (let i = 0; i < maxLen; i++) {
+    const oldLine = oldLines[i] || ""
+    const newLine = newLines[i] || ""
+
+    if (oldLine !== newLine) {
+      if (oldLine) diff += `-${oldLine}\n`
+      if (newLine) diff += `+${newLine}\n`
+      hasChanges = true
+    } else if (oldLine) {
+      diff += ` ${oldLine}\n`
+    }
+  }
+
+  return hasChanges ? diff : ""
+}
+
+// Apply hunks to filesystem
+export async function applyHunksToFiles(hunks: Hunk[]): Promise<AffectedPaths> {
+  if (hunks.length === 0) {
+    throw new Error("No files were modified.")
+  }
+
+  const added: string[] = []
+  const modified: string[] = []
+  const deleted: string[] = []
+
+  for (const hunk of hunks) {
+    switch (hunk.type) {
+      case "add":
+        // Create parent directories
+        const addDir = path.dirname(hunk.path)
+        if (addDir !== "." && addDir !== "/") {
+          await fs.mkdir(addDir, { recursive: true })
+        }
+
+        await fs.writeFile(hunk.path, hunk.contents, "utf-8")
+        added.push(hunk.path)
+        log.info(`Added file: ${hunk.path}`)
+        break
+
+      case "delete":
+        await fs.unlink(hunk.path)
+        deleted.push(hunk.path)
+        log.info(`Deleted file: ${hunk.path}`)
+        break
+
+      case "update":
+        const fileUpdate = deriveNewContentsFromChunks(hunk.path, hunk.chunks)
+
+        if (hunk.move_path) {
+          // Handle file move
+          const moveDir = path.dirname(hunk.move_path)
+          if (moveDir !== "." && moveDir !== "/") {
+            await fs.mkdir(moveDir, { recursive: true })
+          }
+
+          await fs.writeFile(hunk.move_path, fileUpdate.content, "utf-8")
+          await fs.unlink(hunk.path)
+          modified.push(hunk.move_path)
+          log.info(`Moved file: ${hunk.path} -> ${hunk.move_path}`)
+        } else {
+          // Regular update
+          await fs.writeFile(hunk.path, fileUpdate.content, "utf-8")
+          modified.push(hunk.path)
+          log.info(`Updated file: ${hunk.path}`)
+        }
+        break
+    }
+  }
+
+  return { added, modified, deleted }
+}
+
+// Main patch application function
+export async function applyPatch(patchText: string): Promise<AffectedPaths> {
+  const { hunks } = parsePatch(patchText)
+  return applyHunksToFiles(hunks)
+}
+
+// Async version of maybeParseApplyPatchVerified
+export async function maybeParseApplyPatchVerified(
+  argv: string[],
+  cwd: string,
+): Promise<
+  | { type: MaybeApplyPatchVerified.Body; action: ApplyPatchAction }
+  | { type: MaybeApplyPatchVerified.CorrectnessError; error: Error }
+  | { type: MaybeApplyPatchVerified.NotApplyPatch }
+> {
+  // Detect implicit patch invocation (raw patch without apply_patch command)
+  if (argv.length === 1) {
+    try {
+      parsePatch(argv[0])
+      return {
+        type: MaybeApplyPatchVerified.CorrectnessError,
+        error: new Error(ApplyPatchError.ImplicitInvocation),
+      }
+    } catch {
+      // Not a patch, continue
+    }
+  }
+
+  const result = maybeParseApplyPatch(argv)
+
+  switch (result.type) {
+    case MaybeApplyPatch.Body:
+      const { args } = result
+      const effectiveCwd = args.workdir ? path.resolve(cwd, args.workdir) : cwd
+      const changes = new Map<string, ApplyPatchFileChange>()
+
+      for (const hunk of args.hunks) {
+        const resolvedPath = path.resolve(
+          effectiveCwd,
+          hunk.type === "update" && hunk.move_path ? hunk.move_path : hunk.path,
+        )
+
+        switch (hunk.type) {
+          case "add":
+            changes.set(resolvedPath, {
+              type: "add",
+              content: hunk.contents,
+            })
+            break
+
+          case "delete":
+            // For delete, we need to read the current content
+            const deletePath = path.resolve(effectiveCwd, hunk.path)
+            try {
+              const content = await fs.readFile(deletePath, "utf-8")
+              changes.set(resolvedPath, {
+                type: "delete",
+                content,
+              })
+            } catch {
+              return {
+                type: MaybeApplyPatchVerified.CorrectnessError,
+                error: new Error(`Failed to read file for deletion: ${deletePath}`),
+              }
+            }
+            break
+
+          case "update":
+            const updatePath = path.resolve(effectiveCwd, hunk.path)
+            try {
+              const fileUpdate = deriveNewContentsFromChunks(updatePath, hunk.chunks)
+              changes.set(resolvedPath, {
+                type: "update",
+                unified_diff: fileUpdate.unified_diff,
+                move_path: hunk.move_path ? path.resolve(effectiveCwd, hunk.move_path) : undefined,
+                new_content: fileUpdate.content,
+              })
+            } catch (error) {
+              return {
+                type: MaybeApplyPatchVerified.CorrectnessError,
+                error: error as Error,
+              }
+            }
+            break
+        }
+      }
+
+      return {
+        type: MaybeApplyPatchVerified.Body,
+        action: {
+          changes,
+          patch: args.patch,
+          cwd: effectiveCwd,
+        },
+      }
+
+    case MaybeApplyPatch.PatchParseError:
+      return {
+        type: MaybeApplyPatchVerified.CorrectnessError,
+        error: result.error,
+      }
+
+    case MaybeApplyPatch.NotApplyPatch:
+      return { type: MaybeApplyPatchVerified.NotApplyPatch }
+  }
+}
+
+export * as Patch from "."

packages/opencode/src/patch/patch.ts

@@ -1,678 +0,0 @@
-import z from "zod"
-import * as path from "path"
-import * as fs from "fs/promises"
-import { readFileSync } from "fs"
-import { Log } from "../util"
-
-const log = Log.create({ service: "patch" })
-
-// Schema definitions
-export const PatchSchema = z.object({
-  patchText: z.string().describe("The full patch text that describes all changes to be made"),
-})
-
-export type PatchParams = z.infer<typeof PatchSchema>
-
-// Core types matching the Rust implementation
-export interface ApplyPatchArgs {
-  patch: string
-  hunks: Hunk[]
-  workdir?: string
-}
-
-export type Hunk =
-  | { type: "add"; path: string; contents: string }
-  | { type: "delete"; path: string }
-  | { type: "update"; path: string; move_path?: string; chunks: UpdateFileChunk[] }
-
-export interface UpdateFileChunk {
-  old_lines: string[]
-  new_lines: string[]
-  change_context?: string
-  is_end_of_file?: boolean
-}
-
-export interface ApplyPatchAction {
-  changes: Map<string, ApplyPatchFileChange>
-  patch: string
-  cwd: string
-}
-
-export type ApplyPatchFileChange =
-  | { type: "add"; content: string }
-  | { type: "delete"; content: string }
-  | { type: "update"; unified_diff: string; move_path?: string; new_content: string }
-
-export interface AffectedPaths {
-  added: string[]
-  modified: string[]
-  deleted: string[]
-}
-
-export enum ApplyPatchError {
-  ParseError = "ParseError",
-  IoError = "IoError",
-  ComputeReplacements = "ComputeReplacements",
-  ImplicitInvocation = "ImplicitInvocation",
-}
-
-export enum MaybeApplyPatch {
-  Body = "Body",
-  ShellParseError = "ShellParseError",
-  PatchParseError = "PatchParseError",
-  NotApplyPatch = "NotApplyPatch",
-}
-
-export enum MaybeApplyPatchVerified {
-  Body = "Body",
-  ShellParseError = "ShellParseError",
-  CorrectnessError = "CorrectnessError",
-  NotApplyPatch = "NotApplyPatch",
-}
-
-// Parser implementation
-function parsePatchHeader(
-  lines: string[],
-  startIdx: number,
-): { filePath: string; movePath?: string; nextIdx: number } | null {
-  const line = lines[startIdx]
-
-  if (line.startsWith("*** Add File:")) {
-    const filePath = line.slice("*** Add File:".length).trim()
-    return filePath ? { filePath, nextIdx: startIdx + 1 } : null
-  }
-
-  if (line.startsWith("*** Delete File:")) {
-    const filePath = line.slice("*** Delete File:".length).trim()
-    return filePath ? { filePath, nextIdx: startIdx + 1 } : null
-  }
-
-  if (line.startsWith("*** Update File:")) {
-    const filePath = line.slice("*** Update File:".length).trim()
-    let movePath: string | undefined
-    let nextIdx = startIdx + 1
-
-    // Check for move directive
-    if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
-      movePath = lines[nextIdx].slice("*** Move to:".length).trim()
-      nextIdx++
-    }
-
-    return filePath ? { filePath, movePath, nextIdx } : null
-  }
-
-  return null
-}
-
-function parseUpdateFileChunks(lines: string[], startIdx: number): { chunks: UpdateFileChunk[]; nextIdx: number } {
-  const chunks: UpdateFileChunk[] = []
-  let i = startIdx
-
-  while (i < lines.length && !lines[i].startsWith("***")) {
-    if (lines[i].startsWith("@@")) {
-      // Parse context line
-      const contextLine = lines[i].substring(2).trim()
-      i++
-
-      const oldLines: string[] = []
-      const newLines: string[] = []
-      let isEndOfFile = false
-
-      // Parse change lines
-      while (i < lines.length && !lines[i].startsWith("@@") && !lines[i].startsWith("***")) {
-        const changeLine = lines[i]
-
-        if (changeLine === "*** End of File") {
-          isEndOfFile = true
-          i++
-          break
-        }
-
-        if (changeLine.startsWith(" ")) {
-          // Keep line - appears in both old and new
-          const content = changeLine.substring(1)
-          oldLines.push(content)
-          newLines.push(content)
-        } else if (changeLine.startsWith("-")) {
-          // Remove line - only in old
-          oldLines.push(changeLine.substring(1))
-        } else if (changeLine.startsWith("+")) {
-          // Add line - only in new
-          newLines.push(changeLine.substring(1))
-        }
-
-        i++
-      }
-
-      chunks.push({
-        old_lines: oldLines,
-        new_lines: newLines,
-        change_context: contextLine || undefined,
-        is_end_of_file: isEndOfFile || undefined,
-      })
-    } else {
-      i++
-    }
-  }
-
-  return { chunks, nextIdx: i }
-}
-
-function parseAddFileContent(lines: string[], startIdx: number): { content: string; nextIdx: number } {
-  let content = ""
-  let i = startIdx
-
-  while (i < lines.length && !lines[i].startsWith("***")) {
-    if (lines[i].startsWith("+")) {
-      content += lines[i].substring(1) + "\n"
-    }
-    i++
-  }
-
-  // Remove trailing newline
-  if (content.endsWith("\n")) {
-    content = content.slice(0, -1)
-  }
-
-  return { content, nextIdx: i }
-}
-
-function stripHeredoc(input: string): string {
-  // Match heredoc patterns like: cat <<'EOF'\n...\nEOF or <<EOF\n...\nEOF
-  const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/)
-  if (heredocMatch) {
-    return heredocMatch[2]
-  }
-  return input
-}
-
-export function parsePatch(patchText: string): { hunks: Hunk[] } {
-  const cleaned = stripHeredoc(patchText.trim())
-  const lines = cleaned.split("\n")
-  const hunks: Hunk[] = []
-  let i = 0
-
-  // Look for Begin/End patch markers
-  const beginMarker = "*** Begin Patch"
-  const endMarker = "*** End Patch"
-
-  const beginIdx = lines.findIndex((line) => line.trim() === beginMarker)
-  const endIdx = lines.findIndex((line) => line.trim() === endMarker)
-
-  if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
-    throw new Error("Invalid patch format: missing Begin/End markers")
-  }
-
-  // Parse content between markers
-  i = beginIdx + 1
-
-  while (i < endIdx) {
-    const header = parsePatchHeader(lines, i)
-    if (!header) {
-      i++
-      continue
-    }
-
-    if (lines[i].startsWith("*** Add File:")) {
-      const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx)
-      hunks.push({
-        type: "add",
-        path: header.filePath,
-        contents: content,
-      })
-      i = nextIdx
-    } else if (lines[i].startsWith("*** Delete File:")) {
-      hunks.push({
-        type: "delete",
-        path: header.filePath,
-      })
-      i = header.nextIdx
-    } else if (lines[i].startsWith("*** Update File:")) {
-      const { chunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx)
-      hunks.push({
-        type: "update",
-        path: header.filePath,
-        move_path: header.movePath,
-        chunks,
-      })
-      i = nextIdx
-    } else {
-      i++
-    }
-  }
-
-  return { hunks }
-}
-
-// Apply patch functionality
-export function maybeParseApplyPatch(
-  argv: string[],
-):
-  | { type: MaybeApplyPatch.Body; args: ApplyPatchArgs }
-  | { type: MaybeApplyPatch.PatchParseError; error: Error }
-  | { type: MaybeApplyPatch.NotApplyPatch } {
-  const APPLY_PATCH_COMMANDS = ["apply_patch", "applypatch"]
-
-  // Direct invocation: apply_patch <patch>
-  if (argv.length === 2 && APPLY_PATCH_COMMANDS.includes(argv[0])) {
-    try {
-      const { hunks } = parsePatch(argv[1])
-      return {
-        type: MaybeApplyPatch.Body,
-        args: {
-          patch: argv[1],
-          hunks,
-        },
-      }
-    } catch (error) {
-      return {
-        type: MaybeApplyPatch.PatchParseError,
-        error: error as Error,
-      }
-    }
-  }
-
-  // Bash heredoc form: bash -lc 'apply_patch <<"EOF" ...'
-  if (argv.length === 3 && argv[0] === "bash" && argv[1] === "-lc") {
-    // Simple extraction - in real implementation would need proper bash parsing
-    const script = argv[2]
-    const heredocMatch = script.match(/apply_patch\s*<<['"](\w+)['"]\s*\n([\s\S]*?)\n\1/)
-
-    if (heredocMatch) {
-      const patchContent = heredocMatch[2]
-      try {
-        const { hunks } = parsePatch(patchContent)
-        return {
-          type: MaybeApplyPatch.Body,
-          args: {
-            patch: patchContent,
-            hunks,
-          },
-        }
-      } catch (error) {
-        return {
-          type: MaybeApplyPatch.PatchParseError,
-          error: error as Error,
-        }
-      }
-    }
-  }
-
-  return { type: MaybeApplyPatch.NotApplyPatch }
-}
-
-// File content manipulation
-interface ApplyPatchFileUpdate {
-  unified_diff: string
-  content: string
-}
-
-export function deriveNewContentsFromChunks(filePath: string, chunks: UpdateFileChunk[]): ApplyPatchFileUpdate {
-  // Read original file content
-  let originalContent: string
-  try {
-    originalContent = readFileSync(filePath, "utf-8")
-  } catch (error) {
-    throw new Error(`Failed to read file ${filePath}: ${error}`, { cause: error })
-  }
-
-  let originalLines = originalContent.split("\n")
-
-  // Drop trailing empty element for consistent line counting
-  if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
-    originalLines.pop()
-  }
-
-  const replacements = computeReplacements(originalLines, filePath, chunks)
-  let newLines = applyReplacements(originalLines, replacements)
-
-  // Ensure trailing newline
-  if (newLines.length === 0 || newLines[newLines.length - 1] !== "") {
-    newLines.push("")
-  }
-
-  const newContent = newLines.join("\n")
-
-  // Generate unified diff
-  const unifiedDiff = generateUnifiedDiff(originalContent, newContent)
-
-  return {
-    unified_diff: unifiedDiff,
-    content: newContent,
-  }
-}
-
-function computeReplacements(
-  originalLines: string[],
-  filePath: string,
-  chunks: UpdateFileChunk[],
-): Array<[number, number, string[]]> {
-  const replacements: Array<[number, number, string[]]> = []
-  let lineIndex = 0
-
-  for (const chunk of chunks) {
-    // Handle context-based seeking
-    if (chunk.change_context) {
-      const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex)
-      if (contextIdx === -1) {
-        throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`)
-      }
-      lineIndex = contextIdx + 1
-    }
-
-    // Handle pure addition (no old lines)
-    if (chunk.old_lines.length === 0) {
-      const insertionIdx =
-        originalLines.length > 0 && originalLines[originalLines.length - 1] === ""
-          ? originalLines.length - 1
-          : originalLines.length
-      replacements.push([insertionIdx, 0, chunk.new_lines])
-      continue
-    }
-
-    // Try to match old lines in the file
-    let pattern = chunk.old_lines
-    let newSlice = chunk.new_lines
-    let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file)
-
-    // Retry without trailing empty line if not found
-    if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
-      pattern = pattern.slice(0, -1)
-      if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
-        newSlice = newSlice.slice(0, -1)
-      }
-      found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file)
-    }
-
-    if (found !== -1) {
-      replacements.push([found, pattern.length, newSlice])
-      lineIndex = found + pattern.length
-    } else {
-      throw new Error(`Failed to find expected lines in ${filePath}:\n${chunk.old_lines.join("\n")}`)
-    }
-  }
-
-  // Sort replacements by index to apply in order
-  replacements.sort((a, b) => a[0] - b[0])
-
-  return replacements
-}
-
-function applyReplacements(lines: string[], replacements: Array<[number, number, string[]]>): string[] {
-  // Apply replacements in reverse order to avoid index shifting
-  const result = [...lines]
-
-  for (let i = replacements.length - 1; i >= 0; i--) {
-    const [startIdx, oldLen, newSegment] = replacements[i]
-
-    // Remove old lines
-    result.splice(startIdx, oldLen)
-
-    // Insert new lines
-    for (let j = 0; j < newSegment.length; j++) {
-      result.splice(startIdx + j, 0, newSegment[j])
-    }
-  }
-
-  return result
-}
-
-// Normalize Unicode punctuation to ASCII equivalents (like Rust's normalize_unicode)
-function normalizeUnicode(str: string): string {
-  return str
-    .replace(/[\u2018\u2019\u201A\u201B]/g, "'") // single quotes
-    .replace(/[\u201C\u201D\u201E\u201F]/g, '"') // double quotes
-    .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, "-") // dashes
-    .replace(/\u2026/g, "...") // ellipsis
-    .replace(/\u00A0/g, " ") // non-breaking space
-}
-
-type Comparator = (a: string, b: string) => boolean
-
-function tryMatch(lines: string[], pattern: string[], startIndex: number, compare: Comparator, eof: boolean): number {
-  // If EOF anchor, try matching from end of file first
-  if (eof) {
-    const fromEnd = lines.length - pattern.length
-    if (fromEnd >= startIndex) {
-      let matches = true
-      for (let j = 0; j < pattern.length; j++) {
-        if (!compare(lines[fromEnd + j], pattern[j])) {
-          matches = false
-          break
-        }
-      }
-      if (matches) return fromEnd
-    }
-  }
-
-  // Forward search from startIndex
-  for (let i = startIndex; i <= lines.length - pattern.length; i++) {
-    let matches = true
-    for (let j = 0; j < pattern.length; j++) {
-      if (!compare(lines[i + j], pattern[j])) {
-        matches = false
-        break
-      }
-    }
-    if (matches) return i
-  }
-
-  return -1
-}
-
-function seekSequence(lines: string[], pattern: string[], startIndex: number, eof = false): number {
-  if (pattern.length === 0) return -1
-
-  // Pass 1: exact match
-  const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof)
-  if (exact !== -1) return exact
-
-  // Pass 2: rstrip (trim trailing whitespace)
-  const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof)
-  if (rstrip !== -1) return rstrip
-
-  // Pass 3: trim (both ends)
-  const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof)
-  if (trim !== -1) return trim
-
-  // Pass 4: normalized (Unicode punctuation to ASCII)
-  const normalized = tryMatch(
-    lines,
-    pattern,
-    startIndex,
-    (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()),
-    eof,
-  )
-  return normalized
-}
-
-function generateUnifiedDiff(oldContent: string, newContent: string): string {
-  const oldLines = oldContent.split("\n")
-  const newLines = newContent.split("\n")
-
-  // Simple diff generation - in a real implementation you'd use a proper diff algorithm
-  let diff = "@@ -1 +1 @@\n"
-
-  // Find changes (simplified approach)
-  const maxLen = Math.max(oldLines.length, newLines.length)
-  let hasChanges = false
-
-  for (let i = 0; i < maxLen; i++) {
-    const oldLine = oldLines[i] || ""
-    const newLine = newLines[i] || ""
-
-    if (oldLine !== newLine) {
-      if (oldLine) diff += `-${oldLine}\n`
-      if (newLine) diff += `+${newLine}\n`
-      hasChanges = true
-    } else if (oldLine) {
-      diff += ` ${oldLine}\n`
-    }
-  }
-
-  return hasChanges ? diff : ""
-}
-
-// Apply hunks to filesystem
-export async function applyHunksToFiles(hunks: Hunk[]): Promise<AffectedPaths> {
-  if (hunks.length === 0) {
-    throw new Error("No files were modified.")
-  }
-
-  const added: string[] = []
-  const modified: string[] = []
-  const deleted: string[] = []
-
-  for (const hunk of hunks) {
-    switch (hunk.type) {
-      case "add":
-        // Create parent directories
-        const addDir = path.dirname(hunk.path)
-        if (addDir !== "." && addDir !== "/") {
-          await fs.mkdir(addDir, { recursive: true })
-        }
-
-        await fs.writeFile(hunk.path, hunk.contents, "utf-8")
-        added.push(hunk.path)
-        log.info(`Added file: ${hunk.path}`)
-        break
-
-      case "delete":
-        await fs.unlink(hunk.path)
-        deleted.push(hunk.path)
-        log.info(`Deleted file: ${hunk.path}`)
-        break
-
-      case "update":
-        const fileUpdate = deriveNewContentsFromChunks(hunk.path, hunk.chunks)
-
-        if (hunk.move_path) {
-          // Handle file move
-          const moveDir = path.dirname(hunk.move_path)
-          if (moveDir !== "." && moveDir !== "/") {
-            await fs.mkdir(moveDir, { recursive: true })
-          }
-
-          await fs.writeFile(hunk.move_path, fileUpdate.content, "utf-8")
-          await fs.unlink(hunk.path)
-          modified.push(hunk.move_path)
-          log.info(`Moved file: ${hunk.path} -> ${hunk.move_path}`)
-        } else {
-          // Regular update
-          await fs.writeFile(hunk.path, fileUpdate.content, "utf-8")
-          modified.push(hunk.path)
-          log.info(`Updated file: ${hunk.path}`)
-        }
-        break
-    }
-  }
-
-  return { added, modified, deleted }
-}
-
-// Main patch application function
-export async function applyPatch(patchText: string): Promise<AffectedPaths> {
-  const { hunks } = parsePatch(patchText)
-  return applyHunksToFiles(hunks)
-}
-
-// Async version of maybeParseApplyPatchVerified
-export async function maybeParseApplyPatchVerified(
-  argv: string[],
-  cwd: string,
-): Promise<
-  | { type: MaybeApplyPatchVerified.Body; action: ApplyPatchAction }
-  | { type: MaybeApplyPatchVerified.CorrectnessError; error: Error }
-  | { type: MaybeApplyPatchVerified.NotApplyPatch }
-> {
-  // Detect implicit patch invocation (raw patch without apply_patch command)
-  if (argv.length === 1) {
-    try {
-      parsePatch(argv[0])
-      return {
-        type: MaybeApplyPatchVerified.CorrectnessError,
-        error: new Error(ApplyPatchError.ImplicitInvocation),
-      }
-    } catch {
-      // Not a patch, continue
-    }
-  }
-
-  const result = maybeParseApplyPatch(argv)
-
-  switch (result.type) {
-    case MaybeApplyPatch.Body:
-      const { args } = result
-      const effectiveCwd = args.workdir ? path.resolve(cwd, args.workdir) : cwd
-      const changes = new Map<string, ApplyPatchFileChange>()
-
-      for (const hunk of args.hunks) {
-        const resolvedPath = path.resolve(
-          effectiveCwd,
-          hunk.type === "update" && hunk.move_path ? hunk.move_path : hunk.path,
-        )
-
-        switch (hunk.type) {
-          case "add":
-            changes.set(resolvedPath, {
-              type: "add",
-              content: hunk.contents,
-            })
-            break
-
-          case "delete":
-            // For delete, we need to read the current content
-            const deletePath = path.resolve(effectiveCwd, hunk.path)
-            try {
-              const content = await fs.readFile(deletePath, "utf-8")
-              changes.set(resolvedPath, {
-                type: "delete",
-                content,
-              })
-            } catch {
-              return {
-                type: MaybeApplyPatchVerified.CorrectnessError,
-                error: new Error(`Failed to read file for deletion: ${deletePath}`),
-              }
-            }
-            break
-
-          case "update":
-            const updatePath = path.resolve(effectiveCwd, hunk.path)
-            try {
-              const fileUpdate = deriveNewContentsFromChunks(updatePath, hunk.chunks)
-              changes.set(resolvedPath, {
-                type: "update",
-                unified_diff: fileUpdate.unified_diff,
-                move_path: hunk.move_path ? path.resolve(effectiveCwd, hunk.move_path) : undefined,
-                new_content: fileUpdate.content,
-              })
-            } catch (error) {
-              return {
-                type: MaybeApplyPatchVerified.CorrectnessError,
-                error: error as Error,
-              }
-            }
-            break
-        }
-      }
-
-      return {
-        type: MaybeApplyPatchVerified.Body,
-        action: {
-          changes,
-          patch: args.patch,
-          cwd: effectiveCwd,
-        },
-      }
-
-    case MaybeApplyPatch.PatchParseError:
-      return {
-        type: MaybeApplyPatchVerified.CorrectnessError,
-        error: result.error,
-      }
-
-    case MaybeApplyPatch.NotApplyPatch:
-      return { type: MaybeApplyPatchVerified.NotApplyPatch }
-  }
-}

packages/opencode/src/session/compaction.ts

@@ -1,6 +1,6 @@
 import { BusEvent } from "@/bus/bus-event"
 import { Bus } from "@/bus"
-import * as Session from "."
+import * as Session from "./session"
 import { SessionID, MessageID, PartID } from "./schema"
 import { Provider } from "../provider"
 import { MessageV2 } from "./message-v2"

packages/opencode/src/session/index.ts

@@ -1,812 +1 @@
-import { Slug } from "@opencode-ai/shared/util/slug"
-import path from "path"
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { Decimal } from "decimal.js"
-import z from "zod"
-import { type ProviderMetadata, type LanguageModelUsage } from "ai"
-import { Flag } from "../flag/flag"
-import { Installation } from "../installation"
-import { InstallationVersion } from "../installation/version"
-
-import { Database, NotFoundError, eq, and, gte, isNull, desc, like, inArray, lt } from "../storage"
-import { SyncEvent } from "../sync"
-import type { SQL } from "../storage"
-import { PartTable, SessionTable } from "./session.sql"
-import { ProjectTable } from "../project/project.sql"
-import { Storage } from "@/storage"
-import { Log } from "../util"
-import { updateSchema } from "../util/update-schema"
-import { MessageV2 } from "./message-v2"
-import { Instance } from "../project/instance"
-import { InstanceState } from "@/effect"
-import { Snapshot } from "@/snapshot"
-import { ProjectID } from "../project/schema"
-import { WorkspaceID } from "../control-plane/schema"
-import { SessionID, MessageID, PartID } from "./schema"
-
-import type { Provider } from "@/provider"
-import { Permission } from "@/permission"
-import { Global } from "@/global"
-import { Effect, Layer, Option, Context } from "effect"
-
-const log = Log.create({ service: "session" })
-
-const parentTitlePrefix = "New session - "
-const childTitlePrefix = "Child session - "
-
-function createDefaultTitle(isChild = false) {
-  return (isChild ? childTitlePrefix : parentTitlePrefix) + new Date().toISOString()
-}
-
-export function isDefaultTitle(title: string) {
-  return new RegExp(
-    `^(${parentTitlePrefix}|${childTitlePrefix})\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$`,
-  ).test(title)
-}
-
-type SessionRow = typeof SessionTable.$inferSelect
-
-export function fromRow(row: SessionRow): Info {
-  const summary =
-    row.summary_additions !== null || row.summary_deletions !== null || row.summary_files !== null
-      ? {
-          additions: row.summary_additions ?? 0,
-          deletions: row.summary_deletions ?? 0,
-          files: row.summary_files ?? 0,
-          diffs: row.summary_diffs ?? undefined,
-        }
-      : undefined
-  const share = row.share_url ? { url: row.share_url } : undefined
-  const revert = row.revert ?? undefined
-  return {
-    id: row.id,
-    slug: row.slug,
-    projectID: row.project_id,
-    workspaceID: row.workspace_id ?? undefined,
-    directory: row.directory,
-    parentID: row.parent_id ?? undefined,
-    title: row.title,
-    version: row.version,
-    summary,
-    share,
-    revert,
-    permission: row.permission ?? undefined,
-    time: {
-      created: row.time_created,
-      updated: row.time_updated,
-      compacting: row.time_compacting ?? undefined,
-      archived: row.time_archived ?? undefined,
-    },
-  }
-}
-
-export function toRow(info: Info) {
-  return {
-    id: info.id,
-    project_id: info.projectID,
-    workspace_id: info.workspaceID,
-    parent_id: info.parentID,
-    slug: info.slug,
-    directory: info.directory,
-    title: info.title,
-    version: info.version,
-    share_url: info.share?.url,
-    summary_additions: info.summary?.additions,
-    summary_deletions: info.summary?.deletions,
-    summary_files: info.summary?.files,
-    summary_diffs: info.summary?.diffs,
-    revert: info.revert ?? null,
-    permission: info.permission,
-    time_created: info.time.created,
-    time_updated: info.time.updated,
-    time_compacting: info.time.compacting,
-    time_archived: info.time.archived,
-  }
-}
-
-function getForkedTitle(title: string): string {
-  const match = title.match(/^(.+) \(fork #(\d+)\)$/)
-  if (match) {
-    const base = match[1]
-    const num = parseInt(match[2], 10)
-    return `${base} (fork #${num + 1})`
-  }
-  return `${title} (fork #1)`
-}
-
-export const Info = z
-  .object({
-    id: SessionID.zod,
-    slug: z.string(),
-    projectID: ProjectID.zod,
-    workspaceID: WorkspaceID.zod.optional(),
-    directory: z.string(),
-    parentID: SessionID.zod.optional(),
-    summary: z
-      .object({
-        additions: z.number(),
-        deletions: z.number(),
-        files: z.number(),
-        diffs: Snapshot.FileDiff.array().optional(),
-      })
-      .optional(),
-    share: z
-      .object({
-        url: z.string(),
-      })
-      .optional(),
-    title: z.string(),
-    version: z.string(),
-    time: z.object({
-      created: z.number(),
-      updated: z.number(),
-      compacting: z.number().optional(),
-      archived: z.number().optional(),
-    }),
-    permission: Permission.Ruleset.zod.optional(),
-    revert: z
-      .object({
-        messageID: MessageID.zod,
-        partID: PartID.zod.optional(),
-        snapshot: z.string().optional(),
-        diff: z.string().optional(),
-      })
-      .optional(),
-  })
-  .meta({
-    ref: "Session",
-  })
-export type Info = z.output<typeof Info>
-
-export const ProjectInfo = z
-  .object({
-    id: ProjectID.zod,
-    name: z.string().optional(),
-    worktree: z.string(),
-  })
-  .meta({
-    ref: "ProjectSummary",
-  })
-export type ProjectInfo = z.output<typeof ProjectInfo>
-
-export const GlobalInfo = Info.extend({
-  project: ProjectInfo.nullable(),
-}).meta({
-  ref: "GlobalSession",
-})
-export type GlobalInfo = z.output<typeof GlobalInfo>
-
-export const CreateInput = z
-  .object({
-    parentID: SessionID.zod.optional(),
-    title: z.string().optional(),
-    permission: Info.shape.permission,
-    workspaceID: WorkspaceID.zod.optional(),
-  })
-  .optional()
-export type CreateInput = z.output<typeof CreateInput>
-
-export const ForkInput = z.object({ sessionID: SessionID.zod, messageID: MessageID.zod.optional() })
-export const GetInput = SessionID.zod
-export const ChildrenInput = SessionID.zod
-export const RemoveInput = SessionID.zod
-export const SetTitleInput = z.object({ sessionID: SessionID.zod, title: z.string() })
-export const SetArchivedInput = z.object({ sessionID: SessionID.zod, time: z.number().optional() })
-export const SetPermissionInput = z.object({ sessionID: SessionID.zod, permission: Permission.Ruleset.zod })
-export const SetRevertInput = z.object({
-  sessionID: SessionID.zod,
-  revert: Info.shape.revert,
-  summary: Info.shape.summary,
-})
-export const MessagesInput = z.object({ sessionID: SessionID.zod, limit: z.number().optional() })
-
-export const Event = {
-  Created: SyncEvent.define({
-    type: "session.created",
-    version: 1,
-    aggregate: "sessionID",
-    schema: z.object({
-      sessionID: SessionID.zod,
-      info: Info,
-    }),
-  }),
-  Updated: SyncEvent.define({
-    type: "session.updated",
-    version: 1,
-    aggregate: "sessionID",
-    schema: z.object({
-      sessionID: SessionID.zod,
-      info: updateSchema(Info).extend({
-        share: updateSchema(Info.shape.share.unwrap()).optional(),
-        time: updateSchema(Info.shape.time).optional(),
-      }),
-    }),
-    busSchema: z.object({
-      sessionID: SessionID.zod,
-      info: Info,
-    }),
-  }),
-  Deleted: SyncEvent.define({
-    type: "session.deleted",
-    version: 1,
-    aggregate: "sessionID",
-    schema: z.object({
-      sessionID: SessionID.zod,
-      info: Info,
-    }),
-  }),
-  Diff: BusEvent.define(
-    "session.diff",
-    z.object({
-      sessionID: SessionID.zod,
-      diff: Snapshot.FileDiff.array(),
-    }),
-  ),
-  Error: BusEvent.define(
-    "session.error",
-    z.object({
-      sessionID: SessionID.zod.optional(),
-      error: MessageV2.Assistant.shape.error,
-    }),
-  ),
-}
-
-export function plan(input: { slug: string; time: { created: number } }) {
-  const base = Instance.project.vcs
-    ? path.join(Instance.worktree, ".opencode", "plans")
-    : path.join(Global.Path.data, "plans")
-  return path.join(base, [input.time.created, input.slug].join("-") + ".md")
-}
-
-export const getUsage = (input: { model: Provider.Model; usage: LanguageModelUsage; metadata?: ProviderMetadata }) => {
-  const safe = (value: number) => {
-    if (!Number.isFinite(value)) return 0
-    return value
-  }
-  const inputTokens = safe(input.usage.inputTokens ?? 0)
-  const outputTokens = safe(input.usage.outputTokens ?? 0)
-  const reasoningTokens = safe(input.usage.outputTokenDetails?.reasoningTokens ?? input.usage.reasoningTokens ?? 0)
-
-  const cacheReadInputTokens = safe(
-    input.usage.inputTokenDetails?.cacheReadTokens ?? input.usage.cachedInputTokens ?? 0,
-  )
-  const cacheWriteInputTokens = safe(
-    (input.usage.inputTokenDetails?.cacheWriteTokens ??
-      input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ??
-      // google-vertex-anthropic returns metadata under "vertex" key
-      // (AnthropicMessagesLanguageModel custom provider key from 'vertex.anthropic.messages')
-      input.metadata?.["vertex"]?.["cacheCreationInputTokens"] ??
-      // @ts-expect-error
-      input.metadata?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ??
-      // @ts-expect-error
-      input.metadata?.["venice"]?.["usage"]?.["cacheCreationInputTokens"] ??
-      0) as number,
-  )
-
-  // AI SDK v6 normalized inputTokens to include cached tokens across all providers
-  // (including Anthropic/Bedrock which previously excluded them). Always subtract cache
-  // tokens to get the non-cached input count for separate cost calculation.
-  const adjustedInputTokens = safe(inputTokens - cacheReadInputTokens - cacheWriteInputTokens)
-
-  const total = input.usage.totalTokens
-
-  const tokens = {
-    total,
-    input: adjustedInputTokens,
-    output: safe(outputTokens - reasoningTokens),
-    reasoning: reasoningTokens,
-    cache: {
-      write: cacheWriteInputTokens,
-      read: cacheReadInputTokens,
-    },
-  }
-
-  const costInfo =
-    input.model.cost?.experimentalOver200K && tokens.input + tokens.cache.read > 200_000
-      ? input.model.cost.experimentalOver200K
-      : input.model.cost
-  return {
-    cost: safe(
-      new Decimal(0)
-        .add(new Decimal(tokens.input).mul(costInfo?.input ?? 0).div(1_000_000))
-        .add(new Decimal(tokens.output).mul(costInfo?.output ?? 0).div(1_000_000))
-        .add(new Decimal(tokens.cache.read).mul(costInfo?.cache?.read ?? 0).div(1_000_000))
-        .add(new Decimal(tokens.cache.write).mul(costInfo?.cache?.write ?? 0).div(1_000_000))
-        // TODO: update models.dev to have better pricing model, for now:
-        // charge reasoning tokens at the same rate as output tokens
-        .add(new Decimal(tokens.reasoning).mul(costInfo?.output ?? 0).div(1_000_000))
-        .toNumber(),
-    ),
-    tokens,
-  }
-}
-
-export class BusyError extends Error {
-  constructor(public readonly sessionID: string) {
-    super(`Session ${sessionID} is busy`)
-  }
-}
-
-export interface Interface {
-  readonly create: (input?: {
-    parentID?: SessionID
-    title?: string
-    permission?: Permission.Ruleset
-    workspaceID?: WorkspaceID
-  }) => Effect.Effect<Info>
-  readonly fork: (input: { sessionID: SessionID; messageID?: MessageID }) => Effect.Effect<Info>
-  readonly touch: (sessionID: SessionID) => Effect.Effect<void>
-  readonly get: (id: SessionID) => Effect.Effect<Info>
-  readonly setTitle: (input: { sessionID: SessionID; title: string }) => Effect.Effect<void>
-  readonly setArchived: (input: { sessionID: SessionID; time?: number }) => Effect.Effect<void>
-  readonly setPermission: (input: { sessionID: SessionID; permission: Permission.Ruleset }) => Effect.Effect<void>
-  readonly setRevert: (input: {
-    sessionID: SessionID
-    revert: Info["revert"]
-    summary: Info["summary"]
-  }) => Effect.Effect<void>
-  readonly clearRevert: (sessionID: SessionID) => Effect.Effect<void>
-  readonly setSummary: (input: { sessionID: SessionID; summary: Info["summary"] }) => Effect.Effect<void>
-  readonly diff: (sessionID: SessionID) => Effect.Effect<Snapshot.FileDiff[]>
-  readonly messages: (input: { sessionID: SessionID; limit?: number }) => Effect.Effect<MessageV2.WithParts[]>
-  readonly children: (parentID: SessionID) => Effect.Effect<Info[]>
-  readonly remove: (sessionID: SessionID) => Effect.Effect<void>
-  readonly updateMessage: <T extends MessageV2.Info>(msg: T) => Effect.Effect<T>
-  readonly removeMessage: (input: { sessionID: SessionID; messageID: MessageID }) => Effect.Effect<MessageID>
-  readonly removePart: (input: { sessionID: SessionID; messageID: MessageID; partID: PartID }) => Effect.Effect<PartID>
-  readonly getPart: (input: {
-    sessionID: SessionID
-    messageID: MessageID
-    partID: PartID
-  }) => Effect.Effect<MessageV2.Part | undefined>
-  readonly updatePart: <T extends MessageV2.Part>(part: T) => Effect.Effect<T>
-  readonly updatePartDelta: (input: {
-    sessionID: SessionID
-    messageID: MessageID
-    partID: PartID
-    field: string
-    delta: string
-  }) => Effect.Effect<void>
-  /** Finds the first message matching the predicate, searching newest-first. */
-  readonly findMessage: (
-    sessionID: SessionID,
-    predicate: (msg: MessageV2.WithParts) => boolean,
-  ) => Effect.Effect<Option.Option<MessageV2.WithParts>>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Session") {}
-
-type Patch = z.infer<typeof Event.Updated.schema>["info"]
-
-const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
-  Effect.sync(() => Database.use(fn))
-
-export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service> = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const bus = yield* Bus.Service
-    const storage = yield* Storage.Service
-
-    const createNext = Effect.fn("Session.createNext")(function* (input: {
-      id?: SessionID
-      title?: string
-      parentID?: SessionID
-      workspaceID?: WorkspaceID
-      directory: string
-      permission?: Permission.Ruleset
-    }) {
-      const ctx = yield* InstanceState.context
-      const result: Info = {
-        id: SessionID.descending(input.id),
-        slug: Slug.create(),
-        version: InstallationVersion,
-        projectID: ctx.project.id,
-        directory: input.directory,
-        workspaceID: input.workspaceID,
-        parentID: input.parentID,
-        title: input.title ?? createDefaultTitle(!!input.parentID),
-        permission: input.permission,
-        time: {
-          created: Date.now(),
-          updated: Date.now(),
-        },
-      }
-      log.info("created", result)
-
-      yield* Effect.sync(() => SyncEvent.run(Event.Created, { sessionID: result.id, info: result }))
-
-      if (!Flag.OPENCODE_EXPERIMENTAL_WORKSPACES) {
-        // This only exist for backwards compatibility. We should not be
-        // manually publishing this event; it is a sync event now
-        yield* bus.publish(Event.Updated, {
-          sessionID: result.id,
-          info: result,
-        })
-      }
-
-      return result
-    })
-
-    const get = Effect.fn("Session.get")(function* (id: SessionID) {
-      const row = yield* db((d) => d.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-      if (!row) throw new NotFoundError({ message: `Session not found: ${id}` })
-      return fromRow(row)
-    })
-
-    const children = Effect.fn("Session.children")(function* (parentID: SessionID) {
-      const rows = yield* db((d) =>
-        d
-          .select()
-          .from(SessionTable)
-          .where(and(eq(SessionTable.parent_id, parentID)))
-          .all(),
-      )
-      return rows.map(fromRow)
-    })
-
-    const remove: Interface["remove"] = Effect.fnUntraced(function* (sessionID: SessionID) {
-      try {
-        const session = yield* get(sessionID)
-        const kids = yield* children(sessionID)
-        for (const child of kids) {
-          yield* remove(child.id)
-        }
-
-        // `remove` needs to work in all cases, such as a broken
-        // sessions that run cleanup. In certain cases these will
-        // run without any instance state, so we need to turn off
-        // publishing of events in that case
-        const hasInstance = yield* InstanceState.directory.pipe(
-          Effect.as(true),
-          Effect.catchCause(() => Effect.succeed(false)),
-        )
-
-        yield* Effect.sync(() => {
-          SyncEvent.run(Event.Deleted, { sessionID, info: session }, { publish: hasInstance })
-          SyncEvent.remove(sessionID)
-        })
-      } catch (e) {
-        log.error(e)
-      }
-    })
-
-    const updateMessage = <T extends MessageV2.Info>(msg: T): Effect.Effect<T> =>
-      Effect.gen(function* () {
-        yield* Effect.sync(() => SyncEvent.run(MessageV2.Event.Updated, { sessionID: msg.sessionID, info: msg }))
-        return msg
-      }).pipe(Effect.withSpan("Session.updateMessage"))
-
-    const updatePart = <T extends MessageV2.Part>(part: T): Effect.Effect<T> =>
-      Effect.gen(function* () {
-        yield* Effect.sync(() =>
-          SyncEvent.run(MessageV2.Event.PartUpdated, {
-            sessionID: part.sessionID,
-            part: structuredClone(part),
-            time: Date.now(),
-          }),
-        )
-        return part
-      }).pipe(Effect.withSpan("Session.updatePart"))
-
-    const getPart: Interface["getPart"] = Effect.fn("Session.getPart")(function* (input) {
-      const row = Database.use((db) =>
-        db
-          .select()
-          .from(PartTable)
-          .where(
-            and(
-              eq(PartTable.session_id, input.sessionID),
-              eq(PartTable.message_id, input.messageID),
-              eq(PartTable.id, input.partID),
-            ),
-          )
-          .get(),
-      )
-      if (!row) return
-      return {
-        ...row.data,
-        id: row.id,
-        sessionID: row.session_id,
-        messageID: row.message_id,
-      } as MessageV2.Part
-    })
-
-    const create = Effect.fn("Session.create")(function* (input?: {
-      parentID?: SessionID
-      title?: string
-      permission?: Permission.Ruleset
-      workspaceID?: WorkspaceID
-    }) {
-      const directory = yield* InstanceState.directory
-      const workspace = yield* InstanceState.workspaceID
-      return yield* createNext({
-        parentID: input?.parentID,
-        directory,
-        title: input?.title,
-        permission: input?.permission,
-        workspaceID: workspace,
-      })
-    })
-
-    const fork = Effect.fn("Session.fork")(function* (input: { sessionID: SessionID; messageID?: MessageID }) {
-      const directory = yield* InstanceState.directory
-      const original = yield* get(input.sessionID)
-      const title = getForkedTitle(original.title)
-      const session = yield* createNext({
-        directory,
-        workspaceID: original.workspaceID,
-        title,
-      })
-      const msgs = yield* messages({ sessionID: input.sessionID })
-      const idMap = new Map<string, MessageID>()
-
-      for (const msg of msgs) {
-        if (input.messageID && msg.info.id >= input.messageID) break
-        const newID = MessageID.ascending()
-        idMap.set(msg.info.id, newID)
-
-        const parentID = msg.info.role === "assistant" && msg.info.parentID ? idMap.get(msg.info.parentID) : undefined
-        const cloned = yield* updateMessage({
-          ...msg.info,
-          sessionID: session.id,
-          id: newID,
-          ...(parentID && { parentID }),
-        })
-
-        for (const part of msg.parts) {
-          yield* updatePart({
-            ...part,
-            id: PartID.ascending(),
-            messageID: cloned.id,
-            sessionID: session.id,
-          })
-        }
-      }
-      return session
-    })
-
-    const patch = (sessionID: SessionID, info: Patch) =>
-      Effect.sync(() => SyncEvent.run(Event.Updated, { sessionID, info }))
-
-    const touch = Effect.fn("Session.touch")(function* (sessionID: SessionID) {
-      yield* patch(sessionID, { time: { updated: Date.now() } })
-    })
-
-    const setTitle = Effect.fn("Session.setTitle")(function* (input: { sessionID: SessionID; title: string }) {
-      yield* patch(input.sessionID, { title: input.title })
-    })
-
-    const setArchived = Effect.fn("Session.setArchived")(function* (input: { sessionID: SessionID; time?: number }) {
-      yield* patch(input.sessionID, { time: { archived: input.time } })
-    })
-
-    const setPermission = Effect.fn("Session.setPermission")(function* (input: {
-      sessionID: SessionID
-      permission: Permission.Ruleset
-    }) {
-      yield* patch(input.sessionID, { permission: input.permission, time: { updated: Date.now() } })
-    })
-
-    const setRevert = Effect.fn("Session.setRevert")(function* (input: {
-      sessionID: SessionID
-      revert: Info["revert"]
-      summary: Info["summary"]
-    }) {
-      yield* patch(input.sessionID, { summary: input.summary, time: { updated: Date.now() }, revert: input.revert })
-    })
-
-    const clearRevert = Effect.fn("Session.clearRevert")(function* (sessionID: SessionID) {
-      yield* patch(sessionID, { time: { updated: Date.now() }, revert: null })
-    })
-
-    const setSummary = Effect.fn("Session.setSummary")(function* (input: {
-      sessionID: SessionID
-      summary: Info["summary"]
-    }) {
-      yield* patch(input.sessionID, { time: { updated: Date.now() }, summary: input.summary })
-    })
-
-    const diff = Effect.fn("Session.diff")(function* (sessionID: SessionID) {
-      return yield* storage
-        .read<Snapshot.FileDiff[]>(["session_diff", sessionID])
-        .pipe(Effect.orElseSucceed((): Snapshot.FileDiff[] => []))
-    })
-
-    const messages = Effect.fn("Session.messages")(function* (input: { sessionID: SessionID; limit?: number }) {
-      if (input.limit) {
-        return MessageV2.page({ sessionID: input.sessionID, limit: input.limit }).items
-      }
-      return Array.from(MessageV2.stream(input.sessionID)).reverse()
-    })
-
-    const removeMessage = Effect.fn("Session.removeMessage")(function* (input: {
-      sessionID: SessionID
-      messageID: MessageID
-    }) {
-      yield* Effect.sync(() =>
-        SyncEvent.run(MessageV2.Event.Removed, {
-          sessionID: input.sessionID,
-          messageID: input.messageID,
-        }),
-      )
-      return input.messageID
-    })
-
-    const removePart = Effect.fn("Session.removePart")(function* (input: {
-      sessionID: SessionID
-      messageID: MessageID
-      partID: PartID
-    }) {
-      yield* Effect.sync(() =>
-        SyncEvent.run(MessageV2.Event.PartRemoved, {
-          sessionID: input.sessionID,
-          messageID: input.messageID,
-          partID: input.partID,
-        }),
-      )
-      return input.partID
-    })
-
-    const updatePartDelta = Effect.fn("Session.updatePartDelta")(function* (input: {
-      sessionID: SessionID
-      messageID: MessageID
-      partID: PartID
-      field: string
-      delta: string
-    }) {
-      yield* bus.publish(MessageV2.Event.PartDelta, input)
-    })
-
-    /** Finds the first message matching the predicate, searching newest-first. */
-    const findMessage = Effect.fn("Session.findMessage")(function* (
-      sessionID: SessionID,
-      predicate: (msg: MessageV2.WithParts) => boolean,
-    ) {
-      for (const item of MessageV2.stream(sessionID)) {
-        if (predicate(item)) return Option.some(item)
-      }
-      return Option.none<MessageV2.WithParts>()
-    })
-
-    return Service.of({
-      create,
-      fork,
-      touch,
-      get,
-      setTitle,
-      setArchived,
-      setPermission,
-      setRevert,
-      clearRevert,
-      setSummary,
-      diff,
-      messages,
-      children,
-      remove,
-      updateMessage,
-      removeMessage,
-      removePart,
-      updatePart,
-      getPart,
-      updatePartDelta,
-      findMessage,
-    })
-  }),
-)
-
-export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Storage.defaultLayer))
-
-export function* list(input?: {
-  directory?: string
-  workspaceID?: WorkspaceID
-  roots?: boolean
-  start?: number
-  search?: string
-  limit?: number
-}) {
-  const project = Instance.project
-  const conditions = [eq(SessionTable.project_id, project.id)]
-
-  if (input?.workspaceID) {
-    conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
-  }
-  if (input?.directory) {
-    conditions.push(eq(SessionTable.directory, input.directory))
-  }
-  if (input?.roots) {
-    conditions.push(isNull(SessionTable.parent_id))
-  }
-  if (input?.start) {
-    conditions.push(gte(SessionTable.time_updated, input.start))
-  }
-  if (input?.search) {
-    conditions.push(like(SessionTable.title, `%${input.search}%`))
-  }
-
-  const limit = input?.limit ?? 100
-
-  const rows = Database.use((db) =>
-    db
-      .select()
-      .from(SessionTable)
-      .where(and(...conditions))
-      .orderBy(desc(SessionTable.time_updated))
-      .limit(limit)
-      .all(),
-  )
-  for (const row of rows) {
-    yield fromRow(row)
-  }
-}
-
-export function* listGlobal(input?: {
-  directory?: string
-  roots?: boolean
-  start?: number
-  cursor?: number
-  search?: string
-  limit?: number
-  archived?: boolean
-}) {
-  const conditions: SQL[] = []
-
-  if (input?.directory) {
-    conditions.push(eq(SessionTable.directory, input.directory))
-  }
-  if (input?.roots) {
-    conditions.push(isNull(SessionTable.parent_id))
-  }
-  if (input?.start) {
-    conditions.push(gte(SessionTable.time_updated, input.start))
-  }
-  if (input?.cursor) {
-    conditions.push(lt(SessionTable.time_updated, input.cursor))
-  }
-  if (input?.search) {
-    conditions.push(like(SessionTable.title, `%${input.search}%`))
-  }
-  if (!input?.archived) {
-    conditions.push(isNull(SessionTable.time_archived))
-  }
-
-  const limit = input?.limit ?? 100
-
-  const rows = Database.use((db) => {
-    const query =
-      conditions.length > 0
-        ? db
-            .select()
-            .from(SessionTable)
-            .where(and(...conditions))
-        : db.select().from(SessionTable)
-    return query.orderBy(desc(SessionTable.time_updated), desc(SessionTable.id)).limit(limit).all()
-  })
-
-  const ids = [...new Set(rows.map((row) => row.project_id))]
-  const projects = new Map<string, ProjectInfo>()
-
-  if (ids.length > 0) {
-    const items = Database.use((db) =>
-      db
-        .select({ id: ProjectTable.id, name: ProjectTable.name, worktree: ProjectTable.worktree })
-        .from(ProjectTable)
-        .where(inArray(ProjectTable.id, ids))
-        .all(),
-    )
-    for (const item of items) {
-      projects.set(item.id, {
-        id: item.id,
-        name: item.name ?? undefined,
-        worktree: item.worktree,
-      })
-    }
-  }
-
-  for (const row of rows) {
-    const project = projects.get(row.project_id) ?? null
-    yield { ...fromRow(row), project }
-  }
-}
-
-export * as Session from "."
+export * as Session from "./session"

packages/opencode/src/session/processor.ts

@@ -6,7 +6,7 @@ import { Config } from "@/config"
 import { Permission } from "@/permission"
 import { Plugin } from "@/plugin"
 import { Snapshot } from "@/snapshot"
-import * as Session from "."
+import * as Session from "./session"
 import { LLM } from "./llm"
 import { MessageV2 } from "./message-v2"
 import { isOverflow } from "./overflow"

packages/opencode/src/session/projectors.ts

@@ -1,6 +1,6 @@
 import { NotFoundError, eq, and } from "../storage"
 import { SyncEvent } from "@/sync"
-import * as Session from "."
+import * as Session from "./session"
 import { MessageV2 } from "./message-v2"
 import { SessionTable, MessageTable, PartTable } from "./session.sql"
 import { Log } from "../util"

packages/opencode/src/session/prompt.ts

@@ -5,7 +5,7 @@ import { SessionID, MessageID, PartID } from "./schema"
 import { MessageV2 } from "./message-v2"
 import { Log } from "../util"
 import { SessionRevert } from "./revert"
-import * as Session from "."
+import * as Session from "./session"
 import { Agent } from "../agent/agent"
 import { Provider } from "../provider"
 import { ModelID, ProviderID } from "../provider/schema"

packages/opencode/src/session/revert.ts

@@ -5,7 +5,7 @@ import { Snapshot } from "../snapshot"
 import { Storage } from "@/storage"
 import { SyncEvent } from "../sync"
 import { Log } from "../util"
-import * as Session from "."
+import * as Session from "./session"
 import { MessageV2 } from "./message-v2"
 import { SessionID, MessageID, PartID } from "./schema"
 import { SessionRunState } from "./run-state"

packages/opencode/src/session/run-state.ts

@@ -1,7 +1,7 @@
 import { InstanceState } from "@/effect"
 import { Runner } from "@/effect"
 import { Effect, Layer, Scope, Context } from "effect"
-import * as Session from "."
+import * as Session from "./session"
 import { MessageV2 } from "./message-v2"
 import { SessionID } from "./schema"
 import { SessionStatus } from "./status"

packages/opencode/src/session/session.ts

@@ -0,0 +1,810 @@
+import { Slug } from "@opencode-ai/shared/util/slug"
+import path from "path"
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import { Decimal } from "decimal.js"
+import z from "zod"
+import { type ProviderMetadata, type LanguageModelUsage } from "ai"
+import { Flag } from "../flag/flag"
+import { Installation } from "../installation"
+import { InstallationVersion } from "../installation/version"
+
+import { Database, NotFoundError, eq, and, gte, isNull, desc, like, inArray, lt } from "../storage"
+import { SyncEvent } from "../sync"
+import type { SQL } from "../storage"
+import { PartTable, SessionTable } from "./session.sql"
+import { ProjectTable } from "../project/project.sql"
+import { Storage } from "@/storage"
+import { Log } from "../util"
+import { updateSchema } from "../util/update-schema"
+import { MessageV2 } from "./message-v2"
+import { Instance } from "../project/instance"
+import { InstanceState } from "@/effect"
+import { Snapshot } from "@/snapshot"
+import { ProjectID } from "../project/schema"
+import { WorkspaceID } from "../control-plane/schema"
+import { SessionID, MessageID, PartID } from "./schema"
+
+import type { Provider } from "@/provider"
+import { Permission } from "@/permission"
+import { Global } from "@/global"
+import { Effect, Layer, Option, Context } from "effect"
+
+const log = Log.create({ service: "session" })
+
+const parentTitlePrefix = "New session - "
+const childTitlePrefix = "Child session - "
+
+function createDefaultTitle(isChild = false) {
+  return (isChild ? childTitlePrefix : parentTitlePrefix) + new Date().toISOString()
+}
+
+export function isDefaultTitle(title: string) {
+  return new RegExp(
+    `^(${parentTitlePrefix}|${childTitlePrefix})\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$`,
+  ).test(title)
+}
+
+type SessionRow = typeof SessionTable.$inferSelect
+
+export function fromRow(row: SessionRow): Info {
+  const summary =
+    row.summary_additions !== null || row.summary_deletions !== null || row.summary_files !== null
+      ? {
+          additions: row.summary_additions ?? 0,
+          deletions: row.summary_deletions ?? 0,
+          files: row.summary_files ?? 0,
+          diffs: row.summary_diffs ?? undefined,
+        }
+      : undefined
+  const share = row.share_url ? { url: row.share_url } : undefined
+  const revert = row.revert ?? undefined
+  return {
+    id: row.id,
+    slug: row.slug,
+    projectID: row.project_id,
+    workspaceID: row.workspace_id ?? undefined,
+    directory: row.directory,
+    parentID: row.parent_id ?? undefined,
+    title: row.title,
+    version: row.version,
+    summary,
+    share,
+    revert,
+    permission: row.permission ?? undefined,
+    time: {
+      created: row.time_created,
+      updated: row.time_updated,
+      compacting: row.time_compacting ?? undefined,
+      archived: row.time_archived ?? undefined,
+    },
+  }
+}
+
+export function toRow(info: Info) {
+  return {
+    id: info.id,
+    project_id: info.projectID,
+    workspace_id: info.workspaceID,
+    parent_id: info.parentID,
+    slug: info.slug,
+    directory: info.directory,
+    title: info.title,
+    version: info.version,
+    share_url: info.share?.url,
+    summary_additions: info.summary?.additions,
+    summary_deletions: info.summary?.deletions,
+    summary_files: info.summary?.files,
+    summary_diffs: info.summary?.diffs,
+    revert: info.revert ?? null,
+    permission: info.permission,
+    time_created: info.time.created,
+    time_updated: info.time.updated,
+    time_compacting: info.time.compacting,
+    time_archived: info.time.archived,
+  }
+}
+
+function getForkedTitle(title: string): string {
+  const match = title.match(/^(.+) \(fork #(\d+)\)$/)
+  if (match) {
+    const base = match[1]
+    const num = parseInt(match[2], 10)
+    return `${base} (fork #${num + 1})`
+  }
+  return `${title} (fork #1)`
+}
+
+export const Info = z
+  .object({
+    id: SessionID.zod,
+    slug: z.string(),
+    projectID: ProjectID.zod,
+    workspaceID: WorkspaceID.zod.optional(),
+    directory: z.string(),
+    parentID: SessionID.zod.optional(),
+    summary: z
+      .object({
+        additions: z.number(),
+        deletions: z.number(),
+        files: z.number(),
+        diffs: Snapshot.FileDiff.array().optional(),
+      })
+      .optional(),
+    share: z
+      .object({
+        url: z.string(),
+      })
+      .optional(),
+    title: z.string(),
+    version: z.string(),
+    time: z.object({
+      created: z.number(),
+      updated: z.number(),
+      compacting: z.number().optional(),
+      archived: z.number().optional(),
+    }),
+    permission: Permission.Ruleset.zod.optional(),
+    revert: z
+      .object({
+        messageID: MessageID.zod,
+        partID: PartID.zod.optional(),
+        snapshot: z.string().optional(),
+        diff: z.string().optional(),
+      })
+      .optional(),
+  })
+  .meta({
+    ref: "Session",
+  })
+export type Info = z.output<typeof Info>
+
+export const ProjectInfo = z
+  .object({
+    id: ProjectID.zod,
+    name: z.string().optional(),
+    worktree: z.string(),
+  })
+  .meta({
+    ref: "ProjectSummary",
+  })
+export type ProjectInfo = z.output<typeof ProjectInfo>
+
+export const GlobalInfo = Info.extend({
+  project: ProjectInfo.nullable(),
+}).meta({
+  ref: "GlobalSession",
+})
+export type GlobalInfo = z.output<typeof GlobalInfo>
+
+export const CreateInput = z
+  .object({
+    parentID: SessionID.zod.optional(),
+    title: z.string().optional(),
+    permission: Info.shape.permission,
+    workspaceID: WorkspaceID.zod.optional(),
+  })
+  .optional()
+export type CreateInput = z.output<typeof CreateInput>
+
+export const ForkInput = z.object({ sessionID: SessionID.zod, messageID: MessageID.zod.optional() })
+export const GetInput = SessionID.zod
+export const ChildrenInput = SessionID.zod
+export const RemoveInput = SessionID.zod
+export const SetTitleInput = z.object({ sessionID: SessionID.zod, title: z.string() })
+export const SetArchivedInput = z.object({ sessionID: SessionID.zod, time: z.number().optional() })
+export const SetPermissionInput = z.object({ sessionID: SessionID.zod, permission: Permission.Ruleset.zod })
+export const SetRevertInput = z.object({
+  sessionID: SessionID.zod,
+  revert: Info.shape.revert,
+  summary: Info.shape.summary,
+})
+export const MessagesInput = z.object({ sessionID: SessionID.zod, limit: z.number().optional() })
+
+export const Event = {
+  Created: SyncEvent.define({
+    type: "session.created",
+    version: 1,
+    aggregate: "sessionID",
+    schema: z.object({
+      sessionID: SessionID.zod,
+      info: Info,
+    }),
+  }),
+  Updated: SyncEvent.define({
+    type: "session.updated",
+    version: 1,
+    aggregate: "sessionID",
+    schema: z.object({
+      sessionID: SessionID.zod,
+      info: updateSchema(Info).extend({
+        share: updateSchema(Info.shape.share.unwrap()).optional(),
+        time: updateSchema(Info.shape.time).optional(),
+      }),
+    }),
+    busSchema: z.object({
+      sessionID: SessionID.zod,
+      info: Info,
+    }),
+  }),
+  Deleted: SyncEvent.define({
+    type: "session.deleted",
+    version: 1,
+    aggregate: "sessionID",
+    schema: z.object({
+      sessionID: SessionID.zod,
+      info: Info,
+    }),
+  }),
+  Diff: BusEvent.define(
+    "session.diff",
+    z.object({
+      sessionID: SessionID.zod,
+      diff: Snapshot.FileDiff.array(),
+    }),
+  ),
+  Error: BusEvent.define(
+    "session.error",
+    z.object({
+      sessionID: SessionID.zod.optional(),
+      error: MessageV2.Assistant.shape.error,
+    }),
+  ),
+}
+
+export function plan(input: { slug: string; time: { created: number } }) {
+  const base = Instance.project.vcs
+    ? path.join(Instance.worktree, ".opencode", "plans")
+    : path.join(Global.Path.data, "plans")
+  return path.join(base, [input.time.created, input.slug].join("-") + ".md")
+}
+
+export const getUsage = (input: { model: Provider.Model; usage: LanguageModelUsage; metadata?: ProviderMetadata }) => {
+  const safe = (value: number) => {
+    if (!Number.isFinite(value)) return 0
+    return value
+  }
+  const inputTokens = safe(input.usage.inputTokens ?? 0)
+  const outputTokens = safe(input.usage.outputTokens ?? 0)
+  const reasoningTokens = safe(input.usage.outputTokenDetails?.reasoningTokens ?? input.usage.reasoningTokens ?? 0)
+
+  const cacheReadInputTokens = safe(
+    input.usage.inputTokenDetails?.cacheReadTokens ?? input.usage.cachedInputTokens ?? 0,
+  )
+  const cacheWriteInputTokens = safe(
+    (input.usage.inputTokenDetails?.cacheWriteTokens ??
+      input.metadata?.["anthropic"]?.["cacheCreationInputTokens"] ??
+      // google-vertex-anthropic returns metadata under "vertex" key
+      // (AnthropicMessagesLanguageModel custom provider key from 'vertex.anthropic.messages')
+      input.metadata?.["vertex"]?.["cacheCreationInputTokens"] ??
+      // @ts-expect-error
+      input.metadata?.["bedrock"]?.["usage"]?.["cacheWriteInputTokens"] ??
+      // @ts-expect-error
+      input.metadata?.["venice"]?.["usage"]?.["cacheCreationInputTokens"] ??
+      0) as number,
+  )
+
+  // AI SDK v6 normalized inputTokens to include cached tokens across all providers
+  // (including Anthropic/Bedrock which previously excluded them). Always subtract cache
+  // tokens to get the non-cached input count for separate cost calculation.
+  const adjustedInputTokens = safe(inputTokens - cacheReadInputTokens - cacheWriteInputTokens)
+
+  const total = input.usage.totalTokens
+
+  const tokens = {
+    total,
+    input: adjustedInputTokens,
+    output: safe(outputTokens - reasoningTokens),
+    reasoning: reasoningTokens,
+    cache: {
+      write: cacheWriteInputTokens,
+      read: cacheReadInputTokens,
+    },
+  }
+
+  const costInfo =
+    input.model.cost?.experimentalOver200K && tokens.input + tokens.cache.read > 200_000
+      ? input.model.cost.experimentalOver200K
+      : input.model.cost
+  return {
+    cost: safe(
+      new Decimal(0)
+        .add(new Decimal(tokens.input).mul(costInfo?.input ?? 0).div(1_000_000))
+        .add(new Decimal(tokens.output).mul(costInfo?.output ?? 0).div(1_000_000))
+        .add(new Decimal(tokens.cache.read).mul(costInfo?.cache?.read ?? 0).div(1_000_000))
+        .add(new Decimal(tokens.cache.write).mul(costInfo?.cache?.write ?? 0).div(1_000_000))
+        // TODO: update models.dev to have better pricing model, for now:
+        // charge reasoning tokens at the same rate as output tokens
+        .add(new Decimal(tokens.reasoning).mul(costInfo?.output ?? 0).div(1_000_000))
+        .toNumber(),
+    ),
+    tokens,
+  }
+}
+
+export class BusyError extends Error {
+  constructor(public readonly sessionID: string) {
+    super(`Session ${sessionID} is busy`)
+  }
+}
+
+export interface Interface {
+  readonly create: (input?: {
+    parentID?: SessionID
+    title?: string
+    permission?: Permission.Ruleset
+    workspaceID?: WorkspaceID
+  }) => Effect.Effect<Info>
+  readonly fork: (input: { sessionID: SessionID; messageID?: MessageID }) => Effect.Effect<Info>
+  readonly touch: (sessionID: SessionID) => Effect.Effect<void>
+  readonly get: (id: SessionID) => Effect.Effect<Info>
+  readonly setTitle: (input: { sessionID: SessionID; title: string }) => Effect.Effect<void>
+  readonly setArchived: (input: { sessionID: SessionID; time?: number }) => Effect.Effect<void>
+  readonly setPermission: (input: { sessionID: SessionID; permission: Permission.Ruleset }) => Effect.Effect<void>
+  readonly setRevert: (input: {
+    sessionID: SessionID
+    revert: Info["revert"]
+    summary: Info["summary"]
+  }) => Effect.Effect<void>
+  readonly clearRevert: (sessionID: SessionID) => Effect.Effect<void>
+  readonly setSummary: (input: { sessionID: SessionID; summary: Info["summary"] }) => Effect.Effect<void>
+  readonly diff: (sessionID: SessionID) => Effect.Effect<Snapshot.FileDiff[]>
+  readonly messages: (input: { sessionID: SessionID; limit?: number }) => Effect.Effect<MessageV2.WithParts[]>
+  readonly children: (parentID: SessionID) => Effect.Effect<Info[]>
+  readonly remove: (sessionID: SessionID) => Effect.Effect<void>
+  readonly updateMessage: <T extends MessageV2.Info>(msg: T) => Effect.Effect<T>
+  readonly removeMessage: (input: { sessionID: SessionID; messageID: MessageID }) => Effect.Effect<MessageID>
+  readonly removePart: (input: { sessionID: SessionID; messageID: MessageID; partID: PartID }) => Effect.Effect<PartID>
+  readonly getPart: (input: {
+    sessionID: SessionID
+    messageID: MessageID
+    partID: PartID
+  }) => Effect.Effect<MessageV2.Part | undefined>
+  readonly updatePart: <T extends MessageV2.Part>(part: T) => Effect.Effect<T>
+  readonly updatePartDelta: (input: {
+    sessionID: SessionID
+    messageID: MessageID
+    partID: PartID
+    field: string
+    delta: string
+  }) => Effect.Effect<void>
+  /** Finds the first message matching the predicate, searching newest-first. */
+  readonly findMessage: (
+    sessionID: SessionID,
+    predicate: (msg: MessageV2.WithParts) => boolean,
+  ) => Effect.Effect<Option.Option<MessageV2.WithParts>>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Session") {}
+
+type Patch = z.infer<typeof Event.Updated.schema>["info"]
+
+const db = <T>(fn: (d: Parameters<typeof Database.use>[0] extends (trx: infer D) => any ? D : never) => T) =>
+  Effect.sync(() => Database.use(fn))
+
+export const layer: Layer.Layer<Service, never, Bus.Service | Storage.Service> = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const bus = yield* Bus.Service
+    const storage = yield* Storage.Service
+
+    const createNext = Effect.fn("Session.createNext")(function* (input: {
+      id?: SessionID
+      title?: string
+      parentID?: SessionID
+      workspaceID?: WorkspaceID
+      directory: string
+      permission?: Permission.Ruleset
+    }) {
+      const ctx = yield* InstanceState.context
+      const result: Info = {
+        id: SessionID.descending(input.id),
+        slug: Slug.create(),
+        version: InstallationVersion,
+        projectID: ctx.project.id,
+        directory: input.directory,
+        workspaceID: input.workspaceID,
+        parentID: input.parentID,
+        title: input.title ?? createDefaultTitle(!!input.parentID),
+        permission: input.permission,
+        time: {
+          created: Date.now(),
+          updated: Date.now(),
+        },
+      }
+      log.info("created", result)
+
+      yield* Effect.sync(() => SyncEvent.run(Event.Created, { sessionID: result.id, info: result }))
+
+      if (!Flag.OPENCODE_EXPERIMENTAL_WORKSPACES) {
+        // This only exist for backwards compatibility. We should not be
+        // manually publishing this event; it is a sync event now
+        yield* bus.publish(Event.Updated, {
+          sessionID: result.id,
+          info: result,
+        })
+      }
+
+      return result
+    })
+
+    const get = Effect.fn("Session.get")(function* (id: SessionID) {
+      const row = yield* db((d) => d.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
+      if (!row) throw new NotFoundError({ message: `Session not found: ${id}` })
+      return fromRow(row)
+    })
+
+    const children = Effect.fn("Session.children")(function* (parentID: SessionID) {
+      const rows = yield* db((d) =>
+        d
+          .select()
+          .from(SessionTable)
+          .where(and(eq(SessionTable.parent_id, parentID)))
+          .all(),
+      )
+      return rows.map(fromRow)
+    })
+
+    const remove: Interface["remove"] = Effect.fnUntraced(function* (sessionID: SessionID) {
+      try {
+        const session = yield* get(sessionID)
+        const kids = yield* children(sessionID)
+        for (const child of kids) {
+          yield* remove(child.id)
+        }
+
+        // `remove` needs to work in all cases, such as a broken
+        // sessions that run cleanup. In certain cases these will
+        // run without any instance state, so we need to turn off
+        // publishing of events in that case
+        const hasInstance = yield* InstanceState.directory.pipe(
+          Effect.as(true),
+          Effect.catchCause(() => Effect.succeed(false)),
+        )
+
+        yield* Effect.sync(() => {
+          SyncEvent.run(Event.Deleted, { sessionID, info: session }, { publish: hasInstance })
+          SyncEvent.remove(sessionID)
+        })
+      } catch (e) {
+        log.error(e)
+      }
+    })
+
+    const updateMessage = <T extends MessageV2.Info>(msg: T): Effect.Effect<T> =>
+      Effect.gen(function* () {
+        yield* Effect.sync(() => SyncEvent.run(MessageV2.Event.Updated, { sessionID: msg.sessionID, info: msg }))
+        return msg
+      }).pipe(Effect.withSpan("Session.updateMessage"))
+
+    const updatePart = <T extends MessageV2.Part>(part: T): Effect.Effect<T> =>
+      Effect.gen(function* () {
+        yield* Effect.sync(() =>
+          SyncEvent.run(MessageV2.Event.PartUpdated, {
+            sessionID: part.sessionID,
+            part: structuredClone(part),
+            time: Date.now(),
+          }),
+        )
+        return part
+      }).pipe(Effect.withSpan("Session.updatePart"))
+
+    const getPart: Interface["getPart"] = Effect.fn("Session.getPart")(function* (input) {
+      const row = Database.use((db) =>
+        db
+          .select()
+          .from(PartTable)
+          .where(
+            and(
+              eq(PartTable.session_id, input.sessionID),
+              eq(PartTable.message_id, input.messageID),
+              eq(PartTable.id, input.partID),
+            ),
+          )
+          .get(),
+      )
+      if (!row) return
+      return {
+        ...row.data,
+        id: row.id,
+        sessionID: row.session_id,
+        messageID: row.message_id,
+      } as MessageV2.Part
+    })
+
+    const create = Effect.fn("Session.create")(function* (input?: {
+      parentID?: SessionID
+      title?: string
+      permission?: Permission.Ruleset
+      workspaceID?: WorkspaceID
+    }) {
+      const directory = yield* InstanceState.directory
+      const workspace = yield* InstanceState.workspaceID
+      return yield* createNext({
+        parentID: input?.parentID,
+        directory,
+        title: input?.title,
+        permission: input?.permission,
+        workspaceID: workspace,
+      })
+    })
+
+    const fork = Effect.fn("Session.fork")(function* (input: { sessionID: SessionID; messageID?: MessageID }) {
+      const directory = yield* InstanceState.directory
+      const original = yield* get(input.sessionID)
+      const title = getForkedTitle(original.title)
+      const session = yield* createNext({
+        directory,
+        workspaceID: original.workspaceID,
+        title,
+      })
+      const msgs = yield* messages({ sessionID: input.sessionID })
+      const idMap = new Map<string, MessageID>()
+
+      for (const msg of msgs) {
+        if (input.messageID && msg.info.id >= input.messageID) break
+        const newID = MessageID.ascending()
+        idMap.set(msg.info.id, newID)
+
+        const parentID = msg.info.role === "assistant" && msg.info.parentID ? idMap.get(msg.info.parentID) : undefined
+        const cloned = yield* updateMessage({
+          ...msg.info,
+          sessionID: session.id,
+          id: newID,
+          ...(parentID && { parentID }),
+        })
+
+        for (const part of msg.parts) {
+          yield* updatePart({
+            ...part,
+            id: PartID.ascending(),
+            messageID: cloned.id,
+            sessionID: session.id,
+          })
+        }
+      }
+      return session
+    })
+
+    const patch = (sessionID: SessionID, info: Patch) =>
+      Effect.sync(() => SyncEvent.run(Event.Updated, { sessionID, info }))
+
+    const touch = Effect.fn("Session.touch")(function* (sessionID: SessionID) {
+      yield* patch(sessionID, { time: { updated: Date.now() } })
+    })
+
+    const setTitle = Effect.fn("Session.setTitle")(function* (input: { sessionID: SessionID; title: string }) {
+      yield* patch(input.sessionID, { title: input.title })
+    })
+
+    const setArchived = Effect.fn("Session.setArchived")(function* (input: { sessionID: SessionID; time?: number }) {
+      yield* patch(input.sessionID, { time: { archived: input.time } })
+    })
+
+    const setPermission = Effect.fn("Session.setPermission")(function* (input: {
+      sessionID: SessionID
+      permission: Permission.Ruleset
+    }) {
+      yield* patch(input.sessionID, { permission: input.permission, time: { updated: Date.now() } })
+    })
+
+    const setRevert = Effect.fn("Session.setRevert")(function* (input: {
+      sessionID: SessionID
+      revert: Info["revert"]
+      summary: Info["summary"]
+    }) {
+      yield* patch(input.sessionID, { summary: input.summary, time: { updated: Date.now() }, revert: input.revert })
+    })
+
+    const clearRevert = Effect.fn("Session.clearRevert")(function* (sessionID: SessionID) {
+      yield* patch(sessionID, { time: { updated: Date.now() }, revert: null })
+    })
+
+    const setSummary = Effect.fn("Session.setSummary")(function* (input: {
+      sessionID: SessionID
+      summary: Info["summary"]
+    }) {
+      yield* patch(input.sessionID, { time: { updated: Date.now() }, summary: input.summary })
+    })
+
+    const diff = Effect.fn("Session.diff")(function* (sessionID: SessionID) {
+      return yield* storage
+        .read<Snapshot.FileDiff[]>(["session_diff", sessionID])
+        .pipe(Effect.orElseSucceed((): Snapshot.FileDiff[] => []))
+    })
+
+    const messages = Effect.fn("Session.messages")(function* (input: { sessionID: SessionID; limit?: number }) {
+      if (input.limit) {
+        return MessageV2.page({ sessionID: input.sessionID, limit: input.limit }).items
+      }
+      return Array.from(MessageV2.stream(input.sessionID)).reverse()
+    })
+
+    const removeMessage = Effect.fn("Session.removeMessage")(function* (input: {
+      sessionID: SessionID
+      messageID: MessageID
+    }) {
+      yield* Effect.sync(() =>
+        SyncEvent.run(MessageV2.Event.Removed, {
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+        }),
+      )
+      return input.messageID
+    })
+
+    const removePart = Effect.fn("Session.removePart")(function* (input: {
+      sessionID: SessionID
+      messageID: MessageID
+      partID: PartID
+    }) {
+      yield* Effect.sync(() =>
+        SyncEvent.run(MessageV2.Event.PartRemoved, {
+          sessionID: input.sessionID,
+          messageID: input.messageID,
+          partID: input.partID,
+        }),
+      )
+      return input.partID
+    })
+
+    const updatePartDelta = Effect.fn("Session.updatePartDelta")(function* (input: {
+      sessionID: SessionID
+      messageID: MessageID
+      partID: PartID
+      field: string
+      delta: string
+    }) {
+      yield* bus.publish(MessageV2.Event.PartDelta, input)
+    })
+
+    /** Finds the first message matching the predicate, searching newest-first. */
+    const findMessage = Effect.fn("Session.findMessage")(function* (
+      sessionID: SessionID,
+      predicate: (msg: MessageV2.WithParts) => boolean,
+    ) {
+      for (const item of MessageV2.stream(sessionID)) {
+        if (predicate(item)) return Option.some(item)
+      }
+      return Option.none<MessageV2.WithParts>()
+    })
+
+    return Service.of({
+      create,
+      fork,
+      touch,
+      get,
+      setTitle,
+      setArchived,
+      setPermission,
+      setRevert,
+      clearRevert,
+      setSummary,
+      diff,
+      messages,
+      children,
+      remove,
+      updateMessage,
+      removeMessage,
+      removePart,
+      updatePart,
+      getPart,
+      updatePartDelta,
+      findMessage,
+    })
+  }),
+)
+
+export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Storage.defaultLayer))
+
+export function* list(input?: {
+  directory?: string
+  workspaceID?: WorkspaceID
+  roots?: boolean
+  start?: number
+  search?: string
+  limit?: number
+}) {
+  const project = Instance.project
+  const conditions = [eq(SessionTable.project_id, project.id)]
+
+  if (input?.workspaceID) {
+    conditions.push(eq(SessionTable.workspace_id, input.workspaceID))
+  }
+  if (input?.directory) {
+    conditions.push(eq(SessionTable.directory, input.directory))
+  }
+  if (input?.roots) {
+    conditions.push(isNull(SessionTable.parent_id))
+  }
+  if (input?.start) {
+    conditions.push(gte(SessionTable.time_updated, input.start))
+  }
+  if (input?.search) {
+    conditions.push(like(SessionTable.title, `%${input.search}%`))
+  }
+
+  const limit = input?.limit ?? 100
+
+  const rows = Database.use((db) =>
+    db
+      .select()
+      .from(SessionTable)
+      .where(and(...conditions))
+      .orderBy(desc(SessionTable.time_updated))
+      .limit(limit)
+      .all(),
+  )
+  for (const row of rows) {
+    yield fromRow(row)
+  }
+}
+
+export function* listGlobal(input?: {
+  directory?: string
+  roots?: boolean
+  start?: number
+  cursor?: number
+  search?: string
+  limit?: number
+  archived?: boolean
+}) {
+  const conditions: SQL[] = []
+
+  if (input?.directory) {
+    conditions.push(eq(SessionTable.directory, input.directory))
+  }
+  if (input?.roots) {
+    conditions.push(isNull(SessionTable.parent_id))
+  }
+  if (input?.start) {
+    conditions.push(gte(SessionTable.time_updated, input.start))
+  }
+  if (input?.cursor) {
+    conditions.push(lt(SessionTable.time_updated, input.cursor))
+  }
+  if (input?.search) {
+    conditions.push(like(SessionTable.title, `%${input.search}%`))
+  }
+  if (!input?.archived) {
+    conditions.push(isNull(SessionTable.time_archived))
+  }
+
+  const limit = input?.limit ?? 100
+
+  const rows = Database.use((db) => {
+    const query =
+      conditions.length > 0
+        ? db
+            .select()
+            .from(SessionTable)
+            .where(and(...conditions))
+        : db.select().from(SessionTable)
+    return query.orderBy(desc(SessionTable.time_updated), desc(SessionTable.id)).limit(limit).all()
+  })
+
+  const ids = [...new Set(rows.map((row) => row.project_id))]
+  const projects = new Map<string, ProjectInfo>()
+
+  if (ids.length > 0) {
+    const items = Database.use((db) =>
+      db
+        .select({ id: ProjectTable.id, name: ProjectTable.name, worktree: ProjectTable.worktree })
+        .from(ProjectTable)
+        .where(inArray(ProjectTable.id, ids))
+        .all(),
+    )
+    for (const item of items) {
+      projects.set(item.id, {
+        id: item.id,
+        name: item.name ?? undefined,
+        worktree: item.worktree,
+      })
+    }
+  }
+
+  for (const row of rows) {
+    const project = projects.get(row.project_id) ?? null
+    yield { ...fromRow(row), project }
+  }
+}

packages/opencode/src/session/summary.ts

@@ -3,7 +3,7 @@ import { Effect, Layer, Context } from "effect"
 import { Bus } from "@/bus"
 import { Snapshot } from "@/snapshot"
 import { Storage } from "@/storage"
-import * as Session from "."
+import * as Session from "./session"
 import { MessageV2 } from "./message-v2"
 import { SessionID, MessageID } from "./schema"