Merge remote-tracking branch 'origin/dev' into fix/1716-disabled-agents-enforcement

# Conflicts: # src/plugin/tool-registry.ts # src/tools/call-omo-agent/tools.test.ts # src/tools/call-omo-agent/tools.ts
2026-02-17 02:04:19 +09:00 · 2026-02-17 02:04:19 +09:00 · ea589e66e8
commit ea589e66e8
parent 56353ae4b2 e299c09ee8
76 changed files with 3369 additions and 300 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -56,6 +56,7 @@ jobs:
          bun test src/cli/doctor/format-default.test.ts
          bun test src/tools/call-omo-agent/sync-executor.test.ts
          bun test src/tools/call-omo-agent/session-creator.test.ts
+          bun test src/tools/session-manager
          bun test src/features/opencode-skill-loader/loader.test.ts

      - name: Run remaining tests
@ -63,7 +64,7 @@ jobs:
          # Enumerate subdirectories/files explicitly to EXCLUDE mock-heavy files
          # that were already run in isolation above.
          # Excluded from src/cli: doctor/formatter.test.ts, doctor/format-default.test.ts
-          # Excluded from src/tools: call-omo-agent/sync-executor.test.ts, call-omo-agent/session-creator.test.ts
+          # Excluded from src/tools: call-omo-agent/sync-executor.test.ts, call-omo-agent/session-creator.test.ts, session-manager (all)
          bun test bin script src/config src/mcp src/index.test.ts \
            src/agents src/shared \
            src/cli/run src/cli/config-manager src/cli/mcp-oauth \
@ -72,7 +73,7 @@ jobs:
            src/cli/doctor/runner.test.ts src/cli/doctor/checks \
            src/tools/ast-grep src/tools/background-task src/tools/delegate-task \
            src/tools/glob src/tools/grep src/tools/interactive-bash \
-            src/tools/look-at src/tools/lsp src/tools/session-manager \
+            src/tools/look-at src/tools/lsp \
            src/tools/skill src/tools/skill-mcp src/tools/slashcommand src/tools/task \
            src/tools/call-omo-agent/background-agent-executor.test.ts \
            src/tools/call-omo-agent/background-executor.test.ts \
--- a/assets/oh-my-opencode.schema.json
+++ b/assets/oh-my-opencode.schema.json
@ -98,7 +98,8 @@
          "stop-continuation-guard",
          "tasks-todowrite-disabler",
          "write-existing-file-guard",
-          "anthropic-effort"
+          "anthropic-effort",
+          "hashline-read-enhancer"
        ]
      }
    },
@ -2830,6 +2831,9 @@
        },
        "safe_hook_creation": {
          "type": "boolean"
+        },
+        "hashline_edit": {
+          "type": "boolean"
        }
      },
      "additionalProperties": false
--- a/bun.lock
+++ b/bun.lock
@ -28,13 +28,13 @@
        "typescript": "^5.7.3",
      },
      "optionalDependencies": {
-        "oh-my-opencode-darwin-arm64": "3.5.5",
-        "oh-my-opencode-darwin-x64": "3.5.5",
-        "oh-my-opencode-linux-arm64": "3.5.5",
-        "oh-my-opencode-linux-arm64-musl": "3.5.5",
-        "oh-my-opencode-linux-x64": "3.5.5",
-        "oh-my-opencode-linux-x64-musl": "3.5.5",
-        "oh-my-opencode-windows-x64": "3.5.5",
+        "oh-my-opencode-darwin-arm64": "3.6.0",
+        "oh-my-opencode-darwin-x64": "3.6.0",
+        "oh-my-opencode-linux-arm64": "3.6.0",
+        "oh-my-opencode-linux-arm64-musl": "3.6.0",
+        "oh-my-opencode-linux-x64": "3.6.0",
+        "oh-my-opencode-linux-x64-musl": "3.6.0",
+        "oh-my-opencode-windows-x64": "3.6.0",
      },
    },
  },
@ -226,19 +226,19 @@

    "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],

