Merge branch 'dev' into snapshot-node-shim-stuff

Allows beta releases to include properly signed Windows CLI executables, ensuring consistent security verification across all release channels.

.github/workflows/publish.yml

@@ -114,7 +114,7 @@ jobs:
       - build-cli
       - version
     runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
       AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
@@ -213,7 +213,6 @@ jobs:
     needs:
       - build-cli
       - version
-    if: github.ref_name != 'beta'
     continue-on-error: false
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -390,7 +389,7 @@ jobs:
     needs:
       - build-cli
       - version
-    if: github.repository == 'anomalyco/opencode' && github.ref_name != 'beta'
+    if: github.repository == 'anomalyco/opencode'
     continue-on-error: false
     env:
       AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
@@ -591,13 +590,12 @@ jobs:
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@v4
-        if: github.ref_name != 'beta'
         with:
           name: opencode-cli-signed-windows
           path: packages/opencode/dist
 
       - uses: actions/download-artifact@v4
-        if: needs.version.outputs.release && github.ref_name != 'beta'
+        if: needs.version.outputs.release
         with:
           pattern: latest-yml-*
           path: /tmp/latest-yml

packages/opencode/bin/opencode

@@ -6,20 +6,33 @@ const path = require("path")
 const os = require("os")
 
 function run(target) {
-  const result = childProcess.spawnSync(target, process.argv.slice(2), {
+  const child = childProcess.spawn(target, process.argv.slice(2), {
     stdio: "inherit",
   })
-  if (result.error) {
-    console.error(result.error.message)
+  child.on("error", (err) => {
+    console.error(err.message)
     process.exit(1)
+  })
+  const forward = (sig) => {
+    if (!child.killed) {
+      try { child.kill(sig) } catch {}
+    }
   }
-  const code = typeof result.status === "number" ? result.status : 0
-  process.exit(code)
+  ;["SIGINT", "SIGTERM", "SIGHUP"].forEach((sig) => {
+    process.on(sig, () => forward(sig))
+  })
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal)
+      return
+    }
+    process.exit(typeof code === "number" ? code : 1)
+  })
 }
 
 const envPath = process.env.OPENCODE_BIN_PATH
 if (envPath) {
-  run(envPath)
+  return run(envPath)
 }
 
 const scriptPath = fs.realpathSync(__filename)
@@ -28,7 +41,7 @@ const scriptDir = path.dirname(scriptPath)
 //
 const cached = path.join(scriptDir, ".opencode")
 if (fs.existsSync(cached)) {
-  run(cached)
+  return run(cached)
 }
 
 const platformMap = {

packages/opencode/package.json

@@ -14,18 +14,11 @@
     "fix-node-pty": "bun run script/fix-node-pty.ts",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "dev": "bun run --conditions=browser ./src/index.ts",
-    "random": "echo 'Random script updated at $(date)' && echo 'Change queued successfully' && echo 'Another change made' && echo 'Yet another change' && echo 'One more change' && echo 'Final change' && echo 'Another final change' && echo 'Yet another final change'",
-    "clean": "echo 'Cleaning up...' && rm -rf node_modules dist",
-    "lint": "echo 'Running lint checks...' && bun test --coverage",
-    "format": "echo 'Formatting code...' && bun run --prettier --write src/**/*.ts",
-    "docs": "echo 'Generating documentation...' && find src -name '*.ts' -exec echo 'Processing: {}' \\;",
-    "deploy": "echo 'Deploying application...' && bun run build && echo 'Deployment completed successfully'",
     "db": "bun drizzle-kit"
   },
   "bin": {
     "opencode": "./bin/opencode"
   },
-  "randomField": "this-is-a-random-value-12345",
   "exports": {
     "./*": "./src/*.ts"
   },

packages/opencode/src/cli/cmd/tui/app.tsx

@@ -59,7 +59,6 @@ import { TuiConfigProvider, useTuiConfig } from "./context/tui-config"
 import { TuiConfig } from "@/config/tui"
 import { createTuiApi, TuiPluginRuntime, type RouteMap } from "./plugin"
 import { FormatError, FormatUnknownError } from "@/cli/error"
