Merge branch 'dev' into fix/session-prompt-permission-draft

fix(tui): preserve session prompt draft during permissions
feat(server): extract question httpapi contract into packages/server (#22502 )
2026-04-14 19:31:49 -04:00 · 2026-04-14 19:30:24 -04:00 · 2026-04-15 04:54:40 +05:30 · 2026-04-14 23:13:28 +00:00 · 2026-04-14 18:48:00 -04:00 · 2026-04-14 18:37:02 -04:00
130 changed files with 4830 additions and 2307 deletions
@@ -3,4 +3,5 @@ plans
 package.json
 bun.lock
 .gitignore
-package-lock.json
+package-lock.json
+references/
@@ -0,0 +1,21 @@
+---
+name: effect
+description: Answer questions about the Effect framework
+---
+
+# Effect
+
+This codebase uses Effect, a framework for writing typescript.
+
+## How to Answer Effect Questions
+
+1. Clone the Effect repository: `https://github.com/Effect-TS/effect-smol` to
+   `.opencode/references/effect-smol` in this project NOT the skill folder.
+2. Use the explore agent to search the codebase for answers about Effect patterns, APIs, and concepts
+3. Provide responses based on the actual Effect source code and documentation
+
+## Guidelines
+
+- Always use the explore agent with the cloned repository when answering Effect-related questions
+- Reference specific files and patterns found in the Effect codebase
+- Do not answer from memory - always verify against the source
@@ -116,8 +116,8 @@
      "light": "nord5"
    },
    "diffLineNumber": {
-      "dark": "nord2",
-      "light": "nord4"
+      "dark": "#abafb7",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#3B4252",
@@ -342,7 +342,6 @@
        "@aws-sdk/credential-providers": "3.993.0",
        "@clack/prompts": "1.0.0-alpha.1",
        "@effect/platform-node": "catalog:",
-        "@ff-labs/fff-bun": "0.5.2",
        "@gitlab/opencode-gitlab-auth": "1.3.3",
        "@hono/node-server": "1.19.11",
        "@hono/node-ws": "1.3.0",
@@ -357,10 +356,11 @@
        "@opencode-ai/plugin": "workspace:*",
        "@opencode-ai/script": "workspace:*",
        "@opencode-ai/sdk": "workspace:*",
+        "@opencode-ai/server": "workspace:*",
        "@opencode-ai/util": "workspace:*",
        "@openrouter/ai-sdk-provider": "2.5.1",
-        "@opentui/core": "0.1.97",
-        "@opentui/solid": "0.1.97",
+        "@opentui/core": "0.1.99",
+        "@opentui/solid": "0.1.99",
        "@parcel/watcher": "2.5.1",
        "@pierre/diffs": "catalog:",
        "@solid-primitives/event-bus": "1.1.2",
@@ -387,6 +387,7 @@
        "hono": "catalog:",
        "hono-openapi": "catalog:",
        "ignore": "7.0.5",
+        "immer": "11.1.4",
        "jsonc-parser": "3.3.1",
        "mime-types": "3.0.2",
        "minimatch": "10.0.3",
@@ -457,16 +458,16 @@
        "zod": "catalog:",
      },
      "devDependencies": {
-        "@opentui/core": "0.1.97",
-        "@opentui/solid": "0.1.97",
+        "@opentui/core": "0.1.99",
+        "@opentui/solid": "0.1.99",
        "@tsconfig/node22": "catalog:",
        "@types/node": "catalog:",
        "@typescript/native-preview": "catalog:",
        "typescript": "catalog:",
      },
      "peerDependencies": {
-        "@opentui/core": ">=0.1.97",
-        "@opentui/solid": ">=0.1.97",
+        "@opentui/core": ">=0.1.99",
+        "@opentui/solid": ">=0.1.99",
      },
      "optionalPeers": [
        "@opentui/core",
@@ -498,6 +499,16 @@
        "typescript": "catalog:",
      },
    },