-    "oh-my-opencode-darwin-arm64": ["oh-my-opencode-darwin-arm64@3.5.5", "", { "os": "darwin", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-XtcCQ8/iVT6T1B58y0N1oMgOK4beTW8DW98b/ITnINb7b3hNSv5754Af/2Rx67BV0iE0ezC6uXaqz45C7ru1rw=="],
+    "oh-my-opencode-darwin-arm64": ["oh-my-opencode-darwin-arm64@3.6.0", "", { "os": "darwin", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-JkyJC3b9ueRgSyPJMjTKlBO99gIyTpI87lEV5Tk7CBv6TFbj2ZFxfaA8mEm138NbwmYa/Z4Rf7I5tZyp2as93A=="],

-    "oh-my-opencode-darwin-x64": ["oh-my-opencode-darwin-x64@3.5.5", "", { "os": "darwin", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-ReSDqU6jihh7lpGNmEt3REzc5bOcyfv3cMHitpecKq0wRrJoTBI+dgNPk90BLjHobGbhAm0TE8VZ9tqTkivnIQ=="],
+    "oh-my-opencode-darwin-x64": ["oh-my-opencode-darwin-x64@3.6.0", "", { "os": "darwin", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-5HsXz3F42T6CmPk6IW+pErJVSmPnqc3Gc1OntoKp/b4FwuWkFJh9kftDSH3cnKTX98H6XBqnwZoFKCNCiiVLEA=="],

-    "oh-my-opencode-linux-arm64": ["oh-my-opencode-linux-arm64@3.5.5", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-Zs/ETIxwcWBvw+jdlo8t+3+92oMMaXkFg1ZCuZrBRZOmtPFefdsH5/QEIe2TlNSjfoTwlA7cbpOD6oXgxRVrtg=="],
+    "oh-my-opencode-linux-arm64": ["oh-my-opencode-linux-arm64@3.6.0", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-KjCSC2i9XdjzGsX6coP9xwj7naxTpdqnB53TiLbVH+KeF0X0dNsVV7PHbme3I1orjjzYoEbVYVC3ZNaleubzog=="],

-    "oh-my-opencode-linux-arm64-musl": ["oh-my-opencode-linux-arm64-musl@3.5.5", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-m9r4OW1XhGtm/SvHM3kzpS4pEiI2eIh5Tj+j5hpMW3wu+AqE3F1XGUpu8RgvIpupFo8beimJWDYQujqokReQqg=="],
+    "oh-my-opencode-linux-arm64-musl": ["oh-my-opencode-linux-arm64-musl@3.6.0", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-EARvFQXnkqSnwPpKtghmoV5e/JmweJXhjcOrRNvEwQ8HSb4FIhdRmJkTw4Z/EzyoIRTQcY019ALOiBbdIiOUEA=="],

-    "oh-my-opencode-linux-x64": ["oh-my-opencode-linux-x64@3.5.5", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-N6ysF5Pr2C1dyC5Dftzp05RJODgL+EYCWcOV59/UCV152cINlOhg80804o+6XTKV/taOAaboYaQwsBKiCs/BNQ=="],
+    "oh-my-opencode-linux-x64": ["oh-my-opencode-linux-x64@3.6.0", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-jYyew4NKAOM6NrMM0+LlRlz6s1EVMI9cQdK/o0t8uqFheZVeb7u4cBZwwfhJ79j7EWkSWGc0Jdj9G2dOukbDxg=="],

-    "oh-my-opencode-linux-x64-musl": ["oh-my-opencode-linux-x64-musl@3.5.5", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-MOxW1FMTJT3Ze/U2fDedcZUYTFaA9PaKIiqtsBIHOSb+fFgdo51RIuUlKCELN/g9I9dYhw0yP2n9tBMBG6feSg=="],
+    "oh-my-opencode-linux-x64-musl": ["oh-my-opencode-linux-x64-musl@3.6.0", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-BrR+JftCXP/il04q2uImWIueCiuTmXbivsXYkfFONdO1Rq9b4t0BVua9JIYk7l3OUfeRlrKlFNYNfpFhvVADOw=="],

-    "oh-my-opencode-windows-x64": ["oh-my-opencode-windows-x64@3.5.5", "", { "os": "win32", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode.exe" } }, "sha512-dWRtPyIdMFQIw1BwVO4PbGqoo0UWs7NES+YJC7BLGv0YnWN7Q2tatmOviSeSgMELeMsWSbDNisEB79jsfShXjA=="],
+    "oh-my-opencode-windows-x64": ["oh-my-opencode-windows-x64@3.6.0", "", { "os": "win32", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode.exe" } }, "sha512-cIYQYzcQGhGFE99ulHGXs8S1vDHjgCtT3ID2dDoOztnOQW0ZVa61oCHlkBtjdP/BEv2tH5AGvKrXAICXs19iFw=="],

    "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],

--- a/src/agents/builtin-agents.ts
+++ b/src/agents/builtin-agents.ts
@ -13,7 +13,11 @@ import { createAtlasAgent, atlasPromptMetadata } from "./atlas"
 import { createMomusAgent, momusPromptMetadata } from "./momus"
 import { createHephaestusAgent } from "./hephaestus"
 import type { AvailableCategory } from "./dynamic-agent-prompt-builder"
-import { fetchAvailableModels, readConnectedProvidersCache } from "../shared"
+import {
+  fetchAvailableModels,
+  readConnectedProvidersCache,
+  readProviderModelsCache,
+} from "../shared"
 import { CATEGORY_DESCRIPTIONS } from "../tools/delegate-task/constants"
 import { mergeCategories } from "../shared/merge-categories"
 import { buildAvailableSkills } from "./builtin-agents/available-skills"
@ -68,14 +72,20 @@ export async function createBuiltinAgents(
  useTaskSystem = false
 ): Promise<Record<string, AgentConfig>> {
  const connectedProviders = readConnectedProvidersCache()
+  const providerModelsConnected = connectedProviders
+    ? (readProviderModelsCache()?.connected ?? [])
+    : []
+  const mergedConnectedProviders = Array.from(
+    new Set([...(connectedProviders ?? []), ...providerModelsConnected])
+  )
  // IMPORTANT: Do NOT call OpenCode client APIs during plugin initialization.
  // This function is called from config handler, and calling client API causes deadlock.
  // See: https://github.com/code-yeongyu/oh-my-opencode/issues/1301
  const availableModels = await fetchAvailableModels(undefined, {
-    connectedProviders: connectedProviders ?? undefined,
+    connectedProviders: mergedConnectedProviders.length > 0 ? mergedConnectedProviders : undefined,
  })
  const isFirstRunNoCache =
-    availableModels.size === 0 && (!connectedProviders || connectedProviders.length === 0)
+    availableModels.size === 0 && mergedConnectedProviders.length === 0

  const result: Record<string, AgentConfig> = {}

--- a/src/agents/utils.test.ts
+++ b/src/agents/utils.test.ts
@ -428,7 +428,7 @@ describe("createBuiltinAgents with model overrides", () => {
      )

      // #then
-      const matches = agents.sisyphus.prompt.match(/Custom agent: researcher/gi) ?? []
+      const matches = (agents.sisyphus?.prompt ?? "").match(/Custom agent: researcher/gi) ?? []
      expect(matches.length).toBe(1)
    } finally {
      fetchSpy.mockRestore()
@ -525,6 +525,34 @@ describe("createBuiltinAgents without systemDefaultModel", () => {
 })

 describe("createBuiltinAgents with requiresProvider gating (hephaestus)", () => {
+  test("hephaestus is created when provider-models cache connected list includes required provider", async () => {
+    // #given
+    const connectedCacheSpy = spyOn(connectedProvidersCache, "readConnectedProvidersCache").mockReturnValue(["anthropic"])
+    const providerModelsSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockReturnValue({
+      connected: ["openai"],
+      models: {},
+      updatedAt: new Date().toISOString(),
+    })
+    const fetchSpy = spyOn(shared, "fetchAvailableModels").mockImplementation(async (_, options) => {
+      const providers = options?.connectedProviders ?? []
+      return providers.includes("openai")
+        ? new Set(["openai/gpt-5.3-codex"])
+        : new Set(["anthropic/claude-opus-4-6"])
+    })
+
+    try {
+      // #when
+      const agents = await createBuiltinAgents([], {}, undefined, TEST_DEFAULT_MODEL, undefined, undefined, [], {})
+
+      // #then
+      expect(agents.hephaestus).toBeDefined()
+    } finally {
+      connectedCacheSpy.mockRestore()
+      providerModelsSpy.mockRestore()
+      fetchSpy.mockRestore()
+    }
+  })
+
  test("hephaestus is not created when no required provider is connected", async () => {
    // #given - only anthropic models available, not in hephaestus requiresProvider
    const fetchSpy = spyOn(shared, "fetchAvailableModels").mockResolvedValue(
--- a/src/cli/run/integration.test.ts
+++ b/src/cli/run/integration.test.ts
@ -1,9 +1,11 @@
-import { describe, it, expect, mock, spyOn, beforeEach, afterEach } from "bun:test"
+import { describe, it, expect, mock, spyOn, beforeEach, afterEach, afterAll } from "bun:test"
 import type { RunResult } from "./types"
 import { createJsonOutputManager } from "./json-output"
 import { resolveSession } from "./session-resolver"
 import { executeOnCompleteHook } from "./on-complete-hook"
 import type { OpencodeClient } from "./types"
+import * as originalSdk from "@opencode-ai/sdk"
+import * as originalPortUtils from "../../shared/port-utils"

 const mockServerClose = mock(() => {})
 const mockCreateOpencode = mock(() =>
@ -27,6 +29,11 @@ mock.module("../../shared/port-utils", () => ({
  DEFAULT_SERVER_PORT: 4096,
 }))

+afterAll(() => {
+  mock.module("@opencode-ai/sdk", () => originalSdk)
+  mock.module("../../shared/port-utils", () => originalPortUtils)
+})
+
 const { createServerConnection } = await import("./server-connection")

 interface MockWriteStream {
--- a/src/cli/run/server-connection.test.ts
+++ b/src/cli/run/server-connection.test.ts
@ -1,4 +1,7 @@
-import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test"
+import { describe, it, expect, mock, beforeEach, afterEach, afterAll } from "bun:test"
+
+import * as originalSdk from "@opencode-ai/sdk"
+import * as originalPortUtils from "../../shared/port-utils"

 const originalConsole = globalThis.console

@ -25,6 +28,11 @@ mock.module("../../shared/port-utils", () => ({
  DEFAULT_SERVER_PORT: 4096,
 }))

+afterAll(() => {
+  mock.module("@opencode-ai/sdk", () => originalSdk)
+  mock.module("../../shared/port-utils", () => originalPortUtils)
+})
+
 const { createServerConnection } = await import("./server-connection")

 describe("createServerConnection", () => {
--- a/src/config/schema.test.ts
+++ b/src/config/schema.test.ts
@ -553,6 +553,18 @@ describe("BrowserAutomationProviderSchema", () => {
    // then
    expect(result.success).toBe(false)
  })
+
+  test("accepts 'playwright-cli' as valid provider", () => {
+    // given
+    const input = "playwright-cli"
+
+    // when
+    const result = BrowserAutomationProviderSchema.safeParse(input)
+
+    // then
+    expect(result.success).toBe(true)
+    expect(result.data).toBe("playwright-cli")
+  })
 })

 describe("BrowserAutomationConfigSchema", () => {
@ -577,6 +589,17 @@ describe("BrowserAutomationConfigSchema", () => {
    // then
    expect(result.provider).toBe("agent-browser")
  })
+
+  test("accepts playwright-cli provider in config", () => {
+    // given
+    const input = { provider: "playwright-cli" }
+
+    // when
+    const result = BrowserAutomationConfigSchema.parse(input)
+
+    // then
+    expect(result.provider).toBe("playwright-cli")
+  })
 })

 describe("OhMyOpenCodeConfigSchema - browser_automation_engine", () => {
@ -607,6 +630,18 @@ describe("OhMyOpenCodeConfigSchema - browser_automation_engine", () => {
    expect(result.success).toBe(true)
    expect(result.data?.browser_automation_engine).toBeUndefined()
  })
+
+  test("accepts browser_automation_engine with playwright-cli", () => {
+    // given
+    const input = { browser_automation_engine: { provider: "playwright-cli" } }
+
+    // when
+    const result = OhMyOpenCodeConfigSchema.safeParse(input)
+
+    // then
+    expect(result.success).toBe(true)
+    expect(result.data?.browser_automation_engine?.provider).toBe("playwright-cli")
+  })
 })

 describe("ExperimentalConfigSchema feature flags", () => {
@ -663,6 +698,59 @@ describe("ExperimentalConfigSchema feature flags", () => {
      expect(result.data.safe_hook_creation).toBeUndefined()
    }
  })
+
+  test("accepts hashline_edit as true", () => {
+    //#given
+    const config = { hashline_edit: true }
+
+    //#when
+    const result = ExperimentalConfigSchema.safeParse(config)
+
+    //#then
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.hashline_edit).toBe(true)
+    }
+  })
+
+  test("accepts hashline_edit as false", () => {
+    //#given
+    const config = { hashline_edit: false }
+
+    //#when
+    const result = ExperimentalConfigSchema.safeParse(config)
+
+    //#then
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.hashline_edit).toBe(false)
+    }
+  })
+
+  test("hashline_edit is optional", () => {
+    //#given
+    const config = { safe_hook_creation: true }
+
+    //#when
+    const result = ExperimentalConfigSchema.safeParse(config)
+
+    //#then
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.hashline_edit).toBeUndefined()
+    }
+  })
+
+  test("rejects non-boolean hashline_edit", () => {
+    //#given
+    const config = { hashline_edit: "true" }
+
+    //#when
+    const result = ExperimentalConfigSchema.safeParse(config)
+
+    //#then
+    expect(result.success).toBe(false)
+  })
 })

 describe("GitMasterConfigSchema", () => {
--- a/src/config/schema/browser-automation.ts
+++ b/src/config/schema/browser-automation.ts
@ -4,6 +4,7 @@ export const BrowserAutomationProviderSchema = z.enum([
  "playwright",
  "agent-browser",
  "dev-browser",
+  "playwright-cli",
 ])

 export const BrowserAutomationConfigSchema = z.object({
@ -12,6 +13,7 @@ export const BrowserAutomationConfigSchema = z.object({
   * - "playwright": Uses Playwright MCP server (@playwright/mcp) - default
   * - "agent-browser": Uses Vercel's agent-browser CLI (requires: bun add -g agent-browser)
   * - "dev-browser": Uses dev-browser skill with persistent browser state
+   * - "playwright-cli": Uses Playwright CLI (@playwright/cli) - token-efficient CLI alternative
   */
  provider: BrowserAutomationProviderSchema.default("playwright"),
 })
--- a/src/config/schema/experimental.ts
+++ b/src/config/schema/experimental.ts
@ -15,6 +15,8 @@ export const ExperimentalConfigSchema = z.object({
  plugin_load_timeout_ms: z.number().min(1000).optional(),
  /** Wrap hook creation in try/catch to prevent one failing hook from crashing the plugin (default: true at call site) */
  safe_hook_creation: z.boolean().optional(),
+  /** Enable hashline_edit tool for improved file editing with hash-based line anchors */
+  hashline_edit: z.boolean().optional(),
 })

 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>
--- a/src/config/schema/hooks.ts
+++ b/src/config/schema/hooks.ts
@ -45,6 +45,7 @@ export const HookNameSchema = z.enum([
  "tasks-todowrite-disabler",
  "write-existing-file-guard",
  "anthropic-effort",
+  "hashline-read-enhancer",
 ])

 export type HookName = z.infer<typeof HookNameSchema>
--- a/src/create-managers.ts
+++ b/src/create-managers.ts
@ -22,8 +22,9 @@ export function createManagers(args: {
  pluginConfig: OhMyOpenCodeConfig
  tmuxConfig: TmuxConfig
  modelCacheState: ModelCacheState
+  backgroundNotificationHookEnabled: boolean
 }): Managers {
-  const { ctx, pluginConfig, tmuxConfig, modelCacheState } = args
+  const { ctx, pluginConfig, tmuxConfig, modelCacheState, backgroundNotificationHookEnabled } = args

  const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig)

@ -57,6 +58,7 @@ export function createManagers(args: {
          log("[index] tmux cleanup error during shutdown:", error)
        })
      },
+      enableParentSessionNotifications: backgroundNotificationHookEnabled,
    },
  )

--- a/src/features/background-agent/manager.test.ts
+++ b/src/features/background-agent/manager.test.ts
@ -805,6 +805,62 @@ interface CurrentMessage {
 }

 describe("BackgroundManager.notifyParentSession - dynamic message lookup", () => {
+  test("should skip compaction agent and use nearest non-compaction message", async () => {
+    //#given
+    let capturedBody: Record<string, unknown> | undefined
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async (args: { body: Record<string, unknown> }) => {
+          capturedBody = args.body
+          return {}
+        },
+        abort: async () => ({}),
+        messages: async () => ({
+          data: [
+            {
+              info: {
+                agent: "sisyphus",
+                model: { providerID: "anthropic", modelID: "claude-opus-4-6" },
+              },
+            },
+            {
+              info: {
+                agent: "compaction",
+                model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
+              },
+            },
+          ],
+        }),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
+    const task: BackgroundTask = {
+      id: "task-skip-compaction",
+      sessionID: "session-child",
+      parentSessionID: "session-parent",
+      parentMessageID: "msg-parent",
+      description: "task with compaction at tail",
+      prompt: "test",
+      agent: "explore",
+      status: "completed",
+      startedAt: new Date(),
+      completedAt: new Date(),
+      parentAgent: "fallback-agent",
+    }
+    getPendingByParent(manager).set("session-parent", new Set([task.id, "still-running"]))
+
+    //#when
+    await (manager as unknown as { notifyParentSession: (value: BackgroundTask) => Promise<void> })
+      .notifyParentSession(task)
+
+    //#then
+    expect(capturedBody?.agent).toBe("sisyphus")
+    expect(capturedBody?.model).toEqual({ providerID: "anthropic", modelID: "claude-opus-4-6" })
+
+    manager.shutdown()
+  })
+
  test("should use currentMessage model/agent when available", async () => {
    // given - currentMessage has model and agent
    const task: BackgroundTask = {
@ -1003,6 +1059,52 @@ describe("BackgroundManager.notifyParentSession - aborted parent", () => {
  })
 })

+describe("BackgroundManager.notifyParentSession - notifications toggle", () => {
+  test("should skip parent prompt injection when notifications are disabled", async () => {
+    //#given
+    let promptCalled = false
+    const promptMock = async () => {
+      promptCalled = true
+      return {}
+    }
+    const client = {
+      session: {
+        prompt: promptMock,
+        promptAsync: promptMock,
+        abort: async () => ({}),
+        messages: async () => ({ data: [] }),
+      },
+    }
+    const manager = new BackgroundManager(
+      { client, directory: tmpdir() } as unknown as PluginInput,
+      undefined,
+      { enableParentSessionNotifications: false },
+    )
+    const task: BackgroundTask = {
+      id: "task-no-parent-notification",
+      sessionID: "session-child",
+      parentSessionID: "session-parent",
+      parentMessageID: "msg-parent",
+      description: "task notifications disabled",
+      prompt: "test",
+      agent: "explore",
+      status: "completed",
+      startedAt: new Date(),
+      completedAt: new Date(),
+    }
+    getPendingByParent(manager).set("session-parent", new Set([task.id]))
+
+    //#when
+    await (manager as unknown as { notifyParentSession: (task: BackgroundTask) => Promise<void> })
+      .notifyParentSession(task)
+
+    //#then
+    expect(promptCalled).toBe(false)
+
+    manager.shutdown()
+  })
+})
+
 function buildNotificationPromptBody(
  task: BackgroundTask,
  currentMessage: CurrentMessage | null
--- a/src/features/background-agent/manager.ts
+++ b/src/features/background-agent/manager.ts
@ -23,8 +23,8 @@ import {

 import { subagentSessions } from "../claude-code-session-state"
 import { getTaskToastManager } from "../task-toast-manager"
-import { findNearestMessageWithFields, MESSAGE_STORAGE } from "../hook-message-injector"
-import { existsSync, readdirSync } from "node:fs"
+import { MESSAGE_STORAGE, type StoredMessage } from "../hook-message-injector"
+import { existsSync, readFileSync, readdirSync } from "node:fs"
 import { join } from "node:path"

 type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit"
@ -92,6 +92,7 @@ export class BackgroundManager {
  private completionTimers: Map<string, ReturnType<typeof setTimeout>> = new Map()
  private idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>> = new Map()
  private notificationQueueByParent: Map<string, Promise<void>> = new Map()
+  private enableParentSessionNotifications: boolean
  readonly taskHistory = new TaskHistory()

  constructor(
@ -101,6 +102,7 @@ export class BackgroundManager {
      tmuxConfig?: TmuxConfig
      onSubagentSessionCreated?: OnSubagentSessionCreated
      onShutdown?: () => void
+      enableParentSessionNotifications?: boolean
    }
  ) {
    this.tasks = new Map()
@ -113,6 +115,7 @@ export class BackgroundManager {
    this.tmuxEnabled = options?.tmuxConfig?.enabled ?? false
    this.onSubagentSessionCreated = options?.onSubagentSessionCreated
    this.onShutdown = options?.onShutdown
+    this.enableParentSessionNotifications = options?.enableParentSessionNotifications ?? true
    this.registerProcessCleanup()
  }

@ -1203,19 +1206,21 @@ export class BackgroundManager {
      allComplete = true
    }

+    const completedTasks = allComplete
+      ? Array.from(this.tasks.values())
+        .filter(t => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending")
+      : []
+
    const statusText = task.status === "completed" ? "COMPLETED" : task.status === "interrupt" ? "INTERRUPTED" : "CANCELLED"
    const errorInfo = task.error ? `\n**Error:** ${task.error}` : ""
-    
-    let notification: string
-    let completedTasks: BackgroundTask[] = []
-    if (allComplete) {
-      completedTasks = Array.from(this.tasks.values())
-        .filter(t => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending")
-      const completedTasksText = completedTasks
-        .map(t => `- \`${t.id}\`: ${t.description}`)
-        .join("\n")

-      notification = `<system-reminder>
+    let notification: string
+    if (allComplete) {
+        const completedTasksText = completedTasks
+          .map(t => `- \`${t.id}\`: ${t.description}`)
+          .join("\n")
+
+        notification = `<system-reminder>
 [ALL BACKGROUND TASKS COMPLETE]

 **Completed:**
@ -1238,69 +1243,79 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 </system-reminder>`
    }

-    let agent: string | undefined = task.parentAgent
-    let model: { providerID: string; modelID: string } | undefined
+      let agent: string | undefined = task.parentAgent
+      let model: { providerID: string; modelID: string } | undefined

-    try {
-      const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } })
-      const messages = normalizeSDKResponse(messagesResp, [] as Array<{
-        info?: { agent?: string; model?: { providerID: string; modelID: string }; modelID?: string; providerID?: string }
-      }>)
-      for (let i = messages.length - 1; i >= 0; i--) {
-        const info = messages[i].info
-        if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
-          agent = info.agent ?? task.parentAgent
-          model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
-          break
+      if (this.enableParentSessionNotifications) {
+        try {
+          const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } })
+          const messages = normalizeSDKResponse(messagesResp, [] as Array<{
+            info?: { agent?: string; model?: { providerID: string; modelID: string }; modelID?: string; providerID?: string }
+          }>)
+          for (let i = messages.length - 1; i >= 0; i--) {
+            const info = messages[i].info
+            if (isCompactionAgent(info?.agent)) {
+              continue
+            }
+            if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
+              agent = info.agent ?? task.parentAgent
+              model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
+              break
+            }
+          }
+        } catch (error) {
+          if (this.isAbortedSessionError(error)) {
+            log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
+              taskId: task.id,
+              parentSessionID: task.parentSessionID,
+            })
+          }
+          const messageDir = getMessageDir(task.parentSessionID)
+          const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir) : null
+          agent = currentMessage?.agent ?? task.parentAgent
+          model = currentMessage?.model?.providerID && currentMessage?.model?.modelID
+            ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID }
+            : undefined
        }
-      }
-    } catch (error) {
-      if (this.isAbortedSessionError(error)) {
-        log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
-          taskId: task.id,
-          parentSessionID: task.parentSessionID,
-        })
-      }
-      const messageDir = getMessageDir(task.parentSessionID)
-      const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-      agent = currentMessage?.agent ?? task.parentAgent
-      model = currentMessage?.model?.providerID && currentMessage?.model?.modelID
-        ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID }
-        : undefined
-    }

-    log("[background-agent] notifyParentSession context:", {
-      taskId: task.id,
-      resolvedAgent: agent,
-      resolvedModel: model,
-    })
-
-    try {
-      await this.client.session.promptAsync({
-        path: { id: task.parentSessionID },
-        body: {
-          noReply: !allComplete,
-          ...(agent !== undefined ? { agent } : {}),
-          ...(model !== undefined ? { model } : {}),
-          ...(task.parentTools ? { tools: task.parentTools } : {}),
-          parts: [{ type: "text", text: notification }],
-        },
-      })
-      log("[background-agent] Sent notification to parent session:", {
-        taskId: task.id,
-        allComplete,
-        noReply: !allComplete,
-      })
-    } catch (error) {
-      if (this.isAbortedSessionError(error)) {
-        log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
+        log("[background-agent] notifyParentSession context:", {
          taskId: task.id,
-          parentSessionID: task.parentSessionID,
+          resolvedAgent: agent,
+          resolvedModel: model,
        })
+
+        try {
+          await this.client.session.promptAsync({
+            path: { id: task.parentSessionID },
+            body: {
+              noReply: !allComplete,
+              ...(agent !== undefined ? { agent } : {}),
+              ...(model !== undefined ? { model } : {}),
+              ...(task.parentTools ? { tools: task.parentTools } : {}),
+              parts: [{ type: "text", text: notification }],
+            },
+          })
+          log("[background-agent] Sent notification to parent session:", {
+            taskId: task.id,
+            allComplete,
+            noReply: !allComplete,
+          })
+        } catch (error) {
+          if (this.isAbortedSessionError(error)) {
+            log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
+              taskId: task.id,
+              parentSessionID: task.parentSessionID,
+            })
+          } else {
+            log("[background-agent] Failed to send notification:", error)
+          }
+        }
      } else {
-        log("[background-agent] Failed to send notification:", error)
+        log("[background-agent] Parent session notifications disabled, skipping prompt injection:", {
+          taskId: task.id,
+          parentSessionID: task.parentSessionID,
+        })
      }
-    }

    if (allComplete) {
      for (const completedTask of completedTasks) {
@ -1703,3 +1718,57 @@ function getMessageDir(sessionID: string): string | null {
  }
  return null
 }
+
+function isCompactionAgent(agent: string | undefined): boolean {
+  return agent?.trim().toLowerCase() === "compaction"
+}
+
+function hasFullAgentAndModel(message: StoredMessage): boolean {
+  return !!message.agent &&
+    !isCompactionAgent(message.agent) &&
+    !!message.model?.providerID &&
+    !!message.model?.modelID
+}
+
+function hasPartialAgentOrModel(message: StoredMessage): boolean {
+  const hasAgent = !!message.agent && !isCompactionAgent(message.agent)
+  const hasModel = !!message.model?.providerID && !!message.model?.modelID
+  return hasAgent || hasModel
+}
+
+function findNearestMessageExcludingCompaction(messageDir: string): StoredMessage | null {
+  try {
+    const files = readdirSync(messageDir)
+      .filter((name) => name.endsWith(".json"))
+      .sort()
+      .reverse()
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(messageDir, file), "utf-8")
+        const parsed = JSON.parse(content) as StoredMessage
+        if (hasFullAgentAndModel(parsed)) {
+          return parsed
+        }
+      } catch {
+        continue
+      }
+    }
+
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(messageDir, file), "utf-8")
+        const parsed = JSON.parse(content) as StoredMessage
+        if (hasPartialAgentOrModel(parsed)) {
+          return parsed
+        }
+      } catch {
+        continue
+      }
+    }
+  } catch {
+    return null
+  }
+
+  return null
+}
--- a/src/features/background-agent/spawner/parent-directory-resolver.test.ts
+++ b/src/features/background-agent/spawner/parent-directory-resolver.test.ts
@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test"
+
+import { resolveParentDirectory } from "./parent-directory-resolver"
+
+describe("background-agent parent-directory-resolver", () => {
+  const originalPlatform = process.platform
+
+  test("uses current working directory on Windows when parent session directory is AppData", async () => {
+    //#given
+    Object.defineProperty(process, "platform", { value: "win32" })
+    try {
+      const client = {
+        session: {
+          get: async () => ({
+            data: { directory: "C:\\Users\\test\\AppData\\Local\\ai.opencode.desktop" },
+          }),
+        },
+      }
+
+      //#when
+      const result = await resolveParentDirectory({
+        client: client as Parameters<typeof resolveParentDirectory>[0]["client"],
+        parentSessionID: "ses_parent",
+        defaultDirectory: "C:\\Users\\test\\AppData\\Roaming\\opencode",
+      })
+
+      //#then
+      expect(result).toBe(process.cwd())
+    } finally {
+      Object.defineProperty(process, "platform", { value: originalPlatform })
+    }
+  })
+})
--- a/src/features/background-agent/spawner/parent-directory-resolver.ts
+++ b/src/features/background-agent/spawner/parent-directory-resolver.ts
@ -1,5 +1,5 @@
 import type { OpencodeClient } from "../constants"
-import { log } from "../../../shared"
+import { log, resolveSessionDirectory } from "../../../shared"

 export async function resolveParentDirectory(options: {
  client: OpencodeClient
@ -15,7 +15,10 @@ export async function resolveParentDirectory(options: {
      return null
    })

-  const parentDirectory = parentSession?.data?.directory ?? defaultDirectory
+  const parentDirectory = resolveSessionDirectory({
+    parentDirectory: parentSession?.data?.directory,
+    fallbackDirectory: defaultDirectory,
+  })
  log(`[background-agent] Parent dir: ${parentSession?.data?.directory}, using: ${parentDirectory}`)
  return parentDirectory
 }
--- a/src/features/builtin-skills/skills.test.ts
+++ b/src/features/builtin-skills/skills.test.ts
@ -140,4 +140,35 @@ describe("createBuiltinSkills", () => {
 		// #then
 		expect(skills.length).toBe(4)
 	})
+
+	test("returns playwright-cli skill when browserProvider is 'playwright-cli'", () => {
+		// given
+		const options = { browserProvider: "playwright-cli" as const }
+
+		// when
+		const skills = createBuiltinSkills(options)
+
+		// then
+		const playwrightSkill = skills.find((s) => s.name === "playwright")
+		const agentBrowserSkill = skills.find((s) => s.name === "agent-browser")
+		expect(playwrightSkill).toBeDefined()
+		expect(playwrightSkill!.description).toContain("browser")
+		expect(playwrightSkill!.allowedTools).toContain("Bash(playwright-cli:*)")
+		expect(playwrightSkill!.mcpConfig).toBeUndefined()
+		expect(agentBrowserSkill).toBeUndefined()
+	})
+
+	test("playwright-cli skill template contains CLI commands", () => {
+		// given
+		const options = { browserProvider: "playwright-cli" as const }
+
+		// when
+		const skills = createBuiltinSkills(options)
+		const skill = skills.find((s) => s.name === "playwright")
+
+		// then
+		expect(skill!.template).toContain("playwright-cli open")
+		expect(skill!.template).toContain("playwright-cli snapshot")
+		expect(skill!.template).toContain("playwright-cli click")
+	})
 })
--- a/src/features/builtin-skills/skills.ts
+++ b/src/features/builtin-skills/skills.ts
@ -4,6 +4,7 @@ import type { BrowserAutomationProvider } from "../../config/schema"
 import {
  playwrightSkill,
  agentBrowserSkill,
+  playwrightCliSkill,
  frontendUiUxSkill,
  gitMasterSkill,
  devBrowserSkill,
@ -17,7 +18,14 @@ export interface CreateBuiltinSkillsOptions {
 export function createBuiltinSkills(options: CreateBuiltinSkillsOptions = {}): BuiltinSkill[] {
  const { browserProvider = "playwright", disabledSkills } = options

-  const browserSkill = browserProvider === "agent-browser" ? agentBrowserSkill : playwrightSkill
+  let browserSkill: BuiltinSkill
+  if (browserProvider === "agent-browser") {
+    browserSkill = agentBrowserSkill
+  } else if (browserProvider === "playwright-cli") {
+    browserSkill = playwrightCliSkill
+  } else {
+    browserSkill = playwrightSkill
+  }

  const skills = [browserSkill, frontendUiUxSkill, gitMasterSkill, devBrowserSkill]

--- a/src/features/builtin-skills/skills/index.ts
+++ b/src/features/builtin-skills/skills/index.ts
@ -1,4 +1,5 @@
 export { playwrightSkill, agentBrowserSkill } from "./playwright"
+export { playwrightCliSkill } from "./playwright-cli"
 export { frontendUiUxSkill } from "./frontend-ui-ux"
 export { gitMasterSkill } from "./git-master"
 export { devBrowserSkill } from "./dev-browser"
--- a/src/features/builtin-skills/skills/playwright-cli.ts
+++ b/src/features/builtin-skills/skills/playwright-cli.ts
@ -0,0 +1,268 @@
+import type { BuiltinSkill } from "../types"
+
+/**
+ * Playwright CLI skill — token-efficient CLI alternative to the MCP-based playwright skill.
+ *
+ * Uses name "playwright" (not "playwright-cli") because agents hardcode "playwright" as the
+ * canonical browser skill name. The browserProvider config swaps the implementation behind
+ * the same name: "playwright" gives MCP, "playwright-cli" gives this CLI variant.
+ * The binary is still called `playwright-cli` (see allowedTools).
+ */
+export const playwrightCliSkill: BuiltinSkill = {
+  name: "playwright",
+  description: "MUST USE for any browser-related tasks. Browser automation via playwright-cli - verification, browsing, information gathering, web scraping, testing, screenshots, and all browser interactions.",
+  template: `# Browser Automation with playwright-cli
+
+## Quick start
+
+\`\`\`bash
+# open new browser
+playwright-cli open
+# navigate to a page
+playwright-cli goto https://playwright.dev
+# interact with the page using refs from the snapshot
+playwright-cli click e15
+playwright-cli type "page.click"
+playwright-cli press Enter
+# take a screenshot
+playwright-cli screenshot
+# close the browser
+playwright-cli close
+\`\`\`
+
+## Commands
+
+### Core
+
+\`\`\`bash
+playwright-cli open
+# open and navigate right away
+playwright-cli open https://example.com/
+playwright-cli goto https://playwright.dev
+playwright-cli type "search query"
+playwright-cli click e3
+playwright-cli dblclick e7
+playwright-cli fill e5 "user@example.com"
+playwright-cli drag e2 e8
+playwright-cli hover e4
+playwright-cli select e9 "option-value"
+playwright-cli upload ./document.pdf
+playwright-cli check e12
+playwright-cli uncheck e12
+playwright-cli snapshot
+playwright-cli snapshot --filename=after-click.yaml
+playwright-cli eval "document.title"
+playwright-cli eval "el => el.textContent" e5
+playwright-cli dialog-accept
+playwright-cli dialog-accept "confirmation text"
+playwright-cli dialog-dismiss
+playwright-cli resize 1920 1080
+playwright-cli close
+\`\`\`
+
+### Navigation
+
+\`\`\`bash
+playwright-cli go-back
+playwright-cli go-forward
+playwright-cli reload
+\`\`\`
+
+### Keyboard
+
+\`\`\`bash
+playwright-cli press Enter
+playwright-cli press ArrowDown
+playwright-cli keydown Shift
+playwright-cli keyup Shift
+\`\`\`
+
+### Mouse
+
+\`\`\`bash
+playwright-cli mousemove 150 300
+playwright-cli mousedown
+playwright-cli mousedown right
+playwright-cli mouseup
+playwright-cli mouseup right
+playwright-cli mousewheel 0 100
+\`\`\`
+
+### Save as
+
+\`\`\`bash
+playwright-cli screenshot
+playwright-cli screenshot e5
+playwright-cli screenshot --filename=page.png
+playwright-cli pdf --filename=page.pdf
+\`\`\`
+
+### Tabs
+
+\`\`\`bash
+playwright-cli tab-list
+playwright-cli tab-new
+playwright-cli tab-new https://example.com/page
+playwright-cli tab-close
+playwright-cli tab-close 2
+playwright-cli tab-select 0
+\`\`\`
+
+### Storage
+
+\`\`\`bash
+playwright-cli state-save
+playwright-cli state-save auth.json
+playwright-cli state-load auth.json
+
+# Cookies
+playwright-cli cookie-list
+playwright-cli cookie-list --domain=example.com
+playwright-cli cookie-get session_id
+playwright-cli cookie-set session_id abc123
+playwright-cli cookie-set session_id abc123 --domain=example.com --httpOnly --secure
+playwright-cli cookie-delete session_id
+playwright-cli cookie-clear
+
+# LocalStorage
+playwright-cli localstorage-list
+playwright-cli localstorage-get theme
+playwright-cli localstorage-set theme dark
+playwright-cli localstorage-delete theme
+playwright-cli localstorage-clear
+
+# SessionStorage
+playwright-cli sessionstorage-list
+playwright-cli sessionstorage-get step
+playwright-cli sessionstorage-set step 3
+playwright-cli sessionstorage-delete step
+playwright-cli sessionstorage-clear
+\`\`\`
+
+### Network
+
+\`\`\`bash
+playwright-cli route "**/*.jpg" --status=404
+playwright-cli route "https://api.example.com/**" --body='{"mock": true}'
+playwright-cli route-list
+playwright-cli unroute "**/*.jpg"
+playwright-cli unroute
+\`\`\`
+
+### DevTools
+
+\`\`\`bash
+playwright-cli console
+playwright-cli console warning
+playwright-cli network
+playwright-cli run-code "async page => await page.context().grantPermissions(['geolocation'])"
+playwright-cli tracing-start
+playwright-cli tracing-stop
+playwright-cli video-start
+playwright-cli video-stop video.webm
+\`\`\`
+
+### Install
+
+\`\`\`bash
+playwright-cli install --skills
+playwright-cli install-browser
+\`\`\`
+
+### Configuration
+\`\`\`bash
+# Use specific browser when creating session
+playwright-cli open --browser=chrome
+playwright-cli open --browser=firefox
+playwright-cli open --browser=webkit
+playwright-cli open --browser=msedge
+# Connect to browser via extension
+playwright-cli open --extension
+
+# Use persistent profile (by default profile is in-memory)
+playwright-cli open --persistent
+# Use persistent profile with custom directory
+playwright-cli open --profile=/path/to/profile
+
+# Start with config file
+playwright-cli open --config=my-config.json
+
+# Close the browser
+playwright-cli close
+# Delete user data for the default session
+playwright-cli delete-data
+\`\`\`
+
+### Browser Sessions
+
+\`\`\`bash
+# create new browser session named "mysession" with persistent profile
+playwright-cli -s=mysession open example.com --persistent
+# same with manually specified profile directory (use when requested explicitly)
+playwright-cli -s=mysession open example.com --profile=/path/to/profile
+playwright-cli -s=mysession click e6
+playwright-cli -s=mysession close  # stop a named browser
+playwright-cli -s=mysession delete-data  # delete user data for persistent session
+
+playwright-cli list
+# Close all browsers
+playwright-cli close-all
+# Forcefully kill all browser processes
+playwright-cli kill-all
+\`\`\`
+
+## Example: Form submission
+
+\`\`\`bash
+playwright-cli open https://example.com/form
+playwright-cli snapshot
+
+playwright-cli fill e1 "user@example.com"
+playwright-cli fill e2 "password123"
+playwright-cli click e3
+playwright-cli snapshot
+playwright-cli close
+\`\`\`
+
+## Example: Multi-tab workflow
+
+\`\`\`bash
+playwright-cli open https://example.com
+playwright-cli tab-new https://example.com/other
+playwright-cli tab-list
+playwright-cli tab-select 0
+playwright-cli snapshot
+playwright-cli close
+\`\`\`
+
+## Example: Debugging with DevTools
+
+\`\`\`bash
+playwright-cli open https://example.com
+playwright-cli click e4
+playwright-cli fill e7 "test"
+playwright-cli console
+playwright-cli network
+playwright-cli close
+\`\`\`
+
+\`\`\`bash
+playwright-cli open https://example.com
+playwright-cli tracing-start
+playwright-cli click e4
+playwright-cli fill e7 "test"
+playwright-cli tracing-stop
+playwright-cli close
+\`\`\`
+
+## Specific tasks
+
+* **Request mocking** [references/request-mocking.md](references/request-mocking.md)
+* **Running Playwright code** [references/running-code.md](references/running-code.md)
+* **Browser session management** [references/session-management.md](references/session-management.md)
+* **Storage state (cookies, localStorage)** [references/storage-state.md](references/storage-state.md)
+* **Test generation** [references/test-generation.md](references/test-generation.md)
+* **Tracing** [references/tracing.md](references/tracing.md)
+* **Video recording** [references/video-recording.md](references/video-recording.md)`,
+  allowedTools: ["Bash(playwright-cli:*)"],
+}
--- a/src/features/tmux-subagent/action-executor-core.ts
+++ b/src/features/tmux-subagent/action-executor-core.ts
@ -0,0 +1,75 @@
+import type { TmuxConfig } from "../../config/schema"
+import type { applyLayout, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane, spawnTmuxPane } from "../../shared/tmux"
+import type { PaneAction, WindowState } from "./types"
+
+export interface ActionResult {
+	success: boolean
+	paneId?: string
+	error?: string
+}
+
+export interface ExecuteContext {
+	config: TmuxConfig
+	serverUrl: string
+	windowState: WindowState
+}
+
+export interface ActionExecutorDeps {
+	spawnTmuxPane: typeof spawnTmuxPane
+	closeTmuxPane: typeof closeTmuxPane
+	replaceTmuxPane: typeof replaceTmuxPane
+	applyLayout: typeof applyLayout
+	enforceMainPaneWidth: typeof enforceMainPaneWidth
+}
+
+async function enforceMainPane(windowState: WindowState, deps: ActionExecutorDeps): Promise<void> {
+	if (!windowState.mainPane) return
+	await deps.enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth)
+}
+
+export async function executeActionWithDeps(
+	action: PaneAction,
+	ctx: ExecuteContext,
+	deps: ActionExecutorDeps,
+): Promise<ActionResult> {
+	if (action.type === "close") {
+		const success = await deps.closeTmuxPane(action.paneId)
+		if (success) {
+			await enforceMainPane(ctx.windowState, deps)
+		}
+		return { success }
+	}
+
+	if (action.type === "replace") {
+		const result = await deps.replaceTmuxPane(
+			action.paneId,
+			action.newSessionId,
+			action.description,
+			ctx.config,
+			ctx.serverUrl,
+		)
+		return {
+			success: result.success,
+			paneId: result.paneId,
+		}
+	}
+
+	const result = await deps.spawnTmuxPane(
+		action.sessionId,
+		action.description,
+		ctx.config,
+		ctx.serverUrl,
+		action.targetPaneId,
+		action.splitDirection,
+	)
+
+	if (result.success) {
+		await deps.applyLayout(ctx.config.layout, ctx.config.main_pane_size)
+		await enforceMainPane(ctx.windowState, deps)
+	}
+
+	return {
+		success: result.success,
+		paneId: result.paneId,
+	}
+}
--- a/src/features/tmux-subagent/action-executor.test.ts
+++ b/src/features/tmux-subagent/action-executor.test.ts
@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test"
+import type { TmuxConfig } from "../../config/schema"
+import { executeActionWithDeps } from "./action-executor-core"
+import type { ActionExecutorDeps, ExecuteContext } from "./action-executor-core"
+import type { WindowState } from "./types"
+
+const mockSpawnTmuxPane = mock(async () => ({ success: true, paneId: "%7" }))
+const mockCloseTmuxPane = mock(async () => true)
+const mockEnforceMainPaneWidth = mock(async () => undefined)
+const mockReplaceTmuxPane = mock(async () => ({ success: true, paneId: "%7" }))
+const mockApplyLayout = mock(async () => undefined)
+
+const mockDeps: ActionExecutorDeps = {
+	spawnTmuxPane: mockSpawnTmuxPane,
+	closeTmuxPane: mockCloseTmuxPane,
+	enforceMainPaneWidth: mockEnforceMainPaneWidth,
+	replaceTmuxPane: mockReplaceTmuxPane,
+	applyLayout: mockApplyLayout,
+}
+
+function createConfig(overrides?: Partial<TmuxConfig>): TmuxConfig {
+	return {
+		enabled: true,
+		layout: "main-horizontal",
+		main_pane_size: 55,
+		main_pane_min_width: 120,
+		agent_pane_min_width: 40,
+		...overrides,
+	}
+}
+
+function createWindowState(overrides?: Partial<WindowState>): WindowState {
+	return {
+		windowWidth: 220,
+		windowHeight: 44,
+		mainPane: {
+			paneId: "%0",
+			width: 110,
+			height: 44,
+			left: 0,
+			top: 0,
+			title: "main",
+			isActive: true,
+		},
+		agentPanes: [],
+		...overrides,
+	}
+}
+
+function createContext(overrides?: Partial<ExecuteContext>): ExecuteContext {
+	return {
+		config: createConfig(),
+		serverUrl: "http://localhost:4096",
+		windowState: createWindowState(),
+		...overrides,
+	}
+}
+
+describe("executeAction", () => {
+	beforeEach(() => {
+		mockSpawnTmuxPane.mockClear()
+		mockCloseTmuxPane.mockClear()
+		mockEnforceMainPaneWidth.mockClear()
+		mockReplaceTmuxPane.mockClear()
+		mockApplyLayout.mockClear()
+		mockSpawnTmuxPane.mockImplementation(async () => ({ success: true, paneId: "%7" }))
+	})
+
+	test("applies configured tmux layout after successful spawn", async () => {
+		// given
+		// when
+		const result = await executeActionWithDeps(
+			{
+				type: "spawn",
+				sessionId: "ses_new",
+				description: "background task",
+				targetPaneId: "%0",
+				splitDirection: "-h",
+			},
+			createContext(),
+			mockDeps,
+		)
+
+		// then
+		expect(result).toEqual({ success: true, paneId: "%7" })
+		expect(mockApplyLayout).toHaveBeenCalledTimes(1)
+		expect(mockApplyLayout).toHaveBeenCalledWith("main-horizontal", 55)
+		expect(mockEnforceMainPaneWidth).toHaveBeenCalledTimes(1)
+	})
+
+	test("does not apply layout when spawn fails", async () => {
+		// given
+		mockSpawnTmuxPane.mockImplementationOnce(async () => ({ success: false }))
+
+		// when
+		const result = await executeActionWithDeps(
+			{
+				type: "spawn",
+				sessionId: "ses_new",
+				description: "background task",
+				targetPaneId: "%0",
+				splitDirection: "-h",
+			},
+			createContext(),
+			mockDeps,
+		)
+
+		// then
+		expect(result).toEqual({ success: false, paneId: undefined })
+		expect(mockApplyLayout).not.toHaveBeenCalled()
+		expect(mockEnforceMainPaneWidth).not.toHaveBeenCalled()
+	})
+})
--- a/src/features/tmux-subagent/action-executor.ts
+++ b/src/features/tmux-subagent/action-executor.ts
@ -1,13 +1,14 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { PaneAction, WindowState } from "./types"
-import { spawnTmuxPane, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane } from "../../shared/tmux"
+import type { PaneAction } from "./types"
+import { applyLayout, spawnTmuxPane, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane } from "../../shared/tmux"
 import { log } from "../../shared"
+import type {
+  ActionExecutorDeps,
+  ActionResult,
+  ExecuteContext,
+} from "./action-executor-core"
+import { executeActionWithDeps } from "./action-executor-core"

-export interface ActionResult {
-  success: boolean
-  paneId?: string
-  error?: string
-}
+export type { ActionExecutorDeps, ActionResult, ExecuteContext } from "./action-executor-core"

 export interface ExecuteActionsResult {
  success: boolean
@ -15,60 +16,19 @@ export interface ExecuteActionsResult {
  results: Array<{ action: PaneAction; result: ActionResult }>
 }

-export interface ExecuteContext {
-  config: TmuxConfig
-  serverUrl: string
-  windowState: WindowState
-}
-
-async function enforceMainPane(windowState: WindowState): Promise<void> {
-  if (!windowState.mainPane) return
-  await enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth)
+const DEFAULT_DEPS: ActionExecutorDeps = {
+  spawnTmuxPane,
+  closeTmuxPane,
+  replaceTmuxPane,
+  applyLayout,
+  enforceMainPaneWidth,
 }

 export async function executeAction(
  action: PaneAction,
  ctx: ExecuteContext
 ): Promise<ActionResult> {
-  if (action.type === "close") {
-    const success = await closeTmuxPane(action.paneId)
-    if (success) {
-      await enforceMainPane(ctx.windowState)
-    }
-    return { success }
-  }
-
-  if (action.type === "replace") {
-    const result = await replaceTmuxPane(
-      action.paneId,
-      action.newSessionId,
-      action.description,
-      ctx.config,
-      ctx.serverUrl
-    )
-    return {
-      success: result.success,
-      paneId: result.paneId,
-    }
-  }
-
-  const result = await spawnTmuxPane(
-    action.sessionId,
-    action.description,
-    ctx.config,
-    ctx.serverUrl,
-    action.targetPaneId,
-    action.splitDirection
-  )
-
-  if (result.success) {
-    await enforceMainPane(ctx.windowState)
-  }
-
-  return {
-    success: result.success,
-    paneId: result.paneId,
-  }
+  return executeActionWithDeps(action, ctx, DEFAULT_DEPS)
 }

 export async function executeActions(
--- a/src/features/tmux-subagent/manager.test.ts
+++ b/src/features/tmux-subagent/manager.test.ts
@ -55,6 +55,7 @@ mock.module('./pane-state-querier', () => ({
 mock.module('./action-executor', () => ({
  executeActions: mockExecuteActions,
  executeAction: mockExecuteAction,
+  executeActionWithDeps: mockExecuteAction,
 }))

 mock.module('../../shared/tmux', () => {
--- a/src/hooks/anthropic-context-window-limit-recovery/recovery-deduplication.test.ts
+++ b/src/hooks/anthropic-context-window-limit-recovery/recovery-deduplication.test.ts
@ -1,6 +1,7 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test"
 import type { PluginInput } from "@opencode-ai/plugin"
 import type { ExperimentalConfig } from "../../config"
+import * as originalDeduplicationRecovery from "./deduplication-recovery"

 const attemptDeduplicationRecoveryMock = mock(async () => {})

@ -8,6 +9,10 @@ mock.module("./deduplication-recovery", () => ({
  attemptDeduplicationRecovery: attemptDeduplicationRecoveryMock,
 }))

+afterAll(() => {
+  mock.module("./deduplication-recovery", () => originalDeduplicationRecovery)
+})
+
 function createImmediateTimeouts(): () => void {
  const originalSetTimeout = globalThis.setTimeout
  const originalClearTimeout = globalThis.clearTimeout
--- a/src/hooks/anthropic-context-window-limit-recovery/storage.test.ts
+++ b/src/hooks/anthropic-context-window-limit-recovery/storage.test.ts
@ -1,4 +1,4 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test"
+import { describe, test, expect, mock, beforeEach, afterAll } from "bun:test"
 import { truncateUntilTargetTokens } from "./storage"
 import * as storage from "./storage"

@ -11,6 +11,10 @@ mock.module("./storage", () => {
  }
 })

+afterAll(() => {
+  mock.module("./storage", () => storage)
+})
+
 describe("truncateUntilTargetTokens", () => {
  const sessionID = "test-session"
  
--- a/src/hooks/anthropic-effort/hook.ts
+++ b/src/hooks/anthropic-effort/hook.ts
@ -7,7 +7,7 @@ function normalizeModelID(modelID: string): string {
 }

 function isClaudeProvider(providerID: string, modelID: string): boolean {
-  if (["anthropic", "opencode"].includes(providerID)) return true
+  if (["anthropic", "google-vertex-anthropic", "opencode"].includes(providerID)) return true
  if (providerID === "github-copilot" && modelID.toLowerCase().includes("claude")) return true
  return false
 }
--- a/src/hooks/anthropic-effort/index.test.ts
+++ b/src/hooks/anthropic-effort/index.test.ts
@ -88,6 +88,21 @@ describe("createAnthropicEffortHook", () => {
      expect(output.options.effort).toBe("max")
    })

+    it("should inject effort max for google-vertex-anthropic provider", async () => {
+      //#given google-vertex-anthropic provider with claude-opus-4-6
+      const hook = createAnthropicEffortHook()
+      const { input, output } = createMockParams({
+        providerID: "google-vertex-anthropic",
+        modelID: "claude-opus-4-6",
+      })
+
+      //#when chat.params hook is called
+      await hook["chat.params"](input, output)
+
+      //#then effort should be injected
+      expect(output.options.effort).toBe("max")
+    })
+
    it("should handle normalized model ID with dots (opus-4.6)", async () => {
      //#given model ID with dots instead of hyphens
      const hook = createAnthropicEffortHook()
--- a/src/hooks/compaction-todo-preserver/index.test.ts
+++ b/src/hooks/compaction-todo-preserver/index.test.ts
@ -1,5 +1,7 @@
-import { describe, expect, it, mock } from "bun:test"
+import { describe, expect, it, afterAll, mock } from "bun:test"
 import type { PluginInput } from "@opencode-ai/plugin"
+import { createOpencodeClient } from "@opencode-ai/sdk"
+import type { Todo } from "@opencode-ai/sdk"
 import { createCompactionTodoPreserverHook } from "./index"

 const updateMock = mock(async () => {})
@ -10,27 +12,37 @@ mock.module("opencode/session/todo", () => ({
  },
 }))

-type TodoSnapshot = {
-  id: string
-  content: string
-  status: "pending" | "in_progress" | "completed" | "cancelled"
-  priority?: "low" | "medium" | "high"
-}
-
-function createMockContext(todoResponses: TodoSnapshot[][]): PluginInput {
-  let callIndex = 0
-  return {
-    client: {
-      session: {
-        todo: async () => {
-          const current = todoResponses[Math.min(callIndex, todoResponses.length - 1)] ?? []
-          callIndex += 1
-          return { data: current }
-        },
-      },
+afterAll(() => {
+  mock.module("opencode/session/todo", () => ({
+    Todo: {
+      update: async () => {},
    },
+  }))
+})
+
+function createMockContext(todoResponses: Array<Todo>[]): PluginInput {
+  let callIndex = 0
+
+  const client = createOpencodeClient({ directory: "/tmp/test" })
+  type SessionTodoOptions = Parameters<typeof client.session.todo>[0]
+  type SessionTodoResult = ReturnType<typeof client.session.todo>
+
+  const request = new Request("http://localhost")
+  const response = new Response()
+  client.session.todo = mock((_: SessionTodoOptions): SessionTodoResult => {
+    const current = todoResponses[Math.min(callIndex, todoResponses.length - 1)] ?? []
+    callIndex += 1
+    return Promise.resolve({ data: current, error: undefined, request, response })
+  })
+
+  return {
+    client,
+    project: { id: "test-project", worktree: "/tmp/test", time: { created: Date.now() } },
    directory: "/tmp/test",
-  } as PluginInput
+    worktree: "/tmp/test",
+    serverUrl: new URL("http://localhost"),
+    $: Bun.$,
+  }
 }

 describe("compaction-todo-preserver", () => {
@ -38,7 +50,7 @@ describe("compaction-todo-preserver", () => {
    //#given
    updateMock.mockClear()
    const sessionID = "session-compaction-missing"
-    const todos = [
+    const todos: Todo[] = [
      { id: "1", content: "Task 1", status: "pending", priority: "high" },
      { id: "2", content: "Task 2", status: "in_progress", priority: "medium" },
    ]
@ -58,7 +70,7 @@ describe("compaction-todo-preserver", () => {
    //#given
    updateMock.mockClear()
    const sessionID = "session-compaction-present"
-    const todos = [
+    const todos: Todo[] = [
      { id: "1", content: "Task 1", status: "pending", priority: "high" },
    ]
    const ctx = createMockContext([todos, todos])
--- a/src/hooks/context-window-monitor.test.ts
+++ b/src/hooks/context-window-monitor.test.ts
@ -113,6 +113,42 @@ describe("context-window-monitor", () => {
    expect(ctx.client.session.messages).not.toHaveBeenCalled()
  })

+  it("should append context reminder for google-vertex-anthropic provider", async () => {
+    //#given cached usage for google-vertex-anthropic above threshold
+    const hook = createContextWindowMonitorHook(ctx as never)
+    const sessionID = "ses_vertex_anthropic_high_usage"
+
+    await hook.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            role: "assistant",
+            sessionID,
+            providerID: "google-vertex-anthropic",
+            finish: true,
+            tokens: {
+              input: 150000,
+              output: 1000,
+              reasoning: 0,
+              cache: { read: 10000, write: 0 },
+            },
+          },
+        },
+      },
+    })
+
+    //#when tool.execute.after runs
+    const output = { title: "", output: "original", metadata: null }
+    await hook["tool.execute.after"](
+      { tool: "bash", sessionID, callID: "call_1" },
+      output
+    )
+
+    //#then context reminder should be appended
+    expect(output.output).toContain("context remaining")
+  })
+
  // #given session is deleted
  // #when session.deleted event fires
  // #then cached data should be cleaned up
--- a/src/hooks/context-window-monitor.ts
+++ b/src/hooks/context-window-monitor.ts
@ -27,6 +27,10 @@ interface CachedTokenState {
  tokens: TokenInfo
 }

+function isAnthropicProvider(providerID: string): boolean {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic"
+}
+
 export function createContextWindowMonitorHook(_ctx: PluginInput) {
  const remindedSessions = new Set<string>()
  const tokenCache = new Map<string, CachedTokenState>()
@ -42,7 +46,7 @@ export function createContextWindowMonitorHook(_ctx: PluginInput) {
    const cached = tokenCache.get(sessionID)
    if (!cached) return

-    if (cached.providerID !== "anthropic") return
+    if (!isAnthropicProvider(cached.providerID)) return

    const lastTokens = cached.tokens
    const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
--- a/src/hooks/hashline-read-enhancer/hook.ts
+++ b/src/hooks/hashline-read-enhancer/hook.ts
@ -0,0 +1,66 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { computeLineHash } from "../../tools/hashline-edit/hash-computation"
+
+interface HashlineReadEnhancerConfig {
+  hashline_edit?: { enabled: boolean }
+}
+
+const READ_LINE_PATTERN = /^(\d+): (.*)$/
+
+function isReadTool(toolName: string): boolean {
+  return toolName.toLowerCase() === "read"
+}
+
+function shouldProcess(config: HashlineReadEnhancerConfig): boolean {
+  return config.hashline_edit?.enabled ?? false
+}
+
+function isTextFile(output: string): boolean {
+  const firstLine = output.split("\n")[0] ?? ""
+  return READ_LINE_PATTERN.test(firstLine)
+}
+
+function transformLine(line: string): string {
+  const match = READ_LINE_PATTERN.exec(line)
+  if (!match) {
+    return line
+  }
+  const lineNumber = parseInt(match[1], 10)
+  const content = match[2]
+  const hash = computeLineHash(lineNumber, content)
+  return `${lineNumber}:${hash}|${content}`
+}
+
+function transformOutput(output: string): string {
+  if (!output) {
+    return output
+  }
+  if (!isTextFile(output)) {
+    return output
+  }
+  const lines = output.split("\n")
+  return lines.map(transformLine).join("\n")
+}
+
+export function createHashlineReadEnhancerHook(
+  _ctx: PluginInput,
+  config: HashlineReadEnhancerConfig
+) {
+  return {
+    "tool.execute.after": async (
+      input: { tool: string; sessionID: string; callID: string },
+      output: { title: string; output: string; metadata: unknown }
+    ) => {
+      if (!isReadTool(input.tool)) {
+        return
+      }
+      if (typeof output.output !== "string") {
+        return
+      }
+      if (!shouldProcess(config)) {
+        return
+      }
+      output.output = transformOutput(output.output)
+    },
+  }
+}
--- a/src/hooks/hashline-read-enhancer/index.test.ts
+++ b/src/hooks/hashline-read-enhancer/index.test.ts
@ -0,0 +1,248 @@
+import { describe, it, expect, beforeEach } from "bun:test"
+import { createHashlineReadEnhancerHook } from "./hook"
+import type { PluginInput } from "@opencode-ai/plugin"
+
+//#given - Test setup helpers
+function createMockContext(): PluginInput {
+  return {
+    client: {} as unknown as PluginInput["client"],
+    directory: "/test",
+  }
+}
+
+interface TestConfig {
+  hashline_edit?: { enabled: boolean }
+}
+
+function createMockConfig(enabled: boolean): TestConfig {
+  return {
+    hashline_edit: { enabled },
+  }
+}
+
+describe("createHashlineReadEnhancerHook", () => {
+  let mockCtx: PluginInput
+  const sessionID = "test-session-123"
+
+  beforeEach(() => {
+    mockCtx = createMockContext()
+  })
+
+  describe("tool name matching", () => {
+    it("should process 'read' tool (lowercase)", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: hello\n2: world", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toContain("1:")
+      expect(output.output).toContain("|")
+    })
+
+    it("should process 'Read' tool (mixed case)", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "Read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: hello\n2: world", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toContain("|")
+    })
+
+    it("should process 'READ' tool (uppercase)", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "READ", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: hello\n2: world", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toContain("|")
+    })
+
+    it("should skip non-read tools", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "edit", sessionID, callID: "call-1" }
+      const originalOutput = "1: hello\n2: world"
+      const output = { title: "Edit", output: originalOutput, metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBe(originalOutput)
+    })
+  })
+
+  describe("config flag check", () => {
+    it("should skip when hashline_edit is disabled", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(false))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const originalOutput = "1: hello\n2: world"
+      const output = { title: "Read", output: originalOutput, metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBe(originalOutput)
+    })
+
+    it("should skip when hashline_edit config is missing", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, {})
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const originalOutput = "1: hello\n2: world"
+      const output = { title: "Read", output: originalOutput, metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBe(originalOutput)
+    })
+  })
+
+  describe("output transformation", () => {
+    it("should transform 'N: content' format to 'N:HASH|content'", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: function hello() {\n2:   console.log('world')\n3: }", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      const lines = output.output.split("\n")
+      expect(lines[0]).toMatch(/^1:[a-f0-9]{2}\|function hello\(\) \{$/)
+      expect(lines[1]).toMatch(/^2:[a-f0-9]{2}\|  console\.log\('world'\)$/)
+      expect(lines[2]).toMatch(/^3:[a-f0-9]{2}\|\}$/)
+    })
+
+    it("should handle empty output", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBe("")
+    })
+
+    it("should handle single line", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: const x = 1", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toMatch(/^1:[a-f0-9]{2}\|const x = 1$/)
+    })
+  })
+
+  describe("binary file detection", () => {
+    it("should skip binary files (no line number prefix)", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const originalOutput = "PNG\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"
+      const output = { title: "Read", output: originalOutput, metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBe(originalOutput)
+    })
+
+    it("should skip if first line doesn't match pattern", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const originalOutput = "some binary data\nmore data"
+      const output = { title: "Read", output: originalOutput, metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBe(originalOutput)
+    })
+
+    it("should process if first line matches 'N: ' pattern", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: valid line\n2: another line", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toContain("|")
+    })
+  })
+
+  describe("edge cases", () => {
+    it("should handle non-string output gracefully", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: null as unknown as string, metadata: {} }
+
+      //#when - should not throw
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toBeNull()
+    })
+
+    it("should handle lines with no content after colon", async () => {
+      //#given
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: "1: hello\n2: \n3: world", metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      const lines = output.output.split("\n")
+      expect(lines[0]).toMatch(/^1:[a-f0-9]{2}\|hello$/)
+      expect(lines[1]).toMatch(/^2:[a-f0-9]{2}\|$/)
+      expect(lines[2]).toMatch(/^3:[a-f0-9]{2}\|world$/)
+    })
+
+    it("should handle very long lines", async () => {
+      //#given
+      const longContent = "a".repeat(1000)
+      const hook = createHashlineReadEnhancerHook(mockCtx, createMockConfig(true))
+      const input = { tool: "read", sessionID, callID: "call-1" }
+      const output = { title: "Read", output: `1: ${longContent}`, metadata: {} }
+
+      //#when
+      await hook["tool.execute.after"](input, output)
+
+      //#then
+      expect(output.output).toMatch(/^1:[a-f0-9]{2}\|a+$/)
+    })
+  })
+})
--- a/src/hooks/hashline-read-enhancer/index.ts
+++ b/src/hooks/hashline-read-enhancer/index.ts
@ -0,0 +1 @@
+export { createHashlineReadEnhancerHook } from "./hook"
--- a/src/hooks/index.ts
+++ b/src/hooks/index.ts
@ -43,3 +43,4 @@ export { createUnstableAgentBabysitterHook } from "./unstable-agent-babysitter";
 export { createPreemptiveCompactionHook } from "./preemptive-compaction";
 export { createTasksTodowriteDisablerHook } from "./tasks-todowrite-disabler";
 export { createWriteExistingFileGuardHook } from "./write-existing-file-guard";
+export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
--- a/src/hooks/preemptive-compaction.test.ts
+++ b/src/hooks/preemptive-compaction.test.ts
@ -123,6 +123,43 @@ describe("preemptive-compaction", () => {
    expect(ctx.client.session.summarize).toHaveBeenCalled()
  })

+  it("should trigger compaction for google-vertex-anthropic provider", async () => {
+    //#given google-vertex-anthropic usage above threshold
+    const hook = createPreemptiveCompactionHook(ctx as never)
+    const sessionID = "ses_vertex_anthropic_high"
+
+    await hook.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            role: "assistant",
+            sessionID,
+            providerID: "google-vertex-anthropic",
+            modelID: "claude-sonnet-4-5",
+            finish: true,
+            tokens: {
+              input: 170000,
+              output: 1000,
+              reasoning: 0,
+              cache: { read: 10000, write: 0 },
+            },
+          },
+        },
+      },
+    })
+
+    //#when tool.execute.after runs
+    const output = { title: "", output: "test", metadata: null }
+    await hook["tool.execute.after"](
+      { tool: "bash", sessionID, callID: "call_1" },
+      output
+    )
+
+    //#then summarize should be triggered
+    expect(ctx.client.session.summarize).toHaveBeenCalled()
+  })
+
  // #given session deleted
  // #then cache should be cleaned up
  it("should clean up cache on session.deleted", async () => {
--- a/src/hooks/preemptive-compaction.ts
+++ b/src/hooks/preemptive-compaction.ts
@ -23,6 +23,10 @@ interface CachedCompactionState {
  tokens: TokenInfo
 }

+function isAnthropicProvider(providerID: string): boolean {
+  return providerID === "anthropic" || providerID === "google-vertex-anthropic"
+}
+
 type PluginInput = {
  client: {
    session: {
@ -55,7 +59,7 @@ export function createPreemptiveCompactionHook(ctx: PluginInput) {
    if (!cached) return

    const actualLimit =
-      cached.providerID === "anthropic"
+      isAnthropicProvider(cached.providerID)
        ? ANTHROPIC_ACTUAL_LIMIT
        : DEFAULT_ACTUAL_LIMIT

--- a/src/hooks/think-mode/index.test.ts
+++ b/src/hooks/think-mode/index.test.ts
@ -214,6 +214,27 @@ describe("createThinkModeHook integration", () => {
      expect(message.thinking).toBeDefined()
    })

+    it("should work for direct google-vertex-anthropic provider", async () => {
+      //#given direct google-vertex-anthropic provider
+      const hook = createThinkModeHook()
+      const input = createMockInput(
+        "google-vertex-anthropic",
+        "claude-opus-4-6",
+        "think deeply"
+      )
+
+      //#when the chat.params hook is called
+      await hook["chat.params"](input, sessionID)
+
+      //#then should upgrade model and inject Claude thinking config
+      const message = input.message as MessageWithInjectedProps
+      expect(input.message.model?.modelID).toBe("claude-opus-4-6-high")
+      expect(message.thinking).toBeDefined()
+      expect((message.thinking as Record<string, unknown>)?.budgetTokens).toBe(
+        64000
+      )
+    })
+
    it("should still work for direct google provider", async () => {
      // given direct google provider
      const hook = createThinkModeHook()
--- a/src/hooks/think-mode/switcher.test.ts
+++ b/src/hooks/think-mode/switcher.test.ts
@ -266,6 +266,24 @@ describe("think-mode switcher", () => {
      expect((config?.thinking as Record<string, unknown>)?.type).toBe("enabled")
    })

+    it("should work for direct google-vertex-anthropic provider", () => {
+      //#given direct google-vertex-anthropic provider
+      const config = getThinkingConfig(
+        "google-vertex-anthropic",
+        "claude-opus-4-6"
+      )
+
+      //#when thinking config is resolved
+
+      //#then it should return anthropic-style thinking config
+      expect(config).not.toBeNull()
+      expect(config?.thinking).toBeDefined()
+      expect((config?.thinking as Record<string, unknown>)?.type).toBe("enabled")
+      expect((config?.thinking as Record<string, unknown>)?.budgetTokens).toBe(
+        64000
+      )
+    })
+
    it("should still work for direct google provider", () => {
      // given direct google provider
      const config = getThinkingConfig("google", "gemini-3-pro")
@ -314,6 +332,17 @@ describe("think-mode switcher", () => {
      expect(config.maxTokens).toBe(128000)
    })

+    it("should have correct structure for google-vertex-anthropic", () => {
+      //#given google-vertex-anthropic config entry
+      const config = THINKING_CONFIGS["google-vertex-anthropic"]
+
+      //#when structure is validated
+
+      //#then it should match anthropic style structure
+      expect(config.thinking).toBeDefined()
+      expect(config.maxTokens).toBe(128000)
+    })
+
    it("should have correct structure for google", () => {
      const config = THINKING_CONFIGS.google
      expect(config.providerOptions).toBeDefined()
--- a/src/hooks/think-mode/switcher.ts
+++ b/src/hooks/think-mode/switcher.ts
@ -121,6 +121,13 @@ export const THINKING_CONFIGS = {
    },
    maxTokens: 128000,
  },
+  "google-vertex-anthropic": {
+    thinking: {
+      type: "enabled",
+      budgetTokens: 64000,
+    },
+    maxTokens: 128000,
+  },
  "amazon-bedrock": {
    reasoningConfig: {
      type: "enabled",
@ -164,6 +171,7 @@ export const THINKING_CONFIGS = {

 const THINKING_CAPABLE_MODELS = {
  anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
+  "google-vertex-anthropic": ["claude-sonnet-4", "claude-opus-4", "claude-3"],
  "amazon-bedrock": ["claude", "anthropic"],
  google: ["gemini-2", "gemini-3"],
  "google-vertex": ["gemini-2", "gemini-3"],
--- a/src/index.ts
+++ b/src/index.ts
@ -44,6 +44,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
    pluginConfig,
    tmuxConfig,
    modelCacheState,
+    backgroundNotificationHookEnabled: isHookEnabled("background-notification"),
  })

  const toolsResult = await createTools({
--- a/src/plugin-handlers/agent-config-handler.ts
+++ b/src/plugin-handlers/agent-config-handler.ts
@ -23,6 +23,11 @@ type AgentConfigRecord = Record<string, Record<string, unknown> | undefined> & {
  plan?: Record<string, unknown>;
 };

+function hasConfiguredDefaultAgent(config: Record<string, unknown>): boolean {
+  const defaultAgent = config.default_agent;
+  return typeof defaultAgent === "string" && defaultAgent.trim().length > 0;
+}
+
 export async function applyAgentConfig(params: {
  config: Record<string, unknown>;
  pluginConfig: OhMyOpenCodeConfig;
@ -106,7 +111,10 @@ export async function applyAgentConfig(params: {
  const configAgent = params.config.agent as AgentConfigRecord | undefined;

  if (isSisyphusEnabled && builtinAgents.sisyphus) {
-    (params.config as { default_agent?: string }).default_agent = getAgentDisplayName("sisyphus");
+    if (!hasConfiguredDefaultAgent(params.config)) {
+      (params.config as { default_agent?: string }).default_agent =
+        getAgentDisplayName("sisyphus");
+    }

    const agentConfig: Record<string, unknown> = {
      sisyphus: builtinAgents.sisyphus,
--- a/src/plugin-handlers/config-handler.test.ts
+++ b/src/plugin-handlers/config-handler.test.ts
@ -349,6 +349,55 @@ describe("Agent permission defaults", () => {
  })
 })

+describe("default_agent behavior with Sisyphus orchestration", () => {
+  test("preserves existing default_agent when already set", async () => {
+    // #given
+    const pluginConfig: OhMyOpenCodeConfig = {}
+    const config: Record<string, unknown> = {
+      model: "anthropic/claude-opus-4-6",
+      default_agent: "hephaestus",
+      agent: {},
+    }
+    const handler = createConfigHandler({
+      ctx: { directory: "/tmp" },
+      pluginConfig,
+      modelCacheState: {
+        anthropicContext1MEnabled: false,
+        modelContextLimitsCache: new Map(),
+      },
+    })
+
+    // #when
+    await handler(config)
+
+    // #then
+    expect(config.default_agent).toBe("hephaestus")
+  })
+
+  test("sets default_agent to sisyphus when missing", async () => {
+    // #given
+    const pluginConfig: OhMyOpenCodeConfig = {}
+    const config: Record<string, unknown> = {
+      model: "anthropic/claude-opus-4-6",
+      agent: {},
+    }
+    const handler = createConfigHandler({
+      ctx: { directory: "/tmp" },
+      pluginConfig,
+      modelCacheState: {
+        anthropicContext1MEnabled: false,
+        modelContextLimitsCache: new Map(),
+      },
+    })
+
+    // #when
+    await handler(config)
+
+    // #then
+    expect(config.default_agent).toBe(getAgentDisplayName("sisyphus"))
+  })
+})
+
 describe("Prometheus category config resolution", () => {
  test("resolves ultrabrain category config", () => {
    // given
--- a/src/plugin/hooks/create-tool-guard-hooks.ts
+++ b/src/plugin/hooks/create-tool-guard-hooks.ts
@ -10,6 +10,7 @@ import {
  createRulesInjectorHook,
  createTasksTodowriteDisablerHook,
  createWriteExistingFileGuardHook,
+  createHashlineReadEnhancerHook,
 } from "../../hooks"
 import {
  getOpenCodeVersion,
@ -28,6 +29,7 @@ export type ToolGuardHooks = {
  rulesInjector: ReturnType<typeof createRulesInjectorHook> | null
  tasksTodowriteDisabler: ReturnType<typeof createTasksTodowriteDisablerHook> | null
  writeExistingFileGuard: ReturnType<typeof createWriteExistingFileGuardHook> | null
+  hashlineReadEnhancer: ReturnType<typeof createHashlineReadEnhancerHook> | null
 }

 export function createToolGuardHooks(args: {
@ -85,6 +87,10 @@ export function createToolGuardHooks(args: {
    ? safeHook("write-existing-file-guard", () => createWriteExistingFileGuardHook(ctx))
    : null

+  const hashlineReadEnhancer = isHookEnabled("hashline-read-enhancer")
+    ? safeHook("hashline-read-enhancer", () => createHashlineReadEnhancerHook(ctx, { hashline_edit: { enabled: pluginConfig.experimental?.hashline_edit ?? false } }))
+    : null
+
  return {
    commentChecker,
    toolOutputTruncator,
@ -94,5 +100,6 @@ export function createToolGuardHooks(args: {
    rulesInjector,
    tasksTodowriteDisabler,
    writeExistingFileGuard,
+    hashlineReadEnhancer,
  }
 }
--- a/src/plugin/tool-execute-after.ts
+++ b/src/plugin/tool-execute-after.ts
@ -43,5 +43,6 @@ export function createToolExecuteAfterHandler(args: {
    await hooks.delegateTaskRetry?.["tool.execute.after"]?.(input, output)
    await hooks.atlasHook?.["tool.execute.after"]?.(input, output)
    await hooks.taskResumeInfo?.["tool.execute.after"]?.(input, output)
+    await hooks.hashlineReadEnhancer?.["tool.execute.after"]?.(input, output)
  }
 }
--- a/src/plugin/tool-execute-before.ts
+++ b/src/plugin/tool-execute-before.ts
@ -29,7 +29,6 @@ export function createToolExecuteBeforeHandler(args: {
    await hooks.prometheusMdOnly?.["tool.execute.before"]?.(input, output)
    await hooks.sisyphusJuniorNotepad?.["tool.execute.before"]?.(input, output)
    await hooks.atlasHook?.["tool.execute.before"]?.(input, output)
-
    if (input.tool === "task") {
      const argsObject = output.args
      const category = typeof argsObject.category === "string" ? argsObject.category : undefined
--- a/src/plugin/tool-registry.ts
+++ b/src/plugin/tool-registry.ts
@ -25,6 +25,7 @@ import {
  createTaskGetTool,
  createTaskList,
  createTaskUpdateTool,
+  createHashlineEditTool,
 } from "../tools"
 import { getMainSessionID } from "../features/claude-code-session-state"
 import { filterDisabledTools } from "../shared/disabled-tools"
@ -48,11 +49,7 @@ export function createToolRegistry(args: {
  const { ctx, pluginConfig, managers, skillContext, availableCategories } = args

  const backgroundTools = createBackgroundTools(managers.backgroundManager, ctx.client)
-  const callOmoAgent = createCallOmoAgent(
-    ctx,
-    managers.backgroundManager,
-    pluginConfig.disabled_agents ?? [],
-  )
+  const callOmoAgent = createCallOmoAgent(ctx, managers.backgroundManager, pluginConfig.disabled_agents ?? [])

  const isMultimodalLookerEnabled = !(pluginConfig.disabled_agents ?? []).some(
    (agent) => agent.toLowerCase() === "multimodal-looker",
@ -121,6 +118,11 @@ export function createToolRegistry(args: {
      }
    : {}

+  const hashlineEnabled = pluginConfig.experimental?.hashline_edit ?? false
+  const hashlineToolsRecord: Record<string, ToolDefinition> = hashlineEnabled
+    ? { edit: createHashlineEditTool() }
+    : {}
+
  const allTools: Record<string, ToolDefinition> = {
    ...builtinTools,
    ...createGrepTools(ctx),
@ -136,6 +138,7 @@ export function createToolRegistry(args: {
    slashcommand: slashcommandTool,
    interactive_bash,
    ...taskToolsRecord,
+    ...hashlineToolsRecord,
  }

  const filteredTools = filterDisabledTools(allTools, pluginConfig.disabled_tools)
--- a/src/shared/index.ts
+++ b/src/shared/index.ts
@ -54,3 +54,4 @@ export * from "./truncate-description"
 export * from "./opencode-storage-paths"
 export * from "./opencode-message-dir"
 export * from "./normalize-sdk-response"
+export * from "./session-directory-resolver"
--- a/src/shared/model-availability.test.ts
+++ b/src/shared/model-availability.test.ts
@ -233,6 +233,27 @@ describe("fuzzyMatchModel", () => {
 		expect(result).toBe("anthropic/claude-opus-4-6")
 	})

+	// given github-copilot serves claude versions with dot notation
+	// when fallback chain uses hyphen notation in requested model
+	// then normalize both forms and match github-copilot model
+	it("should match github-copilot claude-opus-4-6 to claude-opus-4.6", () => {
+		const available = new Set([
+			"github-copilot/claude-opus-4.6",
+			"opencode/glm-4.7-free",
+		])
+		const result = fuzzyMatchModel("claude-opus-4-6", available, ["github-copilot"])
+		expect(result).toBe("github-copilot/claude-opus-4.6")
+	})
+
+	// given claude models can evolve to newer version numbers
+	// when matching across dot and hyphen version separators
+	// then normalize generically without hardcoding specific versions
+	it("should normalize claude version separators for future versions", () => {
+		const available = new Set(["github-copilot/claude-sonnet-5.1"])
+		const result = fuzzyMatchModel("claude-sonnet-5-1", available, ["github-copilot"])
+		expect(result).toBe("github-copilot/claude-sonnet-5.1")
+	})
+
 	// given available models from multiple providers
 	// when providers filter is specified
 	// then only search models from specified providers
--- a/src/shared/model-availability.ts
+++ b/src/shared/model-availability.ts
@ -28,8 +28,7 @@ import { normalizeSDKResponse } from "./normalize-sdk-response"
 function normalizeModelName(name: string): string {
 	return name
 		.toLowerCase()
-		.replace(/claude-(opus|sonnet|haiku)-4-5/g, "claude-$1-4.5")
-		.replace(/claude-(opus|sonnet|haiku)-4\.5/g, "claude-$1-4.5")
+		.replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3")
 }

 export function fuzzyMatchModel(
--- a/src/shared/model-name-matcher.ts
+++ b/src/shared/model-name-matcher.ts
@ -3,8 +3,7 @@ import { log } from "./logger"
 function normalizeModelName(name: string): string {
 	return name
 		.toLowerCase()
-		.replace(/claude-(opus|sonnet|haiku)-4-5/g, "claude-$1-4.5")
-		.replace(/claude-(opus|sonnet|haiku)-4\.5/g, "claude-$1-4.5")
+		.replace(/claude-(opus|sonnet|haiku)-(\d+)[.-](\d+)/g, "claude-$1-$2.$3")
 }

 export function fuzzyMatchModel(
@ -82,4 +81,3 @@ export function fuzzyMatchModel(
 	log("[fuzzyMatchModel] shortest match", { result })
 	return result
 }
-
--- a/src/shared/session-directory-resolver.test.ts
+++ b/src/shared/session-directory-resolver.test.ts
@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test"
+
+import { isWindowsAppDataDirectory, resolveSessionDirectory } from "./session-directory-resolver"
+
+describe("session-directory-resolver", () => {
+  describe("isWindowsAppDataDirectory", () => {
+    test("returns true when path is under AppData Local", () => {
+      //#given
+      const directory = "C:/Users/test/AppData/Local/opencode"
+
+      //#when
+      const result = isWindowsAppDataDirectory(directory)
+
+      //#then
+      expect(result).toBe(true)
+    })
+
+    test("returns true when path ends with AppData directory segment", () => {
+      //#given
+      const directory = "C:/Users/test/AppData/Local"
+
+      //#when
+      const result = isWindowsAppDataDirectory(directory)
+
+      //#then
+      expect(result).toBe(true)
+    })
+
+    test("returns false when path is outside AppData", () => {
+      //#given
+      const directory = "D:/projects/oh-my-opencode"
+
+      //#when
+      const result = isWindowsAppDataDirectory(directory)
+
+      //#then
+      expect(result).toBe(false)
+    })
+
+    test("returns false for lookalike non-AppData segment", () => {
+      //#given
+      const directory = "D:/projects/appdata/local-tools"
+
+      //#when
+      const result = isWindowsAppDataDirectory(directory)
+
+      //#then
+      expect(result).toBe(false)
+    })
+  })
+
+  describe("resolveSessionDirectory", () => {
+    test("uses process working directory on Windows when parent directory drifts to AppData", () => {
+      //#given
+      const options = {
+        parentDirectory: "C:\\Users\\test\\AppData\\Local\\ai.opencode.desktop",
+        fallbackDirectory: "C:\\Users\\test\\AppData\\Roaming\\opencode",
+        platform: "win32" as const,
+        currentWorkingDirectory: "D:\\projects\\oh-my-opencode",
+      }
+
+      //#when
+      const result = resolveSessionDirectory(options)
+
+      //#then
+      expect(result).toBe("D:\\projects\\oh-my-opencode")
+    })
+
+    test("keeps AppData directory when current working directory is also AppData", () => {
+      //#given
+      const options = {
+        parentDirectory: "C:\\Users\\test\\AppData\\Local\\ai.opencode.desktop",
+        fallbackDirectory: "C:\\Users\\test\\AppData\\Roaming\\opencode",
+        platform: "win32" as const,
+        currentWorkingDirectory: "C:\\Users\\test\\AppData\\Local\\Temp",
+      }
+
+      //#when
+      const result = resolveSessionDirectory(options)
+
+      //#then
+      expect(result).toBe("C:\\Users\\test\\AppData\\Local\\ai.opencode.desktop")
+    })
+
+    test("keeps original directory outside Windows", () => {
+      //#given
+      const options = {
+        parentDirectory: "/tmp/opencode",
+        fallbackDirectory: "/workspace/project",
+        platform: "darwin" as const,
+        currentWorkingDirectory: "/workspace/project",
+      }
+
+      //#when
+      const result = resolveSessionDirectory(options)
+
+      //#then
+      expect(result).toBe("/tmp/opencode")
+    })
+  })
+})
--- a/src/shared/session-directory-resolver.ts
+++ b/src/shared/session-directory-resolver.ts
@ -0,0 +1,41 @@
+const WINDOWS_APPDATA_SEGMENTS = ["\\appdata\\local", "\\appdata\\roaming", "\\appdata\\locallow"]
+
+function normalizeWindowsPath(directory: string): string {
+  return directory.replaceAll("/", "\\").toLowerCase()
+}
+
+export function isWindowsAppDataDirectory(directory: string): boolean {
+  const normalizedDirectory = normalizeWindowsPath(directory)
+  return WINDOWS_APPDATA_SEGMENTS.some((segment) => {
+    return normalizedDirectory.endsWith(segment) || normalizedDirectory.includes(`${segment}\\`)
+  })
+}
+
+export function resolveSessionDirectory(options: {
+  parentDirectory: string | null | undefined
+  fallbackDirectory: string
+  platform?: NodeJS.Platform
+  currentWorkingDirectory?: string
+}): string {
+  const {
+    parentDirectory,
+    fallbackDirectory,
+    platform = process.platform,
+    currentWorkingDirectory = process.cwd(),
+  } = options
+
+  const sessionDirectory = parentDirectory ?? fallbackDirectory
+  if (platform !== "win32") {
+    return sessionDirectory
+  }
+
+  if (!isWindowsAppDataDirectory(sessionDirectory)) {
+    return sessionDirectory
+  }
+
+  if (isWindowsAppDataDirectory(currentWorkingDirectory)) {
+    return sessionDirectory
+  }
+
+  return currentWorkingDirectory
+}
--- a/src/shared/tmux/tmux-utils/layout.ts
+++ b/src/shared/tmux/tmux-utils/layout.ts
@ -3,10 +3,12 @@ import type { TmuxLayout } from "../../../config/schema"
 import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver"

 export async function applyLayout(
-	tmux: string,
 	layout: TmuxLayout,
 	mainPaneSize: number,
 ): Promise<void> {
+	const tmux = await getTmuxPath()
+	if (!tmux) return
+
 	const layoutProc = spawn([tmux, "select-layout", layout], {
 		stdout: "ignore",
 		stderr: "ignore",
--- a/src/tools/ast-grep/cli.ts
+++ b/src/tools/ast-grep/cli.ts
@ -29,11 +29,17 @@ export interface RunOptions {
 }

 export async function runSg(options: RunOptions): Promise<SgResult> {
+  // ast-grep CLI silently ignores --update-all when --json is present.
+  // When both rewrite and updateAll are requested, we must run two separate
+  // invocations: one with --json=compact to collect match results, and
+  // another with --update-all to perform the actual file writes.
+  const shouldSeparateWritePass = !!(options.rewrite && options.updateAll)
+
  const args = ["run", "-p", options.pattern, "--lang", options.lang, "--json=compact"]

  if (options.rewrite) {
    args.push("-r", options.rewrite)
-    if (options.updateAll) {
+    if (options.updateAll && !shouldSeparateWritePass) {
      args.push("--update-all")
    }
  }
@ -144,5 +150,28 @@ export async function runSg(options: RunOptions): Promise<SgResult> {
    return { matches: [], totalMatches: 0, truncated: false }
  }

-  return createSgResultFromStdout(stdout)
+  const jsonResult = createSgResultFromStdout(stdout)
+
+  if (shouldSeparateWritePass && jsonResult.matches.length > 0) {
+    const writeArgs = args.filter(a => a !== "--json=compact")
+    writeArgs.push("--update-all")
+
+    const writeProc = spawn([cliPath, ...writeArgs], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    try {
+      const writeOutput = await collectProcessOutputWithTimeout(writeProc, timeout)
+      if (writeOutput.exitCode !== 0) {
+        const errorDetail = writeOutput.stderr.trim() || `ast-grep exited with code ${writeOutput.exitCode}`
+        return { ...jsonResult, error: `Replace failed: ${errorDetail}` }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      return { ...jsonResult, error: `Replace failed: ${errorMessage}` }
+    }
+  }
+
+  return jsonResult
 }
--- a/src/tools/call-omo-agent/subagent-session-creator.test.ts
+++ b/src/tools/call-omo-agent/subagent-session-creator.test.ts
@ -4,44 +4,88 @@ import { resolveOrCreateSessionId } from "./subagent-session-creator"
 import { _resetForTesting, subagentSessions } from "../../features/claude-code-session-state"

 describe("call-omo-agent resolveOrCreateSessionId", () => {
-  test("tracks newly created child session as subagent session", async () => {
-    // given
-    _resetForTesting()
+  const originalPlatform = process.platform
+
+  function buildInput(options: {
+    parentDirectory?: string
+    contextDirectory: string
+  }): {
+    ctx: Parameters<typeof resolveOrCreateSessionId>[0]
+    args: Parameters<typeof resolveOrCreateSessionId>[1]
+    toolContext: Parameters<typeof resolveOrCreateSessionId>[2]
+    createCalls: Array<{ query?: { directory?: string } }>
+  } {
+    const createCalls: Array<{ query?: { directory?: string } }> = []
+    const { parentDirectory, contextDirectory } = options
+    const parentSessionData = parentDirectory ? { data: { directory: parentDirectory } } : { data: {} }

-    const createCalls: Array<unknown> = []
    const ctx = {
-      directory: "/project",
+      directory: contextDirectory,
      client: {
        session: {
-          get: async () => ({ data: { directory: "/parent" } }),
-          create: async (args: unknown) => {
-            createCalls.push(args)
+          get: async () => parentSessionData,
+          create: async (createInput: unknown) => {
+            const payload = createInput as { query?: { directory?: string } }
+            createCalls.push(payload)
            return { data: { id: "ses_child_sync" } }
          },
        },
      },
-    }
+    } as unknown as Parameters<typeof resolveOrCreateSessionId>[0]

    const args = {
      description: "sync test",
      prompt: "hello",
      subagent_type: "explore",
      run_in_background: false,
-    }
+    } satisfies Parameters<typeof resolveOrCreateSessionId>[1]

    const toolContext = {
      sessionID: "ses_parent",
      messageID: "msg_parent",
      agent: "sisyphus",
      abort: new AbortController().signal,
-    }
+    } satisfies Parameters<typeof resolveOrCreateSessionId>[2]

-    // when
-    const result = await resolveOrCreateSessionId(ctx as any, args as any, toolContext as any)
+    return { ctx, args, toolContext, createCalls }
+  }

-    // then
+  test("tracks newly created child session as subagent session", async () => {
+    //#given
+    _resetForTesting()
+
+    const { ctx, args, toolContext, createCalls } = buildInput({
+      parentDirectory: "/parent",
+      contextDirectory: "/project",
+    })
+
+    //#when
+    const result = await resolveOrCreateSessionId(ctx, args, toolContext)
+
+    //#then
    expect(result).toEqual({ ok: true, sessionID: "ses_child_sync" })
    expect(createCalls).toHaveLength(1)
    expect(subagentSessions.has("ses_child_sync")).toBe(true)
  })
+
+  test("uses current working directory on Windows when parent directory is under AppData", async () => {
+    //#given
+    _resetForTesting()
+    Object.defineProperty(process, "platform", { value: "win32" })
+    try {
+      const { ctx, args, toolContext, createCalls } = buildInput({
+        parentDirectory: "C:\\Users\\test\\AppData\\Local\\ai.opencode.desktop",
+        contextDirectory: "C:\\Users\\test\\AppData\\Roaming\\opencode",
+      })
+
+      //#when
+      await resolveOrCreateSessionId(ctx, args, toolContext)
+
+      //#then
+      expect(createCalls).toHaveLength(1)
+      expect(createCalls[0]?.query?.directory).toBe(process.cwd())
+    } finally {
+      Object.defineProperty(process, "platform", { value: originalPlatform })
+    }
+  })
 })
--- a/src/tools/call-omo-agent/subagent-session-creator.ts
+++ b/src/tools/call-omo-agent/subagent-session-creator.ts
@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 import { log } from "../../shared"
+import { resolveSessionDirectory } from "../../shared"
 import { subagentSessions } from "../../features/claude-code-session-state"
 import type { CallOmoAgentArgs } from "./types"
 import type { ToolContextWithMetadata } from "./tool-context-with-metadata"
@ -27,11 +28,14 @@ export async function resolveOrCreateSessionId(
 	log(`[call_omo_agent] Creating new session with parent: ${toolContext.sessionID}`)
 	const parentSession = await ctx.client.session
 		.get({ path: { id: toolContext.sessionID } })
-		.catch((err) => {
+		.catch((err: unknown) => {
 			log("[call_omo_agent] Failed to get parent session", { error: String(err) })
 			return null
 		})
-	const parentDirectory = parentSession?.data?.directory ?? ctx.directory
+	const parentDirectory = resolveSessionDirectory({
+		parentDirectory: parentSession?.data?.directory,
+		fallbackDirectory: ctx.directory,
+	})

 	const body = {
 		parentID: toolContext.sessionID,
--- a/src/tools/call-omo-agent/tools.test.ts
+++ b/src/tools/call-omo-agent/tools.test.ts
@ -1,62 +1,102 @@
-import { describe, expect, test } from "bun:test"
+import { describe, test, expect, mock } from "bun:test"
+import type { PluginInput } from "@opencode-ai/plugin"
+import type { BackgroundManager } from "../../features/background-agent"
 import { createCallOmoAgent } from "./tools"

-const TEST_TOOL_CONTEXT = {
-  sessionID: "ses-parent",
-  messageID: "msg-1",
-  agent: "sisyphus",
-  abort: new AbortController().signal,
-}
+describe("createCallOmoAgent", () => {
+  const mockCtx = {
+    client: {},
+    directory: "/test",
+  } as unknown as PluginInput

-describe("call_omo_agent disabled_agents enforcement", () => {
-  test("rejects disabled agent from config with clear error", async () => {
+  const mockBackgroundManager = {
+    launch: mock(() => Promise.resolve({
+      id: "test-task-id",
+      sessionID: null,
+      description: "Test task",
+      agent: "test-agent",
+      status: "pending",
+    })),
+  } as unknown as BackgroundManager
+
+  test("should reject agent in disabled_agents list", async () => {
    //#given
-    const tool = createCallOmoAgent(
-      { client: {} } as Parameters<typeof createCallOmoAgent>[0],
-      {} as Parameters<typeof createCallOmoAgent>[1],
-      ["explore"],
-    )
+    const toolDef = createCallOmoAgent(mockCtx, mockBackgroundManager, ["explore"])
+    const executeFunc = toolDef.execute as Function

    //#when
-    const result = await tool.execute(
+    const result = await executeFunc(
      {
-        description: "run search",
-        prompt: "find implementation",
-        subagent_type: "ExPlOrE",
-        run_in_background: false,
+        description: "Test",
+        prompt: "Test prompt",
+        subagent_type: "explore",
+        run_in_background: true,
      },
-      TEST_TOOL_CONTEXT,
+      { sessionID: "test", messageID: "msg", agent: "test", abort: new AbortController().signal }
    )

    //#then
-    expect(result).toBe(
-      'Error: Agent "ExPlOrE" is disabled via disabled_agents config.',
-    )
+    expect(result).toContain("disabled via disabled_agents")
  })

-  test("allows enabled agent even when other agents are disabled", async () => {
+  test("should reject agent in disabled_agents list with case-insensitive matching", async () => {
    //#given
-    const tool = createCallOmoAgent(
-      { client: {} } as Parameters<typeof createCallOmoAgent>[0],
-      {} as Parameters<typeof createCallOmoAgent>[1],
-      ["explore"],
-    )
+    const toolDef = createCallOmoAgent(mockCtx, mockBackgroundManager, ["Explore"])
+    const executeFunc = toolDef.execute as Function

    //#when
-    const result = await tool.execute(
+    const result = await executeFunc(
      {
-        description: "continue session",
-        prompt: "read docs",
-        subagent_type: "librarian",
+        description: "Test",
+        prompt: "Test prompt",
+        subagent_type: "explore",
        run_in_background: true,
-        session_id: "ses-child",
      },
-      TEST_TOOL_CONTEXT,
+      { sessionID: "test", messageID: "msg", agent: "test", abort: new AbortController().signal }
    )

    //#then
-    expect(result).toBe(
-      "Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.",
+    expect(result).toContain("disabled via disabled_agents")
+  })
+
+  test("should allow agent not in disabled_agents list", async () => {
+    //#given
+    const toolDef = createCallOmoAgent(mockCtx, mockBackgroundManager, ["librarian"])
+    const executeFunc = toolDef.execute as Function
+
+    //#when
+    const result = await executeFunc(
+      {
+        description: "Test",
+        prompt: "Test prompt",
+        subagent_type: "explore",
+        run_in_background: true,
+      },
+      { sessionID: "test", messageID: "msg", agent: "test", abort: new AbortController().signal }
    )
+
+    //#then
+    // Should not contain disabled error - may fail for other reasons but disabled check should pass
+    expect(result).not.toContain("disabled via disabled_agents")
+  })
+
+  test("should allow all agents when disabled_agents is empty", async () => {
+    //#given
+    const toolDef = createCallOmoAgent(mockCtx, mockBackgroundManager, [])
+    const executeFunc = toolDef.execute as Function
+
+    //#when
+    const result = await executeFunc(
+      {
+        description: "Test",
+        prompt: "Test prompt",
+        subagent_type: "explore",
+        run_in_background: true,
+      },
+      { sessionID: "test", messageID: "msg", agent: "test", abort: new AbortController().signal }
+    )
+
+    //#then
+    expect(result).not.toContain("disabled via disabled_agents")
  })
 })
--- a/src/tools/call-omo-agent/tools.ts
+++ b/src/tools/call-omo-agent/tools.ts
@ -9,9 +9,8 @@ import { executeSync } from "./sync-executor"
 export function createCallOmoAgent(
  ctx: PluginInput,
  backgroundManager: BackgroundManager,
-  disabledAgents: string[] = [],
+  disabledAgents: string[] = []
 ): ToolDefinition {
-  const disabledAgentSet = new Set(disabledAgents.map((name) => name.toLowerCase()))
  const agentDescriptions = ALLOWED_AGENTS.map(
    (name) => `- ${name}: Specialized agent for ${name} tasks`
  ).join("\n")
@ -43,14 +42,14 @@ export function createCallOmoAgent(
        return `Error: Invalid agent type "${args.subagent_type}". Only ${ALLOWED_AGENTS.join(", ")} are allowed.`
      }

-      const normalizedAgentName = args.subagent_type.toLowerCase()
-      if (disabledAgentSet.has(normalizedAgentName)) {
-        return `Error: Agent "${args.subagent_type}" is disabled via disabled_agents config.`
-      }
-
-      const normalizedAgent = normalizedAgentName as AllowedAgentType
+      const normalizedAgent = args.subagent_type.toLowerCase() as AllowedAgentType
      args = { ...args, subagent_type: normalizedAgent }

+      // Check if agent is disabled
+      if (disabledAgents.some((disabled) => disabled.toLowerCase() === normalizedAgent)) {
+        return `Error: Agent "${normalizedAgent}" is disabled via disabled_agents configuration. Remove it from disabled_agents in your oh-my-opencode.json to use it.`
+      }
+
      if (args.run_in_background) {
        if (args.session_id) {
          return `Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.`
--- a/src/tools/delegate-task/subagent-resolver.test.ts
+++ b/src/tools/delegate-task/subagent-resolver.test.ts
@ -0,0 +1,82 @@
+declare const require: (name: string) => any
+const { describe, test, expect, beforeEach, afterEach, spyOn, mock } = require("bun:test")
+import { resolveSubagentExecution } from "./subagent-resolver"
+import type { DelegateTaskArgs } from "./types"
+import type { ExecutorContext } from "./executor-types"
+import * as logger from "../../shared/logger"
+
+function createBaseArgs(overrides?: Partial<DelegateTaskArgs>): DelegateTaskArgs {
+  return {
+    description: "Run review",
+    prompt: "Review the current changes",
+    run_in_background: false,
+    load_skills: [],
+    subagent_type: "oracle",
+    ...overrides,
+  }
+}
+
+function createExecutorContext(agentsFn: () => Promise<unknown>): ExecutorContext {
+  const client = {
+    app: {
+      agents: agentsFn,
+    },
+  } as ExecutorContext["client"]
+
+  return {
+    client,
+    manager: {} as ExecutorContext["manager"],
+    directory: "/tmp/test",
+  }
+}
+
+describe("resolveSubagentExecution", () => {
+  let logSpy: ReturnType<typeof spyOn> | undefined
+
+  beforeEach(() => {
+    mock.restore()
+    logSpy = spyOn(logger, "log").mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    logSpy?.mockRestore()
+  })
+
+  test("returns delegation error when agent discovery fails instead of silently proceeding", async () => {
+    //#given
+    const resolverError = new Error("agents API unavailable")
+    const args = createBaseArgs()
+    const executorCtx = createExecutorContext(async () => {
+      throw resolverError
+    })
+
+    //#when
+    const result = await resolveSubagentExecution(args, executorCtx, "sisyphus", "deep")
+
+    //#then
+    expect(result.agentToUse).toBe("")
+    expect(result.categoryModel).toBeUndefined()
+    expect(result.error).toBe("Failed to delegate to agent \"oracle\": agents API unavailable")
+  })
+
+  test("logs failure details when subagent resolution throws", async () => {
+    //#given
+    const args = createBaseArgs({ subagent_type: "review" })
+    const executorCtx = createExecutorContext(async () => {
+      throw new Error("network timeout")
+    })
+
+    //#when
+    await resolveSubagentExecution(args, executorCtx, "sisyphus", "deep")
+
+    //#then
+    expect(logSpy).toHaveBeenCalledTimes(1)
+    const callArgs = logSpy?.mock.calls[0]
+    expect(callArgs?.[0]).toBe("[delegate-task] Failed to resolve subagent execution")
+    expect(callArgs?.[1]).toEqual({
+      requestedAgent: "review",
+      parentAgent: "sisyphus",
+      error: "network timeout",
+    })
+  })
+})
--- a/src/tools/delegate-task/subagent-resolver.ts
+++ b/src/tools/delegate-task/subagent-resolver.ts
@ -6,6 +6,7 @@ import { parseModelString } from "./model-string-parser"
 import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
 import { getAgentDisplayName, getAgentConfigKey } from "../../shared/agent-display-names"
 import { normalizeSDKResponse } from "../../shared"
+import { log } from "../../shared/logger"
 import { getAvailableModelsForDelegateTask } from "./available-models"
 import { resolveModelForDelegateTask } from "./model-selection"

@ -119,8 +120,19 @@ Create the work plan directly - that's your job as the planning agent.`,
    if (!categoryModel && matchedAgent.model) {
      categoryModel = matchedAgent.model
    }
-  } catch {
-    // Proceed anyway - session.prompt will fail with clearer error if agent doesn't exist
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    log("[delegate-task] Failed to resolve subagent execution", {
+      requestedAgent: agentToUse,
+      parentAgent,
+      error: errorMessage,
+    })
+
+    return {
+      agentToUse: "",
+      categoryModel: undefined,
+      error: `Failed to delegate to agent "${agentToUse}": ${errorMessage}`,
+    }
  }

  return { agentToUse, categoryModel }
--- a/src/tools/delegate-task/sync-prompt-sender.test.ts
+++ b/src/tools/delegate-task/sync-prompt-sender.test.ts
@ -1,12 +1,17 @@
-const { describe, test, expect, mock } = require("bun:test")
+const {
+  describe: bunDescribe,
+  test: bunTest,
+  expect: bunExpect,
+  mock: bunMock,
+} = require("bun:test")

-describe("sendSyncPrompt", () => {
-  test("passes question=false via tools parameter", async () => {
+bunDescribe("sendSyncPrompt", () => {
+  bunTest("passes question=false via tools parameter", async () => {
    //#given
    const { sendSyncPrompt } = require("./sync-prompt-sender")

    let promptArgs: any
-    const promptAsync = mock(async (input: any) => {
+    const promptAsync = bunMock(async (input: any) => {
      promptArgs = input
      return { data: {} }
    })
@ -33,19 +38,19 @@ describe("sendSyncPrompt", () => {
    }

    //#when
-    await sendSyncPrompt(mockClient as any, input)
+    await sendSyncPrompt(mockClient, input)

    //#then
-    expect(promptAsync).toHaveBeenCalled()
-    expect(promptArgs.body.tools.question).toBe(false)
+    bunExpect(promptAsync).toHaveBeenCalled()
+    bunExpect(promptArgs.body.tools.question).toBe(false)
  })

-  test("applies agent tool restrictions for explore agent", async () => {
+  bunTest("applies agent tool restrictions for explore agent", async () => {
    //#given
    const { sendSyncPrompt } = require("./sync-prompt-sender")

    let promptArgs: any
-    const promptAsync = mock(async (input: any) => {
+    const promptAsync = bunMock(async (input: any) => {
      promptArgs = input
      return { data: {} }
    })
@ -73,19 +78,19 @@ describe("sendSyncPrompt", () => {
    }

    //#when
-    await sendSyncPrompt(mockClient as any, input)
+    await sendSyncPrompt(mockClient, input)

    //#then
-    expect(promptAsync).toHaveBeenCalled()
-    expect(promptArgs.body.tools.call_omo_agent).toBe(false)
+    bunExpect(promptAsync).toHaveBeenCalled()
+    bunExpect(promptArgs.body.tools.call_omo_agent).toBe(false)
  })

-  test("applies agent tool restrictions for librarian agent", async () => {
+  bunTest("applies agent tool restrictions for librarian agent", async () => {
    //#given
    const { sendSyncPrompt } = require("./sync-prompt-sender")

    let promptArgs: any
-    const promptAsync = mock(async (input: any) => {
+    const promptAsync = bunMock(async (input: any) => {
      promptArgs = input
      return { data: {} }
    })
@ -113,19 +118,19 @@ describe("sendSyncPrompt", () => {
    }

    //#when
-    await sendSyncPrompt(mockClient as any, input)
+    await sendSyncPrompt(mockClient, input)

    //#then
-    expect(promptAsync).toHaveBeenCalled()
-    expect(promptArgs.body.tools.call_omo_agent).toBe(false)
+    bunExpect(promptAsync).toHaveBeenCalled()
+    bunExpect(promptArgs.body.tools.call_omo_agent).toBe(false)
  })

-  test("does not restrict call_omo_agent for sisyphus agent", async () => {
+  bunTest("does not restrict call_omo_agent for sisyphus agent", async () => {
    //#given
    const { sendSyncPrompt } = require("./sync-prompt-sender")

    let promptArgs: any
-    const promptAsync = mock(async (input: any) => {
+    const promptAsync = bunMock(async (input: any) => {
      promptArgs = input
      return { data: {} }
    })
@ -153,10 +158,90 @@ describe("sendSyncPrompt", () => {
    }

    //#when
-    await sendSyncPrompt(mockClient as any, input)
+    await sendSyncPrompt(mockClient, input)

    //#then
-    expect(promptAsync).toHaveBeenCalled()
-    expect(promptArgs.body.tools.call_omo_agent).toBe(true)
+    bunExpect(promptAsync).toHaveBeenCalled()
+    bunExpect(promptArgs.body.tools.call_omo_agent).toBe(true)
+  })
+
+  bunTest("retries with promptSync for oracle when promptAsync fails with unexpected EOF", async () => {
+    //#given
+    const { sendSyncPrompt } = require("./sync-prompt-sender")
+
+    const promptWithModelSuggestionRetry = bunMock(async () => {
+      throw new Error("JSON Parse error: Unexpected EOF")
+    })
+    const promptSyncWithModelSuggestionRetry = bunMock(async () => {})
+
+    const input = {
+      sessionID: "test-session",
+      agentToUse: "oracle",
+      args: {
+        description: "test task",
+        prompt: "test prompt",
+        run_in_background: false,
+        load_skills: [],
+      },
+      systemContent: undefined,
+      categoryModel: undefined,
+      toastManager: null,
+      taskId: undefined,
+    }
+
+    //#when
+    const result = await sendSyncPrompt(
+      { session: { promptAsync: bunMock(async () => ({ data: {} })) } },
+      input,
+      {
+        promptWithModelSuggestionRetry,
+        promptSyncWithModelSuggestionRetry,
+      },
+    )
+
+    //#then
+    bunExpect(result).toBeNull()
+    bunExpect(promptWithModelSuggestionRetry).toHaveBeenCalledTimes(1)
+    bunExpect(promptSyncWithModelSuggestionRetry).toHaveBeenCalledTimes(1)
+  })
+
+  bunTest("does not retry with promptSync for non-oracle on unexpected EOF", async () => {
+    //#given
+    const { sendSyncPrompt } = require("./sync-prompt-sender")
+
+    const promptWithModelSuggestionRetry = bunMock(async () => {
+      throw new Error("JSON Parse error: Unexpected EOF")
+    })
+    const promptSyncWithModelSuggestionRetry = bunMock(async () => {})
+
+    const input = {
+      sessionID: "test-session",
+      agentToUse: "metis",
+      args: {
+        description: "test task",
+        prompt: "test prompt",
+        run_in_background: false,
+        load_skills: [],
+      },
+      systemContent: undefined,
+      categoryModel: undefined,
+      toastManager: null,
+      taskId: undefined,
+    }
+
+    //#when
+    const result = await sendSyncPrompt(
+      { session: { promptAsync: bunMock(async () => ({ data: {} })) } },
+      input,
+      {
+        promptWithModelSuggestionRetry,
+        promptSyncWithModelSuggestionRetry,
+      },
+    )
+
+    //#then
+    bunExpect(result).toContain("JSON Parse error: Unexpected EOF")
+    bunExpect(promptWithModelSuggestionRetry).toHaveBeenCalledTimes(1)
+    bunExpect(promptSyncWithModelSuggestionRetry).toHaveBeenCalledTimes(0)
  })
 })
--- a/src/tools/delegate-task/sync-prompt-sender.ts
+++ b/src/tools/delegate-task/sync-prompt-sender.ts
@ -1,10 +1,33 @@
 import type { DelegateTaskArgs, OpencodeClient } from "./types"
 import { isPlanFamily } from "./constants"
-import { promptWithModelSuggestionRetry } from "../../shared/model-suggestion-retry"
+import {
+  promptSyncWithModelSuggestionRetry,
+  promptWithModelSuggestionRetry,
+} from "../../shared/model-suggestion-retry"
 import { formatDetailedError } from "./error-formatting"
 import { getAgentToolRestrictions } from "../../shared/agent-tool-restrictions"
 import { setSessionTools } from "../../shared/session-tools-store"

+type SendSyncPromptDeps = {
+  promptWithModelSuggestionRetry: typeof promptWithModelSuggestionRetry
+  promptSyncWithModelSuggestionRetry: typeof promptSyncWithModelSuggestionRetry
+}
+
+const sendSyncPromptDeps: SendSyncPromptDeps = {
+  promptWithModelSuggestionRetry,
+  promptSyncWithModelSuggestionRetry,
+}
+
+function isOracleAgent(agentToUse: string): boolean {
+  return agentToUse.toLowerCase() === "oracle"
+}
+
+function isUnexpectedEofError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error)
+  const lowered = message.toLowerCase()
+  return lowered.includes("unexpected eof") || lowered.includes("json parse error")
+}
+
 export async function sendSyncPrompt(
  client: OpencodeClient,
  input: {
@ -15,29 +38,44 @@ export async function sendSyncPrompt(
    categoryModel: { providerID: string; modelID: string; variant?: string } | undefined
    toastManager: { removeTask: (id: string) => void } | null | undefined
    taskId: string | undefined
-  }
+  },
+  deps: SendSyncPromptDeps = sendSyncPromptDeps
 ): Promise<string | null> {
+  const allowTask = isPlanFamily(input.agentToUse)
+  const tools = {
+    task: allowTask,
+    call_omo_agent: true,
+    question: false,
+    ...getAgentToolRestrictions(input.agentToUse),
+  }
+  setSessionTools(input.sessionID, tools)
+
+  const promptArgs = {
+    path: { id: input.sessionID },
+    body: {
+      agent: input.agentToUse,
+      system: input.systemContent,
+      tools,
+      parts: [{ type: "text", text: input.args.prompt }],
+      ...(input.categoryModel
+        ? { model: { providerID: input.categoryModel.providerID, modelID: input.categoryModel.modelID } }
+        : {}),
+      ...(input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}),
+    },
+  }
+
  try {
-    const allowTask = isPlanFamily(input.agentToUse)
-    const tools = {
-      task: allowTask,
-      call_omo_agent: true,
-      question: false,
-      ...getAgentToolRestrictions(input.agentToUse),
-    }
-    setSessionTools(input.sessionID, tools)
-    await promptWithModelSuggestionRetry(client, {
-      path: { id: input.sessionID },
-      body: {
-        agent: input.agentToUse,
-        system: input.systemContent,
-        tools,
-        parts: [{ type: "text", text: input.args.prompt }],
-        ...(input.categoryModel ? { model: { providerID: input.categoryModel.providerID, modelID: input.categoryModel.modelID } } : {}),
-        ...(input.categoryModel?.variant ? { variant: input.categoryModel.variant } : {}),
-      },
-    })
+    await deps.promptWithModelSuggestionRetry(client, promptArgs)
  } catch (promptError) {
+    if (isOracleAgent(input.agentToUse) && isUnexpectedEofError(promptError)) {
+      try {
+        await deps.promptSyncWithModelSuggestionRetry(client, promptArgs)
+        return null
+      } catch (oracleRetryError) {
+        promptError = oracleRetryError
+      }
+    }
+
    if (input.toastManager && input.taskId !== undefined) {
      input.toastManager.removeTask(input.taskId)
    }
--- a/src/tools/hashline-edit/constants.ts
+++ b/src/tools/hashline-edit/constants.ts
@ -0,0 +1,30 @@
+export const HASH_DICT = [
+  "00", "01", "02", "03", "04", "05", "06", "07", "08", "09",
+  "0a", "0b", "0c", "0d", "0e", "0f", "10", "11", "12", "13",
+  "14", "15", "16", "17", "18", "19", "1a", "1b", "1c", "1d",
+  "1e", "1f", "20", "21", "22", "23", "24", "25", "26", "27",
+  "28", "29", "2a", "2b", "2c", "2d", "2e", "2f", "30", "31",
+  "32", "33", "34", "35", "36", "37", "38", "39", "3a", "3b",
+  "3c", "3d", "3e", "3f", "40", "41", "42", "43", "44", "45",
+  "46", "47", "48", "49", "4a", "4b", "4c", "4d", "4e", "4f",
+  "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
+  "5a", "5b", "5c", "5d", "5e", "5f", "60", "61", "62", "63",
+  "64", "65", "66", "67", "68", "69", "6a", "6b", "6c", "6d",
+  "6e", "6f", "70", "71", "72", "73", "74", "75", "76", "77",
+  "78", "79", "7a", "7b", "7c", "7d", "7e", "7f", "80", "81",
+  "82", "83", "84", "85", "86", "87", "88", "89", "8a", "8b",
+  "8c", "8d", "8e", "8f", "90", "91", "92", "93", "94", "95",
+  "96", "97", "98", "99", "9a", "9b", "9c", "9d", "9e", "9f",
+  "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9",
+  "aa", "ab", "ac", "ad", "ae", "af", "b0", "b1", "b2", "b3",
+  "b4", "b5", "b6", "b7", "b8", "b9", "ba", "bb", "bc", "bd",
+  "be", "bf", "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7",
+  "c8", "c9", "ca", "cb", "cc", "cd", "ce", "cf", "d0", "d1",
+  "d2", "d3", "d4", "d5", "d6", "d7", "d8", "d9", "da", "db",
+  "dc", "dd", "de", "df", "e0", "e1", "e2", "e3", "e4", "e5",
+  "e6", "e7", "e8", "e9", "ea", "eb", "ec", "ed", "ee", "ef",
+  "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9",
+  "fa", "fb", "fc", "fd", "fe", "ff",
+] as const
+
+export const HASHLINE_PATTERN = /^(\d+):([0-9a-f]{2})\|(.*)$/
--- a/src/tools/hashline-edit/edit-operations.test.ts
+++ b/src/tools/hashline-edit/edit-operations.test.ts
@ -0,0 +1,321 @@
+import { describe, expect, it } from "bun:test"
+import {
+  applyHashlineEdits,
+  applyInsertAfter,
+  applyReplace,
+  applyReplaceLines,
+  applySetLine,
+} from "./edit-operations"
+import type { HashlineEdit, InsertAfter, Replace, ReplaceLines, SetLine } from "./types"
+
+describe("applySetLine", () => {
+  it("replaces a single line at the specified anchor", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const anchor = "2:b2" // line 2 hash
+
+    //#when
+    const result = applySetLine(lines, anchor, "new line 2")
+
+    //#then
+    expect(result).toEqual(["line 1", "new line 2", "line 3"])
+  })
+
+  it("handles newline escapes in replacement text", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const anchor = "2:b2"
+
+    //#when
+    const result = applySetLine(lines, anchor, "new\\nline")
+
+    //#then
+    expect(result).toEqual(["line 1", "new\nline", "line 3"])
+  })
+
+  it("throws on hash mismatch", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const anchor = "2:ff" // wrong hash
+
+    //#when / #then
+    expect(() => applySetLine(lines, anchor, "new")).toThrow("Hash mismatch")
+  })
+
+  it("throws on out of bounds line", () => {
+    //#given
+    const lines = ["line 1", "line 2"]
+    const anchor = "5:00"
+
+    //#when / #then
+    expect(() => applySetLine(lines, anchor, "new")).toThrow("out of bounds")
+  })
+})
+
+describe("applyReplaceLines", () => {
+  it("replaces a range of lines", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3", "line 4", "line 5"]
+    const startAnchor = "2:b2"
+    const endAnchor = "4:5f"
+
+    //#when
+    const result = applyReplaceLines(lines, startAnchor, endAnchor, "replacement")
+
+    //#then
+    expect(result).toEqual(["line 1", "replacement", "line 5"])
+  })
+
+  it("handles newline escapes in replacement text", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const startAnchor = "2:b2"
+    const endAnchor = "2:b2"
+
+    //#when
+    const result = applyReplaceLines(lines, startAnchor, endAnchor, "a\\nb")
+
+    //#then
+    expect(result).toEqual(["line 1", "a", "b", "line 3"])
+  })
+
+  it("throws on start hash mismatch", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const startAnchor = "2:ff"
+    const endAnchor = "3:83"
+
+    //#when / #then
+    expect(() => applyReplaceLines(lines, startAnchor, endAnchor, "new")).toThrow(
+      "Hash mismatch"
+    )
+  })
+
+  it("throws on end hash mismatch", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const startAnchor = "2:b2"
+    const endAnchor = "3:ff"
+
+    //#when / #then
+    expect(() => applyReplaceLines(lines, startAnchor, endAnchor, "new")).toThrow(
+      "Hash mismatch"
+    )
+  })
+
+  it("throws when start > end", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const startAnchor = "3:83"
+    const endAnchor = "2:b2"
+
+    //#when / #then
+    expect(() => applyReplaceLines(lines, startAnchor, endAnchor, "new")).toThrow(
+      "start line 3 cannot be greater than end line 2"
+    )
+  })
+})
+
+describe("applyInsertAfter", () => {
+  it("inserts text after the specified line", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const anchor = "2:b2"
+
+    //#when
+    const result = applyInsertAfter(lines, anchor, "inserted")
+
+    //#then
+    expect(result).toEqual(["line 1", "line 2", "inserted", "line 3"])
+  })
+
+  it("handles newline escapes to insert multiple lines", () => {
+    //#given
+    const lines = ["line 1", "line 2", "line 3"]
+    const anchor = "2:b2"
+
+    //#when
+    const result = applyInsertAfter(lines, anchor, "a\\nb\\nc")
+
+    //#then
+    expect(result).toEqual(["line 1", "line 2", "a", "b", "c", "line 3"])
+  })
+
+  it("inserts at end when anchor is last line", () => {
+    //#given
+    const lines = ["line 1", "line 2"]
+    const anchor = "2:b2"
+
+    //#when
+    const result = applyInsertAfter(lines, anchor, "inserted")
+
+    //#then
+    expect(result).toEqual(["line 1", "line 2", "inserted"])
+  })
+
+  it("throws on hash mismatch", () => {
+    //#given
+    const lines = ["line 1", "line 2"]
+    const anchor = "2:ff"
+
+    //#when / #then
+    expect(() => applyInsertAfter(lines, anchor, "new")).toThrow("Hash mismatch")
+  })
+})
+
+describe("applyReplace", () => {
+  it("replaces exact text match", () => {
+    //#given
+    const content = "hello world foo bar"
+    const oldText = "world"
+    const newText = "universe"
+
+    //#when
+    const result = applyReplace(content, oldText, newText)
+
+    //#then
+    expect(result).toEqual("hello universe foo bar")
+  })
+
+  it("replaces all occurrences", () => {
+    //#given
+    const content = "foo bar foo baz foo"
+    const oldText = "foo"
+    const newText = "qux"
+
+    //#when
+    const result = applyReplace(content, oldText, newText)
+
+    //#then
+    expect(result).toEqual("qux bar qux baz qux")
+  })
+
+  it("handles newline escapes in newText", () => {
+    //#given
+    const content = "hello world"
+    const oldText = "world"
+    const newText = "new\\nline"
+
+    //#when
+    const result = applyReplace(content, oldText, newText)
+
+    //#then
+    expect(result).toEqual("hello new\nline")
+  })
+
+  it("throws when oldText not found", () => {
+    //#given
+    const content = "hello world"
+    const oldText = "notfound"
+    const newText = "replacement"
+
+    //#when / #then
+    expect(() => applyReplace(content, oldText, newText)).toThrow("Text not found")
+  })
+})
+
+describe("applyHashlineEdits", () => {
+  it("applies single set_line edit", () => {
+    //#given
+    const content = "line 1\nline 2\nline 3"
+    const edits: SetLine[] = [{ type: "set_line", line: "2:b2", text: "new line 2" }]
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("line 1\nnew line 2\nline 3")
+  })
+
+  it("applies multiple edits bottom-up (descending line order)", () => {
+    //#given
+    const content = "line 1\nline 2\nline 3\nline 4\nline 5"
+    const edits: SetLine[] = [
+      { type: "set_line", line: "2:b2", text: "new 2" },
+      { type: "set_line", line: "4:5f", text: "new 4" },
+    ]
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("line 1\nnew 2\nline 3\nnew 4\nline 5")
+  })
+
+  it("applies mixed edit types", () => {
+    //#given
+    const content = "line 1\nline 2\nline 3"
+    const edits: HashlineEdit[] = [
+      { type: "insert_after", line: "1:02", text: "inserted" },
+      { type: "set_line", line: "3:83", text: "modified" },
+    ]
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("line 1\ninserted\nline 2\nmodified")
+  })
+
+  it("applies replace_lines edit", () => {
+    //#given
+    const content = "line 1\nline 2\nline 3\nline 4"
+    const edits: ReplaceLines[] = [
+      { type: "replace_lines", start_line: "2:b2", end_line: "3:83", text: "replaced" },
+    ]
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("line 1\nreplaced\nline 4")
+  })
+
+  it("applies replace fallback edit", () => {
+    //#given
+    const content = "hello world foo"
+    const edits: Replace[] = [{ type: "replace", old_text: "world", new_text: "universe" }]
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("hello universe foo")
+  })
+
+  it("handles empty edits array", () => {
+    //#given
+    const content = "line 1\nline 2"
+    const edits: HashlineEdit[] = []
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("line 1\nline 2")
+  })
+
+  it("throws on hash mismatch with descriptive error", () => {
+    //#given
+    const content = "line 1\nline 2\nline 3"
+    const edits: SetLine[] = [{ type: "set_line", line: "2:ff", text: "new" }]
+
+    //#when / #then
+    expect(() => applyHashlineEdits(content, edits)).toThrow("Hash mismatch")
+  })
+
+  it("correctly handles index shifting with multiple edits", () => {
+    //#given
+    const content = "a\nb\nc\nd\ne"
+    const edits: InsertAfter[] = [
+      { type: "insert_after", line: "2:bf", text: "x" },
+      { type: "insert_after", line: "4:90", text: "y" },
+    ]
+
+    //#when
+    const result = applyHashlineEdits(content, edits)
+
+    //#then
+    expect(result).toEqual("a\nb\nx\nc\nd\ny\ne")
+  })
+})
--- a/src/tools/hashline-edit/edit-operations.ts
+++ b/src/tools/hashline-edit/edit-operations.ts
@ -0,0 +1,123 @@
+import { parseLineRef, validateLineRef } from "./validation"
+import type { HashlineEdit } from "./types"
+
+function unescapeNewlines(text: string): string {
+  return text.replace(/\\n/g, "\n")
+}
+
+export function applySetLine(lines: string[], anchor: string, newText: string): string[] {
+  validateLineRef(lines, anchor)
+  const { line } = parseLineRef(anchor)
+  const result = [...lines]
+  result[line - 1] = unescapeNewlines(newText)
+  return result
+}
+
+export function applyReplaceLines(
+  lines: string[],
+  startAnchor: string,
+  endAnchor: string,
+  newText: string
+): string[] {
+  validateLineRef(lines, startAnchor)
+  validateLineRef(lines, endAnchor)
+
+  const { line: startLine } = parseLineRef(startAnchor)
+  const { line: endLine } = parseLineRef(endAnchor)
+
+  if (startLine > endLine) {
+    throw new Error(
+      `Invalid range: start line ${startLine} cannot be greater than end line ${endLine}`
+    )
+  }
+
+  const result = [...lines]
+  const newLines = unescapeNewlines(newText).split("\n")
+  result.splice(startLine - 1, endLine - startLine + 1, ...newLines)
+  return result
+}
+
+export function applyInsertAfter(lines: string[], anchor: string, text: string): string[] {
+  validateLineRef(lines, anchor)
+  const { line } = parseLineRef(anchor)
+  const result = [...lines]
+  const newLines = unescapeNewlines(text).split("\n")
+  result.splice(line, 0, ...newLines)
+  return result
+}
+
+export function applyReplace(content: string, oldText: string, newText: string): string {
+  if (!content.includes(oldText)) {
+    throw new Error(`Text not found: "${oldText}"`)
+  }
+  return content.replaceAll(oldText, unescapeNewlines(newText))
+}
+
+function getEditLineNumber(edit: HashlineEdit): number {
+  switch (edit.type) {
+    case "set_line":
+      return parseLineRef(edit.line).line
+    case "replace_lines":
+      return parseLineRef(edit.end_line).line
+    case "insert_after":
+      return parseLineRef(edit.line).line
+    case "replace":
+      return Number.NEGATIVE_INFINITY
+    default:
+      return Number.POSITIVE_INFINITY
+  }
+}
+
+export function applyHashlineEdits(content: string, edits: HashlineEdit[]): string {
+  if (edits.length === 0) {
+    return content
+  }
+
+  const sortedEdits = [...edits].sort((a, b) => getEditLineNumber(b) - getEditLineNumber(a))
+
+  let result = content
+  let lines = result.split("\n")
+
+  for (const edit of sortedEdits) {
+    switch (edit.type) {
+      case "set_line": {
+        validateLineRef(lines, edit.line)
+        const { line } = parseLineRef(edit.line)
+        lines[line - 1] = unescapeNewlines(edit.text)
+        break
+      }
+      case "replace_lines": {
+        validateLineRef(lines, edit.start_line)
+        validateLineRef(lines, edit.end_line)
+        const { line: startLine } = parseLineRef(edit.start_line)
+        const { line: endLine } = parseLineRef(edit.end_line)
+        if (startLine > endLine) {
+          throw new Error(
+            `Invalid range: start line ${startLine} cannot be greater than end line ${endLine}`
+          )
+        }
+        const newLines = unescapeNewlines(edit.text).split("\n")
+        lines.splice(startLine - 1, endLine - startLine + 1, ...newLines)
+        break
+      }
+      case "insert_after": {
+        validateLineRef(lines, edit.line)
+        const { line } = parseLineRef(edit.line)
+        const newLines = unescapeNewlines(edit.text).split("\n")
+        lines.splice(line, 0, ...newLines)
+        break
+      }
+      case "replace": {
+        result = lines.join("\n")
+        if (!result.includes(edit.old_text)) {
+          throw new Error(`Text not found: "${edit.old_text}"`)
+        }
+        result = result.replaceAll(edit.old_text, unescapeNewlines(edit.new_text))
+        lines = result.split("\n")
+        break
+      }
+    }
+  }
+
+  return lines.join("\n")
+}
--- a/src/tools/hashline-edit/hash-computation.test.ts
+++ b/src/tools/hashline-edit/hash-computation.test.ts
@ -0,0 +1,123 @@
+import { describe, it, expect } from "bun:test"
+import { computeLineHash, formatHashLine, formatHashLines } from "./hash-computation"
+
+describe("computeLineHash", () => {
+  it("returns consistent 2-char hex for same input", () => {
+    //#given
+    const lineNumber = 1
+    const content = "function hello() {"
+
+    //#when
+    const hash1 = computeLineHash(lineNumber, content)
+    const hash2 = computeLineHash(lineNumber, content)
+
+    //#then
+    expect(hash1).toBe(hash2)
+    expect(hash1).toMatch(/^[0-9a-f]{2}$/)
+  })
+
+  it("strips whitespace before hashing", () => {
+    //#given
+    const lineNumber = 1
+    const content1 = "function hello() {"
+    const content2 = "  function hello() {  "
+
+    //#when
+    const hash1 = computeLineHash(lineNumber, content1)
+    const hash2 = computeLineHash(lineNumber, content2)
+
+    //#then
+    expect(hash1).toBe(hash2)
+  })
+
+  it("handles empty lines", () => {
+    //#given
+    const lineNumber = 1
+    const content = ""
+
+    //#when
+    const hash = computeLineHash(lineNumber, content)
+
+    //#then
+    expect(hash).toMatch(/^[0-9a-f]{2}$/)
+  })
+
+  it("returns different hashes for different content", () => {
+    //#given
+    const lineNumber = 1
+    const content1 = "function hello() {"
+    const content2 = "function world() {"
+
+    //#when
+    const hash1 = computeLineHash(lineNumber, content1)
+    const hash2 = computeLineHash(lineNumber, content2)
+
+    //#then
+    expect(hash1).not.toBe(hash2)
+  })
+})
+
+describe("formatHashLine", () => {
+  it("formats line with hash prefix", () => {
+    //#given
+    const lineNumber = 42
+    const content = "function hello() {"
+
+    //#when
+    const result = formatHashLine(lineNumber, content)
+
+    //#then
+    expect(result).toMatch(/^42:[0-9a-f]{2}\|function hello\(\) \{$/)
+  })
+
+  it("preserves content after hash prefix", () => {
+    //#given
+    const lineNumber = 1
+    const content = "const x = 42"
+
+    //#when
+    const result = formatHashLine(lineNumber, content)
+
+    //#then
+    expect(result).toContain("|const x = 42")
+  })
+})
+
+describe("formatHashLines", () => {
+  it("formats all lines with hash prefixes", () => {
+    //#given
+    const content = "function hello() {\n  return 42\n}"
+
+    //#when
+    const result = formatHashLines(content)
+
+    //#then
+    const lines = result.split("\n")
+    expect(lines).toHaveLength(3)
+    expect(lines[0]).toMatch(/^1:[0-9a-f]{2}\|/)
+    expect(lines[1]).toMatch(/^2:[0-9a-f]{2}\|/)
+    expect(lines[2]).toMatch(/^3:[0-9a-f]{2}\|/)
+  })
+
+  it("handles empty file", () => {
+    //#given
+    const content = ""
+
+    //#when
+    const result = formatHashLines(content)
+
+    //#then
+    expect(result).toBe("")
+  })
+
+  it("handles single line", () => {
+    //#given
+    const content = "const x = 42"
+
+    //#when
+    const result = formatHashLines(content)
+
+    //#then
+    expect(result).toMatch(/^1:[0-9a-f]{2}\|const x = 42$/)
+  })
+})
--- a/src/tools/hashline-edit/hash-computation.ts
+++ b/src/tools/hashline-edit/hash-computation.ts
@ -0,0 +1,19 @@
+import { HASH_DICT } from "./constants"
+
+export function computeLineHash(lineNumber: number, content: string): string {
+  const stripped = content.replace(/\s+/g, "")
+  const hash = Bun.hash.xxHash32(stripped)
+  const index = hash % 256
+  return HASH_DICT[index]
+}
+
+export function formatHashLine(lineNumber: number, content: string): string {
+  const hash = computeLineHash(lineNumber, content)
+  return `${lineNumber}:${hash}|${content}`
+}
+
+export function formatHashLines(content: string): string {
+  if (!content) return ""
+  const lines = content.split("\n")
+  return lines.map((line, index) => formatHashLine(index + 1, line)).join("\n")
+}
--- a/src/tools/hashline-edit/index.ts
+++ b/src/tools/hashline-edit/index.ts
@ -0,0 +1,13 @@
+export { computeLineHash, formatHashLine, formatHashLines } from "./hash-computation"
+export { parseLineRef, validateLineRef } from "./validation"
+export type { LineRef } from "./validation"
+export type { SetLine, ReplaceLines, InsertAfter, Replace, HashlineEdit } from "./types"
+export { HASH_DICT, HASHLINE_PATTERN } from "./constants"
+export {
+  applyHashlineEdits,
+  applyInsertAfter,
+  applyReplace,
+  applyReplaceLines,
+  applySetLine,
+} from "./edit-operations"
+export { createHashlineEditTool } from "./tools"
--- a/src/tools/hashline-edit/tools.test.ts
+++ b/src/tools/hashline-edit/tools.test.ts
@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test"
+import { createHashlineEditTool } from "./tools"
+import * as fs from "node:fs"
+import * as path from "node:path"
+import * as os from "node:os"
+import { computeLineHash } from "./hash-computation"
+
+describe("createHashlineEditTool", () => {
+  let tempDir: string
+  let tool: ReturnType<typeof createHashlineEditTool>
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "hashline-edit-test-"))
+    tool = createHashlineEditTool()
+  })
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  describe("tool definition", () => {
+    it("has correct description", () => {
+      //#given tool is created
+      //#when accessing tool properties
+      //#then description explains LINE:HASH format
+      expect(tool.description).toContain("LINE:HASH")
+      expect(tool.description).toContain("set_line")
+      expect(tool.description).toContain("replace_lines")
+      expect(tool.description).toContain("insert_after")
+      expect(tool.description).toContain("replace")
+    })
+
+    it("has path parameter", () => {
+      //#given tool is created
+      //#when checking parameters
+      //#then path parameter exists as required string
+      expect(tool.args.path).toBeDefined()
+    })
+
+    it("has edits parameter as array", () => {
+      //#given tool is created
+      //#when checking parameters
+      //#then edits parameter exists as array
+      expect(tool.args.edits).toBeDefined()
+    })
+  })
+
+  describe("execute", () => {
+    it("returns error when file does not exist", async () => {
+      //#given non-existent file path
+      const nonExistentPath = path.join(tempDir, "non-existent.txt")
+
+      //#when executing tool
+      const result = await tool.execute(
+        {
+          path: nonExistentPath,
+          edits: [{ type: "set_line", line: "1:00", text: "new content" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then error is returned
+      expect(result).toContain("Error")
+      expect(result).toContain("not found")
+    })
+
+    it("applies set_line edit and returns diff", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "line1\nline2\nline3")
+      const line2Hash = computeLineHash(2, "line2")
+
+      //#when executing set_line edit
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [{ type: "set_line", line: `2:${line2Hash}`, text: "modified line2" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then file is modified and diff is returned
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content).toBe("line1\nmodified line2\nline3")
+      expect(result).toContain("modified line2")
+    })
+
+    it("applies insert_after edit", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "line1\nline2")
+      const line1Hash = computeLineHash(1, "line1")
+
+      //#when executing insert_after edit
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [{ type: "insert_after", line: `1:${line1Hash}`, text: "inserted" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then line is inserted after specified line
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content).toBe("line1\ninserted\nline2")
+    })
+
+    it("applies replace_lines edit", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "line1\nline2\nline3\nline4")
+      const line2Hash = computeLineHash(2, "line2")
+      const line3Hash = computeLineHash(3, "line3")
+
+      //#when executing replace_lines edit
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [
+            {
+              type: "replace_lines",
+              start_line: `2:${line2Hash}`,
+              end_line: `3:${line3Hash}`,
+              text: "replaced",
+            },
+          ],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then lines are replaced
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content).toBe("line1\nreplaced\nline4")
+    })
+
+    it("applies replace edit", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "hello world\nfoo bar")
+
+      //#when executing replace edit
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [{ type: "replace", old_text: "world", new_text: "universe" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then text is replaced
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content).toBe("hello universe\nfoo bar")
+    })
+
+    it("applies multiple edits in bottom-up order", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "line1\nline2\nline3")
+      const line1Hash = computeLineHash(1, "line1")
+      const line3Hash = computeLineHash(3, "line3")
+
+      //#when executing multiple edits
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [
+            { type: "set_line", line: `1:${line1Hash}`, text: "new1" },
+            { type: "set_line", line: `3:${line3Hash}`, text: "new3" },
+          ],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then both edits are applied
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content).toBe("new1\nline2\nnew3")
+    })
+
+    it("returns error on hash mismatch", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "line1\nline2")
+
+      //#when executing with wrong hash (valid format but wrong value)
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [{ type: "set_line", line: "1:ff", text: "new" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then hash mismatch error is returned
+      expect(result).toContain("Error")
+      expect(result).toContain("hash")
+    })
+
+    it("handles escaped newlines in text", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "line1\nline2")
+      const line1Hash = computeLineHash(1, "line1")
+
+      //#when executing with escaped newline
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [{ type: "set_line", line: `1:${line1Hash}`, text: "new\\nline" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then newline is unescaped
+      const content = fs.readFileSync(filePath, "utf-8")
+      expect(content).toBe("new\nline\nline2")
+    })
+
+    it("returns success result with diff summary", async () => {
+      //#given file with content
+      const filePath = path.join(tempDir, "test.txt")
+      fs.writeFileSync(filePath, "old content")
+      const line1Hash = computeLineHash(1, "old content")
+
+      //#when executing edit
+      const result = await tool.execute(
+        {
+          path: filePath,
+          edits: [{ type: "set_line", line: `1:${line1Hash}`, text: "new content" }],
+        },
+        { sessionID: "test", messageID: "test", agent: "test", abort: new AbortController() }
+      )
+
+      //#then result contains success indicator and diff
+      expect(result).toContain("Successfully")
+      expect(result).toContain("old content")
+      expect(result).toContain("new content")
+    })
+  })
+})
--- a/src/tools/hashline-edit/tools.ts
+++ b/src/tools/hashline-edit/tools.ts
@ -0,0 +1,137 @@
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
+import type { HashlineEdit } from "./types"
+import { applyHashlineEdits } from "./edit-operations"
+import { computeLineHash } from "./hash-computation"
+
+interface HashlineEditArgs {
+  path: string
+  edits: HashlineEdit[]
+}
+
+function generateDiff(oldContent: string, newContent: string, filePath: string): string {
+  const oldLines = oldContent.split("\n")
+  const newLines = newContent.split("\n")
+
+  let diff = `--- ${filePath}\n+++ ${filePath}\n`
+
+  const maxLines = Math.max(oldLines.length, newLines.length)
+  for (let i = 0; i < maxLines; i++) {
+    const oldLine = oldLines[i] ?? ""
+    const newLine = newLines[i] ?? ""
+    const lineNum = i + 1
+    const hash = computeLineHash(lineNum, newLine)
+
+    if (i >= oldLines.length) {
+      diff += `+ ${lineNum}:${hash}|${newLine}\n`
+    } else if (i >= newLines.length) {
+      diff += `- ${lineNum}:  |${oldLine}\n`
+    } else if (oldLine !== newLine) {
+      diff += `- ${lineNum}:  |${oldLine}\n`
+      diff += `+ ${lineNum}:${hash}|${newLine}\n`
+    }
+  }
+
+  return diff
+}
+
+export function createHashlineEditTool(): ToolDefinition {
+  return tool({
+    description: `Edit files using LINE:HASH format for precise, safe modifications.
+
+LINE:HASH FORMAT:
+Each line reference must be in "LINE:HASH" format where:
+- LINE: 1-based line number
+- HASH: First 2 characters of xxHash32 hash of line content (computed with computeLineHash)
+- Example: "5:a3|const x = 1" means line 5 with hash "a3"
+
+GETTING HASHES:
+Use the read tool - it returns lines in "LINE:HASH|content" format.
+
+FOUR OPERATION TYPES:
+
+1. set_line: Replace a single line
+   { "type": "set_line", "line": "5:a3", "text": "const y = 2" }
+
+2. replace_lines: Replace a range of lines
+   { "type": "replace_lines", "start_line": "5:a3", "end_line": "7:b2", "text": "new\ncontent" }
+
+3. insert_after: Insert lines after a specific line
+   { "type": "insert_after", "line": "5:a3", "text": "console.log('hi')" }
+
+4. replace: Simple text replacement (no hash validation)
+   { "type": "replace", "old_text": "foo", "new_text": "bar" }
+
+HASH MISMATCH HANDLING:
+If the hash doesn't match the current content, the edit fails with a hash mismatch error. This prevents editing stale content.
+
+BOTTOM-UP APPLICATION:
+Edits are applied from bottom to top (highest line numbers first) to preserve line number references.
+
+ESCAPING:
+Use \\n in text to represent literal newlines.`,
+    args: {
+      path: tool.schema.string().describe("Absolute path to the file to edit"),
+      edits: tool.schema
+        .array(
+          tool.schema.union([
+            tool.schema.object({
+              type: tool.schema.literal("set_line"),
+              line: tool.schema.string().describe("Line reference in LINE:HASH format"),
+              text: tool.schema.string().describe("New content for the line"),
+            }),
+            tool.schema.object({
+              type: tool.schema.literal("replace_lines"),
+              start_line: tool.schema.string().describe("Start line in LINE:HASH format"),
+              end_line: tool.schema.string().describe("End line in LINE:HASH format"),
+              text: tool.schema.string().describe("New content to replace the range"),
+            }),
+            tool.schema.object({
+              type: tool.schema.literal("insert_after"),
+              line: tool.schema.string().describe("Line reference in LINE:HASH format"),
+              text: tool.schema.string().describe("Content to insert after the line"),
+            }),
+            tool.schema.object({
+              type: tool.schema.literal("replace"),
+              old_text: tool.schema.string().describe("Text to find"),
+              new_text: tool.schema.string().describe("Replacement text"),
+            }),
+          ])
+        )
+        .describe("Array of edit operations to apply"),
+    },
+    execute: async (args: HashlineEditArgs) => {
+      try {
+        const { path: filePath, edits } = args
+
+        if (!filePath) {
+          return "Error: path parameter is required"
+        }
+
+        if (!edits || !Array.isArray(edits) || edits.length === 0) {
+          return "Error: edits parameter must be a non-empty array"
+        }
+
+        const file = Bun.file(filePath)
+        const exists = await file.exists()
+        if (!exists) {
+          return `Error: File not found: ${filePath}`
+        }
+
+        const oldContent = await file.text()
+        const newContent = applyHashlineEdits(oldContent, edits)
+
+        await Bun.write(filePath, newContent)
+
+        const diff = generateDiff(oldContent, newContent, filePath)
+
+        return `Successfully applied ${edits.length} edit(s) to ${filePath}\n\n${diff}`
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        if (message.includes("hash")) {
+          return `Error: Hash mismatch - ${message}`
+        }
+        return `Error: ${message}`
+      }
+    },
+  })
+}
--- a/src/tools/hashline-edit/types.ts
+++ b/src/tools/hashline-edit/types.ts
@ -0,0 +1,26 @@
+export interface SetLine {
+  type: "set_line"
+  line: string
+  text: string
+}
+
+export interface ReplaceLines {
+  type: "replace_lines"
+  start_line: string
+  end_line: string
+  text: string
+}
+
+export interface InsertAfter {
+  type: "insert_after"
+  line: string
+  text: string
+}
+
+export interface Replace {
+  type: "replace"
+  old_text: string
+  new_text: string
+}
+
+export type HashlineEdit = SetLine | ReplaceLines | InsertAfter | Replace
--- a/src/tools/hashline-edit/validation.test.ts
+++ b/src/tools/hashline-edit/validation.test.ts
@ -0,0 +1,105 @@
+import { describe, it, expect } from "bun:test"
+import { parseLineRef, validateLineRef } from "./validation"
+
+describe("parseLineRef", () => {
+  it("parses valid line reference", () => {
+    //#given
+    const ref = "42:a3"
+
+    //#when
+    const result = parseLineRef(ref)
+
+    //#then
+    expect(result).toEqual({ line: 42, hash: "a3" })
+  })
+
+  it("parses line reference with different hash", () => {
+    //#given
+    const ref = "1:ff"
+
+    //#when
+    const result = parseLineRef(ref)
+
+    //#then
+    expect(result).toEqual({ line: 1, hash: "ff" })
+  })
+
+  it("throws on invalid format - no colon", () => {
+    //#given
+    const ref = "42a3"
+
+    //#when & #then
+    expect(() => parseLineRef(ref)).toThrow()
+  })
+
+  it("throws on invalid format - non-numeric line", () => {
+    //#given
+    const ref = "abc:a3"
+
+    //#when & #then
+    expect(() => parseLineRef(ref)).toThrow()
+  })
+
+  it("throws on invalid format - invalid hash", () => {
+    //#given
+    const ref = "42:xyz"
+
+    //#when & #then
+    expect(() => parseLineRef(ref)).toThrow()
+  })
+
+  it("throws on empty string", () => {
+    //#given
+    const ref = ""
+
+    //#when & #then
+    expect(() => parseLineRef(ref)).toThrow()
+  })
+})
+
+describe("validateLineRef", () => {
+  it("validates matching hash", () => {
+    //#given
+    const lines = ["function hello() {", "  return 42", "}"]
+    const ref = "1:42"
+
+    //#when & #then
+    expect(() => validateLineRef(lines, ref)).not.toThrow()
+  })
+
+  it("throws on hash mismatch", () => {
+    //#given
+    const lines = ["function hello() {", "  return 42", "}"]
+    const ref = "1:00" // Wrong hash
+
+    //#when & #then
+    expect(() => validateLineRef(lines, ref)).toThrow()
+  })
+
+  it("throws on line out of bounds", () => {
+    //#given
+    const lines = ["function hello() {", "  return 42", "}"]
+    const ref = "99:a3"
+
+    //#when & #then
+    expect(() => validateLineRef(lines, ref)).toThrow()
+  })
+
+  it("throws on invalid line number", () => {
+    //#given
+    const lines = ["function hello() {"]
+    const ref = "0:a3" // Line numbers start at 1
+
+    //#when & #then
+    expect(() => validateLineRef(lines, ref)).toThrow()
+  })
+
+  it("error message includes current hash", () => {
+    //#given
+    const lines = ["function hello() {"]
+    const ref = "1:00"
+
+    //#when & #then
+    expect(() => validateLineRef(lines, ref)).toThrow(/current hash/)
+  })
+})
--- a/src/tools/hashline-edit/validation.ts
+++ b/src/tools/hashline-edit/validation.ts
@ -0,0 +1,39 @@
+import { computeLineHash } from "./hash-computation"
+
+export interface LineRef {
+  line: number
+  hash: string
+}
+
+export function parseLineRef(ref: string): LineRef {
+  const match = ref.match(/^(\d+):([0-9a-f]{2})$/)
+  if (!match) {
+    throw new Error(
+      `Invalid line reference format: "${ref}". Expected format: "LINE:HASH" (e.g., "42:a3")`
+    )
+  }
+  return {
+    line: Number.parseInt(match[1], 10),
+    hash: match[2],
+  }
+}
+
+export function validateLineRef(lines: string[], ref: string): void {
+  const { line, hash } = parseLineRef(ref)
+
+  if (line < 1 || line > lines.length) {
+    throw new Error(
+      `Line number ${line} out of bounds. File has ${lines.length} lines.`
+    )
+  }
+
+  const content = lines[line - 1]
+  const currentHash = computeLineHash(line, content)
+
+  if (currentHash !== hash) {
+    throw new Error(
+      `Hash mismatch at line ${line}. Expected hash: ${hash}, current hash: ${currentHash}. ` +
+        `Line content may have changed. Current content: "${content}"`
+    )
+  }
+}
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@ -43,6 +43,7 @@ export {
  createTaskList,
  createTaskUpdateTool,
 } from "./task"
+export { createHashlineEditTool } from "./hashline-edit"

 export function createBackgroundTools(manager: BackgroundManager, client: OpencodeClient): Record<string, ToolDefinition> {
  const outputManager: BackgroundOutputManager = manager
--- a/src/tools/session-manager/storage.test.ts
+++ b/src/tools/session-manager/storage.test.ts
@ -1,5 +1,5 @@
 import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test"
-import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs"
+import { mkdirSync, writeFileSync, rmSync, existsSync, readdirSync } from "node:fs"
 import { join } from "node:path"
 import { tmpdir } from "node:os"
 import { randomUUID } from "node:crypto"
@ -38,6 +38,27 @@ mock.module("../../shared/opencode-storage-paths", () => ({
  SESSION_STORAGE: TEST_SESSION_STORAGE,
 }))

+mock.module("../../shared/opencode-message-dir", () => ({
+  getMessageDir: (sessionID: string) => {
+    if (!sessionID.startsWith("ses_")) return null
+    if (/[/\\]|\.\./.test(sessionID)) return null
+    if (!existsSync(TEST_MESSAGE_STORAGE)) return null
+
+    const directPath = join(TEST_MESSAGE_STORAGE, sessionID)
+    if (existsSync(directPath)) {
+      return directPath
+    }
+
+    for (const dir of readdirSync(TEST_MESSAGE_STORAGE)) {
+      const nestedPath = join(TEST_MESSAGE_STORAGE, dir, sessionID)
+      if (existsSync(nestedPath)) {
+        return nestedPath
+      }
+    }
+
+    return null
+  },
+}))
 const { getAllSessions, getMessageDir, sessionExists, readSessionMessages, readSessionTodos, getSessionInfo } =
  await import("./storage")
				`@ -0,0 +1 @@`
				`export { createHashlineReadEnhancerHook } from "./hook"`