-import { Keybind } from "@/util/keybind"
 
 async function getTerminalBackgroundColor(): Promise<"dark" | "light"> {
   // can't set raw mode if not a TTY
@@ -311,7 +310,7 @@ function App(props: { onSnapshot?: () => Promise<string[]> }) {
     // - Ctrl+C copies and dismisses selection
     // - Esc dismisses selection
     // - Most other key input dismisses selection and is passed through
-    if (Keybind.matchParsedKey("ctrl+c", evt)) {
+    if (evt.ctrl && evt.name === "c") {
       if (!Selection.copy(renderer, toast)) {
         renderer.clearSelection()
         return

packages/opencode/src/cli/cmd/tui/component/dialog-mcp.tsx

@@ -47,7 +47,7 @@ export function DialogMcp() {
 
   const keybinds = createMemo(() => [
     {
-      keybind: Keybind.parseOne("space"),
+      keybind: Keybind.parse("space")[0],
       title: "toggle",
       onTrigger: async (option: DialogSelectOption<string>) => {
         // Prevent toggling while an operation is already in progress

packages/opencode/src/cli/cmd/tui/component/dialog-session-list.tsx

@@ -162,7 +162,7 @@ export function DialogSessionList() {
           },
         },
         {
-          keybind: Keybind.parseOne("ctrl+w"),
+          keybind: Keybind.parse("ctrl+w")[0],
           title: "new workspace",
           side: "right",
           disabled: !Flag.OPENCODE_EXPERIMENTAL_WORKSPACES,

packages/opencode/src/cli/cmd/tui/component/error-component.tsx

@@ -5,7 +5,6 @@ import { createSignal } from "solid-js"
 import { Installation } from "@/installation"
 import { win32FlushInputBuffer } from "../win32"
 import { getScrollAcceleration } from "../util/scroll"
-import { Keybind } from "@/util/keybind"
 
 export function ErrorComponent(props: {
   error: Error
@@ -26,7 +25,7 @@ export function ErrorComponent(props: {
   }
 
   useKeyboard((evt) => {
-    if (Keybind.matchParsedKey("ctrl+c", evt)) {
+    if (evt.ctrl && evt.name === "c") {
       handleExit()
     }
   })

packages/opencode/src/cli/cmd/tui/ui/dialog-select.tsx

@@ -195,8 +195,8 @@ export function DialogSelect<T>(props: DialogSelectProps<T>) {
   useKeyboard((evt) => {
     setStore("input", "keyboard")
 
-    if (evt.name === "up" || Keybind.matchParsedKey("ctrl+p", evt)) move(-1)
-    if (evt.name === "down" || Keybind.matchParsedKey("ctrl+n", evt)) move(1)
+    if (evt.name === "up" || (evt.ctrl && evt.name === "p")) move(-1)
+    if (evt.name === "down" || (evt.ctrl && evt.name === "n")) move(1)
     if (evt.name === "pageup") move(-10)
     if (evt.name === "pagedown") move(10)
     if (evt.name === "home") moveTo(0)

packages/opencode/src/cli/cmd/tui/ui/dialog.tsx

@@ -6,7 +6,6 @@ import { createStore } from "solid-js/store"
 import { useToast } from "./toast"
 import { Flag } from "@/flag/flag"
 import { Selection } from "@tui/util/selection"
-import { Keybind } from "@/util/keybind"
 
 export function Dialog(
   props: ParentProps<{
@@ -73,13 +72,12 @@ function init() {
   })
 
   const renderer = useRenderer()
+
   useKeyboard((evt) => {
     if (store.stack.length === 0) return
     if (evt.defaultPrevented) return
-    const isCtrlC = Keybind.matchParsedKey("ctrl+c", evt)
-
-    if ((evt.name === "escape" || isCtrlC) && renderer.getSelection()?.getSelectedText()) return
-    if (evt.name === "escape" || isCtrlC) {
+    if ((evt.name === "escape" || (evt.ctrl && evt.name === "c")) && renderer.getSelection()?.getSelectedText()) return
+    if (evt.name === "escape" || (evt.ctrl && evt.name === "c")) {
       if (renderer.getSelection()) {
         renderer.clearSelection()
       }

packages/opencode/src/provider/models-snapshot.d.ts

@@ -1,2 +0,0 @@
-// Auto-generated by build.ts - do not edit
-export declare const snapshot: Record<string, unknown>

packages/opencode/src/snapshot/index.ts

@@ -177,8 +177,39 @@ export namespace Snapshot {
             const all = Array.from(new Set([...tracked, ...untracked]))
             if (!all.length) return
 
+            // Filter out files that are now gitignored even if previously tracked
+            // Files may have been tracked before being gitignored, so we need to check
+            // against the source project's current gitignore rules
+            // Use --no-index to check purely against patterns (ignoring whether file is tracked)
+            const checkArgs = [
+              ...quote,
+              "--git-dir",
+              path.join(state.worktree, ".git"),
+              "--work-tree",
+              state.worktree,
+              "check-ignore",
+              "--no-index",
+              "--",
+              ...all,
+            ]
+            const check = yield* git(checkArgs, { cwd: state.directory })
+            const ignored =
+              check.code === 0 ? new Set(check.text.trim().split("\n").filter(Boolean)) : new Set<string>()
+            const filtered = all.filter((item) => !ignored.has(item))
+
+            // Remove newly-ignored files from snapshot index to prevent re-adding
+            if (ignored.size > 0) {
+              const ignoredFiles = Array.from(ignored)
+              log.info("removing gitignored files from snapshot", { count: ignoredFiles.length })
+              yield* git([...cfg, ...args(["rm", "--cached", "-f", "--", ...ignoredFiles])], {
+                cwd: state.directory,
+              })
+            }
+
+            if (!filtered.length) return
+
             const large = (yield* Effect.all(
-              all.map((item) =>
+              filtered.map((item) =>
                 fs
                   .stat(path.join(state.directory, item))
                   .pipe(Effect.catch(() => Effect.void))
@@ -259,14 +290,39 @@ export namespace Snapshot {
                   log.warn("failed to get diff", { hash, exitCode: result.code })
                   return { hash, files: [] }
                 }
+                const files = result.text
+                  .trim()
+                  .split("\n")
+                  .map((x) => x.trim())
+                  .filter(Boolean)
+
+                // Filter out files that are now gitignored
+                if (files.length > 0) {
+                  const checkArgs = [
+                    ...quote,
+                    "--git-dir",
+                    path.join(state.worktree, ".git"),
+                    "--work-tree",
+                    state.worktree,
+                    "check-ignore",
+                    "--no-index",
+                    "--",
+                    ...files,
+                  ]
+                  const check = yield* git(checkArgs, { cwd: state.directory })
+                  if (check.code === 0) {
+                    const ignored = new Set(check.text.trim().split("\n").filter(Boolean))
+                    const filtered = files.filter((item) => !ignored.has(item))
+                    return {
+                      hash,
+                      files: filtered.map((x) => path.join(state.worktree, x).replaceAll("\\", "/")),
+                    }
+                  }
+                }
+
                 return {
                   hash,
-                  files: result.text
-                    .trim()
-                    .split("\n")
-                    .map((x) => x.trim())
-                    .filter(Boolean)
-                    .map((x) => path.join(state.worktree, x).replaceAll("\\", "/")),
+                  files: files.map((x) => path.join(state.worktree, x).replaceAll("\\", "/")),
                 }
               }),
             )
@@ -616,6 +672,30 @@ export namespace Snapshot {
                       } satisfies Row,
                     ]
                   })
+
+                // Filter out files that are now gitignored
+                if (rows.length > 0) {
+                  const files = rows.map((r) => r.file)
+                  const checkArgs = [
+                    ...quote,
+                    "--git-dir",
+                    path.join(state.worktree, ".git"),
+                    "--work-tree",
+                    state.worktree,
+                    "check-ignore",
+                    "--no-index",
+                    "--",
+                    ...files,
+                  ]
+                  const check = yield* git(checkArgs, { cwd: state.directory })
+                  if (check.code === 0) {
+                    const ignored = new Set(check.text.trim().split("\n").filter(Boolean))
+                    const filtered = rows.filter((r) => !ignored.has(r.file))
+                    rows.length = 0
+                    rows.push(...filtered)
+                  }
+                }
+
                 const step = 100
                 const patch = (file: string, before: string, after: string) =>
                   formatPatch(structuredPatch(file, file, before, after, "", "", { context: Number.MAX_SAFE_INTEGER }))

packages/opencode/src/util/keybind.ts

@@ -6,70 +6,15 @@ export namespace Keybind {
    * Keybind info derived from OpenTUI's ParsedKey with our custom `leader` field.
    * This ensures type compatibility and catches missing fields at compile time.
    */
-  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super" | "baseCode"> & {
+  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super"> & {
     leader: boolean // our custom field
   }
 
-  function getBaseCodeName(baseCode: number | undefined): string | undefined {
-    if (baseCode === undefined || baseCode < 32 || baseCode === 127) {
-      return undefined
-    }
-
-    try {
-      const name = String.fromCodePoint(baseCode)
-
-      if (name.length === 1 && name >= "A" && name <= "Z") {
-        return name.toLowerCase()
-      }
-
-      return name
-    } catch {
-      return undefined
-    }
-  }
-
   export function match(a: Info | undefined, b: Info): boolean {
     if (!a) return false
     const normalizedA = { ...a, super: a.super ?? false }
     const normalizedB = { ...b, super: b.super ?? false }
-    if (isDeepEqual(normalizedA, normalizedB)) {
-      return true
-    }
-
-    const modifiersA = {
-      ctrl: normalizedA.ctrl,
-      meta: normalizedA.meta,
-      shift: normalizedA.shift,
-      super: normalizedA.super,
-      leader: normalizedA.leader,
-    }
-    const modifiersB = {
-      ctrl: normalizedB.ctrl,
-      meta: normalizedB.meta,
-      shift: normalizedB.shift,
-      super: normalizedB.super,
-      leader: normalizedB.leader,
-    }
-
-    if (!isDeepEqual(modifiersA, modifiersB)) {
-      return false
-    }
-
-    return (
-      normalizedA.name === normalizedB.name ||
-      getBaseCodeName(normalizedA.baseCode) === normalizedB.name ||
-      getBaseCodeName(normalizedB.baseCode) === normalizedA.name
-    )
-  }
-
-  export function parseOne(key: string): Info {
-    const parsed = parse(key)
-
-    if (parsed.length !== 1) {
-      throw new Error(`Expected exactly one keybind, got ${parsed.length}: ${key}`)
-    }
-
-    return parsed[0]!
+    return isDeepEqual(normalizedA, normalizedB)
   }
 
   /**
@@ -83,23 +28,10 @@ export namespace Keybind {
       meta: key.meta,
       shift: key.shift,
       super: key.super ?? false,
-      baseCode: key.baseCode,
       leader,
     }
   }
 
-  export function matchParsedKey(binding: Info | string | undefined, key: ParsedKey, leader = false): boolean {
-    const bindings = typeof binding === "string" ? parse(binding) : binding ? [binding] : []
-
-    if (!bindings.length) {
-      return false
-    }
-
-    const parsed = fromParsedKey(key, leader)
-
-    return bindings.some((item) => match(item, parsed))
-  }
-
   export function toString(info: Info | undefined): string {
     if (!info) return ""
     const parts: string[] = []

packages/opencode/src/v2/message.ts

@@ -10,59 +10,106 @@ export namespace Message {
     })),
   )
 
-  export class File extends Schema.Class<File>("Message.File")({
-    url: Schema.String,
+  export class Source extends Schema.Class<Source>("Message.Source")({
+    start: Schema.Number,
+    end: Schema.Number,
+    text: Schema.String,
+  }) {}
+
+  export class FileAttachment extends Schema.Class<FileAttachment>("Message.File.Attachment")({
+    uri: Schema.String,
     mime: Schema.String,
+    name: Schema.String.pipe(Schema.optional),
+    description: Schema.String.pipe(Schema.optional),
+    source: Source.pipe(Schema.optional),
   }) {
     static create(url: string) {
-      return new File({
-        url,
+      return new FileAttachment({
+        uri: url,
         mime: "text/plain",
       })
     }
   }
 
-  export class UserContent extends Schema.Class<UserContent>("Message.User.Content")({
-    text: Schema.String,
-    synthetic: Schema.Boolean.pipe(Schema.optional),
-    agent: Schema.String.pipe(Schema.optional),
-    files: Schema.Array(File).pipe(Schema.optional),
+  export class AgentAttachment extends Schema.Class<AgentAttachment>("Message.Agent.Attachment")({
+    name: Schema.String,
+    source: Source.pipe(Schema.optional),
   }) {}
 
   export class User extends Schema.Class<User>("Message.User")({
     id: ID,
     type: Schema.Literal("user"),
+    text: Schema.String,
+    files: Schema.Array(FileAttachment).pipe(Schema.optional),
+    agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
     time: Schema.Struct({
       created: Schema.DateTimeUtc,
     }),
-    content: UserContent,
   }) {
-    static create(content: Schema.Schema.Type<typeof UserContent>) {
+    static create(input: { text: User["text"]; files?: User["files"]; agents?: User["agents"] }) {
       const msg = new User({
         id: ID.create(),
         type: "user",
+        ...input,
         time: {
           created: Effect.runSync(DateTime.now),
         },
-        content,
       })
       return msg
     }
-
-    static file(url: string) {
-      return new File({
-        url,
-        mime: "text/plain",
-      })
-    }
   }
 
-  export namespace User {}
+  export class Synthetic extends Schema.Class<Synthetic>("Message.Synthetic")({
+    id: ID,
+    type: Schema.Literal("synthetic"),
+    text: Schema.String,
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+  }) {}
+
+  export class Request extends Schema.Class<Request>("Message.Request")({
+    id: ID,
+    type: Schema.Literal("start"),
+    model: Schema.Struct({
+      id: Schema.String,
+      providerID: Schema.String,
+      variant: Schema.String.pipe(Schema.optional),
+    }),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+  }) {}
+
+  export class Text extends Schema.Class<Text>("Message.Text")({
+    id: ID,
+    type: Schema.Literal("text"),
+    text: Schema.String,
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+      completed: Schema.DateTimeUtc.pipe(Schema.optional),
+    }),
+  }) {}
+
+  export class Complete extends Schema.Class<Complete>("Message.Complete")({
+    id: ID,
+    type: Schema.Literal("complete"),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
+    cost: Schema.Number,
+    tokens: Schema.Struct({
+      total: Schema.Number,
+      input: Schema.Number,
+      output: Schema.Number,
+      reasoning: Schema.Number,
+      cache: Schema.Struct({
+        read: Schema.Number,
+        write: Schema.Number,
+      }),
+    }),
+  }) {}
+
+  export const Info = Schema.Union([User, Text])
+  export type Info = Schema.Schema.Type<typeof Info>
 }
-
-const msg = Message.User.create({
-  text: "Hello world",
-  files: [Message.File.create("file://example.com/file.txt")],
-})
-
-console.log(JSON.stringify(msg, null, 2))

packages/opencode/src/v2/session.ts

@@ -0,0 +1,71 @@
+import { Context, Layer, Schema, Effect } from "effect"
+import { Message } from "./message"
+import { Struct } from "effect"
+import { Identifier } from "@/id/id"
+import { withStatics } from "@/util/schema"
+import { Session } from "@/session"
+import { SessionID } from "@/session/schema"
+
+export namespace SessionV2 {
+  export const ID = SessionID
+
+  export type ID = Schema.Schema.Type<typeof ID>
+
+  export class PromptInput extends Schema.Class<PromptInput>("Session.PromptInput")({
+    ...Struct.omit(Message.User.fields, ["time", "type"]),
+    id: Schema.optionalKey(Message.ID),
+    sessionID: SessionV2.ID,
+  }) {}
+
+  export class CreateInput extends Schema.Class<CreateInput>("Session.CreateInput")({
+    id: Schema.optionalKey(SessionV2.ID),
+  }) {}
+
+  export class Info extends Schema.Class<Info>("Session.Info")({
+    id: SessionV2.ID,
+    model: Schema.Struct({
+      id: Schema.String,
+      providerID: Schema.String,
+      modelID: Schema.String,
+    }).pipe(Schema.optional),
+  }) {}
+
+  export interface Interface {
+    fromID: (id: SessionV2.ID) => Effect.Effect<Info>
+    create: (input: CreateInput) => Effect.Effect<Info>
+    prompt: (input: PromptInput) => Effect.Effect<Message.User>
+  }
+
+  export class Service extends Context.Service<Service, Interface>()("Session.Service") {}
+
+  export const layer = Layer.effect(Service)(
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+
+      const create: Interface["create"] = Effect.fn("Session.create")(function* (input) {
+        throw new Error("Not implemented")
+      })
+
+      const prompt: Interface["prompt"] = Effect.fn("Session.prompt")(function* (input) {
+        throw new Error("Not implemented")
+      })
+
+      const fromID: Interface["fromID"] = Effect.fn("Session.fromID")(function* (id) {
+        const match = yield* session.get(id)
+        return fromV1(match)
+      })
+
+      return Service.of({
+        create,
+        prompt,
+        fromID,
+      })
+    }),
+  )
+
+  function fromV1(input: Session.Info): Info {
+    return new Info({
+      id: SessionV2.ID.make(input.id),
+    })
+  }
+}

packages/opencode/test/keybind.test.ts

@@ -162,24 +162,6 @@ describe("Keybind.match", () => {
     expect(Keybind.match(a, b)).toBe(true)
   })
 
-  test("should match ctrl shortcuts by baseCode from alternate layouts", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ", baseCode: 99 }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should still match the reported character when baseCode is also present", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ", baseCode: 99 }
-    expect(Keybind.match(a, b)).toBe(true)
-  })
-
-  test("should not match a different shortcut just because baseCode exists", () => {
-    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
-    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "ㅊ", baseCode: 99 }
-    expect(Keybind.match(a, b)).toBe(false)
-  })
-
   test("should match super+shift combination", () => {
     const a: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
     const b: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
@@ -437,68 +419,3 @@ describe("Keybind.parse", () => {
     ])
   })
 })
-
-describe("Keybind.parseOne", () => {
-  test("should parse a single keybind", () => {
-    expect(Keybind.parseOne("ctrl+x")).toEqual({
-      ctrl: true,
-      meta: false,
-      shift: false,
-      leader: false,
-      name: "x",
-    })
-  })
-
-  test("should reject multiple keybinds", () => {
-    expect(() => Keybind.parseOne("ctrl+x,ctrl+y")).toThrow("Expected exactly one keybind")
-  })
-})
-
-describe("Keybind.fromParsedKey", () => {
-  test("should preserve baseCode from ParsedKey", () => {
-    const result = Keybind.fromParsedKey({
-      name: "ㅊ",
-      ctrl: true,
-      meta: false,
-      shift: false,
-      option: false,
-      number: false,
-      sequence: "ㅊ",
-      raw: "\x1b[12618::99;5u",
-      eventType: "press",
-      source: "kitty",
-      baseCode: 99,
-    })
-
-    expect(result).toEqual({
-      name: "ㅊ",
-      ctrl: true,
-      meta: false,
-      shift: false,
-      super: false,
-      leader: false,
-      baseCode: 99,
-    })
-  })
-
-  test("should ignore leader unless explicitly requested", () => {
-    const key = {
-      name: "ㅊ",
-      ctrl: true,
-      meta: false,
-      shift: false,
-      option: false,
-      number: false,
-      sequence: "ㅊ",
-      raw: "\x1b[12618::99;5u",
-      eventType: "press" as const,
-      source: "kitty" as const,
-      baseCode: 99,
-    }
-
-    expect(Keybind.matchParsedKey("ctrl+c", key)).toBe(true)
-    expect(Keybind.matchParsedKey("ctrl+x,ctrl+c", key)).toBe(true)
-    expect(Keybind.matchParsedKey("ctrl+x,ctrl+y", key)).toBe(false)
-    expect(Keybind.matchParsedKey("ctrl+c", key, true)).toBe(false)
-  })
-})

packages/opencode/test/snapshot/snapshot.test.ts

@@ -511,6 +511,49 @@ test("circular symlinks", async () => {
   })
 })
 
+test("source project gitignore is respected - ignored files are not snapshotted", async () => {
+  await using tmp = await tmpdir({
+    git: true,
+    init: async (dir) => {
+      // Create gitignore BEFORE any tracking
+      await Filesystem.write(`${dir}/.gitignore`, "*.ignored\nbuild/\nnode_modules/\n")
+      await Filesystem.write(`${dir}/tracked.txt`, "tracked content")
+      await Filesystem.write(`${dir}/ignored.ignored`, "ignored content")
+      await $`mkdir -p ${dir}/build`.quiet()
+      await Filesystem.write(`${dir}/build/output.js`, "build output")
+      await Filesystem.write(`${dir}/normal.js`, "normal js")
+      await $`git add .`.cwd(dir).quiet()
+      await $`git commit -m init`.cwd(dir).quiet()
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Modify tracked files and create new ones - some ignored, some not
+      await Filesystem.write(`${tmp.path}/tracked.txt`, "modified tracked")
+      await Filesystem.write(`${tmp.path}/new.ignored`, "new ignored")
+      await Filesystem.write(`${tmp.path}/new-tracked.txt`, "new tracked")
+      await Filesystem.write(`${tmp.path}/build/new-build.js`, "new build file")
+
+      const patch = await Snapshot.patch(before!)
+
+      // Modified and new tracked files should be in snapshot
+      expect(patch.files).toContain(fwd(tmp.path, "new-tracked.txt"))
+      expect(patch.files).toContain(fwd(tmp.path, "tracked.txt"))
+
+      // Ignored files should NOT be in snapshot
+      expect(patch.files).not.toContain(fwd(tmp.path, "new.ignored"))
+      expect(patch.files).not.toContain(fwd(tmp.path, "ignored.ignored"))
+      expect(patch.files).not.toContain(fwd(tmp.path, "build/output.js"))
+      expect(patch.files).not.toContain(fwd(tmp.path, "build/new-build.js"))
+    },
+  })
+})
+
 test("gitignore changes", async () => {
   await using tmp = await bootstrap()
   await Instance.provide({
@@ -535,6 +578,75 @@ test("gitignore changes", async () => {
   })
 })
 
+test("files tracked in snapshot but now gitignored are filtered out", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      // First, create a file and snapshot it
+      await Filesystem.write(`${tmp.path}/later-ignored.txt`, "initial content")
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Modify the file (so it appears in diff-files)
+      await Filesystem.write(`${tmp.path}/later-ignored.txt`, "modified content")
+
+      // Now add gitignore that would exclude this file
+      await Filesystem.write(`${tmp.path}/.gitignore`, "later-ignored.txt\n")
+
+      // Also create another tracked file
+      await Filesystem.write(`${tmp.path}/still-tracked.txt`, "new tracked file")
+
+      const patch = await Snapshot.patch(before!)
+
+      // The file that is now gitignored should NOT appear, even though it was
+      // previously tracked and modified
+      expect(patch.files).not.toContain(fwd(tmp.path, "later-ignored.txt"))
+
+      // The gitignore file itself should appear
+      expect(patch.files).toContain(fwd(tmp.path, ".gitignore"))
+
+      // Other tracked files should appear
+      expect(patch.files).toContain(fwd(tmp.path, "still-tracked.txt"))
+    },
+  })
+})
+
+test("gitignore updated between track calls filters from diff", async () => {
+  await using tmp = await bootstrap()
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      // a.txt is already committed from bootstrap - track it in snapshot
+      const before = await Snapshot.track()
+      expect(before).toBeTruthy()
+
+      // Modify a.txt (so it appears in diff-files)
+      await Filesystem.write(`${tmp.path}/a.txt`, "modified content")
+
+      // Now add gitignore that would exclude a.txt
+      await Filesystem.write(`${tmp.path}/.gitignore`, "a.txt\n")
+
+      // Also modify b.txt which is not gitignored
+      await Filesystem.write(`${tmp.path}/b.txt`, "also modified")
+
+      // Second track - should not include a.txt even though it changed
+      const after = await Snapshot.track()
+      expect(after).toBeTruthy()
+
+      // Verify a.txt is NOT in the diff between snapshots
+      const diffs = await Snapshot.diffFull(before!, after!)
+      expect(diffs.some((x) => x.file === "a.txt")).toBe(false)
+
+      // But .gitignore should be in the diff
+      expect(diffs.some((x) => x.file === ".gitignore")).toBe(true)
+
+      // b.txt should be in the diff (not gitignored)
+      expect(diffs.some((x) => x.file === "b.txt")).toBe(true)
+    },
+  })
+})
+
 test("git info exclude changes", async () => {
   await using tmp = await bootstrap()
   await Instance.provide({