+    "packages/server": {
+      "name": "@opencode-ai/server",
+      "version": "1.4.3",
+      "dependencies": {
+        "effect": "catalog:",
+      },
+      "devDependencies": {
+        "typescript": "catalog:",
+      },
+    },
    "packages/slack": {
      "name": "@opencode-ai/slack",
      "version": "1.4.3",
@@ -1153,24 +1164,6 @@

    "@fastify/rate-limit": ["@fastify/rate-limit@10.3.0", "", { "dependencies": { "@lukeed/ms": "^2.0.2", "fastify-plugin": "^5.0.0", "toad-cache": "^3.7.0" } }, "sha512-eIGkG9XKQs0nyynatApA3EVrojHOuq4l6fhB4eeCk4PIOeadvOJz9/4w3vGI44Go17uaXOWEcPkaD8kuKm7g6Q=="],

-    "@ff-labs/fff-bin-darwin-arm64": ["@ff-labs/fff-bin-darwin-arm64@0.5.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-6hkXiB5R5n0eDxibVTDFFXKca1PVpVysWOwgFLyXYr6b0BLI5UcuDSz4vZ1fj4eoH+9rgqIqd65YMZ7e7s3J5g=="],
-
-    "@ff-labs/fff-bin-darwin-x64": ["@ff-labs/fff-bin-darwin-x64@0.5.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-I7q1T9Iw/qnCzGT5dY7nxEdqS18vhTbXwWR2LKNPgxUpoGGv7sMe57QhEGAXT8eKvPh8hgZneU8VLt49wmFYRw=="],
-
-    "@ff-labs/fff-bin-linux-arm64-gnu": ["@ff-labs/fff-bin-linux-arm64-gnu@0.5.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-iputHhH4bpOegz+j14JcypuelNPdUwwx3oJavln02jNY1oouPNhC2tNMJKSXgkUgAbuGRn26iXSlUPNwIl0ftQ=="],
-
-    "@ff-labs/fff-bin-linux-arm64-musl": ["@ff-labs/fff-bin-linux-arm64-musl@0.5.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-5ySavoc0Q5Cr1qKIBj2s8roQEFhCgJM8ndCM6AcPv5tuFirBHJe9iT3OG0x0/u9Mm70MosIYbd3dnbC3QwIWzw=="],
-
-    "@ff-labs/fff-bin-linux-x64-gnu": ["@ff-labs/fff-bin-linux-x64-gnu@0.5.2", "", { "os": "linux", "cpu": "x64" }, "sha512-lRMcoeNlGsqN1jVup95TfWfz74Funn8nuzVVxZUzmZbQOWEDkhfULUB8jpaz9Q7sDq5hqhMa5+zJf29sKuw0hw=="],
-
-    "@ff-labs/fff-bin-linux-x64-musl": ["@ff-labs/fff-bin-linux-x64-musl@0.5.2", "", { "os": "linux", "cpu": "x64" }, "sha512-QvNTGvZNKj8h/ZuCY/g+/WMQagK6E8U0Zv3vCbZgUsegvMtGpVNW42w8jiUC21136DnmfF8rG0mz8SsR/99qHw=="],
-
-    "@ff-labs/fff-bin-win32-arm64": ["@ff-labs/fff-bin-win32-arm64@0.5.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-mT0A0FsZRgVPDsg4czksGYUuMqXodlrg97ss6jEs60upvHWGTWpgkoiRfm80u2ixVzx0z8yqhbquol1C/mvKGA=="],
-
-    "@ff-labs/fff-bin-win32-x64": ["@ff-labs/fff-bin-win32-x64@0.5.2", "", { "os": "win32", "cpu": "x64" }, "sha512-aca29wsv0XcTTwKd0GOpDBZPgMrvs0osqGSqp2cYrznH7/wQZySHYDlXni7b4SY6oqxmuQQYXXwQzAn8CoqLsQ=="],
-
-    "@ff-labs/fff-bun": ["@ff-labs/fff-bun@0.5.2", "", { "optionalDependencies": { "@ff-labs/fff-bin-darwin-arm64": "0.5.2", "@ff-labs/fff-bin-darwin-x64": "0.5.2", "@ff-labs/fff-bin-linux-arm64-gnu": "0.5.2", "@ff-labs/fff-bin-linux-arm64-musl": "0.5.2", "@ff-labs/fff-bin-linux-x64-gnu": "0.5.2", "@ff-labs/fff-bin-linux-x64-musl": "0.5.2", "@ff-labs/fff-bin-win32-arm64": "0.5.2", "@ff-labs/fff-bin-win32-x64": "0.5.2" }, "peerDependencies": { "bun": ">=1.0.0" }, "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "fff-demo": "examples/search.ts", "fff-grep": "examples/grep.ts" } }, "sha512-puwgVLi7RfjzqB4biVB5ZCvtLbTf34yEorJ3PhBpwaM0pB8hFM+9VRXdNhGF+I3F0LU6twuNsS43AomgyrdDvQ=="],
-
    "@floating-ui/core": ["@floating-ui/core@1.7.5", "", { "dependencies": { "@floating-ui/utils": "^0.2.11" } }, "sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ=="],

    "@floating-ui/dom": ["@floating-ui/dom@1.7.6", "", { "dependencies": { "@floating-ui/core": "^1.7.5", "@floating-ui/utils": "^0.2.11" } }, "sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ=="],
@@ -1551,6 +1544,8 @@

    "@opencode-ai/sdk": ["@opencode-ai/sdk@workspace:packages/sdk/js"],

+    "@opencode-ai/server": ["@opencode-ai/server@workspace:packages/server"],
+
    "@opencode-ai/slack": ["@opencode-ai/slack@workspace:packages/slack"],

    "@opencode-ai/storybook": ["@opencode-ai/storybook@workspace:packages/storybook"],
@@ -1565,21 +1560,21 @@

    "@opentelemetry/api": ["@opentelemetry/api@1.9.0", "", {}, "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg=="],

-    "@opentui/core": ["@opentui/core@0.1.97", "", { "dependencies": { "bun-ffi-structs": "0.1.2", "diff": "8.0.2", "jimp": "1.6.0", "marked": "17.0.1", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@dimforge/rapier2d-simd-compat": "^0.17.3", "@opentui/core-darwin-arm64": "0.1.97", "@opentui/core-darwin-x64": "0.1.97", "@opentui/core-linux-arm64": "0.1.97", "@opentui/core-linux-x64": "0.1.97", "@opentui/core-win32-arm64": "0.1.97", "@opentui/core-win32-x64": "0.1.97", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-2ENH0Dc4NUAeHeeQCQhF1lg68RuyntOUP68UvortvDqTz/hqLG0tIwF+DboCKtWi8Nmao4SAQEJ7lfmyQNEDOQ=="],
+    "@opentui/core": ["@opentui/core@0.1.99", "", { "dependencies": { "bun-ffi-structs": "0.1.2", "diff": "8.0.2", "jimp": "1.6.0", "marked": "17.0.1", "yoga-layout": "3.2.1" }, "optionalDependencies": { "@dimforge/rapier2d-simd-compat": "^0.17.3", "@opentui/core-darwin-arm64": "0.1.99", "@opentui/core-darwin-x64": "0.1.99", "@opentui/core-linux-arm64": "0.1.99", "@opentui/core-linux-x64": "0.1.99", "@opentui/core-win32-arm64": "0.1.99", "@opentui/core-win32-x64": "0.1.99", "bun-webgpu": "0.1.5", "planck": "^1.4.2", "three": "0.177.0" }, "peerDependencies": { "web-tree-sitter": "0.25.10" } }, "sha512-I3+AEgGzqNWIpWX9g2WOscSPwtQDNOm4KlBjxBWCZjLxkF07u77heWXF7OiAdhKLtNUW6TFiyt6yznqAZPdG3A=="],

-    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.97", "", { "os": "darwin", "cpu": "arm64" }, "sha512-t7oMGEfMPQsqLEx7/rPqv/UGJ+vqhe4RWHRRQRYcuHuLKssZ2S8P9mSS7MBPtDqGcxg4PosCrh5nHYeZ94EXUw=="],
+    "@opentui/core-darwin-arm64": ["@opentui/core-darwin-arm64@0.1.99", "", { "os": "darwin", "cpu": "arm64" }, "sha512-bzVrqeX2vb5iWrc/ftOUOqeUY8XO+qSgoTwj5TXHuwagavgwD3Hpeyjx8+icnTTeM4pao0som1WR9xfye6/X5Q=="],

-    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.97", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZuPWAawlVat6ZHb8vaH/CVUeGwI0pI4vd+6zz1ZocZn95ZWJztfyhzNZOJrq1WjHmUROieJ7cOuYUZfvYNuLrg=="],
+    "@opentui/core-darwin-x64": ["@opentui/core-darwin-x64@0.1.99", "", { "os": "darwin", "cpu": "x64" }, "sha512-VE4FrXBYpkxnvkqcCV1a8aN9jyyMJMihVW+V2NLCtp+4yQsj0AapG5TiUSN76XnmSZRptxDy5rBmEempeoIZbg=="],

-    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.97", "", { "os": "linux", "cpu": "arm64" }, "sha512-QXxhz654vXgEu2wrFFFFnrSWbyk6/r6nXNnDTcMRWofdMZQLx87NhbcsErNmz9KmFdzoPiQSmlpYubLflKKzqQ=="],
+    "@opentui/core-linux-arm64": ["@opentui/core-linux-arm64@0.1.99", "", { "os": "linux", "cpu": "arm64" }, "sha512-viXQsbpS7yHjYkl7+am32JdvG96QU9lvHh1UiZtpOxcNUUqiYmA2ZwZFPD2Bi54jNyj5l2hjH6YkD3DzE2FEWA=="],

-    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.97", "", { "os": "linux", "cpu": "x64" }, "sha512-v3z0QWpRS3p8blE/A7pTu15hcFMtSndeiYhRxhrjp6zAhQ+UlruQs9DAG1ifSuVO1RJJ0pUKklFivdbu0pMzuw=="],
+    "@opentui/core-linux-x64": ["@opentui/core-linux-x64@0.1.99", "", { "os": "linux", "cpu": "x64" }, "sha512-WLoEFINOSp0tZSR9y4LUuGc7n4Y7H1wcpjUPzQ9vChkYDXrfZltEanzoDWbDcQ4kZQW5tHVC7LrZHpAsRLwFZg=="],

-    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.97", "", { "os": "win32", "cpu": "arm64" }, "sha512-o/m9mD1dvOCwkxOUUyoEILl+d6tzh/85foJc4uqjXYi71NNcwg8u+Eq3/gdHuSKnlT1pusCPKoS1IDuBvZE24A=="],
+    "@opentui/core-win32-arm64": ["@opentui/core-win32-arm64@0.1.99", "", { "os": "win32", "cpu": "arm64" }, "sha512-yWMOLWCEO8HdrctU1dMkgZC8qGkiO4Dwr4/e11tTvVpRmYhDsP/IR89ZjEEtOwnKwFOFuB/MxvflqaEWVQ2g5Q=="],

-    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.97", "", { "os": "win32", "cpu": "x64" }, "sha512-Rwp7JOwrYm4wtzPHY2vv+2l91LXmKSI7CtbmWN1sSUGhBPtPGSvfwux3W5xaAZQa2KPEXicPjaKJZc+pob3YRg=="],
+    "@opentui/core-win32-x64": ["@opentui/core-win32-x64@0.1.99", "", { "os": "win32", "cpu": "x64" }, "sha512-aYRlsL2w8YRL6vPd7/hrqlNVkXU3QowWb01TOvAcHS8UAsXaGFUr47kSDyjxDi1wg1MzmVduCfsC7T3NoThV1w=="],

-    "@opentui/solid": ["@opentui/solid@0.1.97", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.1.97", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.10", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.11" } }, "sha512-ma/uihG38F+6oLJVD8yR7z82FWmR8QhfesNV5SBXbN74riMCRyy6kyQ6SI4xs4ykt9BbZOjrKLq+Xt/0Pd0SJQ=="],
+    "@opentui/solid": ["@opentui/solid@0.1.99", "", { "dependencies": { "@babel/core": "7.28.0", "@babel/preset-typescript": "7.27.1", "@opentui/core": "0.1.99", "babel-plugin-module-resolver": "5.0.2", "babel-preset-solid": "1.9.10", "entities": "7.0.1", "s-js": "^0.4.9" }, "peerDependencies": { "solid-js": "1.9.11" } }, "sha512-DrqqO4h2V88FmeIP2cErYkMU0ZK5MrUsZw3w6IzZpoXyyiL4/9qpWzUq+CXx+r16VP2iGxDJwGKUmtFAzUch2Q=="],

    "@oslojs/asn1": ["@oslojs/asn1@1.0.0", "", { "dependencies": { "@oslojs/binary": "1.0.0" } }, "sha512-zw/wn0sj0j0QKbIXfIlnEcTviaCzYOY3V5rAyjR6YtOByFtJiT574+8p9Wlach0lZH9fddD4yb9laEAIl4vXQA=="],

@@ -1591,30 +1586,6 @@

    "@oslojs/jwt": ["@oslojs/jwt@0.2.0", "", { "dependencies": { "@oslojs/encoding": "0.4.1" } }, "sha512-bLE7BtHrURedCn4Mco3ma9L4Y1GR2SMBuIvjWr7rmQ4/W/4Jy70TIAgZ+0nIlk0xHz1vNP8x8DCns45Sb2XRbg=="],

-    "@oven/bun-darwin-aarch64": ["@oven/bun-darwin-aarch64@1.3.12", "", { "os": "darwin", "cpu": "arm64" }, "sha512-b6CQgT28Jx7uDwMTcGo7WFqUd1+wWTdp8XyPi/4LRcL/R4deKT7cLx/Q2ZCWAiK6ZU7yexoCaIaKun6azjRLVA=="],
-
-    "@oven/bun-darwin-x64": ["@oven/bun-darwin-x64@1.3.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-//6W21c+GinAMMmxD2hFrFmJH+ZlEwJYbLzAGqp0mLFTli9y74RMtDgI2n9pCupXSpU1Kr1sSylVW9yNbAG9Xg=="],
-
-    "@oven/bun-darwin-x64-baseline": ["@oven/bun-darwin-x64-baseline@1.3.12", "", { "os": "darwin", "cpu": "x64" }, "sha512-9jKJNOc9ID3BxPBPR4r1Mp1Wqde89Twi5zo2LoEMLMKbqpvEM/WUGdJ0Vv7OX1QPEqVblFO6NMky5yY7rjDI2w=="],
-
-    "@oven/bun-linux-aarch64": ["@oven/bun-linux-aarch64@1.3.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-eTru6tk3K4Ya3SSkUqq/LbdEjwPqLlfINmIhRORrCExBdB1tQbk+WYYflaymO61fkrjnMAjmLTGqk/K37RMIGA=="],
-
-    "@oven/bun-linux-aarch64-musl": ["@oven/bun-linux-aarch64-musl@1.3.12", "", { "os": "linux", "cpu": "arm64" }, "sha512-HWIwFzm5fALd9Lli0CgaKb6xOGqODYyHpUTgkn/IHHuS/f3XDCu71+GgkyvfgCYbPoBSgBOfp5TzhRehPcgxow=="],
-
-    "@oven/bun-linux-x64": ["@oven/bun-linux-x64@1.3.12", "", { "os": "linux", "cpu": "x64" }, "sha512-H75bcEn46lMDxd+P+R6Q/jlIKl/YO0ZXaalSyWhQHr7qNmFhQt3rOHurFoCxuwQeqFoToh0JpWVyMVzByZqgBQ=="],
-
-    "@oven/bun-linux-x64-baseline": ["@oven/bun-linux-x64-baseline@1.3.12", "", { "os": "linux", "cpu": "x64" }, "sha512-0y+lUiQsPvSGsyM/10KtxhVAQ20p6/D+vj01l6vo9gHpYUpyc1L9pSgaPa7SC9TuaiGASlM3Cb62bmSKW0E/3Q=="],
-
-    "@oven/bun-linux-x64-musl": ["@oven/bun-linux-x64-musl@1.3.12", "", { "os": "linux", "cpu": "x64" }, "sha512-Zb7T3JxWlArSe44ATO5mtjLCBCt7kenWPl9CYD+zeqq9kHswMv8Cd3h/9uzdv2PA4Flrq57J5XBSuRdStTCXCw=="],
-
-    "@oven/bun-linux-x64-musl-baseline": ["@oven/bun-linux-x64-musl-baseline@1.3.12", "", { "os": "linux", "cpu": "x64" }, "sha512-jdsnuFD3H0l4AHtf1nInRHYWIMTWqok0aW8WysjzN5Isn6rBTBGK/ZWX6XjdTgDgcuVbVOYHiLUHHrvT9N6psA=="],
-
-    "@oven/bun-windows-aarch64": ["@oven/bun-windows-aarch64@1.3.12", "", { "os": "win32", "cpu": "arm64" }, "sha512-Oq0FIcCgL3JWf/4qRuxI5fxsOGyWJ1j904PDx/1TxxSCWWAu0Hh2o8ck4TcaPVv/3BMc1k6UxqQQKBrdP7a+qQ=="],
-
-    "@oven/bun-windows-x64": ["@oven/bun-windows-x64@1.3.12", "", { "os": "win32", "cpu": "x64" }, "sha512-veSntY7pDLDh4XmxZMwTqxfoEVp0BDdeqCBoWL46/TigtniPtDFSTIWBxa6l/RcGzklUA/uqLqmsK/9cBZAm8Q=="],
-
-    "@oven/bun-windows-x64-baseline": ["@oven/bun-windows-x64-baseline@1.3.12", "", { "os": "win32", "cpu": "x64" }, "sha512-rV21md7QWnu3r/shev7IFMh6hX8BJHwofxESAofUT4yH866oCIbcNbzp6+fxrj4oGD8uisP6WoaTCboijv9yYg=="],
-
    "@oxc-minify/binding-android-arm64": ["@oxc-minify/binding-android-arm64@0.96.0", "", { "os": "android", "cpu": "arm64" }, "sha512-lzeIEMu/v6Y+La5JSesq4hvyKtKBq84cgQpKYTYM/yGuNk2tfd5Ha31hnC+mTh48lp/5vZH+WBfjVUjjINCfug=="],

    "@oxc-minify/binding-darwin-arm64": ["@oxc-minify/binding-darwin-arm64@0.96.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-i0LkJAUXb4BeBFrJQbMKQPoxf8+cFEffDyLSb7NEzzKuPcH8qrVsnEItoOzeAdYam8Sr6qCHVwmBNEQzl7PWpw=="],
@@ -2627,8 +2598,6 @@

    "builder-util-runtime": ["builder-util-runtime@9.5.1", "", { "dependencies": { "debug": "^4.3.4", "sax": "^1.2.4" } }, "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ=="],

-    "bun": ["bun@1.3.12", "", { "optionalDependencies": { "@oven/bun-darwin-aarch64": "1.3.12", "@oven/bun-darwin-x64": "1.3.12", "@oven/bun-darwin-x64-baseline": "1.3.12", "@oven/bun-linux-aarch64": "1.3.12", "@oven/bun-linux-aarch64-musl": "1.3.12", "@oven/bun-linux-x64": "1.3.12", "@oven/bun-linux-x64-baseline": "1.3.12", "@oven/bun-linux-x64-musl": "1.3.12", "@oven/bun-linux-x64-musl-baseline": "1.3.12", "@oven/bun-windows-aarch64": "1.3.12", "@oven/bun-windows-x64": "1.3.12", "@oven/bun-windows-x64-baseline": "1.3.12" }, "os": [ "linux", "win32", "darwin", ], "cpu": [ "x64", "arm64", ], "bin": { "bun": "bin/bun.exe", "bunx": "bin/bunx.exe" } }, "sha512-KLwDUqs5WIny/94F4xZ4QfaAE6YWyjR+s79pt/ItQhk2CG+PJQ5xL6VuOWhiyN2eP3fryZK95vog9CTLCaYV2Q=="],
-
    "bun-ffi-structs": ["bun-ffi-structs@0.1.2", "", { "peerDependencies": { "typescript": "^5" } }, "sha512-Lh1oQAYHDcnesJauieA4UNkWGXY9hYck7OA5IaRwE3Bp6K2F2pJSNYqq+hIy7P3uOvo3km3oxS8304g5gDMl/w=="],

    "bun-pty": ["bun-pty@0.4.8", "", {}, "sha512-rO70Mrbr13+jxHHHu2YBkk2pNqrJE5cJn29WE++PUr+GFA0hq/VgtQPZANJ8dJo6d7XImvBk37Innt8GM7O28w=="],
@@ -3381,6 +3350,8 @@

    "image-q": ["image-q@4.0.0", "", { "dependencies": { "@types/node": "16.9.1" } }, "sha512-PfJGVgIfKQJuq3s0tTDOKtztksibuUEbJQIYT3by6wctQo+Rdlh7ef4evJ5NCdxY4CfMbvFkocEwbl4BF8RlJw=="],

+    "immer": ["immer@11.1.4", "", {}, "sha512-XREFCPo6ksxVzP4E0ekD5aMdf8WMwmdNaz6vuvxgI40UaEiu6q3p8X52aU6GdyvLY3XXX/8R7JOTXStz/nBbRw=="],
+
    "import-local": ["import-local@3.2.0", "", { "dependencies": { "pkg-dir": "^4.2.0", "resolve-cwd": "^3.0.0" }, "bin": { "import-local-fixture": "fixtures/cli.js" } }, "sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA=="],

    "import-meta-resolve": ["import-meta-resolve@4.2.0", "", {}, "sha512-Iqv2fzaTQN28s/FwZAoFq0ZSs/7hMAHJVX+w8PZl3cY19Pxk6jFFalxQoIfW2826i/fDLXv8IiEZRIT0lDuWcg=="],
@@ -1,8 +1,8 @@
 {
  "nodeModules": {
-    "x86_64-linux": "sha256-StHGWSONcykyo5kk3aEdfTu4BcwPEA5PbtJN2W2rIhs=",
-    "aarch64-linux": "sha256-W0nu5L0W4YiGx15nmzi+JInV0Bh04JOPQxp0lRRgMWQ=",
-    "aarch64-darwin": "sha256-k1hYWg3s5eK7qHFJPBvJtt1IllRL969vNUdXe8ITR4Y=",
-    "x86_64-darwin": "sha256-Mpsgkm5uAREitA9zeG9XtQ8hUL+umLJLENUww4mhWes="
+    "x86_64-linux": "sha256-2p0WOk7qE2zC8S5mIDmpefjhJv8zhsgT33crGFWl6LI=",
+    "aarch64-linux": "sha256-sMW7pXoFtV6r4ySoYB8ISqKFHFeAMmiCUvHtiplwxak=",
+    "aarch64-darwin": "sha256-/4g2e39t9huLXOObdolDPmImGNhndOsxeAGJjw+bE8g=",
+    "x86_64-darwin": "sha256-SJ9y58ZwQnXhMtus0ITQo3sfHzHfOSPkJRK24n5pnBw="
  }
 }
@@ -7,7 +7,6 @@
  sysctl,
  makeBinaryWrapper,
  models-dev,
-  ripgrep,
  installShellFiles,
  versionCheckHook,
  writableTmpDirAsHomeHook,
@@ -52,25 +51,25 @@ stdenvNoCC.mkDerivation (finalAttrs: {
    runHook postBuild
  '';

-  installPhase = ''
-    runHook preInstall
+  installPhase =
+    ''
+      runHook preInstall

-    install -Dm755 dist/opencode-*/bin/opencode $out/bin/opencode
-    install -Dm644 schema.json $out/share/opencode/schema.json
-
-    wrapProgram $out/bin/opencode \
-      --prefix PATH : ${
-        lib.makeBinPath (
-          [
-            ripgrep
+      install -Dm755 dist/opencode-*/bin/opencode $out/bin/opencode
+      install -Dm644 schema.json $out/share/opencode/schema.json
+    ''
+    # bun runs sysctl to detect if dunning on rosetta2
+    + lib.optionalString stdenvNoCC.hostPlatform.isDarwin ''
+      wrapProgram $out/bin/opencode \
+        --prefix PATH : ${
+          lib.makeBinPath [
+            sysctl
          ]
-          # bun runs sysctl to detect if dunning on rosetta2
-          ++ lib.optional stdenvNoCC.hostPlatform.isDarwin sysctl
-        )
-      }
-
-    runHook postInstall
-  '';
+        }
+    ''
+    + ''
+      runHook postInstall
+    '';

  postInstall = lib.optionalString (stdenvNoCC.buildPlatform.canExecute stdenvNoCC.hostPlatform) ''
    # trick yargs into also generating zsh completions
@@ -106,7 +106,7 @@ export async function handler(
    const zenData = ZenData.list(opts.modelList)
    const modelInfo = validateModel(zenData, model)
    const dataDumper = createDataDumper(sessionId, requestId, projectId)
-    const trialLimiter = createTrialLimiter(modelInfo.trialProviders, ip)
+    const trialLimiter = createTrialLimiter(modelInfo.trialProvider, ip)
    const trialProviders = await trialLimiter?.check()
    const rateLimiter = createRateLimiter(
      modelInfo.id,
@@ -392,7 +392,7 @@ export async function handler(
  function validateModel(zenData: ZenData, reqModel: string) {
    if (!(reqModel in zenData.models)) throw new ModelError(t("zen.api.error.modelNotSupported", { model: reqModel }))

-    const modelId = reqModel as keyof typeof zenData.models
+    const modelId = reqModel
    const modelData = Array.isArray(zenData.models[modelId])
      ? zenData.models[modelId].find((model) => opts.format === model.formatFilter)
      : zenData.models[modelId]
@@ -6,12 +6,14 @@ type Usage = {
  total_tokens?: number
  // used by moonshot
  cached_tokens?: number
-  // used by xai
+  // used by xai & alibaba
  prompt_tokens_details?: {
    text_tokens?: number
    audio_tokens?: number
    image_tokens?: number
    cached_tokens?: number
+    // used by alibaba
+    cache_creation_input_tokens?: number
  }
  completion_tokens_details?: {
    reasoning_tokens?: number
@@ -62,6 +64,7 @@ export const oaCompatHelper: ProviderHelper = ({ adjustCacheUsage, safetyIdentif
    const outputTokens = usage.completion_tokens ?? 0
    const reasoningTokens = usage.completion_tokens_details?.reasoning_tokens ?? undefined
    let cacheReadTokens = usage.cached_tokens ?? usage.prompt_tokens_details?.cached_tokens ?? undefined
+    const cacheWriteTokens = usage.prompt_tokens_details?.cache_creation_input_tokens ?? undefined

    if (adjustCacheUsage && !cacheReadTokens) {
      cacheReadTokens = Math.floor(inputTokens * 0.9)
@@ -72,7 +75,7 @@ export const oaCompatHelper: ProviderHelper = ({ adjustCacheUsage, safetyIdentif
      outputTokens,
      reasoningTokens,
      cacheReadTokens,
-      cacheWrite5mTokens: undefined,
+      cacheWrite5mTokens: cacheWriteTokens,
      cacheWrite1hTokens: undefined,
    }
  },
@@ -26,7 +26,7 @@ export namespace ZenData {
    allowAnonymous: z.boolean().optional(),
    byokProvider: z.enum(["openai", "anthropic", "google"]).optional(),
    stickyProvider: z.enum(["strict", "prefer"]).optional(),
-    trialProviders: z.array(z.string()).optional(),
+    trialProvider: z.string().optional(),
    trialEnded: z.boolean().optional(),
    fallbackProvider: z.string().optional(),
    rateLimit: z.number().optional(),
@@ -45,7 +45,7 @@ export namespace ZenData {

  const ProviderSchema = z.object({
    api: z.string(),
-    apiKey: z.string(),
+    apiKey: z.union([z.string(), z.record(z.string(), z.string())]),
    format: FormatSchema.optional(),
    headerMappings: z.record(z.string(), z.string()).optional(),
    payloadModifier: z.record(z.string(), z.any()).optional(),
@@ -54,7 +54,10 @@ export namespace ZenData {
  })

  const ModelsSchema = z.object({
-    models: z.record(z.string(), z.union([ModelSchema, z.array(ModelSchema.extend({ formatFilter: FormatSchema }))])),
+    zenModels: z.record(
+      z.string(),
+      z.union([ModelSchema, z.array(ModelSchema.extend({ formatFilter: FormatSchema }))]),
+    ),
    liteModels: z.record(
      z.string(),
      z.union([ModelSchema, z.array(ModelSchema.extend({ formatFilter: FormatSchema }))]),
@@ -99,10 +102,66 @@ export namespace ZenData {
        Resource.ZEN_MODELS29.value +
        Resource.ZEN_MODELS30.value,
    )
-    const { models, liteModels, providers } = ModelsSchema.parse(json)
+    const { zenModels, liteModels, providers } = ModelsSchema.parse(json)
+    const compositeProviders = Object.fromEntries(
+      Object.entries(providers).map(([id, provider]) => [
+        id,
+        typeof provider.apiKey === "string"
+          ? [{ id: id, key: provider.apiKey }]
+          : Object.entries(provider.apiKey).map(([kid, key]) => ({
+              id: `${id}.${kid}`,
+              key,
+            })),
+      ]),
+    )
    return {
-      models: modelList === "lite" ? liteModels : models,
-      providers,
+      providers: Object.fromEntries(
+        Object.entries(providers).flatMap(([providerId, provider]) =>
+          compositeProviders[providerId].map((p) => [p.id, { ...provider, apiKey: p.key }]),
+        ),
+      ),
+      models: (() => {
+        const normalize = (model: z.infer<typeof ModelSchema>) => {
+          const composite = model.providers.find((p) => compositeProviders[p.id].length > 1)
+          if (!composite)
+            return {
+              trialProvider: model.trialProvider ? [model.trialProvider] : undefined,
+            }
+
+          const weightMulti = compositeProviders[composite.id].length
+
+          return {
+            trialProvider: (() => {
+              if (!model.trialProvider) return undefined
+              if (model.trialProvider === composite.id) return compositeProviders[composite.id].map((p) => p.id)
+              return [model.trialProvider]
+            })(),
+            providers: model.providers.flatMap((p) =>
+              p.id === composite.id
+                ? compositeProviders[p.id].map((sub) => ({
+                    ...p,
+                    id: sub.id,
+                    weight: p.weight ?? 1,
+                  }))
+                : [
+                    {
+                      ...p,
+                      weight: (p.weight ?? 1) * weightMulti,
+                    },
+                  ],
+            ),
+          }
+        }
+
+        return Object.fromEntries(
+          Object.entries(modelList === "lite" ? liteModels : zenModels).map(([modelId, model]) => {
+            const n = Array.isArray(model)
+              ? model.map((m) => ({ ...m, ...normalize(m) }))
+              : { ...model, ...normalize(model) }
+            return [modelId, n]
+          }),
+        )
+      })(),
    }
  })
 }
@@ -28,11 +28,6 @@
      "node": "./src/storage/db.node.ts",
      "default": "./src/storage/db.bun.ts"
    },
-    "#fff": {
-      "bun": "./src/file/fff.bun.ts",
-      "node": "./src/file/fff.node.ts",
-      "default": "./src/file/fff.bun.ts"
-    },
    "#pty": {
      "bun": "./src/pty/pty.bun.ts",
      "node": "./src/pty/pty.node.ts",
@@ -104,7 +99,6 @@
    "@aws-sdk/credential-providers": "3.993.0",
    "@clack/prompts": "1.0.0-alpha.1",
    "@effect/platform-node": "catalog:",
-    "@ff-labs/fff-bun": "0.5.2",
    "@gitlab/opencode-gitlab-auth": "1.3.3",
    "@hono/node-server": "1.19.11",
    "@hono/node-ws": "1.3.0",
@@ -117,12 +111,13 @@
    "@octokit/rest": "catalog:",
    "@openauthjs/openauth": "catalog:",
    "@opencode-ai/plugin": "workspace:*",
+    "@opencode-ai/server": "workspace:*",
    "@opencode-ai/script": "workspace:*",
    "@opencode-ai/sdk": "workspace:*",
    "@opencode-ai/util": "workspace:*",
    "@openrouter/ai-sdk-provider": "2.5.1",
-    "@opentui/core": "0.1.97",
-    "@opentui/solid": "0.1.97",
+    "@opentui/core": "0.1.99",
+    "@opentui/solid": "0.1.99",
    "@parcel/watcher": "2.5.1",
    "@pierre/diffs": "catalog:",
    "@solid-primitives/event-bus": "1.1.2",
@@ -149,6 +144,7 @@
    "hono": "catalog:",
    "hono-openapi": "catalog:",
    "ignore": "7.0.5",
+    "immer": "11.1.4",
    "jsonc-parser": "3.3.1",
    "mime-types": "3.0.2",
    "minimatch": "10.0.3",
@@ -33,31 +33,38 @@ const seed = async () => {
          }),
        )

-        const session = await Session.create({ title })
-        const messageID = MessageID.ascending()
-        const partID = PartID.ascending()
-        const message = {
-          id: messageID,
-          sessionID: session.id,
-          role: "user" as const,
-          time: { created: now },
-          agent: "build",
-          model: {
-            providerID: ProviderID.make(providerID),
-            modelID: ModelID.make(modelID),
-          },
-        }
-        const part = {
-          id: partID,
-          sessionID: session.id,
-          messageID,
-          type: "text" as const,
-          text,
-          time: { start: now },
-        }
-        await Session.updateMessage(message)
-        await Session.updatePart(part)
-        await Project.update({ projectID: Instance.project.id, name: "E2E Project" })
+        await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const session = yield* Session.Service
+            const result = yield* session.create({ title })
+            const messageID = MessageID.ascending()
+            const partID = PartID.ascending()
+            const message = {
+              id: messageID,
+              sessionID: result.id,
+              role: "user" as const,
+              time: { created: now },
+              agent: "build",
+              model: {
+                providerID: ProviderID.make(providerID),
+                modelID: ModelID.make(modelID),
+              },
+            }
+            const part = {
+              id: partID,
+              sessionID: result.id,
+              messageID,
+              type: "text" as const,
+              text,
+              time: { start: now },
+            }
+            yield* session.updateMessage(message)
+            yield* session.updatePart(part)
+          }),
+        )
+        await AppRuntime.runPromise(
+          Project.Service.use((svc) => svc.update({ projectID: Instance.project.id, name: "E2E Project" })),
+        )
      },
    })
  } finally {
@@ -104,6 +104,19 @@ Introduce one small `HttpApi` group for plain JSON endpoints only. Good initial

 Avoid `session.ts`, SSE, websocket, and TUI-facing routes first.

+Recommended first slice:
+
+- start with `question`
+- start with `GET /question`
+- start with `POST /question/:requestID/reply`
+
+Why `question` first:
+
+- already JSON-only
+- already delegates into an Effect service
+- proves list + mutation + params + payload + OpenAPI in one small slice
+- avoids the harder streaming and middleware cases
+
 ### 3. Reuse existing services

 Do not re-architect business logic during the HTTP migration. `HttpApi` handlers should call the same Effect services already used by the Hono handlers.
@@ -121,13 +134,257 @@ Prefer mounting an experimental `HttpApi` surface alongside the existing Hono ro

 If the parallel slice works well, migrate additional JSON route groups one at a time. Leave streaming-style endpoints on Hono until there is a clear reason to move them.

-## Proposed first steps
+## Schema rule for HttpApi work

- [ ] add one small spike that defines an `HttpApi` group for a simple JSON route set
- [ ] use Effect Schema request / response types for that slice
- [ ] keep the underlying service calls identical to the current handlers
- [ ] compare generated OpenAPI against the current Hono/OpenAPI setup
- [ ] document how auth, instance lookup, and error mapping would compose in the new stack
+Every `HttpApi` slice should follow `specs/effect/schema.md` and the Schema -> Zod interop rule in `specs/effect/migration.md`.
+
+Default rule:
+
+- Effect Schema owns the type
+- `.zod` exists only as a compatibility surface
+- do not introduce a new hand-written Zod schema for a type that is already migrating to Effect Schema
+
+Practical implication for `HttpApi` migration:
+
+- if a route boundary already depends on a shared DTO, ID, input, output, or tagged error, migrate that model to Effect Schema first or in the same change
+- if an existing Hono route or tool still needs Zod, derive it with `@/util/effect-zod`
+- avoid maintaining parallel Zod and Effect definitions for the same request or response type
+
+Ordering for a route-group migration:
+
+1. move implicated shared `schema.ts` leaf types to Effect Schema first
+2. move exported `Info` / `Input` / `Output` route DTOs to Effect Schema
+3. move tagged route-facing errors to `Schema.TaggedErrorClass` where needed
+4. switch existing Zod boundary validators to derived `.zod`
+5. define the `HttpApi` contract from the canonical Effect schemas
+
+Temporary exception:
+
+- it is acceptable to keep a route-local Zod schema for the first spike only when the type is boundary-local and migrating it would create unrelated churn
+- if that happens, leave a short note so the type does not become a permanent second source of truth
+
+## First vertical slice
+
+The first `HttpApi` spike should be intentionally small and repeatable.
+
+Chosen slice:
+
+- group: `question`
+- endpoints: `GET /question` and `POST /question/:requestID/reply`
+
+Non-goals:
+
+- no `session` routes
+- no SSE or websocket routes
+- no auth redesign
+- no broad service refactor
+
+Behavior rule:
+
+- preserve current runtime behavior first
+- treat semantic changes such as introducing new `404` behavior as a separate follow-up unless they are required to make the contract honest
+
+Add `POST /question/:requestID/reject` only after the first two endpoints work cleanly.
+
+## Repeatable slice template
+
+Use the same sequence for each route group.
+
+1. Pick one JSON-only route group that already mostly delegates into services.
+2. Identify the shared DTOs, IDs, and errors implicated by that slice.
+3. Apply the schema migration ordering above so those types are Effect Schema-first.
+4. Define the `HttpApi` contract separately from the handlers.
+5. Implement handlers by yielding the existing service from context.
+6. Mount the new surface in parallel under an experimental prefix.
+7. Add one end-to-end test and one OpenAPI-focused test.
+8. Compare ergonomics before migrating the next endpoint.
+
+Rule of thumb:
+
+- migrate one route group at a time
+- migrate one or two endpoints first, not the whole file
+- keep business logic in the existing service
+- keep the first spike easy to delete if the experiment is not worth continuing
+
+## Example structure
+
+Placement rule:
+
+- keep `HttpApi` code under `src/server`, not `src/effect`
+- `src/effect` should stay focused on runtimes, layers, instance state, and shared Effect plumbing
+- place each `HttpApi` slice next to the HTTP boundary it serves
+- for instance-scoped routes, prefer `src/server/instance/httpapi/*`
+- if control-plane routes ever migrate, prefer `src/server/control/httpapi/*`
+
+Suggested file layout for a repeatable spike:
+
+- `src/server/instance/httpapi/question.ts`
+- `src/server/instance/httpapi/index.ts`
+- `test/server/question-httpapi.test.ts`
+- `test/server/question-httpapi-openapi.test.ts`
+
+Suggested responsibilities:
+
+- `question.ts` defines the `HttpApi` contract and `HttpApiBuilder.group(...)` handlers for the experimental slice
+- `index.ts` combines experimental `HttpApi` groups and exposes the mounted handler or layer
+- `question-httpapi.test.ts` proves the route works end-to-end against the real service
+- `question-httpapi-openapi.test.ts` proves the generated OpenAPI is acceptable for the migrated endpoints
+
+## Example migration shape
+
+Each route-group spike should follow the same shape.
+
+### 1. Contract
+
+- define an experimental `HttpApi`
+- define one `HttpApiGroup`
+- define endpoint params, payload, success, and error schemas from canonical Effect schemas
+- annotate summary, description, and operation ids explicitly so generated docs are stable
+
+### 2. Handler layer
+
+- implement with `HttpApiBuilder.group(api, groupName, ...)`
+- yield the existing Effect service from context
+- keep handler bodies thin
+- keep transport mapping at the HTTP boundary only
+
+### 3. Mounting
+
+- mount under an experimental prefix such as `/experimental/httpapi`
+- keep existing Hono routes unchanged
+- expose separate OpenAPI output for the experimental slice first
+
+### 4. Verification
+
+- seed real state through the existing service
+- call the experimental endpoints
+- assert that the service behavior is unchanged
+- assert that the generated OpenAPI contains the migrated paths and schemas
+
+## Boundary composition
+
+The first slices should keep the existing outer server composition and only replace the route contract and handler layer.
+
+### Auth
+
+- keep `AuthMiddleware` at the outer Hono app level
+- do not duplicate auth checks inside each `HttpApi` group for the first parallel slices
+- treat auth as an already-satisfied transport concern before the request reaches the `HttpApi` handler
+
+Practical rule:
+
+- if a route is currently protected by the shared server middleware stack, the experimental `HttpApi` route should stay mounted behind that same stack
+
+### Instance and workspace lookup
+
+- keep `WorkspaceRouterMiddleware` as the source of truth for resolving `directory`, `workspace`, and session-derived workspace context
+- let that middleware provide `Instance.current` and `WorkspaceContext` before the request reaches the `HttpApi` handler
+- keep the `HttpApi` handlers unaware of path-to-instance lookup details when the existing Hono middleware already handles them
+
+Practical rule:
+
+- `HttpApi` handlers should yield services from context and assume the correct instance has already been provided
+- only move instance lookup into the `HttpApi` layer if we later decide to migrate the outer middleware boundary itself
+
+### Error mapping
+
+- keep domain and service errors typed in the service layer
+- declare typed transport errors on the endpoint only when the route can actually return them intentionally
+- prefer explicit endpoint-level error schemas over relying on the outer Hono `ErrorMiddleware` for expected route behavior
+
+Practical rule:
+
+- request decoding failures should remain transport-level `400`s
+- storage or lookup failures that are part of the route contract should be declared as typed endpoint errors
+- unexpected defects can still fall through to the outer error middleware while the slice is experimental
+
+For the current parallel slices, this means:
+
+- auth still composes outside `HttpApi`
+- instance selection still composes outside `HttpApi`
+- success payloads should be schema-defined from canonical Effect schemas
+- known route errors should be modeled at the endpoint boundary incrementally instead of all at once
+
+## Exit criteria for the spike
+
+The first slice is successful if:
+
+- the endpoints run in parallel with the current Hono routes
+- the handlers reuse the existing Effect service
+- request decoding and response shapes are schema-defined from canonical Effect schemas
+- any remaining Zod boundary usage is derived from `.zod` or clearly temporary
+- OpenAPI is generated from the `HttpApi` contract
+- the tests are straightforward enough that the next slice feels mechanical
+
+## Learnings from the question slice
+
+The first parallel `question` spike gave us a concrete pattern to reuse.
+
+- `Schema.Class` works well for route DTOs such as `Question.Request`, `Question.Info`, and `Question.Reply`.
+- scalar or collection schemas such as `Question.Answer` should stay as schemas and use helpers like `withStatics(...)` instead of being forced into classes.
+- if an `HttpApi` success schema uses `Schema.Class`, the handler or underlying service needs to return real schema instances rather than plain objects.
+- internal event payloads can stay anonymous when we want to avoid adding extra named OpenAPI component churn for non-route shapes.
+- the experimental slice should stay mounted in parallel and keep calling the existing service layer unchanged.
+- compare generated OpenAPI semantically at the route and schema level; in the current setup the exported OpenAPI paths do not include the outer Hono mount prefix.
+
+## Route inventory
+
+Status legend:
+
+- `done` - parallel `HttpApi` slice exists
+- `next` - good near-term candidate
+- `later` - possible, but not first wave
+- `defer` - not a good early `HttpApi` target
+
+Current instance route inventory:
+
+- `question` - `done`
+  endpoints in slice: `GET /question`, `POST /question/:requestID/reply`
+- `permission` - `done`
+  endpoints in slice: `GET /permission`, `POST /permission/:requestID/reply`
+- `provider` - `next`
+  best next endpoint: `GET /provider/auth`
+  later endpoint: `GET /provider`
+  defer first-wave OAuth mutations
+- `config` - `next`
+  best next endpoint: `GET /config/providers`
+  later endpoint: `GET /config`
+  defer `PATCH /config` for now
+- `project` - `later`
+  best small reads: `GET /project`, `GET /project/current`
+  defer git-init mutation first
+- `workspace` - `later`
+  best small reads: `GET /experimental/workspace/adaptor`, `GET /experimental/workspace`, `GET /experimental/workspace/status`
+  defer create/remove mutations first
+- `file` - `later`
+  good JSON-only candidate set, but larger than the current first-wave slices
+- `mcp` - `later`
+  has JSON-only endpoints, but interactive OAuth/auth flows make it a worse early fit
+- `session` - `defer`
+  large, stateful, mixes CRUD with prompt/shell/command/share/revert flows and a streaming route
+- `event` - `defer`
+  SSE only
+- `global` - `defer`
+  mixed bag with SSE and process-level side effects
+- `pty` - `defer`
+  websocket-heavy route surface
+- `tui` - `defer`
+  queue-style UI bridge, weak early `HttpApi` fit
+
+Recommended near-term sequence after the first spike:
+
+1. `provider` auth read endpoint
+2. `config` providers read endpoint
+3. `project` read endpoints
+4. `workspace` read endpoints
+
+## Checklist
+
+- [x] add one small spike that defines an `HttpApi` group for a simple JSON route set
+- [x] use Effect Schema request / response types for that slice
+- [x] keep the underlying service calls identical to the current handlers
+- [x] compare generated OpenAPI against the current Hono/OpenAPI setup
+- [x] document how auth, instance lookup, and error mapping would compose in the new stack
 - [ ] decide after the spike whether `HttpApi` should stay parallel, replace only some groups, or become the long-term default

 ## Rule of thumb
@@ -0,0 +1,666 @@
+# Server package extraction
+
+Practical reference for extracting a future `packages/server` from the current `packages/opencode` monolith while `packages/core` is still being migrated to Effect.
+
+This document is intentionally execution-oriented.
+
+It should give an agent enough context to land one incremental PR at a time without needing to rediscover the package strategy, route migration rules, or current constraints.
+
+## Goal
+
+Create `packages/server` as the home for:
+
+- HTTP contract definitions
+- HTTP handler implementations
+- OpenAPI generation
+- eventual embeddable server APIs for Node apps
+
+Do this without blocking on the full `packages/core` extraction.
+
+## Future state
+
+Target package layout:
+
+- `packages/core` - all opencode services, Effect-first source of truth
+- `packages/server` - opencode server, with separate contract and implementation, still producing `openapi.json`
+- `packages/cli` - TUI + CLI entrypoints
+- `packages/sdk` - generated from the server OpenAPI spec, may add higher-level wrappers
+- `packages/plugin` - generated or semi-hand-rolled non-Effect package built from core plugin definitions
+
+Desired user stories:
+
+- import from `core` and build a custom agent or app-specific runtime
+- import from `server` and embed the full opencode server into an existing Node app
+- spawn the CLI and talk to the server through that boundary
+
+## Current state
+
+Everything still lives in `packages/opencode`.
+
+Important current facts:
+
+- there is no `packages/core` or `packages/cli` workspace yet
+- `packages/server` now exists as a minimal scaffold package, but it does not own any real route contracts, handlers, or runtime composition yet
+- the main host server is still Hono-based in `src/server/server.ts`
+- current OpenAPI generation is Hono-based through `Server.openapi()` and `cli/cmd/generate.ts`
+- the Effect runtime and app layer are centralized in `src/effect/app-runtime.ts` and `src/effect/run-service.ts`
+- there is already one experimental Effect `HttpApi` slice at `src/server/instance/httpapi/question.ts`
+- that experimental slice is mounted under `/experimental/httpapi/question`
+- that experimental slice already has an end-to-end test at `test/server/question-httpapi.test.ts`
+
+This means the package split should start from an extraction path, not from greenfield package ownership.
+
+## Structural reference
+
+Use `anomalyco/opentunnel` as the structural reference for `packages/server`.
+
+The important pattern there is:
+
+- `packages/core` owns services and domain schemas
+- `packages/server/src/definition/*` owns pure `HttpApi` contracts
+- `packages/server/src/api/*` owns `HttpApiBuilder.group(...)` implementations and server-side middleware wiring
+- `packages/server/src/index.ts` becomes the composition root only after the server package really owns runtime hosting
+
+Relevant `opentunnel` files:
+
+- `packages/server/src/definition/index.ts`
+- `packages/server/src/definition/tunnel.ts`
+- `packages/server/src/api/index.ts`
+- `packages/server/src/api/tunnel.ts`
+- `packages/server/src/api/client.ts`
+- `packages/server/src/index.ts`
+
+The intended direction here is the same, but the current `opencode` package split is earlier in the migration.
+
+That means:
+
+- we should follow the same `definition` and `api` naming
+- we should keep contract and implementation as separate modules from the start
+- we should postpone the runtime composition root until `packages/core` exists enough to support it cleanly
+
+## Key decision
+
+Start `packages/server` as a contract and implementation package only.
+
+Do not make it the runtime host yet.
+
+Why:
+
+- `packages/core` does not exist yet
+- the current server host still lives in `packages/opencode`
+- moving host ownership immediately would force a large package and runtime shuffle while Effect service extraction is still in flight
+- if `packages/server` imports services from `packages/opencode` while `packages/opencode` imports `packages/server` to host routes, we create a package cycle immediately
+
+Short version:
+
+1. create `packages/server`
+2. move pure `HttpApi` contracts there
+3. move handler factories there
+4. keep `packages/opencode` as the temporary Hono host
+5. merge `packages/server` OpenAPI with the legacy Hono OpenAPI during the transition
+6. move server hosting later, after `packages/core` exists enough
+
+## Dependency rule
+
+Phase 1 rule:
+
+- `packages/server` must not import from `packages/opencode`
+
+Allowed in phase 1:
+
+- `packages/opencode` imports `packages/server`
+- `packages/server` accepts host-provided services, layers, or callbacks as inputs
+- `packages/server` may temporarily own transport-local placeholder schemas when a canonical shared schema does not exist yet
+
+Future rule after `packages/core` exists:
+
+- `packages/server` imports from `packages/core`
+- `packages/cli` imports from `packages/server` and `packages/core`
+- `packages/opencode` shrinks or disappears as package responsibilities are fully split
+
+## HttpApi model
+
+Use Effect v4 `HttpApi` as the source of truth for migrated HTTP routes.
+
+Important properties from the current `effect` / `effect-smol` model:
+
+- `HttpApi`, `HttpApiGroup`, and `HttpApiEndpoint` are pure contract definitions
+- handlers are implemented separately with `HttpApiBuilder.group(...)`
+- OpenAPI can be generated from the contract alone
+- auth and middleware can later be modeled with `HttpApiMiddleware.Service`
+- SSE and websocket routes are not good first-wave `HttpApi` targets
+
+This package split should preserve that separation explicitly.
+
+Default shape for migrated routes:
+
+- contract lives in `packages/server/src/definition/*`
+- implementation lives in `packages/server/src/api/*`
+- host mounting stays outside for now
+
+## OpenAPI rule
+
+During the transition there is still one spec artifact.
+
+Default rule:
+
+- `packages/server` generates OpenAPI from `HttpApi` contract
+- `packages/opencode` keeps generating legacy OpenAPI from Hono routes
+- the temporary exported server spec is a merged document
+- `packages/sdk` continues consuming one `openapi.json`
+
+Merge safety rules:
+
+- fail on duplicate `path + method`
+- fail on duplicate `operationId`
+- prefer explicit summary, description, and operation ids on all new `HttpApi` endpoints
+
+Practical implication:
+
+- do not make the SDK consume two specs
+- do not switch SDK generation to `packages/server` only until enough of the route surface has moved
+
+## Package shape
+
+Minimum viable `packages/server`:
+
+- `src/index.ts`
+- `src/definition/index.ts`
+- `src/definition/api.ts`
+- `src/definition/question.ts`
+- `src/api/index.ts`
+- `src/api/question.ts`
+- `src/openapi.ts`
+- `src/bridge/hono.ts`
+- `src/types.ts`
+
+Later additions, once there is enough real contract surface:
+
+- `src/api/client.ts`
+- runtime composition in `src/index.ts`
+
+Suggested initial exports:
+
+- `api`
+- `openapi`
+- `questionApi`
+- `makeQuestionHandler`
+
+Phase 1 responsibilities:
+
+- own pure API contracts
+- own handler factories for migrated slices
+- own contract-generated OpenAPI
+- expose host adapters needed by `packages/opencode`
+
+Phase 1 non-goals:
+
+- do not own `listen()`
+- do not own adapter selection
+- do not own global server middleware
+- do not own websocket or SSE transport
+- do not own process bootstrapping for CLI entrypoints
+
+## Current source inventory
+
+These files matter for the first phase.
+
+Current host and route composition:
+
+- `src/server/server.ts`
+- `src/server/control/index.ts`
+- `src/server/instance/index.ts`
+- `src/server/middleware.ts`
+- `src/server/adapter.bun.ts`
+- `src/server/adapter.node.ts`
+
+Current experimental `HttpApi` slice:
+
+- `src/server/instance/httpapi/question.ts`
+- `src/server/instance/httpapi/index.ts`
+- `src/server/instance/experimental.ts`
+- `test/server/question-httpapi.test.ts`
+
+Current OpenAPI flow:
+
+- `src/server/server.ts` via `Server.openapi()`
+- `src/cli/cmd/generate.ts`
+- `packages/sdk/js/script/build.ts`
+
+Current runtime and service layer:
+
+- `src/effect/app-runtime.ts`
+- `src/effect/run-service.ts`
+
+## Ownership rules
+
+Move first into `packages/server`:
+
+- the experimental `question` `HttpApi` slice
+- future `provider` and `config` JSON read slices
+- any new `HttpApi` route groups
+- transport-local OpenAPI generation for migrated routes
+
+Keep in `packages/opencode` for now:
+
+- `src/server/server.ts`
+- `src/server/control/index.ts`
+- `src/server/instance/*.ts`
+- `src/server/middleware.ts`
+- `src/server/adapter.*.ts`
+- `src/effect/app-runtime.ts`
+- `src/effect/run-service.ts`
+- all Effect services until they move to `packages/core`
+
+## Placeholder schema rule
+
+`packages/core` is allowed to lag behind.
+
+Until shared canonical schemas move to `packages/core`:
+
+- prefer importing existing Effect Schema DTOs from current locations when practical
+- if a route only needs a transport-local type and moving the canonical schema would create unrelated churn, allow a temporary server-local placeholder schema
+- if a placeholder is introduced, leave a short note so it does not become permanent
+
+The default rule from `schema.md` still applies:
+
+- Effect Schema owns the type
+- `.zod` is compatibility only
+- avoid parallel hand-written Zod and Effect definitions for the same migrated route shape
+
+## Host boundary rule
+
+Until host ownership moves:
+
+- auth stays at the outer Hono app level
+- compression stays at the outer Hono app level
+- CORS stays at the outer Hono app level
+- instance and workspace lookup stay at the current middleware layer
+- `packages/server` handlers should assume the host already provided the right request context
+- do not redesign host middleware just to land the package split
+
+This matches the current guidance in `http-api.md`:
+
+- keep auth outside the first parallel `HttpApi` slices
+- keep instance lookup outside the first parallel `HttpApi` slices
+- keep the first migrations transport-focused and semantics-preserving
+
+## Route selection rules
+
+Good early migration targets:
+
+- `question`
+- `provider` auth read endpoint
+- `config` providers read endpoint
+- small read-only instance routes
+
+Bad early migration targets:
+
+- `session`
+- `event`
+- `pty`
+- most `global` streaming or process-heavy routes
+- anything requiring websocket upgrade handling
+- anything that mixes many mutations and streaming in one file
+
+## First vertical slice
+
+The first slice for the package split is the existing experimental `question` group.
+
+Why `question` first:
+
+- it already exists as an experimental `HttpApi` slice
+- it already follows the desired contract and implementation split in one file
+- it is already mounted through the current Hono host
+- it already has an end-to-end test
+- it is JSON-only
+- it has low blast radius
+
+Use the first slice to prove:
+
+- package boundary
+- contract and implementation split
+- host mounting from `packages/opencode`
+- merged OpenAPI output
+- test ergonomics for future slices
+
+Do not broaden scope in the first slice.
+
+## Incremental migration order
+
+Use small PRs.
+
+Each PR should be easy to review, easy to revert, and should not mix extraction work with unrelated service refactors.
+
+### PR 1. Create `packages/server`
+
+Scope:
+
+- add the new workspace package
+- add package manifest and tsconfig
+- add empty `src/index.ts`, `src/definition/api.ts`, `src/definition/index.ts`, `src/api/index.ts`, `src/openapi.ts`, and supporting scaffolding
+
+Rules:
+
+- no production behavior changes
+- no host server changes yet
+- no imports from `packages/opencode` inside `packages/server`
+- prefer `opentunnel`-style naming from the start: `definition` for contracts, `api` for implementations
+
+Done means:
+
+- `packages/server` typechecks
+- the workspace can import it
+- the package boundary is in place for follow-up PRs
+
+### PR 2. Move the experimental question contract
+
+Scope:
+
+- extract the pure `HttpApi` contract from `src/server/instance/httpapi/question.ts`
+- place it in `packages/server/src/definition/question.ts`
+- aggregate it in `packages/server/src/definition/api.ts`
+- generate OpenAPI in `packages/server/src/openapi.ts`
+
+Rules:
+
+- contract only in this PR
+- no handler movement yet if that keeps the diff simpler
+- keep operation ids and docs metadata stable
+
+Done means:
+
+- question contract lives in `packages/server`
+- OpenAPI can be generated from contract alone
+- no runtime behavior changes yet
+
+### PR 3. Move the experimental question handler factory
+
+Scope:
+
+- extract the question `HttpApiBuilder.group(...)` implementation into `packages/server/src/api/question.ts`
+- expose it as a factory that accepts host-provided dependencies or wiring
+- add a small Hono bridge in `packages/server/src/bridge/hono.ts` if needed
+
+Rules:
+
+- `packages/server` must still not import from `packages/opencode`
+- handler code should stay thin and service-delegating
+- do not redesign the question service itself in this PR
+
+Done means:
+
+- `packages/server` can produce the experimental question handler
+- the package still stays cycle-free
+
+### PR 4. Mount `packages/server` question from `packages/opencode`
+
+Scope:
+
+- replace local experimental question route wiring in `packages/opencode`
+- keep the same mount path:
+- `/experimental/httpapi/question`
+- `/experimental/httpapi/question/doc`
+
+Rules:
+
+- no behavior change
+- preserve existing docs path
+- preserve current request and response shapes
+
+Done means:
+
+- existing question `HttpApi` test still passes
+- runtime behavior is unchanged
+- the current host server is now consuming `packages/server`
+
+### PR 5. Merge legacy and contract OpenAPI
+
+Scope:
+
+- keep `Server.openapi()` as the temporary spec entrypoint
+- generate legacy Hono spec
+- generate `packages/server` contract spec
+- merge them into one document
+- keep `cli/cmd/generate.ts` and `packages/sdk/js/script/build.ts` consuming one spec
+
+Rules:
+
+- fail loudly on duplicate `path + method`
+- fail loudly on duplicate `operationId`
+- do not silently overwrite one source with the other
+
+Done means:
+
+- one merged spec is produced
+- migrated question paths can come from `packages/server`
+- existing SDK generation path still works
+
+### PR 6. Add merged OpenAPI coverage
+
+Scope:
+
+- add one test for merged OpenAPI
+- assert both a legacy Hono route and a migrated `HttpApi` route exist
+
+Rules:
+
+- test the merged document, not just the `packages/server` contract spec in isolation
+- pick one stable legacy route and one stable migrated route
+
+Done means:
+
+- the merged-spec path is covered
+- future route migrations have a guardrail
+
+### PR 7. Migrate `GET /provider/auth`
+
+Scope:
+
+- add `GET /provider/auth` as the next `HttpApi` slice in `packages/server`
+- mount it in parallel from `packages/opencode`
+
+Why this route:
+
+- JSON-only
+- simple service delegation
+- small response shape
+- already listed as the best next `provider` candidate in `http-api.md`
+
+Done means:
+
+- route works through the current host
+- route appears in merged OpenAPI
+- no semantic change to provider auth behavior
+
+### PR 8. Migrate `GET /config/providers`
+
+Scope:
+
+- add `GET /config/providers` as a `HttpApi` slice in `packages/server`
+- mount it in parallel from `packages/opencode`
+
+Why this route:
+
+- JSON-only
+- read-only
+- low transport complexity
+- already listed as the best next `config` candidate in `http-api.md`
+
+Done means:
+
+- route works unchanged
+- route appears in merged OpenAPI
+
+### PR 9+. Migrate small read-only instance routes
+
+Candidate order:
+
+1. `GET /path`
+2. `GET /vcs`
+3. `GET /vcs/diff`
+4. `GET /command`
+5. `GET /agent`
+6. `GET /skill`
+
+Rules:
+
+- one or two endpoints per PR
+- prefer read-only routes first
+- keep outer middleware unchanged
+- keep business logic in the existing service layer
+
+Done means for each PR:
+
+- contract lives in `packages/server`
+- handler lives in `packages/server`
+- route is mounted from the current host
+- route appears in merged OpenAPI
+- behavior remains unchanged
+
+### Later PR. Move host ownership into `packages/server`
+
+Only start this after there is enough `packages/core` surface to depend on directly.
+
+Scope:
+
+- move server composition into `packages/server`
+- add embeddable APIs such as `createServer(...)`, `listen(...)`, or `createApp(...)`
+- move adapter selection and server startup out of `packages/opencode`
+
+Rules:
+
+- do not start this while `packages/server` still depends on `packages/opencode`
+- do not mix this with route migration PRs
+
+Done means:
+
+- `packages/server` can be embedded in another Node app
+- `packages/cli` can depend on `packages/server`
+- host logic no longer lives in `packages/opencode`
+
+## PR sizing rule
+
+Every migration PR should satisfy all of these:
+
+- one route group or one to two endpoints
+- no unrelated service refactor
+- no auth redesign
+- no middleware redesign
+- OpenAPI updated
+- at least one route test or spec test added or updated
+
+## Done means for a migrated route group
+
+A route group migration is complete only when:
+
+1. the `HttpApi` contract lives in `packages/server`
+2. handler implementation lives in `packages/server`
+3. the route is mounted from the current host in `packages/opencode`
+4. the route appears in merged OpenAPI
+5. request and response schemas are Effect Schema-first or clearly temporary placeholders
+6. existing behavior remains unchanged
+7. the route has straightforward test coverage
+
+## Validation expectations
+
+For package-split PRs, validate the smallest useful thing.
+
+Typical validation for the first waves:
+
+- `bun typecheck` in the touched package directory or directories
+- the relevant route test, especially `test/server/question-httpapi.test.ts`
+- merged OpenAPI coverage if the PR touches spec generation
+
+Do not run tests from repo root.
+
+## Main risks
+
+### Package cycle
+
+This is the biggest risk.
+
+Bad state:
+
+- `packages/server` imports services or runtime from `packages/opencode`
+- `packages/opencode` imports route definitions or handlers from `packages/server`
+
+Avoid by:
+
+- keeping phase-1 `packages/server` free of `packages/opencode` imports
+- using factories and host-provided wiring instead of direct service imports
+
+### Spec drift
+
+During the transition there are two route-definition sources.
+
+Avoid by:
+
+- one merged spec
+- collision checks
+- explicit `operationId`s
+- merged OpenAPI tests
+
+### Middleware mismatch
+
+Current auth, compression, CORS, and instance selection are Hono-centered.
+
+Avoid by:
+
+- leaving them where they are during the first wave
+- not trying to solve `HttpApiMiddleware.Service` globally in the package-split PRs
+
+### Core lag
+
+`packages/core` will not be ready everywhere.
+
+Avoid by:
+
+- allowing small transport-local placeholder schemas where necessary
+- keeping those placeholders clearly temporary
+- not blocking the server extraction on full schema movement
+
+### Scope creep
+
+The first vertical slice is easy to overload.
+
+Avoid by:
+
+- proving the package boundary first
+- not mixing package creation, route migration, host redesign, and core extraction in the same change
+
+## Non-goals for the first wave
+
+- do not replace all Hono routes at once
+- do not migrate SSE or websocket routes first
+- do not redesign auth
+- do not redesign instance lookup
+- do not wait for full `packages/core` before starting `packages/server`
+- do not change SDK generation to consume multiple specs
+
+## Checklist
+
+- [x] create `packages/server`
+- [x] add package-level exports for contract and OpenAPI
+- [ ] extract `question` contract into `packages/server`
+- [ ] extract `question` handler factory into `packages/server`
+- [ ] mount `question` from `packages/opencode`
+- [ ] merge legacy and contract OpenAPI into one document
+- [ ] add merged-spec coverage
+- [ ] migrate `GET /provider/auth`
+- [ ] migrate `GET /config/providers`
+- [ ] migrate small read-only instance routes one or two at a time
+- [ ] move host ownership into `packages/server` only after `packages/core` is ready enough
+- [ ] split `packages/cli` after server and core boundaries are stable
+
+## Rule of thumb
+
+The fastest correct path is:
+
+1. establish `packages/server` as the contract-first boundary
+2. keep `packages/opencode` as the temporary host
+3. migrate a few safe JSON routes
+4. keep one merged OpenAPI document
+5. move actual host ownership only after `packages/core` can support it cleanly
+
+If a proposed PR would make `packages/server` import from `packages/opencode`, stop and restructure the boundary first.
@@ -453,19 +453,12 @@ export namespace ACP {
                return
            }
          }
+
+          // ACP clients already know the prompt they just submitted, so replaying
+          // live user parts duplicates the message. We still replay user history in
+          // loadSession() and forkSession() via processMessage().
          if (part.type !== "text" && part.type !== "file") return
-          const msg = await this.sdk.session
-            .message(
-              { sessionID: part.sessionID, messageID: part.messageID, directory: session.cwd },
-              { throwOnError: true },
-            )
-            .then((x) => x.data)
-            .catch((err) => {
-              log.error("failed to fetch message for user chunk", { error: err })
-              return undefined
-            })
-          if (!msg || msg.info.role !== "user") return
-          await this.processMessage({ info: msg.info, parts: [part] })
+
          return
        }

@@ -123,45 +123,49 @@ function parseToolParams(input?: string) {
 }

 async function createToolContext(agent: Agent.Info) {
-  const session = await Session.create({ title: `Debug tool run (${agent.name})` })
-  const messageID = MessageID.ascending()
-  const model =
-    agent.model ??
-    (await AppRuntime.runPromise(
-      Effect.gen(function* () {
-        const provider = yield* Provider.Service
-        return yield* provider.defaultModel()
-      }),
-    ))
-  const now = Date.now()
-  const message: MessageV2.Assistant = {
-    id: messageID,
-    sessionID: session.id,
-    role: "assistant",
-    time: {
-      created: now,
-    },
-    parentID: messageID,
-    modelID: model.modelID,
-    providerID: model.providerID,
-    mode: "debug",
-    agent: agent.name,
-    path: {
-      cwd: Instance.directory,
-      root: Instance.worktree,
-    },
-    cost: 0,
-    tokens: {
-      input: 0,
-      output: 0,
-      reasoning: 0,
-      cache: {
-        read: 0,
-        write: 0,
-      },
-    },
-  }
-  await Session.updateMessage(message)
+  const { session, messageID } = await AppRuntime.runPromise(
+    Effect.gen(function* () {
+      const session = yield* Session.Service
+      const result = yield* session.create({ title: `Debug tool run (${agent.name})` })
+      const messageID = MessageID.ascending()
+      const model = agent.model
+        ? agent.model
+        : yield* Effect.gen(function* () {
+            const provider = yield* Provider.Service
+            return yield* provider.defaultModel()
+          })
+      const now = Date.now()
+      const message: MessageV2.Assistant = {
+        id: messageID,
+        sessionID: result.id,
+        role: "assistant",
+        time: {
+          created: now,
+        },
+        parentID: messageID,
+        modelID: model.modelID,
+        providerID: model.providerID,
+        mode: "debug",
+        agent: agent.name,
+        path: {
+          cwd: Instance.directory,
+          root: Instance.worktree,
+        },
+        cost: 0,
+        tokens: {
+          input: 0,
+          output: 0,
+          reasoning: 0,
+          cache: {
+            read: 0,
+            write: 0,
+          },
+        },
+      }
+      yield* session.updateMessage(message)
+      return { session: result, messageID }
+    }),
+  )

  const ruleset = Permission.merge(agent.permission, session.permission ?? [])

@@ -1,10 +1,10 @@
 import { EOL } from "os"
 import { Effect } from "effect"
 import { AppRuntime } from "@/effect/app-runtime"
-import { Search } from "@/file/search"
 import { File } from "../../../file"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"
+import { Ripgrep } from "@/file/ripgrep"

 const FileSearchCommand = cmd({
  command: "search <query>",
@@ -95,7 +95,7 @@ const FileTreeCommand = cmd({
      default: process.cwd(),
    }),
  async handler(args) {
-    const files = await Search.tree({ cwd: args.dir, limit: 200 })
+    const files = await Ripgrep.tree({ cwd: args.dir, limit: 200 })
    console.log(JSON.stringify(files, null, 2))
  },
 })
@@ -1,6 +1,6 @@
 import { EOL } from "os"
 import { AppRuntime } from "../../../effect/app-runtime"
-import { Search } from "../../../file/search"
+import { Ripgrep } from "../../../file/ripgrep"
 import { Instance } from "../../../project/instance"
 import { bootstrap } from "../../bootstrap"
 import { cmd } from "../cmd"
@@ -21,7 +21,7 @@ const TreeCommand = cmd({
    }),
  async handler(args) {
    await bootstrap(process.cwd(), async () => {
-      process.stdout.write((await Search.tree({ cwd: Instance.directory, limit: args.limit })) + EOL)
+      process.stdout.write((await Ripgrep.tree({ cwd: Instance.directory, limit: args.limit })) + EOL)
    })
  },
 })
@@ -46,7 +46,7 @@ const FilesCommand = cmd({
  async handler(args) {
    await bootstrap(process.cwd(), async () => {
      const files: string[] = []
-      for await (const file of await Search.files({
+      for await (const file of await Ripgrep.files({
        cwd: Instance.directory,
        glob: args.glob ? [args.glob] : undefined,
      })) {
@@ -79,7 +79,7 @@ const SearchCommand = cmd({
  async handler(args) {
    await bootstrap(process.cwd(), async () => {
      const results = await AppRuntime.runPromise(
-        Search.Service.use((svc) =>
+        Ripgrep.Service.use((svc) =>
          svc.search({
            cwd: Instance.directory,
            pattern: args.pattern,
@@ -1,20 +1,238 @@
 import type { Argv } from "yargs"
 import { Session } from "../../session"
+import { MessageV2 } from "../../session/message-v2"
 import { SessionID } from "../../session/schema"
 import { cmd } from "./cmd"
 import { bootstrap } from "../bootstrap"
 import { UI } from "../ui"
 import * as prompts from "@clack/prompts"
 import { EOL } from "os"
+import { AppRuntime } from "@/effect/app-runtime"
+
+function redact(kind: string, id: string, value: string) {
+  return value.trim() ? `[redacted:${kind}:${id}]` : value
+}
+
+function data(kind: string, id: string, value: Record<string, unknown> | undefined) {
+  if (!value) return value
+  return Object.keys(value).length ? { redacted: `${kind}:${id}` } : value
+}
+
+function span(id: string, value: { value: string; start: number; end: number }) {
+  return {
+    ...value,
+    value: redact("file-text", id, value.value),
+  }
+}
+
+function diff(kind: string, diffs: { file: string; patch: string }[] | undefined) {
+  return diffs?.map((item, i) => ({
+    ...item,
+    file: redact(`${kind}-file`, String(i), item.file),
+    patch: redact(`${kind}-patch`, String(i), item.patch),
+  }))
+}
+
+function source(part: MessageV2.FilePart) {
+  if (!part.source) return part.source
+  if (part.source.type === "symbol") {
+    return {
+      ...part.source,
+      path: redact("file-path", part.id, part.source.path),
+      name: redact("file-symbol", part.id, part.source.name),
+      text: span(part.id, part.source.text),
+    }
+  }
+  if (part.source.type === "resource") {
+    return {
+      ...part.source,
+      clientName: redact("file-client", part.id, part.source.clientName),
+      uri: redact("file-uri", part.id, part.source.uri),
+      text: span(part.id, part.source.text),
+    }
+  }
+  return {
+    ...part.source,
+    path: redact("file-path", part.id, part.source.path),
+    text: span(part.id, part.source.text),
+  }
+}
+
+function filepart(part: MessageV2.FilePart): MessageV2.FilePart {
+  return {
+    ...part,
+    url: redact("file-url", part.id, part.url),
+    filename: part.filename === undefined ? undefined : redact("file-name", part.id, part.filename),
+    source: source(part),
+  }
+}
+
+function part(part: MessageV2.Part): MessageV2.Part {
+  switch (part.type) {
+    case "text":
+      return {
+        ...part,
+        text: redact("text", part.id, part.text),
+        metadata: data("text-metadata", part.id, part.metadata),
+      }
+    case "reasoning":
+      return {
+        ...part,
+        text: redact("reasoning", part.id, part.text),
+        metadata: data("reasoning-metadata", part.id, part.metadata),
+      }
+    case "file":
+      return filepart(part)
+    case "subtask":
+      return {
+        ...part,
+        prompt: redact("subtask-prompt", part.id, part.prompt),
+        description: redact("subtask-description", part.id, part.description),
+        command: part.command === undefined ? undefined : redact("subtask-command", part.id, part.command),
+      }
+    case "tool":
+      return {
+        ...part,
+        metadata: data("tool-metadata", part.id, part.metadata),
+        state:
+          part.state.status === "pending"
+            ? {
+                ...part.state,
+                input: data("tool-input", part.id, part.state.input) ?? part.state.input,
+                raw: redact("tool-raw", part.id, part.state.raw),
+              }
+            : part.state.status === "running"
+              ? {
+                  ...part.state,
+                  input: data("tool-input", part.id, part.state.input) ?? part.state.input,
+                  title: part.state.title === undefined ? undefined : redact("tool-title", part.id, part.state.title),
+                  metadata: data("tool-state-metadata", part.id, part.state.metadata),
+                }
+              : part.state.status === "completed"
+                ? {
+                    ...part.state,
+                    input: data("tool-input", part.id, part.state.input) ?? part.state.input,
+                    output: redact("tool-output", part.id, part.state.output),
+                    title: redact("tool-title", part.id, part.state.title),
+                    metadata: data("tool-state-metadata", part.id, part.state.metadata) ?? part.state.metadata,
+                    attachments: part.state.attachments?.map(filepart),
+                  }
+                : {
+                    ...part.state,
+                    input: data("tool-input", part.id, part.state.input) ?? part.state.input,
+                    metadata: data("tool-state-metadata", part.id, part.state.metadata),
+                  },
+      }
+    case "patch":
+      return {
+        ...part,
+        hash: redact("patch", part.id, part.hash),
+        files: part.files.map((item: string, i: number) => redact("patch-file", `${part.id}-${i}`, item)),
+      }
+    case "snapshot":
+      return {
+        ...part,
+        snapshot: redact("snapshot", part.id, part.snapshot),
+      }
+    case "step-start":
+      return {
+        ...part,
+        snapshot: part.snapshot === undefined ? undefined : redact("snapshot", part.id, part.snapshot),
+      }
+    case "step-finish":
+      return {
+        ...part,
+        snapshot: part.snapshot === undefined ? undefined : redact("snapshot", part.id, part.snapshot),
+      }
+    case "agent":
+      return {
+        ...part,
+        source: !part.source
+          ? part.source
+          : {
+              ...part.source,
+              value: redact("agent-source", part.id, part.source.value),
+            },
+      }
+    default:
+      return part
+  }
+}
+
+const partFn = part
+
+function sanitize(data: { info: Session.Info; messages: MessageV2.WithParts[] }) {
+  return {
+    info: {
+      ...data.info,
+      title: redact("session-title", data.info.id, data.info.title),
+      directory: redact("session-directory", data.info.id, data.info.directory),
+      summary: !data.info.summary
+        ? data.info.summary
+        : {
+            ...data.info.summary,
+            diffs: diff("session-diff", data.info.summary.diffs),
+          },
+      revert: !data.info.revert
+        ? data.info.revert
+        : {
+            ...data.info.revert,
+            snapshot:
+              data.info.revert.snapshot === undefined
+                ? undefined
+                : redact("revert-snapshot", data.info.id, data.info.revert.snapshot),
+            diff:
+              data.info.revert.diff === undefined
+                ? undefined
+                : redact("revert-diff", data.info.id, data.info.revert.diff),
+          },
+    },
+    messages: data.messages.map((msg) => ({
+      info:
+        msg.info.role === "user"
+          ? {
+              ...msg.info,
+              system: msg.info.system === undefined ? undefined : redact("system", msg.info.id, msg.info.system),
+              summary: !msg.info.summary
+                ? msg.info.summary
+                : {
+                    ...msg.info.summary,
+                    title:
+                      msg.info.summary.title === undefined
+                        ? undefined
+                        : redact("summary-title", msg.info.id, msg.info.summary.title),
+                    body:
+                      msg.info.summary.body === undefined
+                        ? undefined
+                        : redact("summary-body", msg.info.id, msg.info.summary.body),
+                    diffs: diff("message-diff", msg.info.summary.diffs),
+                  },
+            }
+          : {
+              ...msg.info,
+              path: {
+                cwd: redact("cwd", msg.info.id, msg.info.path.cwd),
+                root: redact("root", msg.info.id, msg.info.path.root),
+              },
+            },
+      parts: msg.parts.map(partFn),
+    })),
+  }
+}

 export const ExportCommand = cmd({
  command: "export [sessionID]",
  describe: "export session data as JSON",
  builder: (yargs: Argv) => {
-    return yargs.positional("sessionID", {
-      describe: "session id to export",
-      type: "string",
-    })
+    return yargs
+      .positional("sessionID", {
+        describe: "session id to export",
+        type: "string",
+      })
+      .option("sanitize", {
+        describe: "redact sensitive transcript and file data",
+        type: "boolean",
+      })
  },
  handler: async (args) => {
    await bootstrap(process.cwd(), async () => {
@@ -67,18 +285,17 @@ export const ExportCommand = cmd({
      }

      try {
-        const sessionInfo = await Session.get(sessionID!)
-        const messages = await Session.messages({ sessionID: sessionInfo.id })
+        const sessionInfo = await AppRuntime.runPromise(Session.Service.use((svc) => svc.get(sessionID!)))
+        const messages = await AppRuntime.runPromise(
+          Session.Service.use((svc) => svc.messages({ sessionID: sessionInfo.id })),
+        )

        const exportData = {
          info: sessionInfo,
-          messages: messages.map((msg) => ({
-            info: msg.info,
-            parts: msg.parts,
-          })),
+          messages,
        }

-        process.stdout.write(JSON.stringify(exportData, null, 2))
+        process.stdout.write(JSON.stringify(args.sanitize ? sanitize(exportData) : exportData, null, 2))
        process.stdout.write(EOL)
      } catch (error) {
        UI.error(`Session not found: ${sessionID!}`)
@@ -33,6 +33,7 @@ import { AppRuntime } from "@/effect/app-runtime"
 import { Git } from "@/git"
 import { setTimeout as sleep } from "node:timers/promises"
 import { Process } from "@/util/process"
+import { Effect } from "effect"

 type GitHubAuthor = {
  login: string
@@ -551,20 +552,24 @@ export const GithubRunCommand = cmd({

        // Setup opencode session
        const repoData = await fetchRepo()
-        session = await Session.create({
-          permission: [
-            {
-              permission: "question",
-              action: "deny",
-              pattern: "*",
-            },
-          ],
-        })
+        session = await AppRuntime.runPromise(
+          Session.Service.use((svc) =>
+            svc.create({
+              permission: [
+                {
+                  permission: "question",
+                  action: "deny",
+                  pattern: "*",
+                },
+              ],
+            }),
+          ),
+        )
        subscribeSessionEvents()
        shareId = await (async () => {
          if (share === false) return
          if (!share && repoData.data.private) return
-          await SessionShare.share(session.id)
+          await AppRuntime.runPromise(SessionShare.Service.use((svc) => svc.share(session.id)))
          return session.id.slice(-8)
        })()
        console.log("opencode session", session.id)
@@ -937,96 +942,86 @@ export const GithubRunCommand = cmd({
      async function chat(message: string, files: PromptFiles = []) {
        console.log("Sending message to opencode...")

-        const result = await SessionPrompt.prompt({
-          sessionID: session.id,
-          messageID: MessageID.ascending(),
-          variant,
-          model: {
-            providerID,
-            modelID,
-          },
-          // agent is omitted - server will use default_agent from config or fall back to "build"
-          parts: [
-            {
-              id: PartID.ascending(),
-              type: "text",
-              text: message,
-            },
-            ...files.flatMap((f) => [
-              {
-                id: PartID.ascending(),
-                type: "file" as const,
-                mime: f.mime,
-                url: `data:${f.mime};base64,${f.content}`,
-                filename: f.filename,
-                source: {
-                  type: "file" as const,
-                  text: {
-                    value: f.replacement,
-                    start: f.start,
-                    end: f.end,
-                  },
-                  path: f.filename,
-                },
+        return AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const prompt = yield* SessionPrompt.Service
+            const result = yield* prompt.prompt({
+              sessionID: session.id,
+              messageID: MessageID.ascending(),
+              variant,
+              model: {
+                providerID,
+                modelID,
              },
-            ]),
-          ],
-        })
+              // agent is omitted - server will use default_agent from config or fall back to "build"
+              parts: [
+                {
+                  id: PartID.ascending(),
+                  type: "text",
+                  text: message,
+                },
+                ...files.flatMap((f) => [
+                  {
+                    id: PartID.ascending(),
+                    type: "file" as const,
+                    mime: f.mime,
+                    url: `data:${f.mime};base64,${f.content}`,
+                    filename: f.filename,
+                    source: {
+                      type: "file" as const,
+                      text: {
+                        value: f.replacement,
+                        start: f.start,
+                        end: f.end,
+                      },
+                      path: f.filename,
+                    },
+                  },
+                ]),
+              ],
+            })

-        // result should always be assistant just satisfying type checker
-        if (result.info.role === "assistant" && result.info.error) {
-          const err = result.info.error
-          console.error("Agent error:", err)
+            if (result.info.role === "assistant" && result.info.error) {
+              const err = result.info.error
+              console.error("Agent error:", err)
+              if (err.name === "ContextOverflowError") throw new Error(formatPromptTooLargeError(files))
+              throw new Error(`${err.name}: ${err.data?.message || ""}`)
+            }

-          if (err.name === "ContextOverflowError") {
-            throw new Error(formatPromptTooLargeError(files))
-          }
+            const text = extractResponseText(result.parts)
+            if (text) return text

-          const errorMsg = err.data?.message || ""
-          throw new Error(`${err.name}: ${errorMsg}`)
-        }
+            console.log("Requesting summary from agent...")
+            const summary = yield* prompt.prompt({
+              sessionID: session.id,
+              messageID: MessageID.ascending(),
+              variant,
+              model: {
+                providerID,
+                modelID,
+              },
+              tools: { "*": false },
+              parts: [
+                {
+                  id: PartID.ascending(),
+                  type: "text",
+                  text: "Summarize the actions (tool calls & reasoning) you did for the user in 1-2 sentences.",
+                },
+              ],
+            })

-        const text = extractResponseText(result.parts)
-        if (text) return text
+            if (summary.info.role === "assistant" && summary.info.error) {
+              const err = summary.info.error
+              console.error("Summary agent error:", err)
+              if (err.name === "ContextOverflowError") throw new Error(formatPromptTooLargeError(files))
+              throw new Error(`${err.name}: ${err.data?.message || ""}`)
+            }

-        // No text part (tool-only or reasoning-only) - ask agent to summarize
-        console.log("Requesting summary from agent...")
-        const summary = await SessionPrompt.prompt({
-          sessionID: session.id,
-          messageID: MessageID.ascending(),
-          variant,
-          model: {
-            providerID,
-            modelID,
-          },
-          tools: { "*": false }, // Disable all tools to force text response
-          parts: [
-            {
-              id: PartID.ascending(),
-              type: "text",
-              text: "Summarize the actions (tool calls & reasoning) you did for the user in 1-2 sentences.",
-            },
-          ],
-        })
-
-        if (summary.info.role === "assistant" && summary.info.error) {
-          const err = summary.info.error
-          console.error("Summary agent error:", err)
-
-          if (err.name === "ContextOverflowError") {
-            throw new Error(formatPromptTooLargeError(files))
-          }
-
-          const errorMsg = err.data?.message || ""
-          throw new Error(`${err.name}: ${errorMsg}`)
-        }
-
-        const summaryText = extractResponseText(summary.parts)
-        if (!summaryText) {
-          throw new Error("Failed to get summary from agent")
-        }
-
-        return summaryText
+            const summaryText = extractResponseText(summary.parts)
+            if (!summaryText) throw new Error("Failed to get summary from agent")
+            return summaryText
+          }),
+        )
      }

      async function getOidcToken() {
@@ -158,13 +158,13 @@ async function handlePluginAuth(plugin: { auth: PluginAuth }, provider: string,
  }

  if (method.type === "api") {
-    const key = await prompts.password({
-      message: "Enter your API key",
-      validate: (x) => (x && x.length > 0 ? undefined : "Required"),
-    })
-    if (prompts.isCancel(key)) throw new UI.CancelledError()
-
    if (method.authorize) {
+      const key = await prompts.password({
+        message: "Enter your API key",
+        validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+      })
+      if (prompts.isCancel(key)) throw new UI.CancelledError()
+
      const result = await method.authorize(inputs)
      if (result.type === "failed") {
        prompts.log.error("Failed to authorize")
@@ -11,6 +11,7 @@ import { Process } from "../../util/process"
 import { EOL } from "os"
 import path from "path"
 import { which } from "../../util/which"
+import { AppRuntime } from "@/effect/app-runtime"

 function pagerCmd(): string[] {
  const lessOptions = ["-R", "-S"]
@@ -60,12 +61,12 @@ export const SessionDeleteCommand = cmd({
    await bootstrap(process.cwd(), async () => {
      const sessionID = SessionID.make(args.sessionID)
      try {
-        await Session.get(sessionID)
+        await AppRuntime.runPromise(Session.Service.use((svc) => svc.get(sessionID)))
      } catch {
        UI.error(`Session not found: ${args.sessionID}`)
        process.exit(1)
      }
-      await Session.remove(sessionID)
+      await AppRuntime.runPromise(Session.Service.use((svc) => svc.remove(sessionID)))
      UI.println(UI.Style.TEXT_SUCCESS_BOLD + `Session ${args.sessionID} deleted` + UI.Style.TEXT_NORMAL)
    })
  },
@@ -6,6 +6,7 @@ import { Database } from "../../storage/db"
 import { SessionTable } from "../../session/session.sql"
 import { Project } from "../../project/project"
 import { Instance } from "../../project/instance"
+import { AppRuntime } from "@/effect/app-runtime"

 interface SessionStats {
  totalSessions: number
@@ -167,7 +168,9 @@ export async function aggregateSessionStats(days?: number, projectFilter?: strin
    const batch = filteredSessions.slice(i, i + BATCH_SIZE)

    const batchPromises = batch.map(async (session) => {
-      const messages = await Session.messages({ sessionID: session.id })
+      const messages = await AppRuntime.runPromise(
+        Session.Service.use((svc) => svc.messages({ sessionID: session.id })),
+      )

      let sessionCost = 0
      let sessionTokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
@@ -542,8 +542,10 @@ function generateSystem(colors: TerminalColors, mode: "dark" | "light"): ThemeJs
  const diffAlpha = isDark ? 0.22 : 0.14
  const diffAddedBg = tint(bg, ansiColors.green, diffAlpha)
  const diffRemovedBg = tint(bg, ansiColors.red, diffAlpha)
-  const diffAddedLineNumberBg = tint(grays[3], ansiColors.green, diffAlpha)
-  const diffRemovedLineNumberBg = tint(grays[3], ansiColors.red, diffAlpha)
+  const diffContextBg = grays[2]
+  const diffAddedLineNumberBg = tint(diffContextBg, ansiColors.green, diffAlpha)
+  const diffRemovedLineNumberBg = tint(diffContextBg, ansiColors.red, diffAlpha)
+  const diffLineNumber = textMuted

  return {
    theme: {
@@ -583,8 +585,8 @@ function generateSystem(colors: TerminalColors, mode: "dark" | "light"): ThemeJs
      diffHighlightRemoved: ansiColors.redBright,
      diffAddedBg,
      diffRemovedBg,
-      diffContextBg: grays[1],
-      diffLineNumber: grays[6],
+      diffContextBg,
+      diffLineNumber,
      diffAddedLineNumberBg,
      diffRemovedLineNumberBg,

@@ -39,7 +39,7 @@
    "diffAddedBg": "#354933",
    "diffRemovedBg": "#3f191a",
    "diffContextBg": "darkBgPanel",
-    "diffLineNumber": "darkBorder",
+    "diffLineNumber": "#898989",
    "diffAddedLineNumberBg": "#162620",
    "diffRemovedLineNumberBg": "#26161a",
    "markdownText": "darkFg",
@@ -50,7 +50,7 @@
    "diffAddedBg": "#20303b",
    "diffRemovedBg": "#37222c",
    "diffContextBg": "darkPanel",
-    "diffLineNumber": "darkGutter",
+    "diffLineNumber": "diffContext",
    "diffAddedLineNumberBg": "#1b2b34",
    "diffRemovedLineNumberBg": "#2d1f26",
    "markdownText": "darkFg",
@@ -141,8 +141,8 @@
      "light": "lbg1"
    },
    "diffLineNumber": {
-      "dark": "fg3",
-      "light": "lfg3"
+      "dark": "#808792",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "diffGreenBg",
@@ -125,10 +125,7 @@
      "dark": "frappeMantle",
      "light": "frappeMantle"
    },
-    "diffLineNumber": {
-      "dark": "frappeSurface1",
-      "light": "frappeSurface1"
-    },
+    "diffLineNumber": "textMuted",
    "diffAddedLineNumberBg": {
      "dark": "#223025",
      "light": "#223025"
@@ -125,10 +125,7 @@
      "dark": "macMantle",
      "light": "macMantle"
    },
-    "diffLineNumber": {
-      "dark": "macSurface1",
-      "light": "macSurface1"
-    },
+    "diffLineNumber": "textMuted",
    "diffAddedLineNumberBg": {
      "dark": "#223025",
      "light": "#223025"
@@ -79,7 +79,7 @@
    "diffAddedBg": { "dark": "#24312b", "light": "#d6f0d9" },
    "diffRemovedBg": { "dark": "#3c2a32", "light": "#f6dfe2" },
    "diffContextBg": { "dark": "darkMantle", "light": "lightMantle" },
-    "diffLineNumber": { "dark": "darkSurface1", "light": "lightSurface1" },
+    "diffLineNumber": { "dark": "textMuted", "light": "#5b5d63" },
    "diffAddedLineNumberBg": { "dark": "#1e2a25", "light": "#c9e3cb" },
    "diffRemovedLineNumberBg": { "dark": "#32232a", "light": "#e9d3d6" },
    "markdownText": { "dark": "darkText", "light": "lightText" },
@@ -120,10 +120,7 @@
      "dark": "#122738",
      "light": "#f5f7fa"
    },
-    "diffLineNumber": {
-      "dark": "#2d5a7b",
-      "light": "#b0bec5"
-    },
+    "diffLineNumber": "textMuted",
    "diffAddedLineNumberBg": {
      "dark": "#1a3a2a",
      "light": "#e8f5e9"
@@ -142,8 +142,8 @@
      "light": "lightPanel"
    },
    "diffLineNumber": {
-      "dark": "#e4e4e442",
-      "light": "#1414147a"
+      "dark": "#eeeeee87",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#3fa26633",
@@ -112,8 +112,8 @@
      "light": "#e8e8e2"
    },
    "diffLineNumber": {
-      "dark": "currentLine",
-      "light": "#c8c8c2"
+      "dark": "#989aa4",
+      "light": "#686865"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1a3a1a",
@@ -134,8 +134,8 @@
      "light": "lightStep2"
    },
    "diffLineNumber": {
-      "dark": "darkStep3",
-      "light": "lightStep3"
+      "dark": "#a0a5a7",
+      "light": "#5b5951"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1b2b34",
@@ -130,8 +130,8 @@
      "light": "base50"
    },
    "diffLineNumber": {
-      "dark": "base600",
-      "light": "base600"
+      "dark": "#888883",
+      "light": "#5a5955"
    },
    "diffAddedLineNumberBg": {
      "dark": "#152515",
@@ -126,8 +126,8 @@
      "light": "lightBgAlt"
    },
    "diffLineNumber": {
-      "dark": "#484f58",
-      "light": "#afb8c1"
+      "dark": "#95999e",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#033a16",
@@ -135,8 +135,8 @@
      "light": "lightBg1"
    },
    "diffLineNumber": {
-      "dark": "darkBg3",
-      "light": "lightBg3"
+      "dark": "#a8a29e",
+      "light": "#564f43"
    },
    "diffAddedLineNumberBg": {
      "dark": "#2a2827",
@@ -47,7 +47,7 @@
    "diffAddedBg": { "dark": "#252E25", "light": "#EAF3E4" },
    "diffRemovedBg": { "dark": "#362020", "light": "#FBE6E6" },
    "diffContextBg": { "dark": "sumiInk1", "light": "lightPaper" },
-    "diffLineNumber": { "dark": "sumiInk3", "light": "#C7BEB4" },
+    "diffLineNumber": { "dark": "#9090a0", "light": "#65615c" },
    "diffAddedLineNumberBg": { "dark": "#202820", "light": "#DDE8D6" },
    "diffRemovedLineNumberBg": { "dark": "#2D1C1C", "light": "#F2DADA" },
    "markdownText": { "dark": "fujiWhite", "light": "lightText" },
@@ -129,10 +129,7 @@
      "dark": "transparent",
      "light": "transparent"
    },
-    "diffLineNumber": {
-      "dark": "#666666",
-      "light": "#999999"
-    },
+    "diffLineNumber": "textMuted",
    "diffAddedLineNumberBg": {
      "dark": "transparent",
      "light": "transparent"
@@ -128,8 +128,8 @@
      "light": "lightBgAlt"
    },
    "diffLineNumber": {
-      "dark": "#37474f",
-      "light": "#cfd8dc"
+      "dark": "#9aa2a6",
+      "light": "#6a6e70"
    },
    "diffAddedLineNumberBg": {
      "dark": "#2e3c2b",
@@ -47,7 +47,7 @@
    "diffAddedBg": { "dark": "#132616", "light": "#e0efde" },
    "diffRemovedBg": { "dark": "#261212", "light": "#f9e5e5" },
    "diffContextBg": { "dark": "matrixInk1", "light": "lightPaper" },
-    "diffLineNumber": { "dark": "matrixInk3", "light": "lightGray" },
+    "diffLineNumber": { "dark": "textMuted", "light": "#556156" },
    "diffAddedLineNumberBg": { "dark": "#0f1b11", "light": "#d6e7d2" },
    "diffRemovedLineNumberBg": { "dark": "#1b1414", "light": "#f2d2d2" },
    "markdownText": { "dark": "rainGreenHi", "light": "lightText" },
@@ -114,8 +114,8 @@
      "light": "#f0f0f0"
    },
    "diffLineNumber": {
-      "dark": "#3e3d32",
-      "light": "#d0d0d0"
+      "dark": "#9b9b95",
+      "light": "#686868"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1a3a1a",
@@ -114,8 +114,8 @@
      "light": "nightOwlPanel"
    },
    "diffLineNumber": {
-      "dark": "nightOwlMuted",
-      "light": "nightOwlMuted"
+      "dark": "#7791a6",
+      "light": "#7791a6"
    },
    "diffAddedLineNumberBg": {
      "dark": "#0a2e1a",
@@ -116,8 +116,8 @@
      "light": "nord5"
    },
    "diffLineNumber": {
-      "dark": "nord2",
-      "light": "nord4"
+      "dark": "#a9aeb6",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#3B4252",
@@ -51,7 +51,7 @@
    "diffAddedBg": { "dark": "#2c382b", "light": "#eafbe9" },
    "diffRemovedBg": { "dark": "#3a2d2f", "light": "#fce9e8" },
    "diffContextBg": { "dark": "darkBgAlt", "light": "lightBgAlt" },
-    "diffLineNumber": { "dark": "#495162", "light": "#c9c9ca" },
+    "diffLineNumber": { "dark": "#9398a2", "light": "#666666" },
    "diffAddedLineNumberBg": { "dark": "#283427", "light": "#e1f3df" },
    "diffRemovedLineNumberBg": { "dark": "#36292b", "light": "#f5e2e1" },
    "markdownText": { "dark": "darkFg", "light": "lightFg" },
@@ -138,8 +138,8 @@
      "light": "lightStep2"
    },
    "diffLineNumber": {
-      "dark": "darkStep3",
-      "light": "lightStep3"
+      "dark": "#8f8f8f",
+      "light": "#595959"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1b2b34",
@@ -142,8 +142,8 @@
      "light": "lightStep2"
    },
    "diffLineNumber": {
-      "dark": "darkStep3",
-      "light": "lightStep3"
+      "dark": "diffContext",
+      "light": "#595755"
    },
    "diffAddedLineNumberBg": {
      "dark": "#162535",
@@ -60,7 +60,7 @@
    "diffAddedBg": { "dark": "#15241c", "light": "#e0eee5" },
    "diffRemovedBg": { "dark": "#241515", "light": "#eee0e0" },
    "diffContextBg": { "dark": "darkBg1", "light": "lightBg1" },
-    "diffLineNumber": { "dark": "darkBg3", "light": "lightBg3" },
+    "diffLineNumber": { "dark": "#828b87", "light": "#5f5e4f" },
    "diffAddedLineNumberBg": { "dark": "#121f18", "light": "#d5e5da" },
    "diffRemovedLineNumberBg": { "dark": "#1f1212", "light": "#e5d5d5" },
    "markdownText": { "dark": "darkFg0", "light": "lightFg0" },
@@ -115,8 +115,8 @@
      "light": "#f5f5f5"
    },
    "diffLineNumber": {
-      "dark": "#444760",
-      "light": "#cfd8dc"
+      "dark": "#a0a2af",
+      "light": "#6a6e70"
    },
    "diffAddedLineNumberBg": {
      "dark": "#2e3c2b",
@@ -127,8 +127,8 @@
      "light": "dawnSurface"
    },
    "diffLineNumber": {
-      "dark": "muted",
-      "light": "dawnMuted"
+      "dark": "#9491a6",
+      "light": "#6c6875"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1f2d3a",
@@ -116,8 +116,8 @@
      "light": "base2"
    },
    "diffLineNumber": {
-      "dark": "base01",
-      "light": "base1"
+      "dark": "#8b9b9f",
+      "light": "#5f6969"
    },
    "diffAddedLineNumberBg": {
      "dark": "#073642",
@@ -119,8 +119,8 @@
      "light": "#f5f5f5"
    },
    "diffLineNumber": {
-      "dark": "#495495",
-      "light": "#b0b0b0"
+      "dark": "#959bc1",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1a3a2a",
@@ -136,8 +136,8 @@
      "light": "lightStep2"
    },
    "diffLineNumber": {
-      "dark": "darkStep3",
-      "light": "lightStep3"
+      "dark": "#8f909a",
+      "light": "#59595b"
    },
    "diffAddedLineNumberBg": {
      "dark": "#1b2b34",
@@ -138,8 +138,8 @@
      "light": "lightBackground"
    },
    "diffLineNumber": {
-      "dark": "gray600",
-      "light": "lightGray600"
+      "dark": "#8a8a8a",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#0F2613",
@@ -111,8 +111,8 @@
      "light": "#F8F8F8"
    },
    "diffLineNumber": {
-      "dark": "#505050",
-      "light": "#808080"
+      "dark": "textMuted",
+      "light": "#6a6a6a"
    },
    "diffAddedLineNumberBg": {
      "dark": "#0d2818",
@@ -116,8 +116,8 @@
      "light": "#f5f5e5"
    },
    "diffLineNumber": {
-      "dark": "#6f6f6f",
-      "light": "#b0b0a0"
+      "dark": "#d2d2d2",
+      "light": "textMuted"
    },
    "diffAddedLineNumberBg": {
      "dark": "#4f5f4f",
@@ -1183,28 +1183,26 @@ export function Session() {
              <Show when={session()?.parentID}>
                <SubagentFooter />
              </Show>
-              <Show when={visible()}>
-                <TuiPluginRuntime.Slot
-                  name="session_prompt"
-                  mode="replace"
-                  session_id={route.sessionID}
+              <TuiPluginRuntime.Slot
+                name="session_prompt"
+                mode="replace"
+                session_id={route.sessionID}
+                visible={visible()}
+                disabled={disabled()}
+                on_submit={toBottom}
+                ref={bind}
+              >
+                <Prompt
                  visible={visible()}
-                  disabled={disabled()}
-                  on_submit={toBottom}
                  ref={bind}
-                >
-                  <Prompt
-                    visible={visible()}
-                    ref={bind}
-                    disabled={disabled()}
-                    onSubmit={() => {
-                      toBottom()
-                    }}
-                    sessionID={route.sessionID}
-                    right={<TuiPluginRuntime.Slot name="session_prompt_right" session_id={route.sessionID} />}
-                  />
-                </TuiPluginRuntime.Slot>
-              </Show>
+                  disabled={disabled()}
+                  onSubmit={() => {
+                    toBottom()
+                  }}
+                  sessionID={route.sessionID}
+                  right={<TuiPluginRuntime.Slot name="session_prompt_right" session_id={route.sessionID} />}
+                />
+              </TuiPluginRuntime.Slot>
            </box>
          </Show>
          <Toast />
@@ -2195,7 +2193,7 @@ function Question(props: ToolProps<typeof QuestionTool>) {
  const { theme } = useTheme()
  const count = createMemo(() => props.input.questions?.length ?? 0)

-  function format(answer?: string[]) {
+  function format(answer?: ReadonlyArray<string>) {
    if (!answer?.length) return "(no answer)"
    return answer.join(", ")
  }
@@ -1,5 +1,5 @@
 import { Layer, ManagedRuntime } from "effect"
-import { memoMap } from "./run-service"
+import { attach, memoMap } from "./run-service"
 import { Observability } from "./oltp"

 import { AppFileSystem } from "@/filesystem"
@@ -8,7 +8,7 @@ import { Auth } from "@/auth"
 import { Account } from "@/account"
 import { Config } from "@/config/config"
 import { Git } from "@/git"
-import { Search } from "@/file/search"
+import { Ripgrep } from "@/file/ripgrep"
 import { FileTime } from "@/file/time"
 import { File } from "@/file"
 import { FileWatcher } from "@/file/watcher"
@@ -49,14 +49,14 @@ import { ShareNext } from "@/share/share-next"
 import { SessionShare } from "@/share/session"

 export const AppLayer = Layer.mergeAll(
-  // Observability.layer,
+  Observability.layer,
  AppFileSystem.defaultLayer,
  Bus.defaultLayer,
  Auth.defaultLayer,
  Account.defaultLayer,
  Config.defaultLayer,
  Git.defaultLayer,
-  Search.defaultLayer,
+  Ripgrep.defaultLayer,
  FileTime.defaultLayer,
  File.defaultLayer,
  FileWatcher.defaultLayer,
@@ -95,6 +95,27 @@ export const AppLayer = Layer.mergeAll(
  Installation.defaultLayer,
  ShareNext.defaultLayer,
  SessionShare.defaultLayer,
-).pipe(Layer.provide(Observability.layer))
+)

-export const AppRuntime = ManagedRuntime.make(AppLayer, { memoMap })
+const rt = ManagedRuntime.make(AppLayer, { memoMap })
+type Runtime = Pick<typeof rt, "runSync" | "runPromise" | "runPromiseExit" | "runFork" | "runCallback" | "dispose">
+const wrap = (effect: Parameters<typeof rt.runSync>[0]) => attach(effect as never) as never
+
+export const AppRuntime: Runtime = {
+  runSync(effect) {
+    return rt.runSync(wrap(effect))
+  },
+  runPromise(effect, options) {
+    return rt.runPromise(wrap(effect), options)
+  },
+  runPromiseExit(effect, options) {
+    return rt.runPromiseExit(wrap(effect), options)
+  },
+  runFork(effect) {
+    return rt.runFork(wrap(effect))
+  },
+  runCallback(effect) {
+    return rt.runCallback(wrap(effect))
+  },
+  dispose: () => rt.dispose(),
+}
@@ -1,89 +0,0 @@
-import {
-  FileFinder,
-  type FileItem,
-  type GrepCursor,
-  type GrepMatch,
-  type GrepResult,
-  type SearchResult,
-} from "@ff-labs/fff-bun"
-
-export namespace Fff {
-  export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
-
-  export interface Init {
-    basePath: string
-    frecencyDbPath?: string
-    historyDbPath?: string
-    aiMode?: boolean
-  }
-
-  export interface Search {
-    items: FileItem[]
-    scores: SearchResult["scores"]
-    totalMatched: number
-    totalFiles: number
-  }
-
-  export type File = FileItem
-  export type Cursor = GrepCursor | null
-  export type Hit = GrepMatch
-
-  export interface Grep {
-    items: GrepResult["items"]
-    totalMatched: number
-    totalFilesSearched: number
-    totalFiles: number
-    filteredFileCount: number
-    nextCursor: Cursor
-    regexFallbackError?: string
-  }
-
-  export interface Picker {
-    destroy(): void
-    waitForScan(timeout?: number): Result<boolean>
-    refreshGitStatus(): Result<number>
-    fileSearch(
-      query: string,
-      opts?: {
-        currentFile?: string
-        pageIndex?: number
-        pageSize?: number
-      },
-    ): Result<Search>
-    grep(
-      query: string,
-      opts?: {
-        mode?: "plain" | "regex" | "fuzzy"
-        maxMatchesPerFile?: number
-        timeBudgetMs?: number
-        beforeContext?: number
-        afterContext?: number
-        cursor?: Cursor
-      },
-    ): Result<Grep>
-    trackQuery(query: string, file: string): Result<boolean>
-    getHistoricalQuery(offset: number): Result<string | null>
-  }
-
-  export function available() {
-    return FileFinder.isAvailable()
-  }
-
-  export function create(opts: Init): Result<Picker> {
-    const made = FileFinder.create(opts)
-    if (!made.ok) return made
-    const pick = made.value
-    return {
-      ok: true,
-      value: {
-        destroy: () => pick.destroy(),
-        waitForScan: (timeout) => pick.waitForScan(timeout),
-        refreshGitStatus: () => pick.refreshGitStatus(),
-        fileSearch: (query, next) => pick.fileSearch(query, next),
-        grep: (query, next) => pick.grep(query, next),
-        trackQuery: (query, file) => pick.trackQuery(query, file),
-        getHistoricalQuery: (offset) => pick.getHistoricalQuery(offset),
-      },
-    }
-  }
-}
@@ -1,82 +0,0 @@
-export namespace Fff {
-  export type Result<T> = { ok: true; value: T } | { ok: false; error: string }
-
-  export interface Init {
-    basePath: string
-    frecencyDbPath?: string
-    historyDbPath?: string
-    aiMode?: boolean
-  }
-
-  export interface File {
-    path: string
-    relativePath: string
-    fileName: string
-  }
-
-  export interface Search {
-    items: File[]
-    scores: unknown[]
-    totalMatched: number
-    totalFiles: number
-  }
-
-  export type Cursor = null
-
-  export interface Hit {
-    path: string
-    relativePath: string
-    fileName: string
-    lineNumber: number
-    byteOffset: number
-    lineContent: string
-    matchRanges: [number, number][]
-    contextBefore?: string[]
-    contextAfter?: string[]
-  }
-
-  export interface Grep {
-    items: Hit[]
-    totalMatched: number
-    totalFilesSearched: number
-    totalFiles: number
-    filteredFileCount: number
-    nextCursor: Cursor
-    regexFallbackError?: string
-  }
-
-  export interface Picker {
-    destroy(): void
-    waitForScan(timeout?: number): Result<boolean>
-    refreshGitStatus(): Result<number>
-    fileSearch(
-      query: string,
-      opts?: {
-        currentFile?: string
-        pageIndex?: number
-        pageSize?: number
-      },
-    ): Result<Search>
-    grep(
-      query: string,
-      opts?: {
-        mode?: "plain" | "regex" | "fuzzy"
-        maxMatchesPerFile?: number
-        timeBudgetMs?: number
-        beforeContext?: number
-        afterContext?: number
-        cursor?: Cursor
-      },
-    ): Result<Grep>
-    trackQuery(query: string, file: string): Result<boolean>
-    getHistoricalQuery(offset: number): Result<string | null>
-  }
-
-  export function available() {
-    return false
-  }
-
-  export function create(): Result<Picker> {
-    return { ok: false, error: "fff unavailable" }
-  }
-}
@@ -14,7 +14,7 @@ import { Global } from "../global"
 import { Instance } from "../project/instance"
 import { Log } from "../util/log"
 import { Protected } from "./protected"
-import { Search } from "./search"
+import { Ripgrep } from "./ripgrep"

 export namespace File {
  export const Info = z
@@ -344,7 +344,7 @@ export namespace File {
    Service,
    Effect.gen(function* () {
      const appFs = yield* AppFileSystem.Service
-      const searchSvc = yield* Search.Service
+      const rg = yield* Ripgrep.Service
      const git = yield* Git.Service

      const state = yield* InstanceState.make<State>(
@@ -384,7 +384,7 @@ export namespace File {

          next.dirs = Array.from(dirs).toSorted()
        } else {
-          const files = yield* searchSvc.files({ cwd: Instance.directory }).pipe(
+          const files = yield* rg.files({ cwd: Instance.directory }).pipe(
            Stream.runCollect,
            Effect.map((chunk) => [...chunk]),
          )
@@ -512,8 +512,6 @@ export namespace File {

        if (!Instance.containsPath(full)) throw new Error("Access denied: path escapes project directory")

-        yield* searchSvc.open({ cwd: Instance.directory, file }).pipe(Effect.ignore)
-
        if (isImageByExtension(file)) {
          const exists = yield* appFs.existsSafe(full)
          if (exists) {
@@ -619,26 +617,14 @@ export namespace File {
        dirs?: boolean
        type?: "file" | "directory"
      }) {
+        yield* ensure()
+        const { cache } = yield* InstanceState.get(state)
+
        const query = input.query.trim()
        const limit = input.limit ?? 100
        const kind = input.type ?? (input.dirs === false ? "file" : "all")
        log.info("search", { query, kind })

-        if (query && kind === "file") {
-          const files = yield* searchSvc.file({
-            cwd: Instance.directory,
-            query,
-            limit,
-          })
-          if (files.length) {
-            log.info("search", { query, kind, results: files.length, mode: "fff" })
-            return files
-          }
-        }
-
-        yield* ensure()
-        const { cache } = yield* InstanceState.get(state)
-
        const preferHidden = query.startsWith(".") || query.includes("/.")

        if (!query) {
@@ -663,7 +649,7 @@ export namespace File {
  )

  export const defaultLayer = layer.pipe(
-    Layer.provide(Search.defaultLayer),
+    Layer.provide(Ripgrep.defaultLayer),
    Layer.provide(AppFileSystem.defaultLayer),
    Layer.provide(Git.defaultLayer),
  )
@@ -1,465 +0,0 @@
-import path from "path"
-import z from "zod"
-import { Context, Deferred, Effect, Layer, Option } from "effect"
-import * as Stream from "effect/Stream"
-import { Fff } from "#fff"
-import { InstanceState } from "@/effect/instance-state"
-import { makeRuntime } from "@/effect/run-service"
-import { AppFileSystem } from "@/filesystem"
-import { Global } from "@/global"
-import { Glob } from "@/util/glob"
-import { Log } from "@/util/log"
-import { Ripgrep } from "./ripgrep"
-
-export namespace Search {
-  const log = Log.create({ service: "file.search" })
-  const root = path.join(Global.Path.cache, "fff")
-
-  export const Match = z.object({
-    path: z.object({
-      text: z.string(),
-    }),
-    lines: z.object({
-      text: z.string(),
-    }),
-    line_number: z.number(),
-    absolute_offset: z.number(),
-    submatches: z.array(
-      z.object({
-        match: z.object({
-          text: z.string(),
-        }),
-        start: z.number(),
-        end: z.number(),
-      }),
-    ),
-  })
-
-  export type Item = z.infer<typeof Match>
-
-  export interface Result {
-    readonly items: Item[]
-    readonly partial: boolean
-    readonly engine: "fff" | "ripgrep"
-    readonly regexFallbackError?: string
-  }
-
-  export interface FileInput {
-    readonly cwd: string
-    readonly query: string
-    readonly limit?: number
-    readonly current?: string
-  }
-
-  export interface GlobInput {
-    readonly cwd: string
-    readonly pattern: string
-    readonly limit?: number
-    readonly signal?: AbortSignal
-  }
-
-  interface Query {
-    readonly dir: string
-    readonly text: string
-    readonly files: string[]
-  }
-
-  interface State {
-    readonly pick: Map<string, Fff.Picker>
-    readonly wait: Map<string, Deferred.Deferred<Fff.Picker, Error>>
-    readonly recent: Query[]
-  }
-
-  export interface Interface {
-    readonly files: (input: Ripgrep.FilesInput) => Stream.Stream<string, Error>
-    readonly tree: (input: Ripgrep.TreeInput) => Effect.Effect<string, Error>
-    readonly search: (input: Ripgrep.SearchInput) => Effect.Effect<Result, Error>
-    readonly file: (input: FileInput) => Effect.Effect<string[]>
-    readonly glob: (input: GlobInput) => Effect.Effect<{ files: string[]; truncated: boolean }, Error>
-    readonly open: (input: { cwd?: string; file: string }) => Effect.Effect<void>
-  }
-
-  export class Service extends Context.Service<Service, Interface>()("@opencode/Search") {}
-
-  function key(dir: string) {
-    return Buffer.from(dir).toString("base64url")
-  }
-
-  function norm(text: string) {
-    return text.replaceAll("\\", "/")
-  }
-
-  function blocked(rel: string) {
-    return norm(rel).split("/").includes(".git")
-  }
-
-  function base(file: string) {
-    return norm(file).split("/").at(-1) ?? file
-  }
-
-  function allow(glob: string[] | undefined, rel: string, file: string) {
-    if (!glob?.length) return true
-    const yes = glob.filter((item) => !item.startsWith("!"))
-    const no = glob.filter((item) => item.startsWith("!")).map((item) => item.slice(1))
-    if (yes.length > 0 && !yes.some((item) => Glob.match(item, rel) || Glob.match(item, file))) return false
-    if (no.some((item) => Glob.match(item, rel) || Glob.match(item, file))) return false
-    return true
-  }
-
-  function include(pattern: string) {
-    const val = pattern.trim().replaceAll("\\", "/")
-    if (!val) return "*"
-    const flat = val.replaceAll("**/", "").replaceAll("/**", "/")
-    const idx = flat.lastIndexOf("/")
-    if (idx < 0) return flat
-    const dir = flat.slice(0, idx + 1)
-    const glob = flat.slice(idx + 1)
-    if (!glob) return dir
-    return `${dir} ${glob}`
-  }
-
-  function remember(st: State, dir: string, text: string, files: string[]) {
-    if (!files.length) return
-    const next = Array.from(new Set(files.map(AppFileSystem.resolve))).slice(0, 64)
-    if (!next.length) return
-    const old = st.recent.findIndex((item) => item.dir === dir && item.text === text)
-    if (old >= 0) st.recent.splice(old, 1)
-    st.recent.unshift({ dir, text, files: next })
-    if (st.recent.length > 32) st.recent.length = 32
-  }
-
-  function item(hit: Fff.Hit): Item {
-    return {
-      path: { text: norm(hit.relativePath) },
-      lines: { text: hit.lineContent },
-      line_number: hit.lineNumber,
-      absolute_offset: hit.byteOffset,
-      submatches: hit.matchRanges
-        .map(([start, end]) => {
-          const text = hit.lineContent.slice(start, end)
-          if (!text) return undefined
-          return {
-            match: { text },
-            start,
-            end,
-          }
-        })
-        .filter((row): row is Item["submatches"][number] => Boolean(row)),
-    }
-  }
-
-  export const layer = Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const fs = yield* AppFileSystem.Service
-      const rg = yield* Ripgrep.Service
-      const state = yield* InstanceState.make<State>(
-        Effect.fn("Search.state")(() =>
-          Effect.gen(function* () {
-            const next: State = {
-              pick: new Map(),
-              wait: new Map(),
-              recent: [],
-            }
-            yield* Effect.addFinalizer(() =>
-              Effect.sync(() => {
-                for (const pick of next.pick.values()) pick.destroy()
-              }),
-            )
-            return next
-          }),
-        ),
-      )
-
-      const rip = Effect.fn("Search.rip")(function* (input: Ripgrep.SearchInput) {
-        const out = yield* rg.search(input)
-        return {
-          items: out.items,
-          partial: out.partial,
-          engine: "ripgrep" as const,
-        }
-      })
-
-      const picker = Effect.fn("Search.picker")(function* (cwd: string) {
-        if (!Fff.available()) return undefined
-        const dir = AppFileSystem.resolve(cwd)
-        const st = yield* InstanceState.get(state)
-        const old = st.pick.get(dir)
-        if (old) return old
-
-        const wait = st.wait.get(dir)
-        if (wait) return yield* Deferred.await(wait)
-
-        const gate = yield* Deferred.make<Fff.Picker, Error>()
-        st.wait.set(dir, gate)
-        try {
-          yield* fs.ensureDir(root)
-          const id = key(dir)
-          const made = yield* Effect.sync(() =>
-            Fff.create({
-              basePath: dir,
-              frecencyDbPath: path.join(root, `${id}.frecency.mdb`),
-              historyDbPath: path.join(root, `${id}.history.mdb`),
-              aiMode: true,
-            }),
-          )
-          if (!made.ok) {
-            const err = new Error(made.error)
-            yield* Deferred.fail(gate, err)
-            return yield* Effect.fail(err)
-          }
-
-          const pick = made.value
-          const done = yield* Effect.sync(() => pick.waitForScan(5_000))
-          if (!done.ok) {
-            pick.destroy()
-            const err = new Error(done.error)
-            yield* Deferred.fail(gate, err)
-            return yield* Effect.fail(err)
-          }
-          if (!done.value) {
-            pick.destroy()
-            const err = new Error("fff scan timed out")
-            yield* Deferred.fail(gate, err)
-            return yield* Effect.fail(err)
-          }
-
-          const git = yield* Effect.sync(() => pick.refreshGitStatus())
-          if (!git.ok) {
-            log.warn("git refresh failed", { dir, error: git.error })
-          }
-
-          st.pick.set(dir, pick)
-          yield* Deferred.succeed(gate, pick)
-          return pick
-        } finally {
-          if (st.wait.get(dir) === gate) st.wait.delete(dir)
-        }
-      })
-
-      const files: Interface["files"] = (input) => rg.files(input)
-      const tree: Interface["tree"] = (input) => rg.tree(input)
-
-      const file: Interface["file"] = Effect.fn("Search.file")(function* (input) {
-        const query = input.query.trim()
-        if (!query) return []
-        const pick = yield* picker(input.cwd).pipe(Effect.catch(() => Effect.succeed(undefined)))
-        if (!pick) return []
-
-        const dir = AppFileSystem.resolve(input.cwd)
-        const out = yield* Effect.sync(() =>
-          pick.fileSearch(query, {
-            currentFile: input.current
-              ? path.isAbsolute(input.current)
-                ? input.current
-                : path.join(dir, input.current)
-              : undefined,
-            pageIndex: 0,
-            pageSize: Math.max(input.limit ?? 100, 100),
-          }),
-        )
-        if (!out.ok) {
-          log.warn("fff file search failed", { dir, query, error: out.error })
-          return []
-        }
-
-        const min = query.length * 10
-        const rows = Array.from(
-          new Set(
-            out.value.items.flatMap((item, idx) => {
-              const score = out.value.scores[idx]
-              if (!score || score.total < min) return []
-              return [norm(item.relativePath)]
-            }),
-          ),
-        )
-        remember(
-          yield* InstanceState.get(state),
-          dir,
-          query,
-          rows.map((row) => path.join(dir, row)),
-        )
-        return rows.slice(0, input.limit ?? 100)
-      })
-
-      const search: Interface["search"] = Effect.fn("Search.search")(function* (input) {
-        input.signal?.throwIfAborted()
-        if (input.file?.length) return yield* rip(input)
-
-        const pick = yield* picker(input.cwd).pipe(Effect.catch(() => Effect.succeed(undefined)))
-        if (!pick) return yield* rip(input)
-
-        const dir = AppFileSystem.resolve(input.cwd)
-        const limit = input.limit ?? 100
-        const rows: Item[] = []
-        const seen = new Set<string>()
-        let cur: Fff.Cursor = null
-        let err: string | undefined
-
-        while (rows.length < limit) {
-          input.signal?.throwIfAborted()
-          const out = yield* Effect.sync(() =>
-            pick.grep(input.pattern, {
-              mode: "regex",
-              cursor: cur,
-              maxMatchesPerFile: limit,
-              timeBudgetMs: 1_500,
-            }),
-          )
-          if (!out.ok) {
-            log.warn("fff grep failed", { dir, pattern: input.pattern, error: out.error })
-            return yield* rip(input)
-          }
-
-          err = err ?? out.value.regexFallbackError
-          for (const hit of out.value.items) {
-            const rel = norm(hit.relativePath)
-            if (!allow(input.glob, rel, norm(hit.fileName))) continue
-            const id = `${rel}:${hit.lineNumber}:${hit.byteOffset}`
-            if (seen.has(id)) continue
-            seen.add(id)
-            rows.push(item(hit))
-            if (rows.length >= limit) break
-          }
-
-          if (!out.value.nextCursor) break
-          cur = out.value.nextCursor
-        }
-
-        if (!rows.length && input.glob?.length) return yield* rip(input)
-
-        remember(
-          yield* InstanceState.get(state),
-          dir,
-          input.pattern,
-          Array.from(new Set(rows.map((row) => path.join(dir, row.path.text)))),
-        )
-
-        return {
-          items: rows,
-          partial: false,
-          engine: "fff" as const,
-          regexFallbackError: err,
-        }
-      })
-
-      const glob: Interface["glob"] = Effect.fn("Search.glob")(function* (input) {
-        input.signal?.throwIfAborted()
-        const dir = AppFileSystem.resolve(input.cwd)
-        const limit = input.limit ?? 100
-        const pick = yield* picker(dir).pipe(Effect.catch(() => Effect.succeed(undefined)))
-
-        if (pick) {
-          const out = yield* Effect.sync(() =>
-            pick.fileSearch(include(input.pattern), {
-              currentFile: path.join(dir, ".opencode"),
-              pageIndex: 0,
-              pageSize: Math.max(limit * 4, 200),
-            }),
-          )
-          if (out.ok) {
-            const rows = Array.from(
-              new Set(
-                out.value.items
-                  .map((item) => norm(item.relativePath))
-                  .filter((item) => !blocked(item))
-                  .filter((item) => Glob.match(input.pattern, item) || Glob.match(input.pattern, base(item))),
-              ),
-            )
-            if (rows.length > 0) {
-              remember(
-                yield* InstanceState.get(state),
-                dir,
-                input.pattern,
-                rows.map((row) => path.join(dir, row)),
-              )
-              return {
-                files: rows.slice(0, limit).map((row) => path.join(dir, row)),
-                truncated: rows.length > limit,
-              }
-            }
-          } else {
-            log.warn("fff glob search failed", { dir, pattern: input.pattern, error: out.error })
-          }
-        }
-
-        const rows = yield* rg.files({ cwd: dir, glob: [input.pattern], signal: input.signal }).pipe(
-          Stream.take(limit + 1),
-          Stream.runCollect,
-          Effect.map((chunk) => [...chunk]),
-        )
-        const cut = rows.length > limit
-        if (cut) rows.length = limit
-
-        const out = yield* Effect.forEach(
-          rows,
-          Effect.fnUntraced(function* (file) {
-            const full = path.join(dir, file)
-            const info = yield* fs.stat(full).pipe(Effect.catch(() => Effect.succeed(undefined)))
-            const time =
-              info?.mtime.pipe(
-                Option.map((item) => item.getTime()),
-                Option.getOrElse(() => 0),
-              ) ?? 0
-            return { file: full, time }
-          }),
-          { concurrency: 16 },
-        )
-        out.sort((a, b) => b.time - a.time)
-        return {
-          files: out.map((item) => item.file),
-          truncated: cut,
-        }
-      })
-
-      const open: Interface["open"] = Effect.fn("Search.open")(function* (input) {
-        const st = yield* InstanceState.get(state)
-        const file = input.cwd
-          ? AppFileSystem.resolve(path.isAbsolute(input.file) ? input.file : path.join(input.cwd, input.file))
-          : AppFileSystem.resolve(input.file)
-        const idx = st.recent.findIndex((item) => item.files.includes(file))
-        if (idx < 0) return
-
-        const row = st.recent[idx]
-        st.recent.splice(idx, 1)
-        const pick = st.pick.get(row.dir)
-        if (!pick) return
-
-        const out = yield* Effect.sync(() => pick.trackQuery(row.text, file))
-        if (!out.ok) {
-          log.warn("fff track query failed", { dir: row.dir, query: row.text, file, error: out.error })
-        }
-      })
-
-      return Service.of({ files, tree, search, file, glob, open })
-    }),
-  )
-
-  export const defaultLayer = layer.pipe(Layer.provide(Ripgrep.defaultLayer), Layer.provide(AppFileSystem.defaultLayer))
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export function files(input: Ripgrep.FilesInput) {
-    return runPromise((svc) => Stream.toAsyncIterableEffect(svc.files(input)))
-  }
-
-  export function tree(input: Ripgrep.TreeInput) {
-    return runPromise((svc) => svc.tree(input))
-  }
-
-  export function search(input: Ripgrep.SearchInput) {
-    return runPromise((svc) => svc.search(input))
-  }
-
-  export function file(input: FileInput) {
-    return runPromise((svc) => svc.file(input))
-  }
-
-  export function glob(input: GlobInput) {
-    return runPromise((svc) => svc.glob(input))
-  }
-
-  export function open(input: { cwd?: string; file: string }) {
-    return runPromise((svc) => svc.open(input))
-  }
-}
@@ -27,16 +27,16 @@ export namespace Identifier {
  let counter = 0

  export function ascending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, false, given)
+    return generateID(prefix, "ascending", given)
  }

  export function descending(prefix: keyof typeof prefixes, given?: string) {
-    return generateID(prefix, true, given)
+    return generateID(prefix, "descending", given)
  }

-  function generateID(prefix: keyof typeof prefixes, descending: boolean, given?: string): string {
+  function generateID(prefix: keyof typeof prefixes, direction: "descending" | "ascending", given?: string): string {
    if (!given) {
-      return create(prefix, descending)
+      return create(prefixes[prefix], direction)
    }

    if (!given.startsWith(prefixes[prefix])) {
@@ -55,7 +55,7 @@ export namespace Identifier {
    return result
  }

-  export function create(prefix: keyof typeof prefixes, descending: boolean, timestamp?: number): string {
+  export function create(prefix: string, direction: "descending" | "ascending", timestamp?: number): string {
    const currentTimestamp = timestamp ?? Date.now()

    if (currentTimestamp !== lastTimestamp) {
@@ -66,14 +66,14 @@ export namespace Identifier {

    let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter)

-    now = descending ? ~now : now
+    now = direction === "descending" ? ~now : now

    const timeBytes = Buffer.alloc(6)
    for (let i = 0; i < 6; i++) {
      timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff))
    }

-    return prefixes[prefix] + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
+    return prefix + "_" + timeBytes.toString("hex") + randomBase62(LENGTH - 12)
  }

  /** Extract timestamp from an ascending ID. Does not work with descending IDs. */
@@ -204,6 +204,12 @@ export namespace MCP {
    defs?: MCPToolDef[]
  }

+  interface AuthResult {
+    authorizationUrl: string
+    oauthState: string
+    client?: MCPClient
+  }
+
  // --- Effect Service ---

  interface State {
@@ -552,6 +558,21 @@ export namespace MCP {
        return Effect.tryPromise(() => client.close()).pipe(Effect.ignore)
      }

+      const storeClient = Effect.fnUntraced(function* (
+        s: State,
+        name: string,
+        client: MCPClient,
+        listed: MCPToolDef[],
+        timeout?: number,
+      ) {
+        yield* closeClient(s, name)
+        s.status[name] = { status: "connected" }
+        s.clients[name] = client
+        s.defs[name] = listed
+        watch(s, name, client, timeout)
+        return s.status[name]
+      })
+
      const status = Effect.fn("MCP.status")(function* () {
        const s = yield* InstanceState.get(state)

@@ -583,11 +604,7 @@ export namespace MCP {
          return result.status
        }

-        yield* closeClient(s, name)
-        s.clients[name] = result.mcpClient
-        s.defs[name] = result.defs!
-        watch(s, name, result.mcpClient, mcp.timeout)
-        return result.status
+        return yield* storeClient(s, name, result.mcpClient, result.defs!, mcp.timeout)
      })

      const add = Effect.fn("MCP.add")(function* (name: string, mcp: Config.Mcp) {
@@ -753,14 +770,16 @@ export namespace MCP {
        return yield* Effect.tryPromise({
          try: () => {
            const client = new Client({ name: "opencode", version: Installation.VERSION })
-            return client.connect(transport).then(() => ({ authorizationUrl: "", oauthState }))
+            return client
+              .connect(transport)
+              .then(() => ({ authorizationUrl: "", oauthState, client }) satisfies AuthResult)
          },
          catch: (error) => error,
        }).pipe(
          Effect.catch((error) => {
            if (error instanceof UnauthorizedError && capturedUrl) {
              pendingOAuthTransports.set(mcpName, transport)
-              return Effect.succeed({ authorizationUrl: capturedUrl.toString(), oauthState })
+              return Effect.succeed({ authorizationUrl: capturedUrl.toString(), oauthState } satisfies AuthResult)
            }
            return Effect.die(error)
          }),
@@ -768,14 +787,31 @@ export namespace MCP {
      })

      const authenticate = Effect.fn("MCP.authenticate")(function* (mcpName: string) {
-        const { authorizationUrl, oauthState } = yield* startAuth(mcpName)
-        if (!authorizationUrl) return { status: "connected" } as Status
+        const result = yield* startAuth(mcpName)
+        if (!result.authorizationUrl) {
+          const client = "client" in result ? result.client : undefined
+          const mcpConfig = yield* getMcpConfig(mcpName)
+          if (!mcpConfig) {
+            yield* Effect.tryPromise(() => client?.close() ?? Promise.resolve()).pipe(Effect.ignore)
+            return { status: "failed", error: "MCP config not found after auth" } as Status
+          }

-        log.info("opening browser for oauth", { mcpName, url: authorizationUrl, state: oauthState })
+          const listed = client ? yield* defs(mcpName, client, mcpConfig.timeout) : undefined
+          if (!client || !listed) {
+            yield* Effect.tryPromise(() => client?.close() ?? Promise.resolve()).pipe(Effect.ignore)
+            return { status: "failed", error: "Failed to get tools" } as Status
+          }

-        const callbackPromise = McpOAuthCallback.waitForCallback(oauthState, mcpName)
+          const s = yield* InstanceState.get(state)
+          yield* auth.clearOAuthState(mcpName)
+          return yield* storeClient(s, mcpName, client, listed, mcpConfig.timeout)
+        }

-        yield* Effect.tryPromise(() => open(authorizationUrl)).pipe(
+        log.info("opening browser for oauth", { mcpName, url: result.authorizationUrl, state: result.oauthState })
+
+        const callbackPromise = McpOAuthCallback.waitForCallback(result.oauthState, mcpName)
+
+        yield* Effect.tryPromise(() => open(result.authorizationUrl)).pipe(
          Effect.flatMap((subprocess) =>
            Effect.callback<void, Error>((resume) => {
              const timer = setTimeout(() => resume(Effect.void), 500)
@@ -793,14 +829,14 @@ export namespace MCP {
          ),
          Effect.catch(() => {
            log.warn("failed to open browser, user must open URL manually", { mcpName })
-            return bus.publish(BrowserOpenFailed, { mcpName, url: authorizationUrl }).pipe(Effect.ignore)
+            return bus.publish(BrowserOpenFailed, { mcpName, url: result.authorizationUrl }).pipe(Effect.ignore)
          }),
        )

        const code = yield* Effect.promise(() => callbackPromise)

        const storedState = yield* auth.getOAuthState(mcpName)
-        if (storedState !== oauthState) {
+        if (storedState !== result.oauthState) {
          yield* auth.clearOAuthState(mcpName)
          throw new Error("OAuth state mismatch - potential CSRF attack")
        }
@@ -1,5 +1,6 @@
 import { GlobalBus } from "@/bus/global"
 import { disposeInstance } from "@/effect/instance-registry"
+import { makeRuntime } from "@/effect/run-service"
 import { Filesystem } from "@/util/filesystem"
 import { iife } from "@/util/iife"
 import { Log } from "@/util/log"
@@ -15,6 +16,7 @@ export interface InstanceContext {

 const context = LocalContext.create<InstanceContext>("instance")
 const cache = new Map<string, Promise<InstanceContext>>()
+const project = makeRuntime(Project.Service, Project.defaultLayer)

 const disposal = {
  all: undefined as Promise<void> | undefined,
@@ -29,11 +31,13 @@ function boot(input: { directory: string; init?: () => Promise<any>; worktree?:
            worktree: input.worktree,
            project: input.project,
          }
-        : await Project.fromDirectory(input.directory).then(({ project, sandbox }) => ({
-            directory: input.directory,
-            worktree: sandbox,
-            project,
-          }))
+        : await project
+            .runPromise((svc) => svc.fromDirectory(input.directory))
+            .then(({ project, sandbox }) => ({
+              directory: input.directory,
+              worktree: sandbox,
+              project,
+            }))
    await context.provide(ctx, async () => {
      await input.init?.()
    })
@@ -10,8 +10,7 @@ import { which } from "../util/which"
 import { ProjectID } from "./schema"
 import { Effect, Layer, Path, Scope, Context, Stream } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import { makeRuntime } from "@/effect/run-service"
+import { NodePath } from "@effect/platform-node"
 import { AppFileSystem } from "@/filesystem"
 import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"

@@ -463,19 +462,6 @@ export namespace Project {
    Layer.provide(AppFileSystem.defaultLayer),
    Layer.provide(NodePath.layer),
  )
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  // ---------------------------------------------------------------------------
-  // Promise-based API (delegates to Effect service via runPromise)
-  // ---------------------------------------------------------------------------
-
-  export function fromDirectory(directory: string) {
-    return runPromise((svc) => svc.fromDirectory(directory))
-  }
-
-  export function discover(input: Info) {
-    return runPromise((svc) => svc.discover(input))
-  }

  export function list() {
    return Database.use((db) =>
@@ -498,24 +484,4 @@ export namespace Project {
      db.update(ProjectTable).set({ time_initialized: Date.now() }).where(eq(ProjectTable.id, id)).run(),
    )
  }
-
-  export function initGit(input: { directory: string; project: Info }) {
-    return runPromise((svc) => svc.initGit(input))
-  }
-
-  export function update(input: UpdateInput) {
-    return runPromise((svc) => svc.update(input))
-  }
-
-  export function sandboxes(id: ProjectID) {
-    return runPromise((svc) => svc.sandboxes(id))
-  }
-
-  export function addSandbox(id: ProjectID, directory: string) {
-    return runPromise((svc) => svc.addSandbox(id, directory))
-  }
-
-  export function removeSandbox(id: ProjectID, directory: string) {
-    return runPromise((svc) => svc.removeSandbox(id, directory))
-  }
 }
@@ -3,8 +3,9 @@ import { Bus } from "@/bus"
 import { BusEvent } from "@/bus/bus-event"
 import { InstanceState } from "@/effect/instance-state"
 import { SessionID, MessageID } from "@/session/schema"
+import { zod } from "@/util/effect-zod"
 import { Log } from "@/util/log"
-import z from "zod"
+import { withStatics } from "@/util/schema"
 import { QuestionID } from "./schema"

 export namespace Question {
@@ -12,67 +13,91 @@ export namespace Question {

  // Schemas

-  export const Option = z
-    .object({
-      label: z.string().describe("Display text (1-5 words, concise)"),
-      description: z.string().describe("Explanation of choice"),
-    })
-    .meta({ ref: "QuestionOption" })
-  export type Option = z.infer<typeof Option>
+  export class Option extends Schema.Class<Option>("QuestionOption")({
+    label: Schema.String.annotate({
+      description: "Display text (1-5 words, concise)",
+    }),
+    description: Schema.String.annotate({
+      description: "Explanation of choice",
+    }),
+  }) {
+    static readonly zod = zod(this)
+  }

-  export const Info = z
-    .object({
-      question: z.string().describe("Complete question"),
-      header: z.string().describe("Very short label (max 30 chars)"),
-      options: z.array(Option).describe("Available choices"),
-      multiple: z.boolean().optional().describe("Allow selecting multiple choices"),
-      custom: z.boolean().optional().describe("Allow typing a custom answer (default: true)"),
-    })
-    .meta({ ref: "QuestionInfo" })
-  export type Info = z.infer<typeof Info>
+  const base = {
+    question: Schema.String.annotate({
+      description: "Complete question",
+    }),
+    header: Schema.String.annotate({
+      description: "Very short label (max 30 chars)",
+    }),
+    options: Schema.Array(Option).annotate({
+      description: "Available choices",
+    }),
+    multiple: Schema.optional(Schema.Boolean).annotate({
+      description: "Allow selecting multiple choices",
+    }),
+  }

-  export const Request = z
-    .object({
-      id: QuestionID.zod,
-      sessionID: SessionID.zod,
-      questions: z.array(Info).describe("Questions to ask"),
-      tool: z
-        .object({
-          messageID: MessageID.zod,
-          callID: z.string(),
-        })
-        .optional(),
-    })
-    .meta({ ref: "QuestionRequest" })
-  export type Request = z.infer<typeof Request>
+  export class Info extends Schema.Class<Info>("QuestionInfo")({
+    ...base,
+    custom: Schema.optional(Schema.Boolean).annotate({
+      description: "Allow typing a custom answer (default: true)",
+    }),
+  }) {
+    static readonly zod = zod(this)
+  }

-  export const Answer = z.array(z.string()).meta({ ref: "QuestionAnswer" })
-  export type Answer = z.infer<typeof Answer>
+  export class Prompt extends Schema.Class<Prompt>("QuestionPrompt")(base) {
+    static readonly zod = zod(this)
+  }

-  export const Reply = z.object({
-    answers: z
-      .array(Answer)
-      .describe("User answers in order of questions (each answer is an array of selected labels)"),
-  })
-  export type Reply = z.infer<typeof Reply>
+  export class Tool extends Schema.Class<Tool>("QuestionTool")({
+    messageID: MessageID,
+    callID: Schema.String,
+  }) {
+    static readonly zod = zod(this)
+  }
+
+  export class Request extends Schema.Class<Request>("QuestionRequest")({
+    id: QuestionID,
+    sessionID: SessionID,
+    questions: Schema.Array(Info).annotate({
+      description: "Questions to ask",
+    }),
+    tool: Schema.optional(Tool),
+  }) {
+    static readonly zod = zod(this)
+  }
+
+  export const Answer = Schema.Array(Schema.String)
+    .annotate({ identifier: "QuestionAnswer" })
+    .pipe(withStatics((s) => ({ zod: zod(s) })))
+  export type Answer = Schema.Schema.Type<typeof Answer>
+
+  export class Reply extends Schema.Class<Reply>("QuestionReply")({
+    answers: Schema.Array(Answer).annotate({
+      description: "User answers in order of questions (each answer is an array of selected labels)",
+    }),
+  }) {
+    static readonly zod = zod(this)
+  }
+
+  class Replied extends Schema.Class<Replied>("QuestionReplied")({
+    sessionID: SessionID,
+    requestID: QuestionID,
+    answers: Schema.Array(Answer),
+  }) {}
+
+  class Rejected extends Schema.Class<Rejected>("QuestionRejected")({
+    sessionID: SessionID,
+    requestID: QuestionID,
+  }) {}

  export const Event = {
-    Asked: BusEvent.define("question.asked", Request),
-    Replied: BusEvent.define(
-      "question.replied",
-      z.object({
-        sessionID: SessionID.zod,
-        requestID: QuestionID.zod,
-        answers: z.array(Answer),
-      }),
-    ),
-    Rejected: BusEvent.define(
-      "question.rejected",
-      z.object({
-        sessionID: SessionID.zod,
-        requestID: QuestionID.zod,
-      }),
-    ),
+    Asked: BusEvent.define("question.asked", Request.zod),
+    Replied: BusEvent.define("question.replied", zod(Replied)),
+    Rejected: BusEvent.define("question.rejected", zod(Rejected)),
  }

  export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("QuestionRejectedError", {}) {
@@ -83,7 +108,7 @@ export namespace Question {

  interface PendingEntry {
    info: Request
-    deferred: Deferred.Deferred<Answer[], RejectedError>
+    deferred: Deferred.Deferred<ReadonlyArray<Answer>, RejectedError>
  }

  interface State {
@@ -95,12 +120,12 @@ export namespace Question {
  export interface Interface {
    readonly ask: (input: {
      sessionID: SessionID
-      questions: Info[]
-      tool?: { messageID: MessageID; callID: string }
-    }) => Effect.Effect<Answer[], RejectedError>
-    readonly reply: (input: { requestID: QuestionID; answers: Answer[] }) => Effect.Effect<void>
+      questions: ReadonlyArray<Info>
+      tool?: Tool
+    }) => Effect.Effect<ReadonlyArray<Answer>, RejectedError>
+    readonly reply: (input: { requestID: QuestionID; answers: ReadonlyArray<Answer> }) => Effect.Effect<void>
    readonly reject: (requestID: QuestionID) => Effect.Effect<void>
-    readonly list: () => Effect.Effect<Request[]>
+    readonly list: () => Effect.Effect<ReadonlyArray<Request>>
  }

  export class Service extends Context.Service<Service, Interface>()("@opencode/Question") {}
@@ -130,20 +155,20 @@ export namespace Question {

      const ask = Effect.fn("Question.ask")(function* (input: {
        sessionID: SessionID
-        questions: Info[]
-        tool?: { messageID: MessageID; callID: string }
+        questions: ReadonlyArray<Info>
+        tool?: Tool
      }) {
        const pending = (yield* InstanceState.get(state)).pending
        const id = QuestionID.ascending()
        log.info("asking", { id, questions: input.questions.length })

-        const deferred = yield* Deferred.make<Answer[], RejectedError>()
-        const info: Request = {
+        const deferred = yield* Deferred.make<ReadonlyArray<Answer>, RejectedError>()
+        const info = Schema.decodeUnknownSync(Request)({
          id,
          sessionID: input.sessionID,
          questions: input.questions,
          tool: input.tool,
-        }
+        })
        pending.set(id, { info, deferred })
        yield* bus.publish(Event.Asked, info)

@@ -155,7 +180,10 @@ export namespace Question {
        )
      })

-      const reply = Effect.fn("Question.reply")(function* (input: { requestID: QuestionID; answers: Answer[] }) {
+      const reply = Effect.fn("Question.reply")(function* (input: {
+        requestID: QuestionID
+        answers: ReadonlyArray<Answer>
+      }) {
        const pending = (yield* InstanceState.get(state)).pending
        const existing = pending.get(input.requestID)
        if (!existing) {
@@ -18,6 +18,7 @@ import { lazy } from "../../util/lazy"
 import { Effect, Option } from "effect"
 import { WorkspaceRoutes } from "./workspace"
 import { Agent } from "@/agent/agent"
+import { HttpApiRoutes } from "./httpapi"

 const ConsoleOrgOption = z.object({
  accountID: z.string(),
@@ -39,6 +40,7 @@ const ConsoleSwitchBody = z.object({

 export const ExperimentalRoutes = lazy(() =>
  new Hono()
+    .route("/httpapi", HttpApiRoutes())
    .get(
      "/console",
      describeRoute({
@@ -276,7 +278,7 @@ export const ExperimentalRoutes = lazy(() =>
        },
      }),
      async (c) => {
-        const sandboxes = await Project.sandboxes(Instance.project.id)
+        const sandboxes = await AppRuntime.runPromise(Project.Service.use((svc) => svc.sandboxes(Instance.project.id)))
        return c.json(sandboxes)
      },
    )
@@ -302,7 +304,9 @@ export const ExperimentalRoutes = lazy(() =>
      async (c) => {
        const body = c.req.valid("json")
        await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.remove(body)))
-        await Project.removeSandbox(Instance.project.id, body.directory)
+        await AppRuntime.runPromise(
+          Project.Service.use((svc) => svc.removeSandbox(Instance.project.id, body.directory)),
+        )
        return c.json(true)
      },
    )
@@ -4,7 +4,7 @@ import { Effect } from "effect"
 import z from "zod"
 import { AppRuntime } from "../../effect/app-runtime"
 import { File } from "../../file"
-import { Search } from "../../file/search"
+import { Ripgrep } from "../../file/ripgrep"
 import { LSP } from "../../lsp"
 import { Instance } from "../../project/instance"
 import { lazy } from "../../util/lazy"
@@ -15,14 +15,14 @@ export const FileRoutes = lazy(() =>
      "/find",
      describeRoute({
        summary: "Find text",
-        description: "Search for text patterns across files in the project.",
+        description: "Search for text patterns across files in the project using ripgrep.",
        operationId: "find.text",
        responses: {
          200: {
            description: "Matches",
            content: {
              "application/json": {
-                schema: resolver(Search.Match.array()),
+                schema: resolver(Ripgrep.Match.shape.data.array()),
              },
            },
          },
@@ -37,7 +37,7 @@ export const FileRoutes = lazy(() =>
      async (c) => {
        const pattern = c.req.valid("query").pattern
        const result = await AppRuntime.runPromise(
-          Search.Service.use((svc) => svc.search({ cwd: Instance.directory, pattern, limit: 10 })),
+          Ripgrep.Service.use((svc) => svc.search({ cwd: Instance.directory, pattern, limit: 10 })),
        )
        return c.json(result.items)
      },
@@ -0,0 +1,7 @@
+import { lazy } from "@/util/lazy"
+import { Hono } from "hono"
+import { QuestionHttpApiHandler } from "./question"
+
+export const HttpApiRoutes = lazy(() =>
+  new Hono().all("/question", QuestionHttpApiHandler).all("/question/*", QuestionHttpApiHandler),
+)
@@ -0,0 +1,56 @@
+import { AppLayer } from "@/effect/app-runtime"
+import { memoMap } from "@/effect/run-service"
+import { Question } from "@/question"
+import { QuestionID } from "@/question/schema"
+import { lazy } from "@/util/lazy"
+import { QuestionReply, QuestionRequest, questionApi } from "@opencode-ai/server"
+import { Effect, Layer, Schema } from "effect"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
+import { HttpApiBuilder } from "effect/unstable/httpapi"
+import type { Handler } from "hono"
+
+const root = "/experimental/httpapi/question"
+
+const QuestionLive = HttpApiBuilder.group(
+  questionApi,
+  "question",
+  Effect.fn("QuestionHttpApi.handlers")(function* (handlers) {
+    const svc = yield* Question.Service
+    const decode = Schema.decodeUnknownSync(Schema.Array(QuestionRequest))
+
+    const list = Effect.fn("QuestionHttpApi.list")(function* () {
+      return decode(yield* svc.list())
+    })
+
+    const reply = Effect.fn("QuestionHttpApi.reply")(function* (ctx: {
+      params: { requestID: string }
+      payload: Schema.Schema.Type<typeof QuestionReply>
+    }) {
+      yield* svc.reply({
+        requestID: QuestionID.make(ctx.params.requestID),
+        answers: ctx.payload.answers,
+      })
+      return true
+    })
+
+    return handlers.handle("list", list).handle("reply", reply)
+  }),
+).pipe(Layer.provide(Question.defaultLayer))
+
+const web = lazy(() =>
+  HttpRouter.toWebHandler(
+    Layer.mergeAll(
+      AppLayer,
+      HttpApiBuilder.layer(questionApi, { openapiPath: `${root}/doc` }).pipe(
+        Layer.provide(QuestionLive),
+        Layer.provide(HttpServer.layerServices),
+      ),
+    ),
+    {
+      disableLogger: true,
+      memoMap,
+    },
+  ),
+)
+
+export const QuestionHttpApiHandler: Handler = (c, _next) => web().handler(c.req.raw)
@@ -41,7 +41,7 @@ async function getSessionWorkspace(url: URL) {
  const id = getSessionID(url)
  if (!id) return null

-  const session = await Session.get(id).catch(() => undefined)
+  const session = await AppRuntime.runPromise(Session.Service.use((svc) => svc.get(id))).catch(() => undefined)
  return session?.workspaceID
 }

@@ -75,10 +75,9 @@ export const ProjectRoutes = lazy(() =>
      async (c) => {
        const dir = Instance.directory
        const prev = Instance.project
-        const next = await Project.initGit({
-          directory: dir,
-          project: prev,
-        })
+        const next = await AppRuntime.runPromise(
+          Project.Service.use((svc) => svc.initGit({ directory: dir, project: prev })),
+        )
        if (next.id === prev.id && next.vcs === prev.vcs && next.worktree === prev.worktree) return c.json(next)
        await Instance.reload({
          directory: dir,
@@ -112,7 +111,7 @@ export const ProjectRoutes = lazy(() =>
      async (c) => {
        const projectID = c.req.valid("param").projectID
        const body = c.req.valid("json")
-        const project = await Project.update({ ...body, projectID })
+        const project = await AppRuntime.runPromise(Project.Service.use((svc) => svc.update({ ...body, projectID })))
        return c.json(project)
      },
    ),
@@ -8,6 +8,12 @@ import z from "zod"
 import { errors } from "../error"
 import { lazy } from "../../util/lazy"

+const Reply = z.object({
+  answers: Question.Answer.zod
+    .array()
+    .describe("User answers in order of questions (each answer is an array of selected labels)"),
+})
+
 export const QuestionRoutes = lazy(() =>
  new Hono()
    .get(
@@ -21,7 +27,7 @@ export const QuestionRoutes = lazy(() =>
            description: "List of pending questions",
            content: {
              "application/json": {
-                schema: resolver(Question.Request.array()),
+                schema: resolver(Question.Request.zod.array()),
              },
            },
          },
@@ -56,7 +62,7 @@ export const QuestionRoutes = lazy(() =>
          requestID: QuestionID.zod,
        }),
      ),
-      validator("json", Question.Reply),
+      validator("json", Reply),
      async (c) => {
        const params = c.req.valid("param")
        const json = c.req.valid("json")
@@ -121,12 +121,12 @@ export const SessionRoutes = lazy(() =>
      validator(
        "param",
        z.object({
-          sessionID: Session.get.schema,
+          sessionID: Session.GetInput,
        }),
      ),
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
-        const session = await Session.get(sessionID)
+        const session = await AppRuntime.runPromise(Session.Service.use((svc) => svc.get(sessionID)))
        return c.json(session)
      },
    )
@@ -152,12 +152,12 @@ export const SessionRoutes = lazy(() =>
      validator(
        "param",
        z.object({
-          sessionID: Session.children.schema,
+          sessionID: Session.ChildrenInput,
        }),
      ),
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
-        const session = await Session.children(sessionID)
+        const session = await AppRuntime.runPromise(Session.Service.use((svc) => svc.children(sessionID)))
        return c.json(session)
      },
    )
@@ -209,10 +209,10 @@ export const SessionRoutes = lazy(() =>
          },
        },
      }),
-      validator("json", Session.create.schema),
+      validator("json", Session.CreateInput),
      async (c) => {
        const body = c.req.valid("json") ?? {}
-        const session = await SessionShare.create(body)
+        const session = await AppRuntime.runPromise(SessionShare.Service.use((svc) => svc.create(body)))
        return c.json(session)
      },
    )
@@ -237,12 +237,12 @@ export const SessionRoutes = lazy(() =>
      validator(
        "param",
        z.object({
-          sessionID: Session.remove.schema,
+          sessionID: Session.RemoveInput,
        }),
      ),
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
-        await Session.remove(sessionID)
+        await AppRuntime.runPromise(Session.Service.use((svc) => svc.remove(sessionID)))
        return c.json(true)
      },
    )
@@ -285,22 +285,27 @@ export const SessionRoutes = lazy(() =>
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
        const updates = c.req.valid("json")
-        const current = await Session.get(sessionID)
+        const session = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const session = yield* Session.Service
+            const current = yield* session.get(sessionID)

-        if (updates.title !== undefined) {
-          await Session.setTitle({ sessionID, title: updates.title })
-        }
-        if (updates.permission !== undefined) {
-          await Session.setPermission({
-            sessionID,
-            permission: Permission.merge(current.permission ?? [], updates.permission),
-          })
-        }
-        if (updates.time?.archived !== undefined) {
-          await Session.setArchived({ sessionID, time: updates.time.archived })
-        }
+            if (updates.title !== undefined) {
+              yield* session.setTitle({ sessionID, title: updates.title })
+            }
+            if (updates.permission !== undefined) {
+              yield* session.setPermission({
+                sessionID,
+                permission: Permission.merge(current.permission ?? [], updates.permission),
+              })
+            }
+            if (updates.time?.archived !== undefined) {
+              yield* session.setArchived({ sessionID, time: updates.time.archived })
+            }

-        const session = await Session.get(sessionID)
+            return yield* session.get(sessionID)
+          }),
+        )
        return c.json(session)
      },
    )
@@ -341,13 +346,17 @@ export const SessionRoutes = lazy(() =>
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
        const body = c.req.valid("json")
-        await SessionPrompt.command({
-          sessionID,
-          messageID: body.messageID,
-          model: body.providerID + "/" + body.modelID,
-          command: Command.Default.INIT,
-          arguments: "",
-        })
+        await AppRuntime.runPromise(
+          SessionPrompt.Service.use((svc) =>
+            svc.command({
+              sessionID,
+              messageID: body.messageID,
+              model: body.providerID + "/" + body.modelID,
+              command: Command.Default.INIT,
+              arguments: "",
+            }),
+          ),
+        )
        return c.json(true)
      },
    )
@@ -371,14 +380,14 @@ export const SessionRoutes = lazy(() =>
      validator(
        "param",
        z.object({
-          sessionID: Session.fork.schema.shape.sessionID,
+          sessionID: Session.ForkInput.shape.sessionID,
        }),
      ),
-      validator("json", Session.fork.schema.omit({ sessionID: true })),
+      validator("json", Session.ForkInput.omit({ sessionID: true })),
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
        const body = c.req.valid("json")
-        const result = await Session.fork({ ...body, sessionID })
+        const result = await AppRuntime.runPromise(Session.Service.use((svc) => svc.fork({ ...body, sessionID })))
        return c.json(result)
      },
    )
@@ -407,7 +416,7 @@ export const SessionRoutes = lazy(() =>
        }),
      ),
      async (c) => {
-        await SessionPrompt.cancel(c.req.valid("param").sessionID)
+        await AppRuntime.runPromise(SessionPrompt.Service.use((svc) => svc.cancel(c.req.valid("param").sessionID)))
        return c.json(true)
      },
    )
@@ -437,8 +446,14 @@ export const SessionRoutes = lazy(() =>
      ),
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
-        await SessionShare.share(sessionID)
-        const session = await Session.get(sessionID)
+        const session = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const share = yield* SessionShare.Service
+            const session = yield* Session.Service
+            yield* share.share(sessionID)
+            return yield* session.get(sessionID)
+          }),
+        )
        return c.json(session)
      },
    )
@@ -511,8 +526,14 @@ export const SessionRoutes = lazy(() =>
      ),
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
-        await SessionShare.unshare(sessionID)
-        const session = await Session.get(sessionID)
+        const session = await AppRuntime.runPromise(
+          Effect.gen(function* () {
+            const share = yield* SessionShare.Service
+            const session = yield* Session.Service
+            yield* share.unshare(sessionID)
+            return yield* session.get(sessionID)
+          }),
+        )
        return c.json(session)
      },
    )
@@ -645,15 +666,14 @@ export const SessionRoutes = lazy(() =>
      async (c) => {
        const query = c.req.valid("query")
        const sessionID = c.req.valid("param").sessionID
-        if (query.limit === undefined) {
-          await Session.get(sessionID)
-          const messages = await Session.messages({ sessionID })
-          return c.json(messages)
-        }
-
-        if (query.limit === 0) {
-          await Session.get(sessionID)
-          const messages = await Session.messages({ sessionID })
+        if (query.limit === undefined || query.limit === 0) {
+          const messages = await AppRuntime.runPromise(
+            Effect.gen(function* () {
+              const session = yield* Session.Service
+              yield* session.get(sessionID)
+              return yield* session.messages({ sessionID })
+            }),
+          )
          return c.json(messages)
        }

@@ -781,11 +801,15 @@ export const SessionRoutes = lazy(() =>
      ),
      async (c) => {
        const params = c.req.valid("param")
-        await Session.removePart({
-          sessionID: params.sessionID,
-          messageID: params.messageID,
-          partID: params.partID,
-        })
+        await AppRuntime.runPromise(
+          Session.Service.use((svc) =>
+            svc.removePart({
+              sessionID: params.sessionID,
+              messageID: params.messageID,
+              partID: params.partID,
+            }),
+          ),
+        )
        return c.json(true)
      },
    )
@@ -823,7 +847,7 @@ export const SessionRoutes = lazy(() =>
            `Part mismatch: body.id='${body.id}' vs partID='${params.partID}', body.messageID='${body.messageID}' vs messageID='${params.messageID}', body.sessionID='${body.sessionID}' vs sessionID='${params.sessionID}'`,
          )
        }
-        const part = await Session.updatePart(body)
+        const part = await AppRuntime.runPromise(Session.Service.use((svc) => svc.updatePart(body)))
        return c.json(part)
      },
    )
@@ -863,7 +887,9 @@ export const SessionRoutes = lazy(() =>
        return stream(c, async (stream) => {
          const sessionID = c.req.valid("param").sessionID
          const body = c.req.valid("json")
-          const msg = await SessionPrompt.prompt({ ...body, sessionID })
+          const msg = await AppRuntime.runPromise(
+            SessionPrompt.Service.use((svc) => svc.prompt({ ...body, sessionID })),
+          )
          stream.write(JSON.stringify(msg))
        })
      },
@@ -892,7 +918,7 @@ export const SessionRoutes = lazy(() =>
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
        const body = c.req.valid("json")
-        SessionPrompt.prompt({ ...body, sessionID }).catch((err) => {
+        AppRuntime.runPromise(SessionPrompt.Service.use((svc) => svc.prompt({ ...body, sessionID }))).catch((err) => {
          log.error("prompt_async failed", { sessionID, error: err })
          Bus.publish(Session.Event.Error, {
            sessionID,
@@ -936,7 +962,7 @@ export const SessionRoutes = lazy(() =>
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
        const body = c.req.valid("json")
-        const msg = await SessionPrompt.command({ ...body, sessionID })
+        const msg = await AppRuntime.runPromise(SessionPrompt.Service.use((svc) => svc.command({ ...body, sessionID })))
        return c.json(msg)
      },
    )
@@ -968,7 +994,7 @@ export const SessionRoutes = lazy(() =>
      async (c) => {
        const sessionID = c.req.valid("param").sessionID
        const body = c.req.valid("json")
-        const msg = await SessionPrompt.shell({ ...body, sessionID })
+        const msg = await AppRuntime.runPromise(SessionPrompt.Service.use((svc) => svc.shell({ ...body, sessionID })))
        return c.json(msg)
      },
    )
@@ -4,6 +4,7 @@ import z from "zod"
 import { Bus } from "../../bus"
 import { Session } from "../../session"
 import { TuiEvent } from "@/cli/cmd/tui/event"
+import { AppRuntime } from "@/effect/app-runtime"
 import { AsyncQueue } from "../../util/queue"
 import { errors } from "../error"
 import { lazy } from "../../util/lazy"
@@ -370,7 +371,7 @@ export const TuiRoutes = lazy(() =>
      validator("json", TuiEvent.SessionSelect.properties),
      async (c) => {
        const { sessionID } = c.req.valid("json")
-        await Session.get(sessionID)
+        await AppRuntime.runPromise(Session.Service.use((svc) => svc.get(sessionID)))
        await Bus.publish(TuiEvent.SessionSelect, { sessionID })
        return c.json(true)
      },
@@ -19,7 +19,6 @@ import { updateSchema } from "../util/update-schema"
 import { MessageV2 } from "./message-v2"
 import { Instance } from "../project/instance"
 import { InstanceState } from "@/effect/instance-state"
-import { fn } from "@/util/fn"
 import { Snapshot } from "@/snapshot"
 import { ProjectID } from "../project/schema"
 import { WorkspaceID } from "../control-plane/schema"
@@ -29,7 +28,6 @@ import type { Provider } from "@/provider/provider"
 import { Permission } from "@/permission"
 import { Global } from "@/global"
 import { Effect, Layer, Option, Context } from "effect"
-import { makeRuntime } from "@/effect/run-service"

 export namespace Session {
  const log = Log.create({ service: "session" })
@@ -179,6 +177,30 @@ export namespace Session {
  })
  export type GlobalInfo = z.output<typeof GlobalInfo>

+  export const CreateInput = z
+    .object({
+      parentID: SessionID.zod.optional(),
+      title: z.string().optional(),
+      permission: Info.shape.permission,
+      workspaceID: WorkspaceID.zod.optional(),
+    })
+    .optional()
+  export type CreateInput = z.output<typeof CreateInput>
+
+  export const ForkInput = z.object({ sessionID: SessionID.zod, messageID: MessageID.zod.optional() })
+  export const GetInput = SessionID.zod
+  export const ChildrenInput = SessionID.zod
+  export const RemoveInput = SessionID.zod
+  export const SetTitleInput = z.object({ sessionID: SessionID.zod, title: z.string() })
+  export const SetArchivedInput = z.object({ sessionID: SessionID.zod, time: z.number().optional() })
+  export const SetPermissionInput = z.object({ sessionID: SessionID.zod, permission: Permission.Ruleset })
+  export const SetRevertInput = z.object({
+    sessionID: SessionID.zod,
+    revert: Info.shape.revert,
+    summary: Info.shape.summary,
+  })
+  export const MessagesInput = z.object({ sessionID: SessionID.zod, limit: z.number().optional() })
+
  export const Event = {
    Created: SyncEvent.define({
      type: "session.created",
@@ -682,48 +704,6 @@ export namespace Session {

  export const defaultLayer = layer.pipe(Layer.provide(Bus.layer), Layer.provide(Storage.defaultLayer))

-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export const create = fn(
-    z
-      .object({
-        parentID: SessionID.zod.optional(),
-        title: z.string().optional(),
-        permission: Info.shape.permission,
-        workspaceID: WorkspaceID.zod.optional(),
-      })
-      .optional(),
-    (input) => runPromise((svc) => svc.create(input)),
-  )
-
-  export const fork = fn(z.object({ sessionID: SessionID.zod, messageID: MessageID.zod.optional() }), (input) =>
-    runPromise((svc) => svc.fork(input)),
-  )
-
-  export const get = fn(SessionID.zod, (id) => runPromise((svc) => svc.get(id)))
-
-  export const setTitle = fn(z.object({ sessionID: SessionID.zod, title: z.string() }), (input) =>
-    runPromise((svc) => svc.setTitle(input)),
-  )
-
-  export const setArchived = fn(z.object({ sessionID: SessionID.zod, time: z.number().optional() }), (input) =>
-    runPromise((svc) => svc.setArchived(input)),
-  )
-
-  export const setPermission = fn(z.object({ sessionID: SessionID.zod, permission: Permission.Ruleset }), (input) =>
-    runPromise((svc) => svc.setPermission(input)),
-  )
-
-  export const setRevert = fn(
-    z.object({ sessionID: SessionID.zod, revert: Info.shape.revert, summary: Info.shape.summary }),
-    (input) =>
-      runPromise((svc) => svc.setRevert({ sessionID: input.sessionID, revert: input.revert, summary: input.summary })),
-  )
-
-  export const messages = fn(z.object({ sessionID: SessionID.zod, limit: z.number().optional() }), (input) =>
-    runPromise((svc) => svc.messages(input)),
-  )
-
  export function* list(input?: {
    directory?: string
    workspaceID?: WorkspaceID
@@ -835,25 +815,4 @@ export namespace Session {
      yield { ...fromRow(row), project }
    }
  }
-
-  export const children = fn(SessionID.zod, (id) => runPromise((svc) => svc.children(id)))
-  export const remove = fn(SessionID.zod, (id) => runPromise((svc) => svc.remove(id)))
-  export async function updateMessage<T extends MessageV2.Info>(msg: T): Promise<T> {
-    MessageV2.Info.parse(msg)
-    return runPromise((svc) => svc.updateMessage(msg))
-  }
-
-  export const removeMessage = fn(z.object({ sessionID: SessionID.zod, messageID: MessageID.zod }), (input) =>
-    runPromise((svc) => svc.removeMessage(input)),
-  )
-
-  export const removePart = fn(
-    z.object({ sessionID: SessionID.zod, messageID: MessageID.zod, partID: PartID.zod }),
-    (input) => runPromise((svc) => svc.removePart(input)),
-  )
-
-  export async function updatePart<T extends MessageV2.Part>(part: T): Promise<T> {
-    MessageV2.Part.parse(part)
-    return runPromise((svc) => svc.updatePart(part))
-  }
 }
@@ -205,7 +205,11 @@ export namespace LLM {
          // calls but no tools param is present. When there are no active tools (e.g.
          // during compaction), inject a stub tool to satisfy the validation requirement.
          // The stub description explicitly tells the model not to call it.
-          if (isLiteLLMProxy && Object.keys(tools).length === 0 && hasToolCalls(input.messages)) {
+          if (
+            (isLiteLLMProxy || input.model.providerID.includes("github-copilot")) &&
+            Object.keys(tools).length === 0 &&
+            hasToolCalls(input.messages)
+          ) {
            tools["_noop"] = tool({
              description: "Do not call this tool. It exists only for API compatibility and must never be invoked.",
              inputSchema: jsonSchema({
@@ -6,7 +6,6 @@ import { Config } from "@/config/config"
 import { Permission } from "@/permission"
 import { Plugin } from "@/plugin"
 import { Snapshot } from "@/snapshot"
-import { EffectLogger } from "@/effect/logger"
 import { Session } from "."
 import { LLM } from "./llm"
 import { MessageV2 } from "./message-v2"
@@ -19,11 +18,12 @@ import { SessionSummary } from "./summary"
 import type { Provider } from "@/provider/provider"
 import { Question } from "@/question"
 import { errorMessage } from "@/util/error"
+import { Log } from "@/util/log"
 import { isRecord } from "@/util/record"

 export namespace SessionProcessor {
  const DOOM_LOOP_THRESHOLD = 3
-  const log = EffectLogger.create({ service: "session.processor" })
+  const log = Log.create({ service: "session.processor" })

  export type Result = "compact" | "stop" | "continue"

@@ -124,7 +124,7 @@ export namespace SessionProcessor {
          reasoningMap: {},
        }
        let aborted = false
-        const slog = log.with({ sessionID: input.sessionID, messageID: input.assistantMessage.id })
+        const slog = log.clone().tag("sessionID", input.sessionID).tag("messageID", input.assistantMessage.id)

        const parse = (e: unknown) =>
          MessageV2.fromError(e, {
@@ -454,7 +454,7 @@ export namespace SessionProcessor {
              return

            default:
-              yield* slog.info("unhandled", { event: value.type, value })
+              slog.info("unhandled", { event: value.type, value })
              return
          }
        })
@@ -520,7 +520,7 @@ export namespace SessionProcessor {
        })

        const halt = Effect.fn("SessionProcessor.halt")(function* (e: unknown) {
-          yield* slog.error("process", { error: errorMessage(e), stack: e instanceof Error ? e.stack : undefined })
+          slog.error("process", { error: errorMessage(e), stack: e instanceof Error ? e.stack : undefined })
          const error = parse(e)
          if (MessageV2.ContextOverflowError.isInstance(error)) {
            ctx.needsCompaction = true
@@ -536,7 +536,7 @@ export namespace SessionProcessor {
        })

        const process = Effect.fn("SessionProcessor.process")(function* (streamInput: LLM.StreamInput) {
-          yield* slog.info("process")
+          slog.info("process")
          ctx.needsCompaction = false
          ctx.shouldBreak = (yield* config.get()).experimental?.continue_loop_on_deny !== true

@@ -46,7 +46,6 @@ import { Process } from "@/util/process"
 import { Cause, Effect, Exit, Layer, Option, Scope, Context } from "effect"
 import { EffectLogger } from "@/effect/logger"
 import { InstanceState } from "@/effect/instance-state"
-import { attach, makeRuntime } from "@/effect/run-service"
 import { TaskTool, type TaskPromptOps } from "@/tool/task"
 import { SessionRunState } from "./run-state"

@@ -105,13 +104,21 @@ export namespace SessionPrompt {
      const summary = yield* SessionSummary.Service
      const sys = yield* SystemPrompt.Service
      const llm = yield* LLM.Service
-
-      const run = {
-        promise: <A, E>(effect: Effect.Effect<A, E>) =>
-          Effect.runPromise(attach(effect).pipe(Effect.provide(EffectLogger.layer))),
-        fork: <A, E>(effect: Effect.Effect<A, E>) =>
-          Effect.runFork(attach(effect).pipe(Effect.provide(EffectLogger.layer))),
-      }
+      const runner = Effect.fn("SessionPrompt.runner")(function* () {
+        const ctx = yield* Effect.context()
+        return {
+          promise: <A, E>(effect: Effect.Effect<A, E>) => Effect.runPromiseWith(ctx)(effect),
+          fork: <A, E>(effect: Effect.Effect<A, E>) => Effect.runForkWith(ctx)(effect),
+        }
+      })
+      const ops = Effect.fn("SessionPrompt.ops")(function* () {
+        const run = yield* runner()
+        return {
+          cancel: (sessionID: SessionID) => run.fork(cancel(sessionID)),
+          resolvePromptParts: (template: string) => resolvePromptParts(template),
+          prompt: (input: PromptInput) => prompt(input),
+        } satisfies TaskPromptOps
+      })

      const cancel = Effect.fn("SessionPrompt.cancel")(function* (sessionID: SessionID) {
        yield* elog.info("cancel", { sessionID })
@@ -361,6 +368,8 @@ NOTE: At any point in time through this workflow you should feel free to ask the
      }) {
        using _ = log.time("resolveTools")
        const tools: Record<string, AITool> = {}
+        const run = yield* runner()
+        const promptOps = yield* ops()

        const context = (args: any, options: ToolExecutionOptions): Tool.Context => ({
          sessionID: input.session.id,
@@ -530,6 +539,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the
      }) {
        const { task, model, lastUser, sessionID, session, msgs } = input
        const ctx = yield* InstanceState.context
+        const promptOps = yield* ops()
        const { task: taskTool } = yield* registry.named()
        const taskModel = task.model ? yield* getModel(task.model.providerID, task.model.modelID, sessionID) : model
        const assistantMessage: MessageV2.Assistant = yield* sessions.updateMessage({
@@ -714,6 +724,7 @@ NOTE: At any point in time through this workflow you should feel free to ask the

      const shellImpl = Effect.fn("SessionPrompt.shellImpl")(function* (input: ShellInput) {
        const ctx = yield* InstanceState.context
+        const run = yield* runner()
        const session = yield* sessions.get(input.sessionID)
        if (session.revert) {
          yield* revert.cleanup(session)
@@ -1661,12 +1672,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
        return result
      })

-      const promptOps: TaskPromptOps = {
-        cancel: (sessionID) => run.fork(cancel(sessionID)),
-        resolvePromptParts: (template) => resolvePromptParts(template),
-        prompt: (input) => prompt(input),
-      }
-
      return Service.of({
        cancel,
        prompt,
@@ -1709,8 +1714,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
      ),
    ),
  )
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
  export const PromptInput = z.object({
    sessionID: SessionID.zod,
    messageID: MessageID.zod.optional(),
@@ -1778,26 +1781,10 @@ NOTE: At any point in time through this workflow you should feel free to ask the
  })
  export type PromptInput = z.infer<typeof PromptInput>

-  export async function prompt(input: PromptInput) {
-    return runPromise((svc) => svc.prompt(PromptInput.parse(input)))
-  }
-
-  export async function resolvePromptParts(template: string) {
-    return runPromise((svc) => svc.resolvePromptParts(z.string().parse(template)))
-  }
-
-  export async function cancel(sessionID: SessionID) {
-    return runPromise((svc) => svc.cancel(SessionID.zod.parse(sessionID)))
-  }
-
  export const LoopInput = z.object({
    sessionID: SessionID.zod,
  })

-  export async function loop(input: z.infer<typeof LoopInput>) {
-    return runPromise((svc) => svc.loop(LoopInput.parse(input)))
-  }
-
  export const ShellInput = z.object({
    sessionID: SessionID.zod,
    messageID: MessageID.zod.optional(),
@@ -1812,10 +1799,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
  })
  export type ShellInput = z.infer<typeof ShellInput>

-  export async function shell(input: ShellInput) {
-    return runPromise((svc) => svc.shell(ShellInput.parse(input)))
-  }
-
  export const CommandInput = z.object({
    messageID: MessageID.zod.optional(),
    sessionID: SessionID.zod,
@@ -1839,10 +1822,6 @@ NOTE: At any point in time through this workflow you should feel free to ask the
  })
  export type CommandInput = z.infer<typeof CommandInput>

-  export async function command(input: CommandInput) {
-    return runPromise((svc) => svc.command(CommandInput.parse(input)))
-  }
-
  /** @internal Exported for testing */
  export function createStructuredOutputTool(input: {
    schema: Record<string, any>
@@ -1,8 +1,6 @@
-import { makeRuntime } from "@/effect/run-service"
 import { Session } from "@/session"
 import { SessionID } from "@/session/schema"
 import { SyncEvent } from "@/sync"
-import { fn } from "@/util/fn"
 import { Effect, Layer, Scope, Context } from "effect"
 import { Config } from "../config/config"
 import { Flag } from "../flag/flag"
@@ -10,7 +8,7 @@ import { ShareNext } from "./share-next"

 export namespace SessionShare {
  export interface Interface {
-    readonly create: (input?: Parameters<typeof Session.create>[0]) => Effect.Effect<Session.Info>
+    readonly create: (input?: Session.CreateInput) => Effect.Effect<Session.Info>
    readonly share: (sessionID: SessionID) => Effect.Effect<{ url: string }, unknown>
    readonly unshare: (sessionID: SessionID) => Effect.Effect<void, unknown>
  }
@@ -40,7 +38,7 @@ export namespace SessionShare {
        yield* Effect.sync(() => SyncEvent.run(Session.Event.Updated, { sessionID, info: { share: { url: null } } }))
      })

-      const create = Effect.fn("SessionShare.create")(function* (input?: Parameters<typeof Session.create>[0]) {
+      const create = Effect.fn("SessionShare.create")(function* (input?: Session.CreateInput) {
        const result = yield* session.create(input)
        if (result.parentID) return result
        const conf = yield* cfg.get()
@@ -58,10 +56,4 @@ export namespace SessionShare {
    Layer.provide(Session.defaultLayer),
    Layer.provide(Config.defaultLayer),
  )
-
-  const { runPromise } = makeRuntime(Service, defaultLayer)
-
-  export const create = fn(Session.create.schema, (input) => runPromise((svc) => svc.create(input)))
-  export const share = fn(SessionID.zod, (sessionID) => runPromise((svc) => svc.share(sessionID)))
-  export const unshare = fn(SessionID.zod, (sessionID) => runPromise((svc) => svc.unshare(sessionID)))
 }
@@ -437,7 +437,11 @@ export const BashTool = Tool.define(
      ).pipe(Effect.orDie)

      const meta: string[] = []
-      if (expired) meta.push(`bash tool terminated command after exceeding timeout ${input.timeout} ms`)
+      if (expired) {
+        meta.push(
+          `bash tool terminated command after exceeding timeout ${input.timeout} ms. If this command is expected to take longer and is not waiting for interactive input, retry with a larger timeout value in milliseconds.`,
+        )
+      }
      if (aborted) meta.push("User aborted the command")
      if (meta.length > 0) {
        output += "\n\n<bash_metadata>\n" + meta.join("\n") + "\n</bash_metadata>"
@@ -1,9 +1,10 @@
 import path from "path"
 import z from "zod"
-import { Effect } from "effect"
+import { Effect, Option } from "effect"
+import * as Stream from "effect/Stream"
 import { InstanceState } from "@/effect/instance-state"
 import { AppFileSystem } from "../filesystem"
-import { Search } from "../file/search"
+import { Ripgrep } from "../file/ripgrep"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import DESCRIPTION from "./glob.txt"
 import { Tool } from "./tool"
@@ -11,8 +12,8 @@ import { Tool } from "./tool"
 export const GlobTool = Tool.define(
  "glob",
  Effect.gen(function* () {
+    const rg = yield* Ripgrep.Service
    const fs = yield* AppFileSystem.Service
-    const searchSvc = yield* Search.Service

    return {
      description: DESCRIPTION,
@@ -47,18 +48,36 @@ export const GlobTool = Tool.define(
          yield* assertExternalDirectoryEffect(ctx, search, { kind: "directory" })

          const limit = 100
-          const files = yield* searchSvc.glob({
-            cwd: search,
-            pattern: params.pattern,
-            limit,
-            signal: ctx.abort,
-          })
+          let truncated = false
+          const files = yield* rg.files({ cwd: search, glob: [params.pattern], signal: ctx.abort }).pipe(
+            Stream.mapEffect((file) =>
+              Effect.gen(function* () {
+                const full = path.resolve(search, file)
+                const info = yield* fs.stat(full).pipe(Effect.catch(() => Effect.succeed(undefined)))
+                const mtime =
+                  info?.mtime.pipe(
+                    Option.map((date) => date.getTime()),
+                    Option.getOrElse(() => 0),
+                  ) ?? 0
+                return { path: full, mtime }
+              }),
+            ),
+            Stream.take(limit + 1),
+            Stream.runCollect,
+            Effect.map((chunk) => [...chunk]),
+          )
+
+          if (files.length > limit) {
+            truncated = true
+            files.length = limit
+          }
+          files.sort((a, b) => b.mtime - a.mtime)

          const output = []
-          if (files.files.length === 0) output.push("No files found")
-          if (files.files.length > 0) {
-            output.push(...files.files)
-            if (files.truncated) {
+          if (files.length === 0) output.push("No files found")
+          if (files.length > 0) {
+            output.push(...files.map((file) => file.path))
+            if (truncated) {
              output.push("")
              output.push(
                `(Results are truncated: showing first ${limit} results. Consider using a more specific path or pattern.)`,
@@ -69,8 +88,8 @@ export const GlobTool = Tool.define(
          return {
            title: path.relative(ins.worktree, search),
            metadata: {
-              count: files.files.length,
-              truncated: files.truncated,
+              count: files.length,
+              truncated,
            },
            output: output.join("\n"),
          }
@@ -1,9 +1,9 @@
 import path from "path"
 import z from "zod"
-import { Effect } from "effect"
+import { Effect, Option } from "effect"
 import { InstanceState } from "@/effect/instance-state"
 import { AppFileSystem } from "../filesystem"
-import { Search } from "../file/search"
+import { Ripgrep } from "../file/ripgrep"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import DESCRIPTION from "./grep.txt"
 import { Tool } from "./tool"
@@ -14,7 +14,7 @@ export const GrepTool = Tool.define(
  "grep",
  Effect.gen(function* () {
    const fs = yield* AppFileSystem.Service
-    const searchSvc = yield* Search.Service
+    const rg = yield* Ripgrep.Service

    return {
      description: DESCRIPTION,
@@ -58,7 +58,7 @@ export const GrepTool = Tool.define(
            kind: info?.type === "Directory" ? "directory" : "file",
          })

-          const result = yield* searchSvc.search({
+          const result = yield* rg.search({
            cwd,
            pattern: params.pattern,
            glob: params.include ? [params.include] : undefined,
@@ -74,13 +74,37 @@ export const GrepTool = Tool.define(
            line: item.line_number,
            text: item.lines.text,
          }))
+          const times = new Map(
+            (yield* Effect.forEach(
+              [...new Set(rows.map((row) => row.path))],
+              Effect.fnUntraced(function* (file) {
+                const info = yield* fs.stat(file).pipe(Effect.catch(() => Effect.succeed(undefined)))
+                if (!info || info.type === "Directory") return undefined
+                return [
+                  file,
+                  info.mtime.pipe(
+                    Option.map((time) => time.getTime()),
+                    Option.getOrElse(() => 0),
+                  ) ?? 0,
+                ] as const
+              }),
+              { concurrency: 16 },
+            )).filter((entry): entry is readonly [string, number] => Boolean(entry)),
+          )
+          const matches = rows.flatMap((row) => {
+            const mtime = times.get(row.path)
+            if (mtime === undefined) return []
+            return [{ ...row, mtime }]
+          })
+
+          matches.sort((a, b) => b.mtime - a.mtime)

          const limit = 100
-          const truncated = rows.length > limit
-          const final = truncated ? rows.slice(0, limit) : rows
+          const truncated = matches.length > limit
+          const final = truncated ? matches.slice(0, limit) : matches
          if (final.length === 0) return empty

-          const total = rows.length
+          const total = matches.length
          const output = [`Found ${total} matches${truncated ? ` (showing first ${limit})` : ""}`]

          let current = ""
@@ -106,10 +130,6 @@ export const GrepTool = Tool.define(
            output.push("")
            output.push("(Some paths were inaccessible and skipped)")
          }
-          if (result.regexFallbackError) {
-            output.push("")
-            output.push(`(Regex fallback: ${result.regexFallbackError})`)
-          }

          return {
            title: params.pattern,
@@ -3,7 +3,7 @@ import z from "zod"
 import { Effect } from "effect"
 import * as Stream from "effect/Stream"
 import { InstanceState } from "@/effect/instance-state"
-import { Search } from "../file/search"
+import { Ripgrep } from "../file/ripgrep"
 import { assertExternalDirectoryEffect } from "./external-directory"
 import DESCRIPTION from "./ls.txt"
 import { Tool } from "./tool"
@@ -40,7 +40,7 @@ const LIMIT = 100
 export const ListTool = Tool.define(
  "list",
  Effect.gen(function* () {
-    const searchSvc = yield* Search.Service
+    const rg = yield* Ripgrep.Service

    return {
      description: DESCRIPTION,
@@ -67,7 +67,7 @@ export const ListTool = Tool.define(
          })

          const glob = IGNORE_PATTERNS.map((item) => `!${item}*`).concat(params.ignore?.map((item) => `!${item}`) || [])
-          const files = yield* searchSvc.files({ cwd: search, glob, signal: ctx.abort }).pipe(
+          const files = yield* rg.files({ cwd: search, glob, signal: ctx.abort }).pipe(
            Stream.take(LIMIT + 1),
            Stream.runCollect,
            Effect.map((chunk) => [...chunk]),
@@ -5,11 +5,11 @@ import { Question } from "../question"
 import DESCRIPTION from "./question.txt"

 const parameters = z.object({
-  questions: z.array(Question.Info.omit({ custom: true })).describe("Questions to ask"),
+  questions: z.array(Question.Prompt.zod).describe("Questions to ask"),
 })

 type Metadata = {
-  answers: Question.Answer[]
+  answers: ReadonlyArray<Question.Answer>
 }

 export const QuestionTool = Tool.define<typeof parameters, Metadata, Question.Service>(
@@ -8,7 +8,6 @@ import { Tool } from "./tool"
 import { AppFileSystem } from "../filesystem"
 import { LSP } from "../lsp"
 import { FileTime } from "../file/time"
-import { Search } from "../file/search"
 import DESCRIPTION from "./read.txt"
 import { Instance } from "../project/instance"
 import { assertExternalDirectoryEffect } from "./external-directory"
@@ -32,7 +31,6 @@ export const ReadTool = Tool.define(
    const fs = yield* AppFileSystem.Service
    const instruction = yield* Instruction.Service
    const lsp = yield* LSP.Service
-    const search = yield* Search.Service
    const time = yield* FileTime.Service
    const scope = yield* Scope.Scope

@@ -78,7 +76,6 @@ export const ReadTool = Tool.define(
    })

    const warm = Effect.fn("ReadTool.warm")(function* (filepath: string, sessionID: Tool.Context["sessionID"]) {
-      yield* search.open({ file: filepath }).pipe(Effect.ignore)
      yield* lsp.touchFile(filepath, false).pipe(Effect.ignore, Effect.forkIn(scope))
      yield* time.read(sessionID, filepath)
    })
@@ -33,7 +33,7 @@ import { Effect, Layer, Context } from "effect"
 import { FetchHttpClient, HttpClient } from "effect/unstable/http"
 import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
 import * as CrossSpawnSpawner from "@/effect/cross-spawn-spawner"
-import { Search } from "../file/search"
+import { Ripgrep } from "../file/ripgrep"
 import { Format } from "../format"
 import { InstanceState } from "@/effect/instance-state"
 import { Env } from "../env"
@@ -93,7 +93,7 @@ export namespace ToolRegistry {
    | Bus.Service
    | HttpClient.HttpClient
    | ChildProcessSpawner
-    | Search.Service
+    | Ripgrep.Service
    | Format.Service
    | Truncate.Service
  > = Layer.effect(
@@ -344,7 +344,7 @@ export namespace ToolRegistry {
      Layer.provide(FetchHttpClient.layer),
      Layer.provide(Format.defaultLayer),
      Layer.provide(CrossSpawnSpawner.defaultLayer),
-      Layer.provide(Search.defaultLayer),
+      Layer.provide(Ripgrep.defaultLayer),
      Layer.provide(Truncate.defaultLayer),
    ),
  )
@@ -4,7 +4,7 @@ import z from "zod"
 import { Effect } from "effect"
 import * as Stream from "effect/Stream"
 import { EffectLogger } from "@/effect/logger"
-import { Search } from "../file/search"
+import { Ripgrep } from "../file/ripgrep"
 import { Skill } from "../skill"
 import { Tool } from "./tool"

@@ -16,7 +16,7 @@ export const SkillTool = Tool.define(
  "skill",
  Effect.gen(function* () {
    const skill = yield* Skill.Service
-    const searchSvc = yield* Search.Service
+    const rg = yield* Ripgrep.Service

    return () =>
      Effect.gen(function* () {
@@ -62,7 +62,7 @@ export const SkillTool = Tool.define(
              const dir = path.dirname(info.location)
              const base = pathToFileURL(dir).href
              const limit = 10
-              const files = yield* searchSvc.files({ cwd: dir, follow: false, hidden: true, signal: ctx.abort }).pipe(
+              const files = yield* rg.files({ cwd: dir, follow: false, hidden: true, signal: ctx.abort }).pipe(
                Stream.filter((file) => !file.includes("SKILL.md")),
                Stream.map((file) => path.resolve(dir, file)),
                Stream.take(limit),
@@ -48,7 +48,9 @@ export namespace Truncate {
      const fs = yield* AppFileSystem.Service

      const cleanup = Effect.fn("Truncate.cleanup")(function* () {
-        const cutoff = Identifier.timestamp(Identifier.create("tool", false, Date.now() - Duration.toMillis(RETENTION)))
+        const cutoff = Identifier.timestamp(
+          Identifier.create("tool", "ascending", Date.now() - Duration.toMillis(RETENTION)),
+        )
        const entries = yield* fs.readDirectory(TRUNCATION_DIR).pipe(
          Effect.map((all) => all.filter((name) => name.startsWith("tool_"))),
          Effect.catch(() => Effect.succeed([])),
@@ -0,0 +1 @@
+export namespace SessionCommon {}
@@ -1,114 +1,51 @@
-import { Identifier } from "@/id/id"
-import { Database } from "@/node"
-import type { SessionID } from "@/session/schema"
-import { SessionEntryTable } from "@/session/session.sql"
-import { withStatics } from "@/util/schema"
-import { Context, DateTime, Effect, Layer, Schema } from "effect"
-import { eq } from "../storage/db"
+import { Schema } from "effect"
+import { SessionEvent } from "./session-event"
+import { produce } from "immer"

 export namespace SessionEntry {
-  export const ID = Schema.String.pipe(Schema.brand("Session.Entry.ID")).pipe(
-    withStatics((s) => ({
-      create: () => s.make(Identifier.ascending("entry")),
-      prefix: "ent",
-    })),
-  )
+  export const ID = SessionEvent.ID
  export type ID = Schema.Schema.Type<typeof ID>

  const Base = {
-    id: ID,
+    id: SessionEvent.ID,
    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
    time: Schema.Struct({
      created: Schema.DateTimeUtc,
    }),
  }

-  export class Source extends Schema.Class<Source>("Session.Entry.Source")({
-    start: Schema.Number,
-    end: Schema.Number,
-    text: Schema.String,
-  }) {}
-
-  export class FileAttachment extends Schema.Class<FileAttachment>("Session.Entry.File.Attachment")({
-    uri: Schema.String,
-    mime: Schema.String,
-    name: Schema.String.pipe(Schema.optional),
-    description: Schema.String.pipe(Schema.optional),
-    source: Source.pipe(Schema.optional),
-  }) {
-    static create(url: string) {
-      return new FileAttachment({
-        uri: url,
-        mime: "text/plain",
-      })
-    }
-  }
-
-  export class AgentAttachment extends Schema.Class<AgentAttachment>("Session.Entry.Agent.Attachment")({
-    name: Schema.String,
-    source: Source.pipe(Schema.optional),
-  }) {}
-
  export class User extends Schema.Class<User>("Session.Entry.User")({
    ...Base,
+    text: SessionEvent.Prompt.fields.text,
+    files: SessionEvent.Prompt.fields.files,
+    agents: SessionEvent.Prompt.fields.agents,
    type: Schema.Literal("user"),
-    text: Schema.String,
-    files: Schema.Array(FileAttachment).pipe(Schema.optional),
-    agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+    }),
  }) {
-    static create(input: { text: User["text"]; files?: User["files"]; agents?: User["agents"] }) {
-      const msg = new User({
-        id: ID.create(),
+    static fromEvent(event: SessionEvent.Prompt) {
+      return new User({
+        id: event.id,
        type: "user",
-        ...input,
-        time: {
-          created: Effect.runSync(DateTime.now),
-        },
+        metadata: event.metadata,
+        text: event.text,
+        files: event.files,
+        agents: event.agents,
+        time: { created: event.timestamp },
      })
-      return msg
    }
  }

  export class Synthetic extends Schema.Class<Synthetic>("Session.Entry.Synthetic")({
+    ...SessionEvent.Synthetic.fields,
    ...Base,
    type: Schema.Literal("synthetic"),
-    text: Schema.String,
-  }) {}
-
-  export class Request extends Schema.Class<Request>("Session.Entry.Request")({
-    ...Base,
-    type: Schema.Literal("start"),
-    model: Schema.Struct({
-      id: Schema.String,
-      providerID: Schema.String,
-      variant: Schema.String.pipe(Schema.optional),
-    }),
-  }) {}
-
-  export class Text extends Schema.Class<Text>("Session.Entry.Text")({
-    ...Base,
-    type: Schema.Literal("text"),
-    text: Schema.String,
-    time: Schema.Struct({
-      ...Base.time.fields,
-      completed: Schema.DateTimeUtc.pipe(Schema.optional),
-    }),
-  }) {}
-
-  export class Reasoning extends Schema.Class<Reasoning>("Session.Entry.Reasoning")({
-    ...Base,
-    type: Schema.Literal("reasoning"),
-    text: Schema.String,
-    time: Schema.Struct({
-      ...Base.time.fields,
-      completed: Schema.DateTimeUtc.pipe(Schema.optional),
-    }),
  }) {}

  export class ToolStatePending extends Schema.Class<ToolStatePending>("Session.Entry.ToolState.Pending")({
    status: Schema.Literal("pending"),
-    input: Schema.Record(Schema.String, Schema.Unknown),
-    raw: Schema.String,
+    input: Schema.String,
  }) {}

  export class ToolStateRunning extends Schema.Class<ToolStateRunning>("Session.Entry.ToolState.Running")({
@@ -124,7 +61,7 @@ export namespace SessionEntry {
    output: Schema.String,
    title: Schema.String,
    metadata: Schema.Record(Schema.String, Schema.Unknown),
-    attachments: Schema.Array(FileAttachment).pipe(Schema.optional),
+    attachments: SessionEvent.FileAttachment.pipe(Schema.Array, Schema.optional),
  }) {}

  export class ToolStateError extends Schema.Class<ToolStateError>("Session.Entry.ToolState.Error")({
@@ -132,34 +69,42 @@ export namespace SessionEntry {
    input: Schema.Record(Schema.String, Schema.Unknown),
    error: Schema.String,
    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
-    time: Schema.Struct({
-      start: Schema.Number,
-      end: Schema.Number,
-    }),
  }) {}

  export const ToolState = Schema.Union([ToolStatePending, ToolStateRunning, ToolStateCompleted, ToolStateError])
  export type ToolState = Schema.Schema.Type<typeof ToolState>

-  export class Tool extends Schema.Class<Tool>("Session.Entry.Tool")({
-    ...Base,
+  export class AssistantTool extends Schema.Class<AssistantTool>("Session.Entry.Assistant.Tool")({
    type: Schema.Literal("tool"),
    callID: Schema.String,
    name: Schema.String,
    state: ToolState,
    time: Schema.Struct({
-      ...Base.time.fields,
+      created: Schema.DateTimeUtc,
      ran: Schema.DateTimeUtc.pipe(Schema.optional),
      completed: Schema.DateTimeUtc.pipe(Schema.optional),
      pruned: Schema.DateTimeUtc.pipe(Schema.optional),
    }),
  }) {}

-  export class Complete extends Schema.Class<Complete>("Session.Entry.Complete")({
+  export class AssistantText extends Schema.Class<AssistantText>("Session.Entry.Assistant.Text")({
+    type: Schema.Literal("text"),
+    text: Schema.String,
+  }) {}
+
+  export class AssistantReasoning extends Schema.Class<AssistantReasoning>("Session.Entry.Assistant.Reasoning")({
+    type: Schema.Literal("reasoning"),
+    text: Schema.String,
+  }) {}
+
+  export const AssistantContent = Schema.Union([AssistantText, AssistantReasoning, AssistantTool])
+  export type AssistantContent = Schema.Schema.Type<typeof AssistantContent>
+
+  export class Assistant extends Schema.Class<Assistant>("Session.Entry.Assistant")({
    ...Base,
-    type: Schema.Literal("complete"),
-    cost: Schema.Number,
-    reason: Schema.String,
+    type: Schema.Literal("assistant"),
+    content: AssistantContent.pipe(Schema.Array),
+    cost: Schema.Number.pipe(Schema.optional),
    tokens: Schema.Struct({
      input: Schema.Number,
      output: Schema.Number,
@@ -168,30 +113,174 @@ export namespace SessionEntry {
        read: Schema.Number,
        write: Schema.Number,
      }),
+    }).pipe(Schema.optional),
+    error: Schema.String.pipe(Schema.optional),
+    time: Schema.Struct({
+      created: Schema.DateTimeUtc,
+      completed: Schema.DateTimeUtc.pipe(Schema.optional),
    }),
  }) {}

-  export class Retry extends Schema.Class<Retry>("Session.Entry.Retry")({
-    ...Base,
-    type: Schema.Literal("retry"),
-    attempt: Schema.Number,
-    error: Schema.String,
-  }) {}
-
  export class Compaction extends Schema.Class<Compaction>("Session.Entry.Compaction")({
-    ...Base,
+    ...SessionEvent.Compacted.fields,
    type: Schema.Literal("compaction"),
-    auto: Schema.Boolean,
-    overflow: Schema.Boolean.pipe(Schema.optional),
+    ...Base,
  }) {}

-  export const Entry = Schema.Union([User, Synthetic, Request, Tool, Text, Reasoning, Complete, Retry, Compaction], {
-    mode: "oneOf",
-  })
+  export const Entry = Schema.Union([User, Synthetic, Assistant, Compaction])
+
  export type Entry = Schema.Schema.Type<typeof Entry>

  export type Type = Entry["type"]

+  export type History = {
+    entries: Entry[]
+    pending: Entry[]
+  }
+
+  export function step(old: History, event: SessionEvent.Event): History {
+    return produce(old, (draft) => {
+      const lastAssistant = draft.entries.findLast((x) => x.type === "assistant")
+      const pendingAssistant = lastAssistant && !lastAssistant.time.completed ? lastAssistant : undefined
+
+      switch (event.type) {
+        case "prompt": {
+          if (pendingAssistant) {
+            // @ts-expect-error
+            draft.pending.push(User.fromEvent(event))
+            break
+          }
+          // @ts-expect-error
+          draft.entries.push(User.fromEvent(event))
+          break
+        }
+        case "step.started": {
+          if (pendingAssistant) pendingAssistant.time.completed = event.timestamp
+          draft.entries.push({
+            id: event.id,
+            type: "assistant",
+            time: {
+              created: event.timestamp,
+            },
+            content: [],
+          })
+          break
+        }
+        case "text.started": {
+          if (!pendingAssistant) break
+          pendingAssistant.content.push({
+            type: "text",
+            text: "",
+          })
+          break
+        }
+        case "text.delta": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "text")
+          if (match) match.text += event.delta
+          break
+        }
+        case "text.ended": {
+          break
+        }
+        case "tool.input.started": {
+          if (!pendingAssistant) break
+          pendingAssistant.content.push({
+            type: "tool",
+            callID: event.callID,
+            name: event.name,
+            time: {
+              created: event.timestamp,
+            },
+            state: {
+              status: "pending",
+              input: "",
+            },
+          })
+          break
+        }
+        case "tool.input.delta": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "tool")
+          if (match) match.state.input += event.delta
+          break
+        }
+        case "tool.input.ended": {
+          break
+        }
+        case "tool.called": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "tool")
+          if (match) {
+            match.time.ran = event.timestamp
+            match.state = {
+              status: "running",
+              input: event.input,
+            }
+          }
+          break
+        }
+        case "tool.success": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "tool")
+          if (match && match.state.status === "running") {
+            match.state = {
+              status: "completed",
+              input: match.state.input,
+              output: event.output ?? "",
+              title: event.title,
+              metadata: event.metadata ?? {},
+              // @ts-expect-error
+              attachments: event.attachments ?? [],
+            }
+          }
+          break
+        }
+        case "tool.error": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "tool")
+          if (match && match.state.status === "running") {
+            match.state = {
+              status: "error",
+              error: event.error,
+              input: match.state.input,
+              metadata: event.metadata ?? {},
+            }
+          }
+          break
+        }
+        case "reasoning.started": {
+          if (!pendingAssistant) break
+          pendingAssistant.content.push({
+            type: "reasoning",
+            text: "",
+          })
+          break
+        }
+        case "reasoning.delta": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "reasoning")
+          if (match) match.text += event.delta
+          break
+        }
+        case "reasoning.ended": {
+          if (!pendingAssistant) break
+          const match = pendingAssistant.content.findLast((x) => x.type === "reasoning")
+          if (match) match.text = event.text
+          break
+        }
+        case "step.ended": {
+          if (!pendingAssistant) break
+          pendingAssistant.time.completed = event.timestamp
+          pendingAssistant.cost = event.cost
+          pendingAssistant.tokens = event.tokens
+          break
+        }
+      }
+    })
+  }
+
+  /*
  export interface Interface {
    readonly decode: (row: typeof SessionEntryTable.$inferSelect) => Entry
    readonly fromSession: (sessionID: SessionID) => Effect.Effect<Entry[], never>
@@ -224,4 +313,5 @@ export namespace SessionEntry {
      })
    }),
  )
+  */
 }
@@ -0,0 +1,443 @@
+import { Identifier } from "@/id/id"
+import { withStatics } from "@/util/schema"
+import * as DateTime from "effect/DateTime"
+import { Schema } from "effect"
+
+export namespace SessionEvent {
+  export const ID = Schema.String.pipe(
+    Schema.brand("Session.Event.ID"),
+    withStatics((s) => ({
+      create: () => s.make(Identifier.create("evt", "ascending")),
+    })),
+  )
+  export type ID = Schema.Schema.Type<typeof ID>
+  type Stamp = Schema.Schema.Type<typeof Schema.DateTimeUtc>
+  type BaseInput = {
+    id?: ID
+    metadata?: Record<string, unknown>
+    timestamp?: Stamp
+  }
+
+  const Base = {
+    id: ID,
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+    timestamp: Schema.DateTimeUtc,
+  }
+
+  export class Source extends Schema.Class<Source>("Session.Event.Source")({
+    start: Schema.Number,
+    end: Schema.Number,
+    text: Schema.String,
+  }) {}
+
+  export class FileAttachment extends Schema.Class<FileAttachment>("Session.Event.FileAttachment")({
+    uri: Schema.String,
+    mime: Schema.String,
+    name: Schema.String.pipe(Schema.optional),
+    description: Schema.String.pipe(Schema.optional),
+    source: Source.pipe(Schema.optional),
+  }) {
+    static create(input: FileAttachment) {
+      return new FileAttachment({
+        ...input,
+      })
+    }
+  }
+
+  export class AgentAttachment extends Schema.Class<AgentAttachment>("Session.Event.AgentAttachment")({
+    name: Schema.String,
+    source: Source.pipe(Schema.optional),
+  }) {}
+
+  export class Prompt extends Schema.Class<Prompt>("Session.Event.Prompt")({
+    ...Base,
+    type: Schema.Literal("prompt"),
+    text: Schema.String,
+    files: Schema.Array(FileAttachment).pipe(Schema.optional),
+    agents: Schema.Array(AgentAttachment).pipe(Schema.optional),
+  }) {
+    static create(input: BaseInput & { text: string; files?: FileAttachment[]; agents?: AgentAttachment[] }) {
+      return new Prompt({
+        id: input.id ?? ID.create(),
+        type: "prompt",
+        timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+        metadata: input.metadata,
+        text: input.text,
+        files: input.files,
+        agents: input.agents,
+      })
+    }
+  }
+
+  export class Synthetic extends Schema.Class<Synthetic>("Session.Event.Synthetic")({
+    ...Base,
+    type: Schema.Literal("synthetic"),
+    text: Schema.String,
+  }) {
+    static create(input: BaseInput & { text: string }) {
+      return new Synthetic({
+        id: input.id ?? ID.create(),
+        type: "synthetic",
+        timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+        metadata: input.metadata,
+        text: input.text,
+      })
+    }
+  }
+
+  export namespace Step {
+    export class Started extends Schema.Class<Started>("Session.Event.Step.Started")({
+      ...Base,
+      type: Schema.Literal("step.started"),
+      model: Schema.Struct({
+        id: Schema.String,
+        providerID: Schema.String,
+        variant: Schema.String.pipe(Schema.optional),
+      }),
+    }) {
+      static create(input: BaseInput & { model: { id: string; providerID: string; variant?: string } }) {
+        return new Started({
+          id: input.id ?? ID.create(),
+          type: "step.started",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          model: input.model,
+        })
+      }
+    }
+
+    export class Ended extends Schema.Class<Ended>("Session.Event.Step.Ended")({
+      ...Base,
+      type: Schema.Literal("step.ended"),
+      reason: Schema.String,
+      cost: Schema.Number,
+      tokens: Schema.Struct({
+        input: Schema.Number,
+        output: Schema.Number,
+        reasoning: Schema.Number,
+        cache: Schema.Struct({
+          read: Schema.Number,
+          write: Schema.Number,
+        }),
+      }),
+    }) {
+      static create(input: BaseInput & { reason: string; cost: number; tokens: Ended["tokens"] }) {
+        return new Ended({
+          id: input.id ?? ID.create(),
+          type: "step.ended",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          reason: input.reason,
+          cost: input.cost,
+          tokens: input.tokens,
+        })
+      }
+    }
+  }
+
+  export namespace Text {
+    export class Started extends Schema.Class<Started>("Session.Event.Text.Started")({
+      ...Base,
+      type: Schema.Literal("text.started"),
+    }) {
+      static create(input: BaseInput = {}) {
+        return new Started({
+          id: input.id ?? ID.create(),
+          type: "text.started",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+        })
+      }
+    }
+
+    export class Delta extends Schema.Class<Delta>("Session.Event.Text.Delta")({
+      ...Base,
+      type: Schema.Literal("text.delta"),
+      delta: Schema.String,
+    }) {
+      static create(input: BaseInput & { delta: string }) {
+        return new Delta({
+          id: input.id ?? ID.create(),
+          type: "text.delta",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          delta: input.delta,
+        })
+      }
+    }
+
+    export class Ended extends Schema.Class<Ended>("Session.Event.Text.Ended")({
+      ...Base,
+      type: Schema.Literal("text.ended"),
+      text: Schema.String,
+    }) {
+      static create(input: BaseInput & { text: string }) {
+        return new Ended({
+          id: input.id ?? ID.create(),
+          type: "text.ended",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          text: input.text,
+        })
+      }
+    }
+  }
+
+  export namespace Reasoning {
+    export class Started extends Schema.Class<Started>("Session.Event.Reasoning.Started")({
+      ...Base,
+      type: Schema.Literal("reasoning.started"),
+    }) {
+      static create(input: BaseInput = {}) {
+        return new Started({
+          id: input.id ?? ID.create(),
+          type: "reasoning.started",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+        })
+      }
+    }
+
+    export class Delta extends Schema.Class<Delta>("Session.Event.Reasoning.Delta")({
+      ...Base,
+      type: Schema.Literal("reasoning.delta"),
+      delta: Schema.String,
+    }) {
+      static create(input: BaseInput & { delta: string }) {
+        return new Delta({
+          id: input.id ?? ID.create(),
+          type: "reasoning.delta",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          delta: input.delta,
+        })
+      }
+    }
+
+    export class Ended extends Schema.Class<Ended>("Session.Event.Reasoning.Ended")({
+      ...Base,
+      type: Schema.Literal("reasoning.ended"),
+      text: Schema.String,
+    }) {
+      static create(input: BaseInput & { text: string }) {
+        return new Ended({
+          id: input.id ?? ID.create(),
+          type: "reasoning.ended",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          text: input.text,
+        })
+      }
+    }
+  }
+
+  export namespace Tool {
+    export namespace Input {
+      export class Started extends Schema.Class<Started>("Session.Event.Tool.Input.Started")({
+        ...Base,
+        callID: Schema.String,
+        name: Schema.String,
+        type: Schema.Literal("tool.input.started"),
+      }) {
+        static create(input: BaseInput & { callID: string; name: string }) {
+          return new Started({
+            id: input.id ?? ID.create(),
+            type: "tool.input.started",
+            timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+            metadata: input.metadata,
+            callID: input.callID,
+            name: input.name,
+          })
+        }
+      }
+
+      export class Delta extends Schema.Class<Delta>("Session.Event.Tool.Input.Delta")({
+        ...Base,
+        callID: Schema.String,
+        type: Schema.Literal("tool.input.delta"),
+        delta: Schema.String,
+      }) {
+        static create(input: BaseInput & { callID: string; delta: string }) {
+          return new Delta({
+            id: input.id ?? ID.create(),
+            type: "tool.input.delta",
+            timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+            metadata: input.metadata,
+            callID: input.callID,
+            delta: input.delta,
+          })
+        }
+      }
+
+      export class Ended extends Schema.Class<Ended>("Session.Event.Tool.Input.Ended")({
+        ...Base,
+        callID: Schema.String,
+        type: Schema.Literal("tool.input.ended"),
+        text: Schema.String,
+      }) {
+        static create(input: BaseInput & { callID: string; text: string }) {
+          return new Ended({
+            id: input.id ?? ID.create(),
+            type: "tool.input.ended",
+            timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+            metadata: input.metadata,
+            callID: input.callID,
+            text: input.text,
+          })
+        }
+      }
+    }
+
+    export class Called extends Schema.Class<Called>("Session.Event.Tool.Called")({
+      ...Base,
+      type: Schema.Literal("tool.called"),
+      callID: Schema.String,
+      tool: Schema.String,
+      input: Schema.Record(Schema.String, Schema.Unknown),
+      provider: Schema.Struct({
+        executed: Schema.Boolean,
+        metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+      }),
+    }) {
+      static create(
+        input: BaseInput & {
+          callID: string
+          tool: string
+          input: Record<string, unknown>
+          provider: Called["provider"]
+        },
+      ) {
+        return new Called({
+          id: input.id ?? ID.create(),
+          type: "tool.called",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          callID: input.callID,
+          tool: input.tool,
+          input: input.input,
+          provider: input.provider,
+        })
+      }
+    }
+
+    export class Success extends Schema.Class<Success>("Session.Event.Tool.Success")({
+      ...Base,
+      type: Schema.Literal("tool.success"),
+      callID: Schema.String,
+      title: Schema.String,
+      output: Schema.String.pipe(Schema.optional),
+      attachments: Schema.Array(FileAttachment).pipe(Schema.optional),
+      provider: Schema.Struct({
+        executed: Schema.Boolean,
+        metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+      }),
+    }) {
+      static create(
+        input: BaseInput & {
+          callID: string
+          title: string
+          output?: string
+          attachments?: FileAttachment[]
+          provider: Success["provider"]
+        },
+      ) {
+        return new Success({
+          id: input.id ?? ID.create(),
+          type: "tool.success",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          callID: input.callID,
+          title: input.title,
+          output: input.output,
+          attachments: input.attachments,
+          provider: input.provider,
+        })
+      }
+    }
+
+    export class Error extends Schema.Class<Error>("Session.Event.Tool.Error")({
+      ...Base,
+      type: Schema.Literal("tool.error"),
+      callID: Schema.String,
+      error: Schema.String,
+      provider: Schema.Struct({
+        executed: Schema.Boolean,
+        metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
+      }),
+    }) {
+      static create(input: BaseInput & { callID: string; error: string; provider: Error["provider"] }) {
+        return new Error({
+          id: input.id ?? ID.create(),
+          type: "tool.error",
+          timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+          metadata: input.metadata,
+          callID: input.callID,
+          error: input.error,
+          provider: input.provider,
+        })
+      }
+    }
+  }
+
+  export class Retried extends Schema.Class<Retried>("Session.Event.Retried")({
+    ...Base,
+    type: Schema.Literal("retried"),
+    error: Schema.String,
+  }) {
+    static create(input: BaseInput & { error: string }) {
+      return new Retried({
+        id: input.id ?? ID.create(),
+        type: "retried",
+        timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+        metadata: input.metadata,
+        error: input.error,
+      })
+    }
+  }
+
+  export class Compacted extends Schema.Class<Compacted>("Session.Event.Compated")({
+    ...Base,
+    type: Schema.Literal("compacted"),
+    auto: Schema.Boolean,
+    overflow: Schema.Boolean.pipe(Schema.optional),
+  }) {
+    static create(input: BaseInput & { auto: boolean; overflow?: boolean }) {
+      return new Compacted({
+        id: input.id ?? ID.create(),
+        type: "compacted",
+        timestamp: input.timestamp ?? DateTime.makeUnsafe(Date.now()),
+        metadata: input.metadata,
+        auto: input.auto,
+        overflow: input.overflow,
+      })
+    }
+  }
+
+  export const Event = Schema.Union(
+    [
+      Prompt,
+      Synthetic,
+      Step.Started,
+      Step.Ended,
+      Text.Started,
+      Text.Delta,
+      Text.Ended,
+      Tool.Input.Started,
+      Tool.Input.Delta,
+      Tool.Input.Ended,
+      Tool.Called,
+      Tool.Success,
+      Tool.Error,
+      Reasoning.Started,
+      Reasoning.Delta,
+      Reasoning.Ended,
+      Retried,
+      Compacted,
+    ],
+    {
+      mode: "oneOf",
+    },
+  )
+  export type Event = Schema.Schema.Type<typeof Event>
+  export type Type = Event["type"]
+}
@@ -295,6 +295,46 @@ describe("acp.agent event subscription", () => {
    })
  })

+  test("does not emit user_message_chunk for live prompt parts", async () => {
+    await using tmp = await tmpdir()
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const { agent, controller, sessionUpdates, stop } = createFakeAgent()
+        const cwd = "/tmp/opencode-acp-test"
+        const sessionId = await agent.newSession({ cwd, mcpServers: [] } as any).then((x) => x.sessionId)
+
+        controller.push({
+          directory: cwd,
+          payload: {
+            type: "message.part.updated",
+            properties: {
+              sessionID: sessionId,
+              time: Date.now(),
+              part: {
+                id: "part_1",
+                sessionID: sessionId,
+                messageID: "msg_user",
+                type: "text",
+                text: "hello",
+              },
+            },
+          },
+        } as any)
+
+        await new Promise((r) => setTimeout(r, 20))
+
+        expect(
+          sessionUpdates
+            .filter((u) => u.sessionId === sessionId)
+            .some((u) => u.update.sessionUpdate === "user_message_chunk"),
+        ).toBe(false)
+
+        stop()
+      },
+    })
+  })
+
  test("keeps concurrent sessions isolated when message.part.delta events are interleaved", async () => {
    await using tmp = await tmpdir()
    await Instance.provide({
@@ -0,0 +1,61 @@
+import { expect, test } from "bun:test"
+import { Context, Effect, Layer, Logger } from "effect"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { InstanceRef } from "../../src/effect/instance-ref"
+import { EffectLogger } from "../../src/effect/logger"
+import { makeRuntime } from "../../src/effect/run-service"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+
+function check(loggers: ReadonlySet<Logger.Logger<unknown, any>>) {
+  return {
+    defaultLogger: loggers.has(Logger.defaultLogger),
+    tracerLogger: loggers.has(Logger.tracerLogger),
+    effectLogger: loggers.has(EffectLogger.logger),
+    size: loggers.size,
+  }
+}
+
+test("makeRuntime installs EffectLogger through Observability.layer", async () => {
+  class Dummy extends Context.Service<Dummy, { readonly current: () => Effect.Effect<ReturnType<typeof check>> }>()(
+    "@test/Dummy",
+  ) {}
+
+  const layer = Layer.effect(
+    Dummy,
+    Effect.gen(function* () {
+      return Dummy.of({
+        current: () => Effect.map(Effect.service(Logger.CurrentLoggers), check),
+      })
+    }),
+  )
+
+  const rt = makeRuntime(Dummy, layer)
+  const current = await rt.runPromise((svc) => svc.current())
+
+  expect(current.effectLogger).toBe(true)
+  expect(current.defaultLogger).toBe(false)
+})
+
+test("AppRuntime also installs EffectLogger through Observability.layer", async () => {
+  const current = await AppRuntime.runPromise(Effect.map(Effect.service(Logger.CurrentLoggers), check))
+
+  expect(current.effectLogger).toBe(true)
+  expect(current.defaultLogger).toBe(false)
+})
+
+test("AppRuntime attaches InstanceRef from ALS", async () => {
+  await using tmp = await tmpdir({ git: true })
+
+  const dir = await Instance.provide({
+    directory: tmp.path,
+    fn: () =>
+      AppRuntime.runPromise(
+        Effect.gen(function* () {
+          return (yield* InstanceRef)?.directory
+        }),
+      ),
+  })
+
+  expect(dir).toBe(tmp.path)
+})
@@ -20,6 +20,7 @@ const transportCalls: Array<{
 // Controls whether the mock transport simulates a 401 that triggers the SDK
 // auth flow (which calls provider.state()) or a simple UnauthorizedError.
 let simulateAuthFlow = true
+let connectSucceedsImmediately = false

 // Mock the transport constructors to simulate OAuth auto-auth on 401
 mock.module("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
@@ -40,6 +41,8 @@ mock.module("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
      })
    }
    async start() {
+      if (connectSucceedsImmediately) return
+
      // Simulate what the real SDK transport does on 401:
      // It calls auth() which eventually calls provider.state(), then
      // provider.redirectToAuthorization(), then throws UnauthorizedError.
@@ -85,6 +88,14 @@ mock.module("@modelcontextprotocol/sdk/client/index.js", () => ({
    async connect(transport: { start: () => Promise<void> }) {
      await transport.start()
    }
+
+    setNotificationHandler() {}
+
+    async listTools() {
+      return { tools: [{ name: "test_tool", inputSchema: { type: "object", properties: {} } }] }
+    }
+
+    async close() {}
  },
 }))

@@ -96,6 +107,7 @@ mock.module("@modelcontextprotocol/sdk/client/auth.js", () => ({
 beforeEach(() => {
  transportCalls.length = 0
  simulateAuthFlow = true
+  connectSucceedsImmediately = false
 })

 // Import modules after mocking
@@ -222,3 +234,49 @@ test("state() returns existing state when one is saved", async () => {
    },
  })
 })
+
+test("authenticate() stores a connected client when auth completes without redirect", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        `${dir}/opencode.json`,
+        JSON.stringify({
+          $schema: "https://opencode.ai/config.json",
+          mcp: {
+            "test-oauth-connect": {
+              type: "remote",
+              url: "https://example.com/mcp",
+            },
+          },
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      await Effect.runPromise(
+        MCP.Service.use((mcp) =>
+          Effect.gen(function* () {
+            const added = yield* mcp.add("test-oauth-connect", {
+              type: "remote",
+              url: "https://example.com/mcp",
+            })
+            const before = added.status as Record<string, { status: string; error?: string }>
+            expect(before["test-oauth-connect"]?.status).toBe("needs_auth")
+
+            simulateAuthFlow = false
+            connectSucceedsImmediately = true
+
+            const result = yield* mcp.authenticate("test-oauth-connect")
+            expect(result.status).toBe("connected")
+
+            const after = yield* mcp.status()
+            expect(after["test-oauth-connect"]?.status).toBe("connected")
+          }),
+        ).pipe(Effect.provide(MCP.defaultLayer)),
+      )
+    },
+  })
+})
@@ -8,9 +8,19 @@ import { SessionID } from "../../src/session/schema"
 import { Log } from "../../src/util/log"
 import { $ } from "bun"
 import { tmpdir } from "../fixture/fixture"
+import { Effect } from "effect"

 Log.init({ print: false })

+function run<A>(fn: (svc: Project.Interface) => Effect.Effect<A>) {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const svc = yield* Project.Service
+      return yield* fn(svc)
+    }).pipe(Effect.provide(Project.defaultLayer)),
+  )
+}
+
 function uid() {
  return SessionID.make(crypto.randomUUID())
 }
@@ -58,7 +68,7 @@ describe("migrateFromGlobal", () => {
    await $`git config user.name "Test"`.cwd(tmp.path).quiet()
    await $`git config user.email "test@opencode.test"`.cwd(tmp.path).quiet()
    await $`git config commit.gpgsign false`.cwd(tmp.path).quiet()
-    const { project: pre } = await Project.fromDirectory(tmp.path)
+    const { project: pre } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(pre.id).toBe(ProjectID.global)

    // 2. Seed a session under "global" with matching directory
@@ -68,7 +78,7 @@ describe("migrateFromGlobal", () => {
    // 3. Make a commit so the project gets a real ID
    await $`git commit --allow-empty -m "root"`.cwd(tmp.path).quiet()

-    const { project: real } = await Project.fromDirectory(tmp.path)
+    const { project: real } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(real.id).not.toBe(ProjectID.global)

    // 4. The session should have been migrated to the real project ID
@@ -80,7 +90,7 @@ describe("migrateFromGlobal", () => {
  test("migrates global sessions even when project row already exists", async () => {
    // 1. Create a repo with a commit — real project ID created immediately
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(project.id).not.toBe(ProjectID.global)

    // 2. Ensure "global" project row exists (as it would from a prior no-git session)
@@ -94,7 +104,7 @@ describe("migrateFromGlobal", () => {

    // 4. Call fromDirectory again — project row already exists,
    //    so the current code skips migration entirely. This is the bug.
-    await Project.fromDirectory(tmp.path)
+    await run((svc) => svc.fromDirectory(tmp.path))

    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
    expect(row).toBeDefined()
@@ -103,7 +113,7 @@ describe("migrateFromGlobal", () => {

  test("does not claim sessions with empty directory", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(project.id).not.toBe(ProjectID.global)

    ensureGlobal()
@@ -113,7 +123,7 @@ describe("migrateFromGlobal", () => {
    const id = uid()
    seed({ id, dir: "", project: ProjectID.global })

-    await Project.fromDirectory(tmp.path)
+    await run((svc) => svc.fromDirectory(tmp.path))

    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
    expect(row).toBeDefined()
@@ -122,7 +132,7 @@ describe("migrateFromGlobal", () => {

  test("does not steal sessions from unrelated directories", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(project.id).not.toBe(ProjectID.global)

    ensureGlobal()
@@ -131,7 +141,7 @@ describe("migrateFromGlobal", () => {
    const id = uid()
    seed({ id, dir: "/some/other/dir", project: ProjectID.global })

-    await Project.fromDirectory(tmp.path)
+    await run((svc) => svc.fromDirectory(tmp.path))

    const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
    expect(row).toBeDefined()
@@ -8,7 +8,7 @@ import { GlobalBus } from "../../src/bus/global"
 import { ProjectID } from "../../src/project/schema"
 import { Effect, Layer, Stream } from "effect"
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
+import { NodePath } from "@effect/platform-node"
 import { AppFileSystem } from "../../src/filesystem"
 import * as CrossSpawnSpawner from "../../src/effect/cross-spawn-spawner"

@@ -16,6 +16,15 @@ Log.init({ print: false })

 const encoder = new TextEncoder()

+function run<A>(fn: (svc: Project.Interface) => Effect.Effect<A>, layer = Project.defaultLayer) {
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const svc = yield* Project.Service
+      return yield* fn(svc)
+    }).pipe(Effect.provide(layer)),
+  )
+}
+
 /**
 * Creates a mock ChildProcessSpawner layer that intercepts git subcommands
 * matching `failArg` and returns exit code 128, while delegating everything
@@ -64,7 +73,7 @@ describe("Project.fromDirectory", () => {
    await using tmp = await tmpdir()
    await $`git init`.cwd(tmp.path).quiet()

-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    expect(project).toBeDefined()
    expect(project.id).toBe(ProjectID.global)
@@ -78,7 +87,7 @@ describe("Project.fromDirectory", () => {
  test("should handle git repository with commits", async () => {
    await using tmp = await tmpdir({ git: true })

-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    expect(project).toBeDefined()
    expect(project.id).not.toBe(ProjectID.global)
@@ -91,14 +100,14 @@ describe("Project.fromDirectory", () => {

  test("returns global for non-git directory", async () => {
    await using tmp = await tmpdir()
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(project.id).toBe(ProjectID.global)
  })

  test("derives stable project ID from root commit", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project: a } = await Project.fromDirectory(tmp.path)
-    const { project: b } = await Project.fromDirectory(tmp.path)
+    const { project: a } = await run((svc) => svc.fromDirectory(tmp.path))
+    const { project: b } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(b.id).toBe(a.id)
  })
 })
@@ -109,7 +118,7 @@ describe("Project.fromDirectory git failure paths", () => {
    await $`git init`.cwd(tmp.path).quiet()

    // rev-list fails because HEAD doesn't exist yet — this is the natural scenario
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    expect(project.vcs).toBe("git")
    expect(project.id).toBe(ProjectID.global)
    expect(project.worktree).toBe(tmp.path)
@@ -119,9 +128,7 @@ describe("Project.fromDirectory git failure paths", () => {
    await using tmp = await tmpdir({ git: true })
    const layer = projectLayerWithFailure("--show-toplevel")

-    const { project, sandbox } = await Effect.runPromise(
-      Project.Service.use((svc) => svc.fromDirectory(tmp.path)).pipe(Effect.provide(layer)),
-    )
+    const { project, sandbox } = await run((svc) => svc.fromDirectory(tmp.path), layer)
    expect(project.worktree).toBe(tmp.path)
    expect(sandbox).toBe(tmp.path)
  })
@@ -130,9 +137,7 @@ describe("Project.fromDirectory git failure paths", () => {
    await using tmp = await tmpdir({ git: true })
    const layer = projectLayerWithFailure("--git-common-dir")

-    const { project, sandbox } = await Effect.runPromise(
-      Project.Service.use((svc) => svc.fromDirectory(tmp.path)).pipe(Effect.provide(layer)),
-    )
+    const { project, sandbox } = await run((svc) => svc.fromDirectory(tmp.path), layer)
    expect(project.worktree).toBe(tmp.path)
    expect(sandbox).toBe(tmp.path)
  })
@@ -142,7 +147,7 @@ describe("Project.fromDirectory with worktrees", () => {
  test("should set worktree to root when called from root", async () => {
    await using tmp = await tmpdir({ git: true })

-    const { project, sandbox } = await Project.fromDirectory(tmp.path)
+    const { project, sandbox } = await run((svc) => svc.fromDirectory(tmp.path))

    expect(project.worktree).toBe(tmp.path)
    expect(sandbox).toBe(tmp.path)
@@ -156,7 +161,7 @@ describe("Project.fromDirectory with worktrees", () => {
    try {
      await $`git worktree add ${worktreePath} -b test-branch-${Date.now()}`.cwd(tmp.path).quiet()

-      const { project, sandbox } = await Project.fromDirectory(worktreePath)
+      const { project, sandbox } = await run((svc) => svc.fromDirectory(worktreePath))

      expect(project.worktree).toBe(tmp.path)
      expect(sandbox).toBe(worktreePath)
@@ -173,13 +178,13 @@ describe("Project.fromDirectory with worktrees", () => {
  test("worktree should share project ID with main repo", async () => {
    await using tmp = await tmpdir({ git: true })

-    const { project: main } = await Project.fromDirectory(tmp.path)
+    const { project: main } = await run((svc) => svc.fromDirectory(tmp.path))

    const worktreePath = path.join(tmp.path, "..", path.basename(tmp.path) + "-wt-shared")
    try {
      await $`git worktree add ${worktreePath} -b shared-${Date.now()}`.cwd(tmp.path).quiet()

-      const { project: wt } = await Project.fromDirectory(worktreePath)
+      const { project: wt } = await run((svc) => svc.fromDirectory(worktreePath))

      expect(wt.id).toBe(main.id)

@@ -205,8 +210,8 @@ describe("Project.fromDirectory with worktrees", () => {
      await $`git clone --bare ${tmp.path} ${bare}`.quiet()
      await $`git clone ${bare} ${clone}`.quiet()

-      const { project: a } = await Project.fromDirectory(tmp.path)
-      const { project: b } = await Project.fromDirectory(clone)
+      const { project: a } = await run((svc) => svc.fromDirectory(tmp.path))
+      const { project: b } = await run((svc) => svc.fromDirectory(clone))

      expect(b.id).toBe(a.id)
    } finally {
@@ -223,8 +228,8 @@ describe("Project.fromDirectory with worktrees", () => {
      await $`git worktree add ${worktree1} -b branch-${Date.now()}`.cwd(tmp.path).quiet()
      await $`git worktree add ${worktree2} -b branch-${Date.now() + 1}`.cwd(tmp.path).quiet()

-      await Project.fromDirectory(worktree1)
-      const { project } = await Project.fromDirectory(worktree2)
+      await run((svc) => svc.fromDirectory(worktree1))
+      const { project } = await run((svc) => svc.fromDirectory(worktree2))

      expect(project.worktree).toBe(tmp.path)
      expect(project.sandboxes).toContain(worktree1)
@@ -246,12 +251,12 @@ describe("Project.fromDirectory with worktrees", () => {
 describe("Project.discover", () => {
  test("should discover favicon.png in root", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    const pngData = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])
    await Bun.write(path.join(tmp.path, "favicon.png"), pngData)

-    await Project.discover(project)
+    await run((svc) => svc.discover(project))

    const updated = Project.get(project.id)
    expect(updated).toBeDefined()
@@ -263,11 +268,11 @@ describe("Project.discover", () => {

  test("should not discover non-image files", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    await Bun.write(path.join(tmp.path, "favicon.txt"), "not an image")

-    await Project.discover(project)
+    await run((svc) => svc.discover(project))

    const updated = Project.get(project.id)
    expect(updated).toBeDefined()
@@ -278,12 +283,14 @@ describe("Project.discover", () => {
 describe("Project.update", () => {
  test("should update name", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

-    const updated = await Project.update({
-      projectID: project.id,
-      name: "New Project Name",
-    })
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        name: "New Project Name",
+      }),
+    )

    expect(updated.name).toBe("New Project Name")

@@ -293,12 +300,14 @@ describe("Project.update", () => {

  test("should update icon url", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

-    const updated = await Project.update({
-      projectID: project.id,
-      icon: { url: "https://example.com/icon.png" },
-    })
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        icon: { url: "https://example.com/icon.png" },
+      }),
+    )

    expect(updated.icon?.url).toBe("https://example.com/icon.png")

@@ -308,12 +317,14 @@ describe("Project.update", () => {

  test("should update icon color", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

-    const updated = await Project.update({
-      projectID: project.id,
-      icon: { color: "#ff0000" },
-    })
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        icon: { color: "#ff0000" },
+      }),
+    )

    expect(updated.icon?.color).toBe("#ff0000")

@@ -323,12 +334,14 @@ describe("Project.update", () => {

  test("should update commands", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

-    const updated = await Project.update({
-      projectID: project.id,
-      commands: { start: "npm run dev" },
-    })
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        commands: { start: "npm run dev" },
+      }),
+    )

    expect(updated.commands?.start).toBe("npm run dev")

@@ -338,16 +351,18 @@ describe("Project.update", () => {

  test("should throw error when project not found", async () => {
    await expect(
-      Project.update({
-        projectID: ProjectID.make("nonexistent-project-id"),
-        name: "Should Fail",
-      }),
+      run((svc) =>
+        svc.update({
+          projectID: ProjectID.make("nonexistent-project-id"),
+          name: "Should Fail",
+        }),
+      ),
    ).rejects.toThrow("Project not found: nonexistent-project-id")
  })

  test("should emit GlobalBus event on update", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    let eventPayload: any = null
    const on = (data: any) => {
@@ -356,10 +371,7 @@ describe("Project.update", () => {
    GlobalBus.on("event", on)

    try {
-      await Project.update({
-        projectID: project.id,
-        name: "Updated Name",
-      })
+      await run((svc) => svc.update({ projectID: project.id, name: "Updated Name" }))

      expect(eventPayload).not.toBeNull()
      expect(eventPayload.payload.type).toBe("project.updated")
@@ -371,14 +383,16 @@ describe("Project.update", () => {

  test("should update multiple fields at once", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

-    const updated = await Project.update({
-      projectID: project.id,
-      name: "Multi Update",
-      icon: { url: "https://example.com/favicon.ico", color: "#00ff00" },
-      commands: { start: "make start" },
-    })
+    const updated = await run((svc) =>
+      svc.update({
+        projectID: project.id,
+        name: "Multi Update",
+        icon: { url: "https://example.com/favicon.ico", color: "#00ff00" },
+        commands: { start: "make start" },
+      }),
+    )

    expect(updated.name).toBe("Multi Update")
    expect(updated.icon?.url).toBe("https://example.com/favicon.ico")
@@ -390,7 +404,7 @@ describe("Project.update", () => {
 describe("Project.list and Project.get", () => {
  test("list returns all projects", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    const all = Project.list()
    expect(all.length).toBeGreaterThan(0)
@@ -399,7 +413,7 @@ describe("Project.list and Project.get", () => {

  test("get returns project by id", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    const found = Project.get(project.id)
    expect(found).toBeDefined()
@@ -415,7 +429,7 @@ describe("Project.list and Project.get", () => {
 describe("Project.setInitialized", () => {
  test("sets time_initialized on project", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))

    expect(project.time.initialized).toBeUndefined()

@@ -429,15 +443,15 @@ describe("Project.setInitialized", () => {
 describe("Project.addSandbox and Project.removeSandbox", () => {
  test("addSandbox adds directory and removeSandbox removes it", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    const sandboxDir = path.join(tmp.path, "sandbox-test")

-    await Project.addSandbox(project.id, sandboxDir)
+    await run((svc) => svc.addSandbox(project.id, sandboxDir))

    let found = Project.get(project.id)
    expect(found?.sandboxes).toContain(sandboxDir)

-    await Project.removeSandbox(project.id, sandboxDir)
+    await run((svc) => svc.removeSandbox(project.id, sandboxDir))

    found = Project.get(project.id)
    expect(found?.sandboxes).not.toContain(sandboxDir)
@@ -445,14 +459,14 @@ describe("Project.addSandbox and Project.removeSandbox", () => {

  test("addSandbox emits GlobalBus event", async () => {
    await using tmp = await tmpdir({ git: true })
-    const { project } = await Project.fromDirectory(tmp.path)
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
    const sandboxDir = path.join(tmp.path, "sandbox-event")

    const events: any[] = []
    const on = (evt: any) => events.push(evt)
    GlobalBus.on("event", on)

-    await Project.addSandbox(project.id, sandboxDir)
+    await run((svc) => svc.addSandbox(project.id, sandboxDir))

    GlobalBus.off("event", on)
    expect(events.some((e) => e.payload.type === Project.Event.Updated.type)).toBe(true)
@@ -6,12 +6,12 @@ import { tmpdir } from "../fixture/fixture"
 import { SessionID } from "../../src/session/schema"
 import { AppRuntime } from "../../src/effect/app-runtime"

-const ask = (input: { sessionID: SessionID; questions: Question.Info[]; tool?: { messageID: any; callID: string } }) =>
+const ask = (input: { sessionID: SessionID; questions: ReadonlyArray<Question.Info>; tool?: Question.Tool }) =>
  AppRuntime.runPromise(Question.Service.use((svc) => svc.ask(input)))

 const list = () => AppRuntime.runPromise(Question.Service.use((svc) => svc.list()))

-const reply = (input: { requestID: QuestionID; answers: Question.Answer[] }) =>
+const reply = (input: { requestID: QuestionID; answers: ReadonlyArray<Question.Answer> }) =>
  AppRuntime.runPromise(Question.Service.use((svc) => svc.reply(input)))

 const reject = (id: QuestionID) => AppRuntime.runPromise(Question.Service.use((svc) => svc.reject(id)))
@@ -1,27 +1,43 @@
 import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import z from "zod"
 import { Instance } from "../../src/project/instance"
 import { Project } from "../../src/project/project"
-import { Session } from "../../src/session"
+import { Session as SessionNs } from "../../src/session"
 import { Log } from "../../src/util/log"
 import { tmpdir } from "../fixture/fixture"

 Log.init({ print: false })

-describe("Session.listGlobal", () => {
+function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
+  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
+}
+
+const svc = {
+  ...SessionNs,
+  create(input?: SessionNs.CreateInput) {
+    return run(SessionNs.Service.use((svc) => svc.create(input)))
+  },
+  setArchived(input: z.output<typeof SessionNs.SetArchivedInput>) {
+    return run(SessionNs.Service.use((svc) => svc.setArchived(input)))
+  },
+}
+
+describe("session.listGlobal", () => {
  test("lists sessions across projects with project metadata", async () => {
    await using first = await tmpdir({ git: true })
    await using second = await tmpdir({ git: true })

    const firstSession = await Instance.provide({
      directory: first.path,
-      fn: async () => Session.create({ title: "first-session" }),
+      fn: async () => svc.create({ title: "first-session" }),
    })
    const secondSession = await Instance.provide({
      directory: second.path,
-      fn: async () => Session.create({ title: "second-session" }),
+      fn: async () => svc.create({ title: "second-session" }),
    })

-    const sessions = [...Session.listGlobal({ limit: 200 })]
+    const sessions = [...svc.listGlobal({ limit: 200 })]
    const ids = sessions.map((session) => session.id)

    expect(ids).toContain(firstSession.id)
@@ -44,20 +60,20 @@ describe("Session.listGlobal", () => {

    const archived = await Instance.provide({
      directory: tmp.path,
-      fn: async () => Session.create({ title: "archived-session" }),
+      fn: async () => svc.create({ title: "archived-session" }),
    })

    await Instance.provide({
      directory: tmp.path,
-      fn: async () => Session.setArchived({ sessionID: archived.id, time: Date.now() }),
+      fn: async () => svc.setArchived({ sessionID: archived.id, time: Date.now() }),
    })

-    const sessions = [...Session.listGlobal({ limit: 200 })]
+    const sessions = [...svc.listGlobal({ limit: 200 })]
    const ids = sessions.map((session) => session.id)

    expect(ids).not.toContain(archived.id)

-    const allSessions = [...Session.listGlobal({ limit: 200, archived: true })]
+    const allSessions = [...svc.listGlobal({ limit: 200, archived: true })]
    const allIds = allSessions.map((session) => session.id)

    expect(allIds).toContain(archived.id)
@@ -68,19 +84,19 @@ describe("Session.listGlobal", () => {

    const first = await Instance.provide({
      directory: tmp.path,
-      fn: async () => Session.create({ title: "page-one" }),
+      fn: async () => svc.create({ title: "page-one" }),
    })
    await new Promise((resolve) => setTimeout(resolve, 5))
    const second = await Instance.provide({
      directory: tmp.path,
-      fn: async () => Session.create({ title: "page-two" }),
+      fn: async () => svc.create({ title: "page-two" }),
    })

-    const page = [...Session.listGlobal({ directory: tmp.path, limit: 1 })]
+    const page = [...svc.listGlobal({ directory: tmp.path, limit: 1 })]
    expect(page.length).toBe(1)
    expect(page[0].id).toBe(second.id)

-    const next = [...Session.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0].time.updated })]
+    const next = [...svc.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0].time.updated })]
    const ids = next.map((session) => session.id)

    expect(ids).toContain(first.id)
@@ -0,0 +1,78 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { AppRuntime } from "../../src/effect/app-runtime"
+import { Instance } from "../../src/project/instance"
+import { Question } from "../../src/question"
+import { Server } from "../../src/server/server"
+import { SessionID } from "../../src/session/schema"
+import { Log } from "../../src/util/log"
+import { tmpdir } from "../fixture/fixture"
+
+Log.init({ print: false })
+
+const ask = (input: { sessionID: SessionID; questions: ReadonlyArray<Question.Info> }) =>
+  AppRuntime.runPromise(Question.Service.use((svc) => svc.ask(input)))
+
+afterEach(async () => {
+  await Instance.disposeAll()
+})
+
+describe("experimental question httpapi", () => {
+  test("lists pending questions, replies, and serves docs", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const app = Server.Default().app
+    const headers = {
+      "content-type": "application/json",
+      "x-opencode-directory": tmp.path,
+    }
+    const questions: ReadonlyArray<Question.Info> = [
+      {
+        question: "What would you like to do?",
+        header: "Action",
+        options: [
+          { label: "Option 1", description: "First option" },
+          { label: "Option 2", description: "Second option" },
+        ],
+      },
+    ]
+
+    let pending!: ReturnType<typeof ask>
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        pending = ask({
+          sessionID: SessionID.make("ses_test"),
+          questions,
+        })
+      },
+    })
+
+    const list = await app.request("/experimental/httpapi/question", {
+      headers,
+    })
+
+    expect(list.status).toBe(200)
+    const items = await list.json()
+    expect(items).toHaveLength(1)
+    expect(items[0]).toMatchObject({ questions })
+
+    const doc = await app.request("/experimental/httpapi/question/doc", {
+      headers,
+    })
+
+    expect(doc.status).toBe(200)
+    const spec = await doc.json()
+    expect(spec.paths["/experimental/httpapi/question"]?.get?.operationId).toBe("question.list")
+    expect(spec.paths["/experimental/httpapi/question/{requestID}/reply"]?.post?.operationId).toBe("question.reply")
+
+    const reply = await app.request(`/experimental/httpapi/question/${items[0].id}/reply`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ answers: [["Option 1"]] }),
+    })
+
+    expect(reply.status).toBe(200)
+    expect(await reply.json()).toBe(true)
+    expect(await pending).toEqual([["Option 1"]])
+  })
+})
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kit LangtonandGitHub	934c605e44	Merge branch 'dev' into fix/session-prompt-permission-draft	2026-04-14 19:31:49 -04:00
Kit Langton	d99467c027	fix(tui): preserve session prompt draft during permissions	2026-04-14 19:30:24 -04:00
Shoubhit DashandGitHub	678d8f6ab2	feat(server): extract question httpapi contract into packages/server (#22502 )	2026-04-15 04:54:40 +05:30
opencode-agent[bot]	50c1d0a43b	chore: update nix node_modules hashes	2026-04-14 23:13:28 +00:00
Frank	60b8041ebb	zen: support alibaba cache write	2026-04-14 18:48:00 -04:00
Frank	3b2a2c461d	sync zen	2026-04-14 18:37:02 -04:00
Shoubhit DashandGitHub	6706358a6e	feat(core): bootstrap packages/server and document extraction plan (#22492 )	2026-04-15 04:01:45 +05:30
Shoubhit DashandGitHub	f6409759e5	fix: restore instance context in prompt runs (#22498 )	2026-04-15 03:59:12 +05:30
Luke ParkerandGitHub	f9d99f044d	fix(session): keep GitHub Copilot compaction requests valid (#22371 )	2026-04-15 08:02:27 +10:00
Caleb NortonandGitHub	bbd5faf5cd	chore(nix): remove external ripgrep (#22482 )	2026-04-14 16:49:44 -05:00
Kit LangtonandGitHub	aeb7d99d20	fix(effect): preserve logger context in prompt runs (#22496 )	2026-04-14 17:33:44 -04:00
Aiden ClineandGitHub	3695057bee	feat: add --sanitize flag to opencode export to strip PII or confidential info (#22489 )	2026-04-14 16:24:18 -05:00
opencode-agent[bot]	4ed3afea84	chore: generate	2026-04-14 20:58:35 +00:00
Kit LangtonandGitHub	3cf7c7536b	fix(question): restore flat reply sdk shape (#22487 )	2026-04-14 16:57:32 -04:00
opencode-agent[bot]	85674f4bfd	chore: generate	2026-04-14 19:45:10 +00:00
Kit LangtonandGitHub	f2525a63c9	add experimental question HttpApi slice (#22357 )	2026-04-14 19:43:49 +00:00
opencode-agent[bot]	8c42d391f5	chore: update nix node_modules hashes	2026-04-14 19:08:59 +00:00
SebastianandGitHub	7f9bf91073	upgrade opentui to 0.1.99 (#22283 )	2026-04-14 20:29:56 +02:00
Dax Raad	6ce5c01b1a	ignore: v2 experiments	2026-04-14 14:25:38 -04:00
SebastianandGitHub	a53fae1511	Fix diff line number contrast for built-in themes (#22464 )	2026-04-14 19:59:41 +02:00
Kit LangtonandGitHub	4626458175	fix(mcp): persist immediate oauth connections (#22376 )	2026-04-14 13:56:45 -04:00
Goni ZahavyandGitHub	9a5178e4ac	fix(cli): handlePluginAuth asks for api key only if authorize method exists (#22475 )	2026-04-14 12:53:00 -05:00
Kit LangtonandGitHub	68384613be	refactor(session): remove async facade exports (#22471 )	2026-04-14 13:45:13 -04:00
Kit LangtonandGitHub	4f967d5bc0	improve bash timeout retry hint (#22390 )	2026-04-14 12:55:03 -04:00
Kit LangtonandGitHub	ff60859e36	fix(project): reuse runtime in instance boot (#22470 )	2026-04-14 12:53:13 -04:00
Kit LangtonandGitHub	020c47a055	refactor(project): remove async facade exports (#22387 )	2026-04-14 12:49:20 -04:00
opencode-agent[bot]	64171db173	chore: generate	2026-04-14 16:39:15 +00:00
Kit LangtonandGitHub	ad265797ab	refactor(share): remove session share async facade exports (#22386 )	2026-04-14 12:38:11 -04:00
Aiden ClineandGitHub	b1312a3181	core: prevent duplicate user messages in ACP clients (#22468 )	2026-04-14 11:37:33 -05:00
RAIT-09andGitHub	a8f9f6b705	fix(acp): stop emitting user_message_chunk during session/prompt turn (#21851 )	2026-04-14 11:25:00 -05:00
Aiden ClineandGitHub	d312c677c5	fix: rm effect logger from processor.ts, use old logger for now instead (#22460 )	2026-04-14 10:39:01 -05:00