refactor(core): bridge plugin runtime in app builder

.github/actions/setup-bun/action.yml

@@ -8,13 +8,6 @@ inputs:
 runs:
   using: "composite"
   steps:
-    # node-gyp@latest (invoked via bunx for native install scripts) requires Node >=22;
-    # some runner images ship an older system Node on PATH
-    - name: Setup Node
-      uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
-      with:
-        node-version: "24"
-
     - name: Get baseline download URL
       id: bun-url
       shell: bash

.github/workflows/typecheck.yml

@@ -2,9 +2,9 @@ name: typecheck
 
 on:
   push:
-    branches: [dev, v2]
+    branches: [dev]
   pull_request:
-    branches: [dev, v2]
+    branches: [dev]
   workflow_dispatch:
 
 jobs:

.opencode/plugins/sample-agent.ts

@@ -0,0 +1,16 @@
+export default {
+  id: "sample-agent-plugin",
+  setup: async (ctx) => {
+    await ctx.agent.transform((agents) => {
+      agents.update("sample-plugin-agent", (agent) => {
+        agent.description = "Example primary agent registered by .opencode/plugins/sample-agent.ts"
+        agent.mode = "primary"
+        agent.system = [
+          "You are the sample plugin agent for this repository.",
+          "Use this agent to verify that local plugin auto-discovery can add agents.",
+          "Keep responses concise and explain which plugin registered you when asked.",
+        ].join("\n")
+      })
+    })
+  },
+}

.opencode/skills/debug-opencode/SKILL.md

@@ -104,25 +104,6 @@ bun dev api <operationId> --param key=value
 - If no compatible background server is registered, `bun dev api` starts one through the daemon service. Use `bun dev service status`, `bun dev service restart`, and `bun dev service stop` when you need explicit lifecycle control.
 - Prefer raw method/path calls for quick server debugging and operation IDs when exercising documented OpenAPI routes with path or query parameters.
 
-## Auditing installed `opencode2` sessions
-
-Installed next-channel sessions normally use `~/.local/share/opencode/opencode-next.db` and `~/.local/share/opencode/log/opencode.log`; `OPENCODE_DB` can override the database. Before calling `opencode2 api`, inspect `~/.local/state/opencode/service.json` because the command may start a daemon when none is healthy.
-
-For a supplied `ses_...` ID, compare three sources:
-
-- `opencode2 api get /api/session/active` and the Session/message endpoints for live server state.
-- The database's ordered `event` rows for durable history.
-- `packages/tui/src/context/data.tsx` and the relevant route for client projection and rendering.
-
-Locate an uncertain database without modifying it:
-
-```bash
-SESSION=ses_...
-for db in ~/.local/share/opencode/*.db; do
-  sqlite3 "file:$db?mode=ro" "select 1 from session where id='$SESSION' limit 1" 2>/dev/null | grep -q 1 && printf '%s\n' "$db"
-done
-```
-
 ## Logs
 
 - Log files live under `~/.local/share/opencode/log/`. In a local/dev checkout the active file is `opencode-local.log`; `opencode.log` is used for non-local (released) channel installs. Both are append-only, shared across every CLI and server process on the machine.

AGENTS.md

@@ -151,15 +151,12 @@ const table = sqliteTable("session", {
 
 ## V2 Session Core
 
-- Keep durable events minimal: record irreducible new facts and do not repeat state derivable by folding the ordered aggregate history. Enrich projections and read models with previous or derived state when consumers need self-contained views.
 - Keep durable prompt admission separate from model execution. `SessionV2.prompt(...)` admits one durable `session_input` row before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. The serialized runner promotes admitted inputs into visible user messages at safe boundaries.
 - Reusing a Session ID adopts the existing Session. Reusing a prompt message ID reconciles an exact retry only when Session, prompt, and delivery mode match; conflicting reuse fails. Historical projected prompts lazily synthesize promoted inbox records during exact retry.
 - Keep `SessionExecution` process-global and Session-ID based. Its local implementation owns the process-local Session coordinator and discovers placement through `SessionStore` plus `LocationServiceMap.get(session.location)` only when a drain starts; no layer should take a Session ID. V2 interruption targets the active process-local ownership chain for that Session; idle or missing interruption is a no-op.
 - Keep `SessionRunner`, model resolution, tool registry, permissions, and filesystem Location-scoped. Omitted `Location.workspaceID` means implicit-local placement; explicit workspace identity remains reserved for future placement semantics.
-- Preserve one explicit `llm.stream(request)` call per step and reload projected history before durable continuation. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
+- Preserve one explicit `llm.stream(request)` call per provider turn and reload projected history before durable continuation. Do not bridge through legacy `SessionPrompt.loop(...)` or delegate orchestration to an in-memory tool loop.
 - Keep local Session drains process-local until clustering is implemented. `SessionRunCoordinator` joins explicit same-Session resumes, coalesces prompt wakeups, and allows different Sessions to run concurrently. Advisory wakes drain eligible durable inbox rows only; post-crash continuation recovery requires a separate explicit design before it may retry provider work. A drain has no durable identity or transcript boundary.
-- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe step boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's step allowance; a batch of steers resets it once.
-- One step is one logical LLM call; its durable record covers only the model-visible span. Do not write "provider turn", and do not use bare "turn" for a single call: "turn" is reserved for the future assistant-turn unit containing all steps from prompt promotion until the session would go idle.
+- Keep delivery vocabulary explicit. Prompts steer by default and promote at the next safe provider-turn boundary while the current drain requires continuation. An explicit `queue` input remains pending until the Session would otherwise become idle; promote one queued input at that boundary, then reevaluate continuation before promoting another. Promoting any new user input resets the selected agent's provider-turn allowance; a batch of steers resets it once.
 - Keep EventV2 replay owner claims separate from clustered Session execution ownership.
-- Keep the System Context algebra and built-ins in `src/system-context`; keep Context Source producers with their observed domains, and keep Session History selection plus Context Checkpoint persistence Session-owned. The runner composes all context producers explicitly in `loadSystemContext`; there is no context registry.
-- The durable Applied record is what the model was last told, per source. Reconcile narrates drift as chronological System updates and never rewrites the baseline; only completed compaction rebaselines, and move or committed revert resets the checkpoint. Unavailable sources keep the model's prior belief, blocking only a session's first baseline.
+- Keep the System Context algebra, registry, and built-ins in `src/system-context`; keep Context Source producers with their observed domains, and keep Session History selection plus Context Epoch persistence Session-owned.

CONTEXT.md

@@ -9,7 +9,7 @@ The structured collection of contextual facts presented to the model as initial
 _Avoid_: System prompt
 
 **Session History**:
-The projected chronological conversation selected for a **Step** after applying the active compaction and **Context Epoch** cutoffs.
+The projected chronological conversation selected for a provider turn after applying the active compaction and **Context Epoch** cutoffs.
 _Avoid_: Session Context
 
 **Context Source**:
@@ -31,13 +31,13 @@ The full **System Context** rendered at the start of a **Context Epoch**.
 _Avoid_: Live system prompt
 
 **Context Snapshot**:
-The overwriteable model-hidden JSON state used to compare each **Context Source** with the value last admitted to a **Step**.
+The overwriteable model-hidden JSON state used to compare each **Context Source** with the value last admitted to a provider turn.
 
 **Unavailable Context**:
 An expected temporary inability to observe a **Context Source** value; the runtime retains its prior effective state and emits no update, or omits it until first successfully loaded.
 
-**Safe Step Boundary**:
-The point immediately before a provider request, after durable input promotion and any required tool settlement, where context changes may be admitted chronologically.
+**Safe Provider-Turn Boundary**:
+The point immediately before a provider call, after durable input promotion and any required tool settlement, where context changes may be admitted chronologically.
 
 **Admitted Prompt**:
 A durable user input accepted into the Session inbox but not yet included in **Session History**.
@@ -45,24 +45,11 @@ A durable user input accepted into the Session inbox but not yet included in **S
 **Prompt Promotion**:
 The durable transition that removes an **Admitted Prompt** from pending input and appends its user message to **Session History**.
 
-**Step**:
-One logical LLM call spanning pre-flight context checkpoint preparation, input promotion, request build, and compaction check; the provider stream; and tool settlement.
-_Avoid_: provider turn, turn (unqualified)
-
-**Physical Attempt**:
-One actual provider request on the wire in service of a **Step**; most Steps have one Physical Attempt, while overflow-triggered compaction recovery may give one Step two.
-
-**Assistant Turn**:
-A reserved name for the not-yet-modeled unit containing all **Steps** from prompt promotion until the assistant yields the floor; do not reify it until something durable needs it.
-
-**Settlement**:
-The terminal transition for a unit of work: Step and tool settlement are durable, while drain and execution settlement are coordinator-observed.
-
-**Execution**:
-One session-scoped coordinator busy period from first wake until idle. An Execution is process-local coordination rather than a durable domain entity.
+**Provider Turn**:
+One request to a model provider and the response projected from that request.
 
 **Session Drain**:
-One process-local execution span that promotes eligible input and runs required **Steps** until no immediate continuation remains. A Session Drain has no durable identity or transcript boundary.
+One process-local execution span that promotes eligible input and runs required **Provider Turns** until no immediate continuation remains. A Session Drain has no durable identity or transcript boundary.
 
 **Model Tool Output**:
 The bounded projection of a Core-executed tool result persisted in Session history and replayed to the model. A tool may shape this projection semantically, but the Tool Registry enforces the final size limit.
@@ -102,25 +89,23 @@ _Avoid_: Response envelope
 
 - A **System Context** is an opaque carrier composed from zero or more **Context Sources**.
 - **Session History** contains projected conversational messages and admitted **Mid-Conversation System Messages**; the active **Baseline System Context** remains separate provider-request state.
-- The **System Context Registry** uses stable-keyed scoped contributions to assemble the current **System Context**; contributor removal naturally removes its sources at the next **Safe Step Boundary**.
+- The **System Context Registry** uses stable-keyed scoped contributions to assemble the current **System Context**; contributor removal naturally removes its sources at the next **Safe Provider-Turn Boundary**.
 - A changed **Context Source** may produce one **Mid-Conversation System Message** containing its newly effective state.
 - A **Mid-Conversation System Message** persists the exact combined rendered text sent to the model.
 - The current **Context Snapshot** advances atomically with the corresponding durable **Mid-Conversation System Message**.
 - A **Context Snapshot** stores one codec-encoded JSON value and, for removable dynamic sources, a pre-rendered removal message per stable **Context Source** key.
 - Changes from multiple **Context Sources** admitted at one safe boundary combine into one **Mid-Conversation System Message**.
-- Context changes are sampled and admitted lazily at a **Safe Step Boundary**, never pushed asynchronously when their source changes.
-- At a **Safe Step Boundary**, newly promoted user input or settled tool results precede any combined **Mid-Conversation System Message**.
+- Context changes are sampled and admitted lazily at a **Safe Provider-Turn Boundary**, never pushed asynchronously when their source changes.
+- At a **Safe Provider-Turn Boundary**, newly promoted user input or settled tool results precede any combined **Mid-Conversation System Message**.
 - An **Admitted Prompt** is replayable pending input, not yet model-visible **Session History**.
 - **Prompt Promotion** atomically consumes the pending inbox entry and appends its model-visible user message.
-- Steering prompts promote at the next **Safe Step Boundary** while the current **Session Drain** still requires continuation. Promoting any newly admitted user input resets the selected agent's step allowance; multiple prompts promoted at one boundary reset it once.
+- Steering prompts promote at the next **Safe Provider-Turn Boundary** while the current **Session Drain** still requires continuation. Promoting any newly admitted user input resets the selected agent's provider-turn allowance; multiple prompts promoted at one boundary reset it once.
 - A queued prompt does not promote while the current **Session Drain** requires continuation. The runner promotes one queued prompt when the Session would otherwise become idle, then reevaluates continuation before promoting another.
-- A **Session Drain** is process-local coordination rather than a durable domain entity. Durable recovery must reason from prompts, projected history, physical attempts, and tool state rather than inventing an enclosing execution identity.
-- An **Execution** contains one or more **Session Drains**; a **Session Drain** contains one reserved assistant-turn span at a time; that span contains **Steps**; and each **Step** contains one or more **Physical Attempts** plus any tool calls it requires.
-- A **Step** record covers only the model-visible span from first assistant output through tool settlement; pre-flight leaves no record, and one Step settles at most one record.
-- The first **Step** renders the latest complete **Baseline System Context** and initializes its **Context Snapshot** without emitting a redundant **Mid-Conversation System Message**; unavailable initial context blocks the Step instead of persisting an incomplete baseline.
+- A **Session Drain** is process-local coordination rather than a durable domain entity. Durable recovery must reason from prompts, projected history, provider attempts, and tool state rather than inventing an enclosing execution identity.
+- The first provider turn renders the latest complete **Baseline System Context** and initializes its **Context Snapshot** without emitting a redundant **Mid-Conversation System Message**; unavailable initial context blocks the turn instead of persisting an incomplete baseline.
 - Initial **System Context** preparation precedes the first durable input promotion so an unavailable baseline leaves that input pending and retryable; ordinary reconciliation remains after promotion.
 - Compaction starts a new **Context Epoch** with a freshly rendered **Baseline System Context** and **Context Snapshot**; prior **Mid-Conversation System Messages** remain durable audit history but leave projected model history.
-- A newly registered core or plugin-defined **Context Source** absent from the current snapshot emits its baseline rendering once at the next **Safe Step Boundary**.
+- A newly registered core or plugin-defined **Context Source** absent from the current snapshot emits its baseline rendering once at the next **Safe Provider-Turn Boundary**.
 - **Context Source** keys are stable and namespaced; duplicate keys fail composition. `SystemContext.combine(...)` preserves caller order; the **System Context Registry** evaluates producers concurrently and combines them in stable contribution-key order so rendered context remains deterministic.
 - Each **Context Source** loader returns one coherent typed value. `SystemContext.make(...)` hides that value type so differently typed sources compose uniformly. Its codec compares and stores that value; its pure renderers produce model-visible baseline, update, and removal text only when needed.
 - `SystemContext.initialize(...)` observes a composed **System Context** once and produces a fresh **Baseline System Context** with its **Context Snapshot**.
@@ -128,26 +113,26 @@ _Avoid_: Response envelope
 - `SystemContext.replace(...)` renders a fresh generation after completed compaction or another baseline-replacing transition; it reports replacement blocked while previously admitted context is unavailable.
 - **Unavailable Context** uses stale-while-revalidate semantics and is distinct from a successfully loaded absence, which may emit removal text.
 - Ordinary **Context Source** loaders return values directly; loaders that intentionally use stale-while-revalidate may explicitly return **Unavailable Context**.
-- Nested project instruction discovery after successful reads remains a follow-up; when implemented, discovered instructions must be admitted durably at the next **Safe Step Boundary**.
+- Nested project instruction discovery after successful reads remains a follow-up; when implemented, discovered instructions must be admitted durably at the next **Safe Provider-Turn Boundary**.
 - Location-scoped services naturally re-resolve effective context when a moved session next runs in its destination location.
 - Moving a Session clears its active **Context Epoch**, so the destination must initialize a complete baseline before another prompt can promote.
 - Instruction discovery, source identity, persistence, and file loading belong to the instruction service; the **System Context** abstraction only composes effectful producers and renders loaded values.
-- The first instruction-service slice observes global and upward project `AGENTS.md` files as one ordered aggregate **Context Source** at each **Safe Step Boundary**.
+- The first instruction-service slice observes global and upward project `AGENTS.md` files as one ordered aggregate **Context Source** at each **Safe Provider-Turn Boundary**.
 - Built-in and instruction context producers register through the **System Context Registry** with stable contribution keys. Plugin-defined context registration and hot-reload lifecycle remain a follow-up built on the same scoped registry seam.
 - Selected-agent available-skill guidance is a **Context Source** composed with Location-wide registry sources immediately before Context Epoch admission. It lists only names and descriptions permitted for that agent; skill bodies and locations are exposed only through the permission-checked `skill` tool.
-- The selected agent and model are sampled when a **Step** starts. Changes admitted after that boundary apply to the next Step and do not restart the current Step.
+- The selected agent and model are sampled when a provider turn starts. Changes admitted after that boundary apply to the next provider turn and do not restart the current turn.
 - Selected-agent available-skill guidance remains a **Context Source**. An agent switch that changes that guidance produces a **Mid-Conversation System Message** while preserving the current baseline.
-- Local tool authorization and pending permission requests retain the effective agent of the **Step** that issued the call; a later agent switch cannot change that call's policy.
-- Context source changes never wake idle sessions; the next naturally scheduled **Safe Step Boundary** loads and compares current values lazily.
-- Once admitted, a **Mid-Conversation System Message** remains durable even if the following **Physical Attempt** fails and is replayed unchanged on retry.
+- Local tool authorization and pending permission requests retain the effective agent of the provider turn that issued the call; a later agent switch cannot change that call's policy.
+- Context source changes never wake idle sessions; the next naturally scheduled **Safe Provider-Turn Boundary** loads and compares current values lazily.
+- Once admitted, a **Mid-Conversation System Message** remains durable even if the following provider attempt fails and is replayed unchanged on retry.
 - **Mid-Conversation System Messages** remain durable Session-message history; normal user-facing transcript surfaces may hide them.
 - The date **Context Source** initially preserves host-local calendar-date behavior; a configured user timezone may replace that default later.
 - A **Context Epoch** begins with one immutable **Baseline System Context**.
 - A **Baseline System Context** is stored durably and reused verbatim across process restarts within its **Context Epoch**.
 - A **Baseline System Context** durably preserves the exact joined text used for the active provider-cache prefix.
-- Completed compaction starts a new **Context Epoch** on the next **Physical Attempt**, folding the current complete **System Context** into a fresh baseline and removing earlier **Mid-Conversation System Messages** from active model history.
-- A model/provider switch preserves the current **Context Epoch** and chronological conversation history; the new selection applies to the next **Step**.
-- **Native Continuation Metadata** remains in durable history. Step projection includes it only for a successful exact originating provider/model match; failed Steps and incompatible models omit opaque metadata, while non-empty visible reasoning lowers to ordinary assistant text after a model switch. This conservative relation may widen only when recorded provider tests establish compatibility.
+- Completed compaction starts a new **Context Epoch** on the next provider attempt, folding the current complete **System Context** into a fresh baseline and removing earlier **Mid-Conversation System Messages** from active model history.
+- A model/provider switch preserves the current **Context Epoch** and chronological conversation history; the new selection applies to the next provider turn.
+- **Native Continuation Metadata** remains in durable history. Provider-turn projection includes it only for a successful exact originating provider/model match; failed turns and incompatible models omit opaque metadata, while non-empty visible reasoning lowers to ordinary assistant text after a model switch. This conservative relation may widen only when recorded provider tests establish compatibility.
 - **Model Request Options** remain provider-semantic through Catalog resolution. The Session runner maps them into the LLM package's provider-option namespace; the selected protocol adapter alone owns provider wire encoding.
 - **Generation Controls**, protocol-semantic **Model Request Options**, and compatibility request body fields are separate Catalog domains. A shared ingestion adapter partitions legacy and models.dev AI-SDK-shaped options before routing.
 - The **PTY Environment** is a server concern rather than a Core PTY concern. PTY creation merges caller values, then the host overlay, then Core-forced terminal invariants such as `TERM` and `OPENCODE_TERMINAL`.

package.json

@@ -14,8 +14,6 @@
     "dev:stats": "bun sst shell --stage=production -- bun run --cwd packages/stats/app dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "lint": "oxlint",
-    "lint:effect-patterns": "ast-grep scan -c script/ast-grep/sgconfig.yml packages/core/src packages/server/src packages/protocol/src packages/cli/src",
-    "test:lint-rules": "ast-grep test -c script/ast-grep/sgconfig.yml",
     "typecheck": "bun turbo typecheck",
     "upgrade-opentui": "bun run script/upgrade-opentui.ts",
     "postinstall": "bun run --cwd packages/core fix-node-pty",
@@ -42,9 +40,9 @@
       "@octokit/rest": "22.0.0",
       "@hono/standard-validator": "0.2.0",
       "@hono/zod-validator": "0.4.2",
-      "@opentui/core": "0.4.3",
-      "@opentui/keymap": "0.4.3",
-      "@opentui/solid": "0.4.3",
+      "@opentui/core": "0.3.4",
+      "@opentui/keymap": "0.3.4",
+      "@opentui/solid": "0.3.4",
       "@tanstack/solid-virtual": "3.13.28",
       "@shikijs/stream": "4.2.0",
       "ulid": "3.0.1",
@@ -97,7 +95,6 @@
   },
   "devDependencies": {
     "@actions/artifact": "5.0.1",
-    "@ast-grep/cli": "0.44.0",
     "@tsconfig/bun": "catalog:",
     "@types/mime-types": "3.0.1",
     "@typescript/native-preview": "catalog:",

packages/app/src/components/dialog-custom-provider.tsx

@@ -177,7 +177,7 @@ export function DialogCustomProvider(props: Props) {
     >
       <div class="flex flex-col gap-6 px-2.5 pb-3 overflow-y-auto max-h-[60vh]">
         <div class="px-2.5 flex gap-4 items-center">
-          <ProviderIcon id="session.synthetic" class="size-5 shrink-0 icon-strong-base" />
+          <ProviderIcon id="synthetic" class="size-5 shrink-0 icon-strong-base" />
           <div class="text-16-medium text-text-strong">{language.t("provider.custom.title")}</div>
         </div>
 

packages/app/src/components/settings-providers.tsx

@@ -226,7 +226,7 @@ const SettingsProvidersContent: Component = () => {
             >
               <div class="flex flex-col min-w-0">
                 <div class="flex flex-wrap items-center gap-x-3 gap-y-1">
-                  <ProviderIcon id="session.synthetic" class="size-5 shrink-0 icon-strong-base" />
+                  <ProviderIcon id="synthetic" class="size-5 shrink-0 icon-strong-base" />
                   <span class="text-14-medium text-text-strong">{language.t("provider.custom.title")}</span>
                   <Tag>{language.t("settings.providers.tag.custom")}</Tag>
                 </div>

packages/app/src/components/settings-v2/providers.tsx

@@ -223,7 +223,7 @@ export const SettingsProvidersV2: Component = () => {
             <div class="settings-v2-provider-row" data-component="custom-provider-section">
               <div class="settings-v2-provider-lead">
                 <ProviderIcon
-                  id="session.synthetic"
+                  id="synthetic"
                   width={PROVIDER_ICON_SIZE}
                   height={PROVIDER_ICON_SIZE}
                   class="settings-v2-provider-icon shrink-0"

packages/app/src/context/file/watcher.test.ts

@@ -7,7 +7,7 @@ describe("file watcher invalidation", () => {
     const refresh: string[] = []
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src/new.ts",
           event: "add",
@@ -32,7 +32,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src/open.ts",
           event: "change",
@@ -63,7 +63,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src",
           event: "change",
@@ -81,7 +81,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: "src/file.ts",
           event: "change",
@@ -111,7 +111,7 @@ describe("file watcher invalidation", () => {
 
     invalidateFromWatcher(
       {
-        type: "filesystem.changed",
+        type: "file.watcher.updated",
         properties: {
           file: ".git/index.lock",
           event: "change",

packages/app/src/context/file/watcher.ts

@@ -16,7 +16,7 @@ type WatcherOps = {
 }
 
 export function invalidateFromWatcher(event: WatcherEvent, ops: WatcherOps) {
-  if (event.type !== "filesystem.changed") return
+  if (event.type !== "file.watcher.updated") return
   const props =
     typeof event.properties === "object" && event.properties ? (event.properties as Record<string, unknown>) : undefined
   const rawPath = typeof props?.file === "string" ? props.file : undefined

packages/app/src/pages/session.tsx

@@ -820,7 +820,7 @@ export default function Page() {
   )
 
   const stopVcs = sdk().event.listen((evt) => {
-    if (evt.details.type !== "filesystem.changed") return
+    if (evt.details.type !== "file.watcher.updated") return
     const props =
       typeof evt.details.properties === "object" && evt.details.properties
         ? (evt.details.properties as Record<string, unknown>)

packages/cli/package.json

@@ -10,46 +10,25 @@
   "files": [
     "bin"
   ],
-  "exports": {
-    "./daemon": "./src/daemon.ts",
-    "./mini": "./src/mini/index.ts",
-    "./mini/footer.command": "./src/mini/footer.command.tsx",
-    "./mini/footer.menu": "./src/mini/footer.menu.tsx",
-    "./mini/footer.permission": "./src/mini/footer.permission.tsx",
-    "./mini/footer.prompt": "./src/mini/footer.prompt.tsx",
-    "./mini/footer.question": "./src/mini/footer.question.tsx",
-    "./mini/footer.subagent": "./src/mini/footer.subagent.tsx",
-    "./mini/footer.view": "./src/mini/footer.view.tsx",
-    "./mini/scrollback.writer": "./src/mini/scrollback.writer.tsx",
-    "./mini/*": "./src/mini/*.ts",
-    "./server-process": "./src/server-process.ts"
-  },
   "scripts": {
     "build": "bun run script/build.ts",
     "dev": "bun run src/index.ts",
-    "test": "bun test --timeout 30000 --only-failures",
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
     "@effect/platform-node": "catalog:",
     "@opencode-ai/client": "workspace:*",
     "@opencode-ai/core": "workspace:*",
-    "@opencode-ai/plugin": "workspace:*",
-    "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/server": "workspace:*",
     "@opencode-ai/tui": "workspace:*",
     "@opentui/core": "catalog:",
-    "@opentui/keymap": "catalog:",
     "@opentui/solid": "catalog:",
     "@parcel/watcher": "2.5.1",
     "effect": "catalog:",
-    "fuzzysort": "catalog:",
     "jsonc-parser": "3.3.1",
-    "opentui-spinner": "catalog:",
     "semver": "catalog:",
-    "solid-js": "catalog:",
-    "strip-ansi": "7.1.2"
+    "solid-js": "catalog:"
   },
   "devDependencies": {
     "@opencode-ai/script": "workspace:*",

packages/cli/src/commands/commands.ts

@@ -3,31 +3,6 @@ import { Spec } from "../framework/spec"
 
 declare const OPENCODE_CLI_NAME: string | undefined
 
-const MiniParams = {
-  continue: Flag.boolean("continue").pipe(
-    Flag.withAlias("c"),
-    Flag.withDescription("Continue the last session"),
-    Flag.withDefault(false),
-  ),
-  session: Flag.string("session").pipe(
-    Flag.withAlias("s"),
-    Flag.withDescription("Session ID to continue"),
-    Flag.optional,
-  ),
-  fork: Flag.boolean("fork").pipe(
-    Flag.withDescription("Fork the session when continuing"),
-    Flag.withDefault(false),
-  ),
-  replay: Flag.boolean("replay").pipe(
-    Flag.withDescription("Replay session history on resume and after resize"),
-    Flag.withDefault(true),
-  ),
-  replayLimit: Flag.integer("replay-limit").pipe(
-    Flag.withDescription("Cap visible replay to the newest N messages"),
-    Flag.optional,
-  ),
-}
-
 export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
   description: "OpenCode 2.0 preview command line interface",
   params: {
@@ -39,10 +14,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       Flag.withDescription("Run with a private server instead of the background service"),
       Flag.withDefault(false),
     ),
-    server: Flag.string("server").pipe(
-      Flag.withDescription("Connect to a server URL instead of the background service"),
-      Flag.optional,
-    ),
     continue: Flag.boolean("continue").pipe(
       Flag.withAlias("c"),
       Flag.withDescription("Continue the last session"),
@@ -113,86 +84,6 @@ export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCO
       ],
     }),
     Spec.make("migrate", { description: "Migrate v1 data to v2" }),
-    Spec.make("mini", {
-      description: "Start the minimal interactive interface",
-      params: {
-        ...MiniParams,
-        project: Argument.string("project").pipe(
-          Argument.withDescription("Path to start OpenCode in"),
-          Argument.optional,
-        ),
-        model: Flag.string("model").pipe(
-          Flag.withAlias("m"),
-          Flag.withDescription("Model to use in the format provider/model"),
-          Flag.optional,
-        ),
-        agent: Flag.string("agent").pipe(Flag.withDescription("Agent to use"), Flag.optional),
-        prompt: Flag.string("prompt").pipe(Flag.withDescription("Prompt to use"), Flag.optional),
-        server: Flag.string("server").pipe(
-          Flag.withDescription("Connect to a server URL instead of the background service"),
-          Flag.optional,
-        ),
-        demo: Flag.boolean("demo").pipe(Flag.withDefault(false), Flag.withHidden),
-      },
-    }),
-    Spec.make("run", {
-      description: "Run OpenCode with a message",
-      params: {
-        message: Argument.string("message").pipe(
-          Argument.withDescription("Message to send"),
-          Argument.variadic({ min: 0 }),
-        ),
-        continue: Flag.boolean("continue").pipe(
-          Flag.withAlias("c"),
-          Flag.withDescription("Continue the last session"),
-          Flag.withDefault(false),
-        ),
-        session: Flag.string("session").pipe(
-          Flag.withAlias("s"),
-          Flag.withDescription("Session ID to continue"),
-          Flag.optional,
-        ),
-        fork: Flag.boolean("fork").pipe(
-          Flag.withDescription("Fork the session before continuing"),
-          Flag.withDefault(false),
-        ),
-        model: Flag.string("model").pipe(
-          Flag.withAlias("m"),
-          Flag.withDescription("Model to use in the format provider/model"),
-          Flag.optional,
-        ),
-        agent: Flag.string("agent").pipe(Flag.withDescription("Agent to use"), Flag.optional),
-        format: Flag.choice("format", ["default", "json"]).pipe(
-          Flag.withDescription("Output format"),
-          Flag.withDefault("default"),
-        ),
-        file: Flag.string("file").pipe(
-          Flag.withAlias("f"),
-          Flag.withDescription("File to attach to the message"),
-          Flag.atMost(100),
-        ),
-        title: Flag.string("title").pipe(Flag.withDescription("Session title"), Flag.optional),
-        server: Flag.string("server").pipe(
-          Flag.withDescription("Connect to a server URL instead of the background service"),
-          Flag.optional,
-        ),
-        dir: Flag.string("dir").pipe(Flag.withDescription("Directory to run in"), Flag.optional),
-        variant: Flag.string("variant").pipe(Flag.withDescription("Model variant"), Flag.optional),
-        thinking: Flag.boolean("thinking").pipe(
-          Flag.withDescription("Show thinking blocks"),
-          Flag.withDefault(false),
-        ),
-        auto: Flag.boolean("auto").pipe(
-          Flag.withDescription("Auto-approve permissions that are not explicitly denied"),
-          Flag.withDefault(false),
-        ),
-        yolo: Flag.boolean("yolo").pipe(Flag.withDefault(false), Flag.withHidden),
-        dangerouslySkipPermissions: Flag.boolean("dangerously-skip-permissions").pipe(
-          Flag.withDefault(false),
-          Flag.withHidden,
-        ),
-      },
-    }),
     Spec.make("service", {
       description: "Manage the background server",
       commands: [

packages/cli/src/commands/handlers/api.ts

@@ -2,8 +2,7 @@ import { EOL } from "node:os"
 import { Effect, Option } from "effect"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
-import { Service } from "@opencode-ai/client/effect"
-import { ServiceConfig } from "../../services/service-config"
+import { Daemon } from "../../services/daemon"
 
 const methods = new Set(["delete", "get", "head", "options", "patch", "post", "put"])
 
@@ -18,9 +17,8 @@ type OpenApi = {
 export default Runtime.handler(
   Commands.commands.api,
   Effect.fn("cli.api")(function* (input) {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const transport = found ?? (yield* Service.start(options))
+    const daemon = yield* Daemon.Service
+    const transport = yield* daemon.transport()
     const params = Option.getOrElse(input.param, () => ({}))
     const request = yield* resolveRequest(transport, input.request, params)
     const headers = new Headers(transport.headers)
@@ -60,7 +58,7 @@ export function rawRequest(input: readonly string[]) {
 }
 
 function resolveRequest(
-  transport: Service.Transport,
+  transport: { url: string; headers: RequestInit["headers"] },
   input: readonly string[],
   params: Record<string, string>,
 ) {

packages/cli/src/commands/handlers/debug/agents.ts

@@ -1,18 +1,14 @@
 import { EOL } from "os"
-import { Effect } from "effect"
-import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { Service } from "@opencode-ai/client/effect"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.debug.commands.agents,
   Effect.fn("cli.debug.agents")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const transport = found ?? (yield* Service.start(options))
-    const client = createOpencodeClient({ baseUrl: transport.url, headers: transport.headers })
+    const daemon = yield* Daemon.Service
+    const client = yield* daemon.client()
     const response = yield* Effect.promise(() => client.v2.agent.list({ location: { directory: process.cwd() } }))
     process.stdout.write(
       JSON.stringify(

packages/cli/src/commands/handlers/default.ts

@@ -1,10 +1,7 @@
-import { NodeFileSystem } from "@effect/platform-node"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
-import { Effect, Option, Redacted } from "effect"
-import { Service } from "@opencode-ai/client/effect"
-import { Env } from "../../env"
-import { ServiceConfig } from "../../services/service-config"
+import { Effect, Option } from "effect"
+import { Daemon } from "../../services/daemon"
 import { Standalone } from "../../services/standalone"
 import { Updater } from "../../services/updater"
 
@@ -14,76 +11,18 @@ export default Runtime.handler(Commands, (input) =>
     if (directory !== undefined) process.chdir(directory)
     const updater = yield* Updater.Service
     yield* updater.check().pipe(Effect.forkScoped)
-    const server = Option.getOrUndefined(input.server)
-    if (server !== undefined && input.standalone)
-      return yield* Effect.fail(new Error("--server and --standalone cannot be combined"))
-    const transport = yield* Effect.gen(function* () {
-      if (server !== undefined) {
-        const password = yield* Env.password
-        const explicit = {
-          url: server,
-          headers: password
-            ? { authorization: "Basic " + btoa("opencode:" + Redacted.value(password)) }
-            : undefined,
-        } satisfies Service.Transport
-        // Fail loudly before entering the TUI: an explicit server that is
-        // unreachable or rejects auth should not present as reconnect churn.
-        const response = yield* Effect.tryPromise(() =>
-          fetch(new URL("/api/health", server), { headers: explicit.headers, signal: AbortSignal.timeout(5_000) }),
-        ).pipe(Effect.mapError((cause) => new Error(`Could not reach server at ${server}`, { cause })))
-        if (response.status === 401)
-          return yield* Effect.fail(
-            new Error(
-              password
-                ? `Server at ${server} rejected the password`
-                : `Server at ${server} requires a password; set OPENCODE_PASSWORD`,
-            ),
-          )
-        if (!response.ok)
-          return yield* Effect.fail(new Error(`Server at ${server} responded with status ${response.status}`))
-        return explicit
-      }
-      if (input.standalone) return yield* Standalone.transport()
-      const options = yield* ServiceConfig.options()
-      const found = yield* Service.discover(options)
-      return found ?? (yield* Service.start(options))
-    })
+    const daemon = yield* Daemon.Service
+    const transport = yield* (input.standalone ? Standalone.transport() : daemon.transport())
     const { runTui } = yield* Effect.promise(() => import("../../tui"))
-    // The TUI re-runs discover whenever its event stream drops. For an explicit
-    // --server or a standalone child the transport is fixed, so reconnects
-    // retry the same address; for the managed service discovery re-reads the
-    // registration and may start a replacement.
-    const serviceOptions = server === undefined && !input.standalone ? yield* ServiceConfig.options() : undefined
-    // Only startup enforces the CLI version. A reconnect must accept a server
-    // replaced by another client or the two clients will restart it forever.
-    const reconnectOptions = serviceOptions ? { ...serviceOptions, version: undefined } : undefined
-    const discover = reconnectOptions
-      ? () =>
-          Effect.runPromise(
-            Effect.gen(function* () {
-              const found = yield* Service.discover(reconnectOptions)
-              return found ?? (yield* Service.start(reconnectOptions))
-            }).pipe(Effect.provide(NodeFileSystem.layer)),
-          )
-      : () => Promise.resolve(transport)
-    // Restart the managed service in place; start() resolves once the
-    // replacement is healthy and the reconnect loop reattaches on its own.
-    // Only meaningful in service mode: --server is not ours to restart and a
-    // standalone child cannot be respawned.
-    const reload = serviceOptions
-      ? () =>
-          Effect.runPromise(
-            Effect.gen(function* () {
-              yield* Service.stop(serviceOptions)
-              yield* Service.start(serviceOptions)
-            }).pipe(Effect.provide(NodeFileSystem.layer)),
-          )
-      : undefined
     yield* runTui(
       transport,
       { continue: input.continue, sessionID: Option.getOrUndefined(input.session) },
-      discover,
-      reload,
+      input.standalone
+        ? undefined
+        : async () => {
+            await Effect.runPromise(daemon.stop())
+            return Effect.runPromise(daemon.transport())
+          },
     )
   }),
 )

packages/cli/src/commands/handlers/mcp/auth.ts

@@ -1,15 +1,9 @@
 import { EOL } from "node:os"
 import { Effect } from "effect"
-import {
-  createOpencodeClient,
-  type IntegrationAttemptStatus,
-  type IntegrationOAuthMethod,
-  type OpencodeClient,
-} from "@opencode-ai/sdk/v2/client"
+import type { IntegrationAttemptStatus, IntegrationOAuthMethod, OpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { Service } from "@opencode-ai/client/effect"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 import { resolveIntegration } from "./resolve"
 
 const location = { directory: process.cwd() }
@@ -17,10 +11,8 @@ const location = { directory: process.cwd() }
 export default Runtime.handler(
   Commands.commands.mcp.commands.auth,
   Effect.fn("cli.mcp.auth")(function* (input) {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const transport = found ?? (yield* Service.start(options))
-    const client = createOpencodeClient({ baseUrl: transport.url, headers: transport.headers })
+    const daemon = yield* Daemon.Service
+    const client = yield* daemon.client()
 
     const integration = yield* resolveIntegration(client, input.name, location)
     if (!integration)

packages/cli/src/commands/handlers/mcp/list.ts

@@ -1,18 +1,15 @@
 import { EOL } from "node:os"
-import { Effect } from "effect"
-import { createOpencodeClient, type McpServer } from "@opencode-ai/sdk/v2/client"
+import * as Effect from "effect/Effect"
+import type { McpServer } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { Service } from "@opencode-ai/client/effect"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.mcp.commands.list,
   Effect.fn("cli.mcp.list")(function* () {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const transport = found ?? (yield* Service.start(options))
-    const client = createOpencodeClient({ baseUrl: transport.url, headers: transport.headers })
+    const daemon = yield* Daemon.Service
+    const client = yield* daemon.client()
     const response = yield* Effect.promise(() => client.v2.mcp.list({ location: { directory: process.cwd() } }))
     const servers = (response.data?.data ?? []).toSorted((a, b) => a.name.localeCompare(b.name))
     if (servers.length === 0) {

packages/cli/src/commands/handlers/mcp/logout.ts

@@ -1,10 +1,8 @@
 import { EOL } from "node:os"
 import { Effect } from "effect"
-import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { Service } from "@opencode-ai/client/effect"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 import { resolveIntegration } from "./resolve"
 
 const location = { directory: process.cwd() }
@@ -12,10 +10,8 @@ const location = { directory: process.cwd() }
 export default Runtime.handler(
   Commands.commands.mcp.commands.logout,
   Effect.fn("cli.mcp.logout")(function* (input) {
-    const options = yield* ServiceConfig.options()
-    const found = yield* Service.discover(options)
-    const transport = found ?? (yield* Service.start(options))
-    const client = createOpencodeClient({ baseUrl: transport.url, headers: transport.headers })
+    const daemon = yield* Daemon.Service
+    const client = yield* daemon.client()
 
     const integration = yield* resolveIntegration(client, input.name, location)
     if (!integration) {

packages/cli/src/commands/handlers/migrate.ts

@@ -1,4 +1,4 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
 

packages/cli/src/commands/handlers/mini.ts

@@ -1,35 +0,0 @@
-import { Effect, Option, Redacted } from "effect"
-import path from "node:path"
-import { Commands } from "../commands"
-import { Env } from "../../env"
-import { Runtime } from "../../framework/runtime"
-
-export default Runtime.handler(Commands.commands.mini, (input) =>
-  Effect.gen(function* () {
-    const { runMini } = yield* Effect.promise(() => import("../../mini"))
-    const project = Option.getOrUndefined(input.project)
-    const server = Option.getOrUndefined(input.server)
-    const password = yield* Env.password
-    yield* Effect.promise(() =>
-      runMini({
-        attach: server,
-        password: password ? Redacted.value(password) : undefined,
-        directory:
-          server !== undefined
-            ? project
-            : project === undefined
-              ? process.cwd()
-              : path.resolve(process.env.PWD ?? process.cwd(), project),
-        continue: input.continue,
-        session: Option.getOrUndefined(input.session),
-        fork: input.fork,
-        model: Option.getOrUndefined(input.model),
-        agent: Option.getOrUndefined(input.agent),
-        prompt: Option.getOrUndefined(input.prompt),
-        replay: input.replay,
-        replayLimit: Option.getOrUndefined(input.replayLimit),
-        demo: input.demo,
-      }),
-    )
-  }),
-)

packages/cli/src/commands/handlers/run.ts

@@ -1,31 +0,0 @@
-import { Effect, Option, Redacted } from "effect"
-import { Commands } from "../commands"
-import { Env } from "../../env"
-import { Runtime } from "../../framework/runtime"
-
-export default Runtime.handler(Commands.commands.run, (input) =>
-  Effect.gen(function* () {
-    const { runNonInteractive } = yield* Effect.promise(() => import("../../mini"))
-    const password = yield* Env.password
-    const separator = process.argv.indexOf("--", 2)
-    yield* Effect.promise(() =>
-      runNonInteractive({
-        message: [...input.message, ...(separator === -1 ? [] : process.argv.slice(separator + 1))],
-        continue: input.continue,
-        session: Option.getOrUndefined(input.session),
-        fork: input.fork,
-        model: Option.getOrUndefined(input.model),
-        agent: Option.getOrUndefined(input.agent),
-        format: input.format,
-        file: [...input.file],
-        title: Option.getOrUndefined(input.title),
-        server: Option.getOrUndefined(input.server),
-        password: password ? Redacted.value(password) : undefined,
-        directory: Option.getOrUndefined(input.dir),
-        variant: Option.getOrUndefined(input.variant),
-        thinking: input.thinking,
-        dangerouslySkipPermissions: input.auto || input.yolo || input.dangerouslySkipPermissions,
-      }),
-    )
-  }),
-)

packages/cli/src/commands/handlers/serve.ts

@@ -1,16 +1,94 @@
-import { Effect, Option } from "effect"
+import { NodeHttpServer } from "@effect/platform-node"
+import { Credential } from "@opencode-ai/core/credential"
+import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
+import { LayerNode } from "@opencode-ai/core/effect/layer-node"
+import { PermissionSaved } from "@opencode-ai/core/permission/saved"
+import { Global } from "@opencode-ai/core/global"
+import { Context, Layer, Option, Schedule } from "effect"
+import * as Effect from "effect/Effect"
+import { HttpRouter, HttpServer } from "effect/unstable/http"
+import { createServer } from "node:http"
+import { createRoutes } from "@opencode-ai/server/routes"
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import { Commands } from "../commands"
 import { Runtime } from "../../framework/runtime"
-import { ServerProcess } from "../../server-process"
+import { Daemon } from "../../services/daemon"
+import { Updater } from "../../services/updater"
+import { randomBytes } from "crypto"
 
 export default Runtime.handler(
   Commands.commands.serve,
   Effect.fn("cli.serve")(function* (input) {
-    if (input.service && input.stdio) return yield* Effect.fail(new Error("--service and --stdio cannot be combined"))
-    return yield* ServerProcess.run({
-      mode: input.service ? "service" : input.stdio ? "stdio" : "default",
-      hostname: Option.getOrUndefined(input.hostname),
-      port: Option.getOrUndefined(input.port),
-    })
+    if (input.service) yield* Effect.sync(() => process.chdir(Global.Path.home))
+    return yield* Effect.scoped(
+      Effect.gen(function* () {
+        const daemon = yield* Daemon.Service
+        const standalonePassword = process.env.OPENCODE_SERVER_PASSWORD
+        if (input.stdio) delete process.env.OPENCODE_SERVER_PASSWORD
+        const config = input.service ? yield* daemon.config() : {}
+        const password = input.service
+          ? yield* daemon.password()
+          : standalonePassword || randomBytes(32).toString("base64url")
+        if (!password) return yield* Effect.fail(new Error("Missing server password"))
+        const hostname = Option.getOrUndefined(input.hostname) ?? config.hostname ?? "127.0.0.1"
+        const port = Option.isSome(input.port)
+          ? input.port
+          : config.port === undefined
+            ? Option.none<number>()
+            : Option.some(config.port)
+        const address = yield* listen(hostname, port, password)
+        yield* Effect.tryPromise(() =>
+          createOpencodeClient({
+            baseUrl: HttpServer.formatAddress(address),
+            headers: ServerAuth.headers({ password }),
+          }).v2.health.get({}),
+        )
+        if (input.service) yield* daemon.register(address)
+        const url = HttpServer.formatAddress(address)
+        console.log(input.stdio ? JSON.stringify({ url }) : `server listening on ${url}`)
+        if (!input.service && !input.stdio && !standalonePassword) console.log(`server password ${password}`)
+        const updater = yield* Updater.Service
+        yield* updater.check().pipe(Effect.schedule(Schedule.spaced("10 minutes")), Effect.forkScoped)
+        return yield* (input.stdio ? waitForStdinClose() : Effect.never)
+      }).pipe(Effect.annotateLogs({ role: "server" })),
+    )
   }),
 )
+
+function waitForStdinClose() {
+  return Effect.callback<void>((resume) => {
+    const close = () => resume(Effect.void)
+    process.stdin.once("end", close)
+    process.stdin.once("close", close)
+    process.stdin.resume()
+    if (process.stdin.readableEnded || process.stdin.destroyed) close()
+    return Effect.sync(() => {
+      process.stdin.off("end", close)
+      process.stdin.off("close", close)
+      process.stdin.pause()
+    })
+  })
+}
+
+function listen(hostname: string, port: Option.Option<number>, password: string) {
+  if (Option.isSome(port)) return bind(hostname, port.value, password)
+  const next = (port: number): ReturnType<typeof bind> =>
+    bind(hostname, port, password).pipe(
+      Effect.catch((error) => (port === 65_535 ? Effect.fail(error) : next(port + 1))),
+    )
+  return next(4096)
+}
+
+function bind(hostname: string, port: number, password: string) {
+  const server = createServer()
+  return Layer.build(
+    HttpRouter.serve(createRoutes(password), { disableListenLog: true, disableLogger: true }).pipe(
+      Layer.provideMerge(NodeHttpServer.layer(() => server, { port, host: hostname })),
+      Layer.provide(AppNodeBuilder.build(LayerNode.group([Credential.node, PermissionSaved.node]))),
+    ),
+  ).pipe(
+    Effect.tap(() => Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()))),
+    Effect.map((context) => Context.get(context, HttpServer.HttpServer).address),
+  )
+}

packages/cli/src/commands/handlers/service/get.ts

@@ -1,12 +1,14 @@
 import { EOL } from "os"
-import { Effect, Option } from "effect"
+import { Option } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.get,
   Effect.fn("cli.service.get")(function* (input) {
-    process.stdout.write((yield* ServiceConfig.get(Option.getOrUndefined(input.key))) + EOL)
+    const daemon = yield* Daemon.Service
+    process.stdout.write((yield* daemon.get(Option.getOrUndefined(input.key))) + EOL)
   }),
 )

packages/cli/src/commands/handlers/service/restart.ts

@@ -1,16 +1,14 @@
 import { EOL } from "os"
-import { Effect } from "effect"
-import { Service } from "@opencode-ai/client/effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.restart,
   Effect.fn("cli.service.restart")(function* () {
-    const options = yield* ServiceConfig.options()
-    yield* Service.stop(options)
-    const transport = yield* Service.start(options)
-    process.stdout.write(transport.url + EOL)
+    const daemon = yield* Daemon.Service
+    yield* daemon.stop()
+    process.stdout.write((yield* daemon.start()) + EOL)
   }),
 )

packages/cli/src/commands/handlers/service/set.ts

@@ -1,11 +1,11 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.set,
   Effect.fn("cli.service.set")(function* (input) {
-    yield* ServiceConfig.set(input.key, input.value)
+    yield* (yield* Daemon.Service).set(input.key, input.value)
   }),
 )

packages/cli/src/commands/handlers/service/start.ts

@@ -1,14 +1,12 @@
 import { EOL } from "os"
-import { Effect } from "effect"
-import { Service } from "@opencode-ai/client/effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.start,
   Effect.fn("cli.service.start")(function* () {
-    const transport = yield* Service.start(yield* ServiceConfig.options())
-    process.stdout.write(transport.url + EOL)
+    process.stdout.write((yield* (yield* Daemon.Service).start()) + EOL)
   }),
 )

packages/cli/src/commands/handlers/service/status.ts

@@ -1,14 +1,13 @@
 import { EOL } from "os"
-import { Effect } from "effect"
-import { Service } from "@opencode-ai/client/effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.status,
   Effect.fn("cli.service.status")(function* () {
-    const found = yield* Service.discover(yield* ServiceConfig.options())
-    process.stdout.write((found ? found.url : "stopped") + EOL)
+    const url = yield* (yield* Daemon.Service).status()
+    process.stdout.write((url ? url : "stopped") + EOL)
   }),
 )

packages/cli/src/commands/handlers/service/stop.ts

@@ -1,12 +1,11 @@
-import { Effect } from "effect"
-import { Service } from "@opencode-ai/client/effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.stop,
   Effect.fn("cli.service.stop")(function* () {
-    yield* Service.stop(yield* ServiceConfig.options())
+    yield* (yield* Daemon.Service).stop()
   }),
 )

packages/cli/src/commands/handlers/service/unset.ts

@@ -1,11 +1,11 @@
-import { Effect } from "effect"
+import * as Effect from "effect/Effect"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
-import { ServiceConfig } from "../../../services/service-config"
+import { Daemon } from "../../../services/daemon"
 
 export default Runtime.handler(
   Commands.commands.service.commands.unset,
   Effect.fn("cli.service.unset")(function* (input) {
-    yield* ServiceConfig.unset(input.key)
+    yield* (yield* Daemon.Service).unset(input.key)
   }),
 )

packages/cli/src/daemon.ts

@@ -1,70 +0,0 @@
-import { Service } from "@opencode-ai/client/effect"
-import { ClientError, isUnauthorizedError, OpenCode } from "@opencode-ai/client/promise"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { ServerAuth } from "@opencode-ai/server/auth"
-import { Effect } from "effect"
-import { ServiceConfig } from "./services/service-config"
-
-export type SharedOptions = {
-  readonly mode: "shared"
-  readonly command?: ReadonlyArray<string>
-}
-export type AttachOptions = {
-  readonly mode: "attach"
-  readonly url: string
-  readonly username?: string
-  readonly password?: string
-}
-export type Options = SharedOptions | AttachOptions
-
-const attach = Effect.fn("cli.daemon.attach")(function* (options: AttachOptions) {
-  const transport = {
-    url: options.url,
-    headers:
-      options.password === undefined
-        ? undefined
-        : ServerAuth.headers({ password: options.password, username: options.username }),
-  } satisfies Service.Transport
-  const client = OpenCode.make({ baseUrl: transport.url, headers: transport.headers })
-  const health = yield* Effect.tryPromise({
-    try: () => client.health.get({ signal: AbortSignal.timeout(5_000) }),
-    catch: (cause) => attachError(options, cause),
-  })
-  if (health.version !== InstallationVersion)
-    process.stderr.write(
-      `Warning: Server at ${options.url} has version ${health.version}; this client is ${InstallationVersion}. Continuing anyway.\n`,
-    )
-  return transport
-})
-
-const shared = Effect.fn("cli.daemon.shared")(function* (options: SharedOptions) {
-  const config = yield* ServiceConfig.options()
-  const service = options.command === undefined ? config : { ...config, command: options.command }
-  const found = yield* Service.discover(service)
-  if (found) return found
-  return yield* Service.start(service)
-})
-
-export function transport(options: AttachOptions): ReturnType<typeof attach>
-export function transport(options: SharedOptions): ReturnType<typeof shared>
-export function transport(options: Options): ReturnType<typeof attach> | ReturnType<typeof shared>
-export function transport(options: Options) {
-  if (options.mode === "attach") return attach(options)
-  return shared(options)
-}
-
-function attachError(options: AttachOptions, cause: unknown) {
-  if (isUnauthorizedError(cause)) {
-    return new Error(
-      options.password === undefined
-        ? `Server at ${options.url} requires authentication; provide a password`
-        : `Server at ${options.url} rejected the supplied credentials`,
-      { cause },
-    )
-  }
-  if (cause instanceof ClientError && cause.reason === "Transport")
-    return new Error(`Could not reach server at ${options.url}`, { cause })
-  return new Error(`Server at ${options.url} did not provide a compatible V2 health response`, { cause })
-}
-
-export * as Daemon from "./daemon"

packages/cli/src/env.ts

@@ -1,15 +0,0 @@
-import { Config } from "effect"
-
-// Every environment variable the CLI reads, in one place. Consumers yield
-// these instead of touching process.env so the full surface stays visible,
-// typed, and redacted where secret.
-
-// The opencode server password: sent by clients connecting to an explicit
-// --server, and adopted by a manually run or standalone server. The legacy
-// name is still honored.
-export const password = Config.redacted("OPENCODE_PASSWORD").pipe(
-  Config.orElse(() => Config.redacted("OPENCODE_SERVER_PASSWORD")),
-  Config.withDefault(undefined),
-)
-
-export * as Env from "./env"

packages/cli/src/framework/runtime.ts

@@ -1,8 +1,9 @@
-import { Effect, FileSystem, Scope } from "effect"
-import { Command } from "effect/unstable/cli"
+import * as Effect from "effect/Effect"
+import * as Command from "effect/unstable/cli/Command"
 import { Spec } from "./spec"
-import { Global } from "@opencode-ai/core/global"
+import { Daemon } from "../services/daemon"
 import { Updater } from "../services/updater"
+import { Scope } from "effect"
 
 export type Input<Value> =
   Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
@@ -11,21 +12,11 @@ export type Input<Value> =
       ? Input
       : never
 
-type RuntimeHandler = (
-  input: unknown,
-) => Effect.Effect<void, unknown, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
+type RuntimeHandler = (input: unknown) => Effect.Effect<void, unknown, Daemon.Service | Updater.Service | Scope.Scope>
 type Loader<Node extends Spec.Any> = () => Promise<{
-  default: (
-    input: Input<Node>,
-  ) => Effect.Effect<void, any, FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope>
+  default: (input: Input<Node>) => Effect.Effect<void, any, Daemon.Service | Updater.Service | Scope.Scope>
 }>
-type ProvidedCommand = Command.Command<
-  string,
-  unknown,
-  unknown,
-  unknown,
-  FileSystem.FileSystem | Global.Service | Updater.Service | Scope.Scope
->
+type ProvidedCommand = Command.Command<string, unknown, unknown, unknown, Daemon.Service | Updater.Service | Scope.Scope>
 
 export type Handlers<Node extends Spec.Any> = keyof Node["commands"] extends never
   ? Loader<Node>

packages/cli/src/framework/spec.ts

@@ -1,4 +1,4 @@
-import { Command } from "effect/unstable/cli"
+import * as Command from "effect/unstable/cli/Command"
 
 type Options<Config extends Command.Command.Config, Commands extends ReadonlyArray<Any>> = {
   readonly description?: string

packages/cli/src/index.ts

@@ -1,9 +1,13 @@
 #!/usr/bin/env bun
 
-import { NodeFileSystem, NodeRuntime, NodeServices } from "@effect/platform-node"
-import { Effect, Layer, Logger, References } from "effect"
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import { NodeFileSystem } from "@effect/platform-node"
+import * as Effect from "effect/Effect"
+import { Layer, Logger, References } from "effect"
 import { Commands } from "./commands/commands"
 import { Runtime } from "./framework/runtime"
+import { Daemon } from "./services/daemon"
 import { Logging } from "@opencode-ai/core/observability/logging"
 import { Updater } from "./services/updater"
 import { InstallationChannel, InstallationVersion, InstallationLocal } from "@opencode-ai/core/installation/version"
@@ -31,8 +35,6 @@ const Handlers = Runtime.handlers(Commands, {
     logout: () => import("./commands/handlers/mcp/logout"),
   },
   migrate: () => import("./commands/handlers/migrate"),
-  mini: () => import("./commands/handlers/mini"),
-  run: () => import("./commands/handlers/run"),
   service: {
     start: () => import("./commands/handlers/service/start"),
     restart: () => import("./commands/handlers/service/restart"),
@@ -45,19 +47,15 @@ const Handlers = Runtime.handlers(Commands, {
   serve: () => import("./commands/handlers/serve"),
 })
 
-Effect.logInfo("cli starting", {
-  version: InstallationVersion,
-  channel: InstallationChannel,
-  local: InstallationLocal,
-  args: process.argv.slice(2),
-}).pipe(
+Effect.logInfo("cli starting", { version: InstallationVersion, channel: InstallationChannel, local: InstallationLocal }).pipe(
   Effect.flatMap(() => Runtime.run(Commands, Handlers, { version: InstallationVersion })),
   Effect.annotateLogs({ role: "cli" }),
+  Effect.provide(Daemon.layer),
   Effect.provide(Updater.layer),
   Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node]))),
   Effect.provide(LoggingLayer),
   Effect.provide(NodeServices.layer),
   Effect.scoped,
-  Effect.tap(() => Effect.sync(() => process.exit(process.exitCode ?? 0))),
+  Effect.tap(() => Effect.sync(() => process.exit(0))),
   NodeRuntime.runMain,
 )

packages/cli/src/mini/catalog.shared.ts

@@ -1,161 +0,0 @@
-import type {
-  AgentListOutput,
-  CommandListOutput,
-  ModelListOutput,
-  OpenCodeClient,
-  ProviderListOutput,
-  SkillListOutput,
-} from "@opencode-ai/client/promise"
-import type { RunAgent, RunCommand, RunProvider, RunReference } from "./types"
-
-type CurrentAgent = AgentListOutput["data"][number]
-type CurrentCommand = CommandListOutput["data"][number]
-type CurrentSkill = SkillListOutput["data"][number]
-type CurrentProvider = ProviderListOutput["data"][number]
-type CurrentModel = ModelListOutput["data"][number]
-
-function location(directory: string, workspace?: string) {
-  return {
-    location: {
-      directory,
-      workspace,
-    },
-  }
-}
-
-function defaultCost(model: CurrentModel) {
-  const picked = model.cost.find((cost) => cost.tier === undefined) ?? model.cost[0]
-  if (!picked) {
-    return undefined
-  }
-
-  return {
-    ...picked,
-    input: model.cost.every((cost) => cost.input === 0) ? 0 : picked.input,
-  }
-}
-
-export function runAgent(input: CurrentAgent): RunAgent {
-  return {
-    name: input.id,
-    description: input.description,
-    mode: input.mode,
-    hidden: input.hidden,
-  }
-}
-
-export function runCommand(input: CurrentCommand): RunCommand {
-  return {
-    name: input.name,
-    description: input.description,
-  }
-}
-
-export function runSkill(input: CurrentSkill): RunCommand {
-  return {
-    name: input.name,
-    description: input.description,
-    source: "skill",
-  }
-}
-
-export function runProviders(providers: CurrentProvider[], models: CurrentModel[]): RunProvider[] {
-  const grouped = new Map<string, RunProvider>()
-
-  for (const provider of providers) {
-    grouped.set(provider.id, {
-      id: provider.id,
-      name: provider.name,
-      models: {},
-    })
-  }
-
-  for (const model of models) {
-    const provider = grouped.get(model.providerID) ?? {
-      id: model.providerID,
-      name: model.providerID,
-      models: {},
-    }
-    provider.models[model.id] = {
-      id: model.id,
-      providerID: model.providerID,
-      name: model.name,
-      capabilities: model.capabilities,
-      cost: defaultCost(model),
-      limit: model.limit,
-      status: model.status,
-      variants: Object.fromEntries(model.variants.map((variant) => [variant.id, {}])),
-    }
-    grouped.set(provider.id, provider)
-  }
-
-  return [...grouped.values()]
-}
-
-// A location boots its plugins in a deferred background batch after the layer
-// is built, so first-turn model resolution can observe empty catalog state.
-// For explicit --model flows, wait for that exact ref to appear before prompt
-// admission. On timeout, return and let the real execution error surface.
-export async function waitForCatalogReady(input: {
-  sdk: OpenCodeClient
-  directory: string
-  workspace?: string
-  model: { providerID: string; modelID: string }
-  timeoutMs?: number
-}) {
-  const deadline = Date.now() + (input.timeoutMs ?? 5_000)
-  while (Date.now() < deadline) {
-    const models = await input.sdk.model
-      .list(location(input.directory, input.workspace))
-      .then((result) => result.data)
-      .catch(() => undefined)
-    if (models?.some((model) => model.providerID === input.model.providerID && model.id === input.model.modelID)) return
-    await new Promise((resolve) => setTimeout(resolve, 25))
-  }
-}
-
-export async function waitForDefaultModel(input: {
-  sdk: OpenCodeClient
-  directory: string
-  timeoutMs?: number
-  active?: () => boolean
-}): Promise<{ providerID: string; modelID: string } | undefined> {
-  const deadline = Date.now() + (input.timeoutMs ?? 5_000)
-  while (Date.now() < deadline && (input.active?.() ?? true)) {
-    const model = await input.sdk.model
-      .default(location(input.directory))
-      .then((result) => result.data)
-      .catch(() => undefined)
-    if (model) return { providerID: model.providerID, modelID: model.id }
-    await new Promise((resolve) => setTimeout(resolve, 25))
-  }
-}
-
-export async function loadRunAgents(sdk: OpenCodeClient, directory: string): Promise<RunAgent[]> {
-  const result = await sdk.agent.list(location(directory))
-  return result.data.map(runAgent)
-}
-
-export async function loadRunCommands(sdk: OpenCodeClient, directory: string): Promise<RunCommand[]> {
-  const [commands, skills] = await Promise.all([
-    sdk.command.list(location(directory)),
-    sdk.skill.list(location(directory)),
-  ])
-  return [
-    ...commands.data.map(runCommand),
-    ...skills.data.filter((skill) => skill.slash !== false).map(runSkill),
-  ]
-}
-
-export async function loadRunReferences(sdk: OpenCodeClient, directory: string): Promise<RunReference[]> {
-  const result = await sdk.reference.list(location(directory))
-  return result.data.filter((reference) => !reference.hidden)
-}
-
-export async function loadRunProviders(sdk: OpenCodeClient, directory: string): Promise<RunProvider[]> {
-  const [providers, models] = await Promise.all([
-    sdk.provider.list(location(directory)),
-    sdk.model.list(location(directory)),
-  ])
-  return runProviders([...providers.data], [...models.data])
-}

packages/cli/src/mini/index.ts

@@ -1,7 +0,0 @@
-export { runMini, mergeInput as mergeInteractiveInput, type MiniCommandInput } from "./mini"
-export {
-  runNonInteractive,
-  mergeInput as mergeNonInteractiveInput,
-  pickRunModel,
-  type RunCommandInput,
-} from "./run"

packages/cli/src/mini/mini.ts

@@ -1,234 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
-import { truthy } from "@opencode-ai/core/flag/flag"
-import { Global } from "@opencode-ai/core/global"
-import { Effect } from "effect"
-import path from "node:path"
-import { Daemon } from "../daemon"
-import { waitForCatalogReady } from "./catalog.shared"
-import { INTERACTIVE_INPUT_ERROR, resolveInteractiveStdin } from "./runtime.stdin"
-import type { RunInput, RunTuiConfig } from "./types"
-
-export type MiniCommandInput = {
-  directory?: string
-  attach?: string
-  password?: string
-  username?: string
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: string
-  agent?: string
-  prompt?: string
-  replay?: boolean
-  replayLimit?: number
-  demo?: boolean
-  serverCommand?: ReadonlyArray<string>
-  tuiConfig?: RunTuiConfig | Promise<RunTuiConfig>
-}
-
-type Session = Awaited<ReturnType<OpenCodeClient["session"]["get"]>>
-type Transport = { readonly url: string; readonly headers?: HeadersInit }
-
-export async function runMini(input: MiniCommandInput) {
-  validate(input)
-  const initialInput = mergeInput(process.stdin.isTTY ? undefined : await Bun.stdin.text(), input.prompt)
-  const runtimeTask = import("./runtime")
-  const directory = input.attach ? input.directory : localDirectory(input.directory)
-  const transportTask = startTransport(input)
-  void transportTask.catch(() => {})
-
-  try {
-    if (input.attach) await transportTask
-    const sdk = OpenCode.make({
-      baseUrl: "http://opencode.pending",
-      fetch: deferredFetch(transportTask),
-    })
-    const attachedSession =
-      input.attach && input.session && !input.directory
-        ? await sdk.session.get({ sessionID: input.session }).catch(() => fail("Session not found"))
-        : undefined
-    const resolvedDirectory =
-      directory ?? attachedSession?.location.directory ?? (await remoteDirectory(await transportTask, sdk))
-    const model = parseModel(input.model)
-    let agentTask: Promise<string | undefined> | undefined
-    const resolveAgent = () => {
-      agentTask ??= validateAgent(sdk, resolvedDirectory, input.agent, input.attach)
-      return agentTask
-    }
-    const resolveSession = async () => {
-      const [agent, selected] = await Promise.all([
-        resolveAgent(),
-        selectSession(sdk, resolvedDirectory, input, attachedSession),
-      ])
-      const readyModel =
-        model ?? (selected?.model ? { providerID: selected.model.providerID, modelID: selected.model.id } : undefined)
-      if (readyModel) await waitForCatalogReady({ sdk, directory: resolvedDirectory, model: readyModel })
-      const session = selected ?? (await createSession(sdk, resolvedDirectory, agent, model))
-      return { id: session.id, title: session.title, resume: selected !== undefined }
-    }
-    const create = (
-      _sdk: OpenCodeClient,
-      next: { agent: string | undefined; model: RunInput["model"]; variant: string | undefined },
-    ) => createSession(sdk, resolvedDirectory, next.agent, next.model, next.variant)
-    const runtime = await runtimeTask
-    await runtime.runInteractiveDeferredMode({
-      sdk,
-      directory: resolvedDirectory,
-      resolveAgent,
-      session: resolveSession,
-      createSession: create,
-      agent: input.agent,
-      model,
-      variant: undefined,
-      files: [],
-      initialInput,
-      thinking: true,
-      backgroundSubagents:
-        truthy("OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS") ||
-        (process.env.OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS === undefined && truthy("OPENCODE_EXPERIMENTAL")),
-      replay: input.replay ?? true,
-      replayLimit: input.replayLimit,
-      demo: input.demo,
-      tuiConfig: input.tuiConfig,
-    })
-  } catch (error) {
-    if (error instanceof Error && error.message === INTERACTIVE_INPUT_ERROR) fail(error.message)
-    throw error
-  }
-}
-
-/** @internal Exported for testing. */
-export function mergeInput(piped: string | undefined, prompt: string | undefined) {
-  if (!prompt) return piped || undefined
-  if (!piped) return prompt
-  return piped + "\n" + prompt
-}
-
-function validate(input: MiniCommandInput) {
-  if (!process.stdout.isTTY) fail("opencode mini requires a TTY stdout")
-  if (input.replayLimit !== undefined && (!Number.isInteger(input.replayLimit) || input.replayLimit <= 0)) {
-    fail("--replay-limit must be a positive integer")
-  }
-  if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
-  resolveInteractiveStdin().cleanup?.()
-}
-
-function localDirectory(directory?: string): string {
-  const root = process.env.PWD ?? process.cwd()
-  try {
-    process.chdir(directory ? (path.isAbsolute(directory) ? directory : path.join(root, directory)) : root)
-    return process.cwd()
-  } catch {
-    fail(`Failed to change directory to ${directory}`)
-  }
-}
-
-function startTransport(input: MiniCommandInput): Promise<Transport> {
-  if (input.attach) {
-    return Effect.runPromise(
-      Daemon.transport({
-        mode: "attach",
-        url: input.attach,
-        password: input.password ?? process.env.OPENCODE_SERVER_PASSWORD,
-        username: input.username ?? process.env.OPENCODE_SERVER_USERNAME,
-      }),
-    )
-  }
-  return Effect.runPromise(
-    Daemon.transport({ mode: "shared", command: input.serverCommand }).pipe(
-      Effect.provide(NodeFileSystem.layer),
-      Effect.provide(Global.layerWith({})),
-    ),
-  )
-}
-
-function deferredFetch(transportTask: Promise<{ url: string; headers?: HeadersInit }>): typeof globalThis.fetch {
-  const fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-    const transport = await transportTask
-    const request = new Request(input, init)
-    const source = new URL(request.url)
-    const headers = new Headers(request.headers)
-    for (const [key, value] of new Headers(transport.headers)) headers.set(key, value)
-    return globalThis.fetch(new Request(new URL(source.pathname + source.search, transport.url), request), { headers })
-  }
-  return fetch as typeof globalThis.fetch
-}
-
-async function remoteDirectory(
-  transport: { url: string; headers?: HeadersInit },
-  sdk: OpenCodeClient,
-): Promise<string> {
-  const location = await sdk.location.get()
-  if (!location.directory) throw new Error(`Failed to resolve remote directory from ${transport.url}`)
-  return location.directory
-}
-
-function parseModel(value?: string): RunInput["model"] {
-  if (!value) return
-  const [providerID, ...rest] = value.split("/")
-  const modelID = rest.join("/")
-  if (!providerID || !modelID) fail("--model must use the format provider/model")
-  return { providerID, modelID }
-}
-
-async function validateAgent(sdk: OpenCodeClient, directory: string, name?: string, attach?: string) {
-  if (!name) return
-  const deadline = Date.now() + 5_000
-  let agents: Awaited<ReturnType<OpenCodeClient["agent"]["list"]>> | undefined
-  while (Date.now() < deadline) {
-    agents = await sdk.agent.list({ location: { directory } }).catch(() => undefined)
-    const agent = agents?.data.find((item) => item.id === name)
-    if (agent?.mode === "subagent") {
-      warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
-      return
-    }
-    if (agent) return name
-    await Bun.sleep(25)
-  }
-  if (!agents) {
-    warning(`failed to list agents${attach ? ` from ${attach}` : ""}. Falling back to default agent`)
-    return
-  }
-  warning(`agent "${name}" not found. Falling back to default agent`)
-}
-
-async function selectSession(sdk: OpenCodeClient, directory: string, input: MiniCommandInput, preselected?: Session) {
-  const selected =
-    preselected ??
-    (input.session
-      ? await sdk.session.get({ sessionID: input.session }).catch(() => undefined)
-      : input.continue
-        ? await sdk.session
-            .list({ directory, parentID: null, limit: 1, order: "desc" })
-            .then((result) => result.data[0])
-        : undefined)
-  if (input.session && !selected) fail("Session not found")
-  if (!selected) return
-  if (!input.fork) return selected
-  return sdk.session.fork({ sessionID: selected.id })
-}
-
-async function createSession(
-  sdk: OpenCodeClient,
-  directory: string,
-  agent: string | undefined,
-  model: RunInput["model"],
-  variant?: string,
-): Promise<Session> {
-  if (model) await waitForCatalogReady({ sdk, directory, model })
-  return sdk.session.create({
-    agent,
-    model: model ? { providerID: model.providerID, id: model.modelID, variant } : undefined,
-    location: { directory },
-  })
-}
-
-function warning(message: string) {
-  process.stderr.write(`\x1b[93m\x1b[1m!\x1b[0m ${message}\n`)
-}
-
-function fail(message: string): never {
-  process.stderr.write(`\x1b[91m\x1b[1mError: \x1b[0m${message}\n`)
-  process.exit(1)
-}

packages/cli/src/mini/noninteractive.ts

@@ -1,489 +0,0 @@
-import type {
-  EventSubscribeOutput,
-  OpenCodeClient,
-} from "@opencode-ai/client/promise"
-import type {
-  ReasoningPart,
-  StepFinishPart,
-  StepStartPart,
-  TextPart,
-  ToolPart,
-} from "@opencode-ai/sdk/v2"
-import { SessionMessage } from "@opencode-ai/schema/session-message"
-import { EOL } from "node:os"
-import { UI } from "./ui"
-
-type Model = {
-  providerID: string
-  modelID: string
-}
-
-type File = {
-  url: string
-  filename: string
-  mime: string
-}
-
-type Input = {
-  client: OpenCodeClient
-  sessionID: string
-  message: string
-  files: File[]
-  agent?: string
-  model?: Model
-  variant?: string
-  thinking: boolean
-  format: "default" | "json"
-  dangerouslySkipPermissions: boolean
-  /** True when the client is attached to a shared server rather than an exclusive in-process one. */
-  attached: boolean
-  renderTool: (part: ToolPart) => Promise<void>
-  renderToolError: (part: ToolPart) => Promise<void>
-}
-
-type StartedPart = {
-  id: string
-  timestamp: number
-}
-
-type ToolState = StartedPart & {
-  assistantMessageID: string
-  tool: string
-  input: Record<string, unknown>
-  raw?: string
-  provider?: unknown
-}
-
-type V2Event = EventSubscribeOutput
-type FormRequest = Extract<V2Event, { type: "form.created" }>["data"]["form"]
-
-// MCP elicitations are temporarily owned by the "global" sentinel instead of a real
-// session. An exclusive local process may treat them as this run's blockers; an
-// attached client must not cancel input that may belong to another session.
-const GLOBAL_FORM_SESSION_ID = "global"
-
-export async function runNonInteractivePrompt(input: Input) {
-  const controller = new AbortController()
-  const stream = input.client.event.subscribe({ signal: controller.signal })[Symbol.asyncIterator]()
-  const connected = await stream.next()
-  if (connected.done) throw new Error("Event stream disconnected before prompt admission")
-
-  const messageID = SessionMessage.ID.create()
-  const starts = new Map<string, StartedPart>()
-  const tools = new Map<string, ToolState>()
-  let submitted = false
-  let promoted = false
-  let emittedError = false
-  let questionRejected = false
-  let permissionRejected = false
-  let formCancelled = false
-  let interrupted = false
-  let admission: AbortController | undefined
-
-  const emit = (type: string, timestamp: number, data: Record<string, unknown>) => {
-    if (input.format !== "json") return false
-    process.stdout.write(JSON.stringify({ type, timestamp, sessionID: input.sessionID, ...data }) + EOL)
-    return true
-  }
-
-  const writeText = (part: TextPart, timestamp: number) => {
-    if (emit("text", timestamp, { part })) return
-    const text = part.text.trim()
-    if (!text) return
-    if (!process.stdout.isTTY) {
-      process.stdout.write(text + EOL)
-      return
-    }
-    UI.empty()
-    UI.println(text)
-    UI.empty()
-  }
-
-  const replyPermission = async (request: { id: string; action: string; resources: ReadonlyArray<string> }) => {
-    if (!input.dangerouslySkipPermissions) {
-      permissionRejected = true
-      UI.println(
-        UI.Style.TEXT_WARNING_BOLD + "!",
-        UI.Style.TEXT_NORMAL +
-          `permission requested: ${request.action} (${request.resources.join(", ")}); auto-rejecting`,
-      )
-    }
-    await input.client.permission
-      .reply({
-        sessionID: input.sessionID,
-        requestID: request.id,
-        reply: input.dangerouslySkipPermissions ? "once" : "reject",
-      })
-      .catch(() => {})
-    if (!input.dangerouslySkipPermissions) {
-      await input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {})
-    }
-  }
-
-  const rejectQuestion = async (request: { id: string }) => {
-    questionRejected = true
-    await input.client.question.reject({ sessionID: input.sessionID, requestID: request.id }).catch(() => {})
-  }
-
-  const cancelForm = async (request: Pick<FormRequest, "id" | "sessionID">) => {
-    formCancelled = true
-    await input.client.form.cancel({ sessionID: request.sessionID, formID: request.id }).catch(() => {})
-  }
-
-  const consume = async () => {
-    while (!controller.signal.aborted) {
-      const next = await stream.next().catch((error) => {
-        if (!emittedError) throw error
-        return { done: true as const, value: undefined }
-      })
-      if (next.done) {
-        if (emittedError) return
-        throw new Error("Event stream disconnected during prompt execution")
-      }
-      const event = next.value
-
-      if (event.type === "permission.v2.asked" && submitted && event.data.sessionID === input.sessionID) {
-        await replyPermission(event.data)
-        continue
-      }
-      if (event.type === "question.v2.asked" && submitted && event.data.sessionID === input.sessionID) {
-        await rejectQuestion(event.data)
-        continue
-      }
-      if (
-        event.type === "form.created" &&
-        submitted &&
-        (event.data.form.sessionID === input.sessionID ||
-          (!input.attached && event.data.form.sessionID === GLOBAL_FORM_SESSION_ID))
-      ) {
-        await cancelForm(event.data.form)
-        continue
-      }
-      if (!("sessionID" in event.data) || event.data.sessionID !== input.sessionID) continue
-      const time = toMillis("created" in event ? event.created : undefined)
-
-      if (event.type === "session.prompt.promoted") {
-        if (event.data.inputID === messageID) {
-          promoted = true
-          continue
-        }
-      }
-      if (
-        event.type === "session.execution.settled" &&
-        event.data.outcome === "interrupted" &&
-        (interrupted || permissionRejected || questionRejected || formCancelled)
-      ) {
-        return
-      }
-      if (!promoted) continue
-
-      if (event.type === "session.step.started") {
-        const part: StepStartPart = {
-          id: partID(event.id),
-          sessionID: input.sessionID,
-          messageID: event.data.assistantMessageID,
-          type: "step-start",
-          snapshot: event.data.snapshot,
-        }
-        if (!emit("step_start", time, { part }) && input.format !== "json") {
-          UI.empty()
-          UI.println(`> ${event.data.agent} · ${event.data.model.id}`)
-          UI.empty()
-        }
-        continue
-      }
-
-      if (event.type === "session.text.started") {
-        starts.set(event.data.textID, { id: partID(event.id), timestamp: time })
-        continue
-      }
-      if (event.type === "session.text.ended") {
-        const started = starts.get(event.data.textID)
-        const part: TextPart = {
-          id: started?.id ?? partID(event.id),
-          sessionID: input.sessionID,
-          messageID: event.data.assistantMessageID,
-          type: "text",
-          text: event.data.text,
-          time: { start: started?.timestamp ?? time, end: time },
-        }
-        writeText(part, time)
-        continue
-      }
-
-      if (event.type === "session.reasoning.started") {
-        starts.set(event.data.reasoningID, { id: partID(event.id), timestamp: time })
-        continue
-      }
-      if (event.type === "session.reasoning.ended" && input.thinking) {
-        const started = starts.get(event.data.reasoningID)
-        const part: ReasoningPart = {
-          id: started?.id ?? partID(event.id),
-          sessionID: input.sessionID,
-          messageID: event.data.assistantMessageID,
-          type: "reasoning",
-          text: event.data.text,
-          metadata: event.data.providerMetadata,
-          time: { start: started?.timestamp ?? time, end: time },
-        }
-        if (emit("reasoning", time, { part })) continue
-        const text = part.text.trim()
-        if (!text) continue
-        const line = `Thinking: ${text}`
-        if (!process.stdout.isTTY) {
-          process.stdout.write(line + EOL)
-          continue
-        }
-        UI.empty()
-        UI.println(`${UI.Style.TEXT_DIM}\u001b[3m${line}\u001b[0m${UI.Style.TEXT_NORMAL}`)
-        UI.empty()
-        continue
-      }
-
-      if (event.type === "session.tool.input.started") {
-        tools.set(event.data.callID, {
-          id: partID(event.id),
-          timestamp: time,
-          assistantMessageID: event.data.assistantMessageID,
-          tool: event.data.name,
-          input: {},
-        })
-        continue
-      }
-      if (event.type === "session.tool.input.ended") {
-        const current = tools.get(event.data.callID)
-        if (current) current.raw = event.data.text
-        continue
-      }
-      if (event.type === "session.tool.called") {
-        const current = tools.get(event.data.callID)
-        tools.set(event.data.callID, {
-          id: current?.id ?? partID(event.id),
-          timestamp: current?.timestamp ?? time,
-          assistantMessageID: event.data.assistantMessageID,
-          tool: event.data.tool,
-          input: event.data.input,
-          raw: current?.raw,
-          provider: event.data.provider,
-        })
-        continue
-      }
-      if (event.type === "session.tool.success") {
-        const current = tools.get(event.data.callID) ?? fallbackTool(event)
-        const part: ToolPart = {
-          id: current.id,
-          sessionID: input.sessionID,
-          messageID: event.data.assistantMessageID,
-          type: "tool",
-          callID: event.data.callID,
-          tool: current.tool,
-          state: {
-            status: "completed",
-            input: current.input,
-            output: event.data.content
-              .filter((item) => item.type === "text")
-              .map((item) => item.text)
-              .join("\n"),
-            title: current.tool,
-            metadata: {
-              structured: event.data.structured,
-              content: event.data.content,
-              outputPaths: event.data.outputPaths,
-              result: event.data.result,
-              providerCall: current.provider,
-              providerResult: event.data.provider,
-              rawInput: current.raw,
-            },
-            time: { start: current.timestamp, end: time },
-          },
-        }
-        tools.delete(event.data.callID)
-        if (!emit("tool_use", time, { part })) await input.renderTool(part)
-        continue
-      }
-      if (event.type === "session.tool.failed") {
-        const current = tools.get(event.data.callID) ?? fallbackTool(event)
-        const error = event.data.error.message
-        const part: ToolPart = {
-          id: current.id,
-          sessionID: input.sessionID,
-          messageID: event.data.assistantMessageID,
-          type: "tool",
-          callID: event.data.callID,
-          tool: current.tool,
-          state: {
-            status: "error",
-            input: current.input,
-            error,
-            metadata: {
-              result: event.data.result,
-              providerCall: current.provider,
-              providerResult: event.data.provider,
-              rawInput: current.raw,
-            },
-            time: { start: current.timestamp, end: time },
-          },
-        }
-        tools.delete(event.data.callID)
-        if (!emit("tool_use", time, { part })) {
-          await input.renderToolError(part)
-          UI.error(error)
-        }
-        continue
-      }
-
-      if (event.type === "session.step.ended") {
-        const part: StepFinishPart = {
-          id: partID(event.id),
-          sessionID: input.sessionID,
-          messageID: event.data.assistantMessageID,
-          type: "step-finish",
-          reason: event.data.finish,
-          snapshot: event.data.snapshot,
-          cost: event.data.cost,
-          tokens: event.data.tokens,
-        }
-        emit("step_finish", time, { part })
-        continue
-      }
-      if (event.type === "session.step.failed") {
-        if (interrupted || permissionRejected || questionRejected || formCancelled) continue
-        emittedError = true
-        process.exitCode = 1
-        if (!emit("error", time, { error: event.data.error })) UI.error(event.data.error.message)
-        continue
-      }
-      if (event.type === "session.execution.settled") {
-        if (event.data.outcome === "failure" && !emittedError && !questionRejected && !formCancelled) {
-          emittedError = true
-          process.exitCode = 1
-          const error = event.data.error ?? { type: "unknown", message: "Session execution failed" }
-          if (!emit("error", time, { error })) UI.error(error.message)
-        }
-        if (event.data.outcome === "interrupted" && interrupted) process.exitCode = 130
-        return
-      }
-    }
-  }
-
-  const interrupt = () => {
-    if (interrupted) process.exit(130)
-    interrupted = true
-    process.exitCode = 130
-    admission?.abort()
-    void input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {})
-  }
-  process.on("SIGINT", interrupt)
-
-  let completed: Promise<void> | undefined
-  try {
-    if (input.agent) {
-      await input.client.session.switchAgent({ sessionID: input.sessionID, agent: input.agent })
-    }
-    const selected = input.model
-      ? { providerID: input.model.providerID, id: input.model.modelID, variant: input.variant }
-      : input.variant
-        ? await input.client.session
-            .get({ sessionID: input.sessionID })
-            .then((result) => result.model)
-            .then(async (model) => {
-              if (model) return { ...model, variant: input.variant }
-              const result = await input.client.model.default()
-              const fallback = result.data
-              return fallback ? { providerID: fallback.providerID, id: fallback.id, variant: input.variant } : undefined
-            })
-        : undefined
-    if (input.variant && !selected) throw new Error("Cannot select a variant before selecting a model")
-    if (selected) {
-      await input.client.session.switchModel({ sessionID: input.sessionID, model: selected })
-    }
-
-    const prepared = await Promise.all(input.files.map(prepareFile))
-    if (interrupted) return
-    submitted = true
-    completed = consume()
-    admission = new AbortController()
-    const response = await input.client.session
-      .prompt(
-        {
-          sessionID: input.sessionID,
-          id: messageID,
-          prompt: {
-            text: [input.message, ...prepared.flatMap((file) => (file.text ? [file.text] : []))].join("\n\n"),
-            files: prepared.flatMap((file) => (file.attachment ? [file.attachment] : [])),
-          },
-          delivery: "steer",
-        },
-        { signal: admission.signal },
-      )
-      .catch(async (error) => {
-        if (interrupted) {
-          await input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {})
-        }
-        controller.abort()
-        await completed?.catch(() => {})
-        if (interrupted || emittedError) return undefined
-        throw error
-      })
-    admission = undefined
-    if (!response) return
-    if (interrupted) await input.client.session.interrupt({ sessionID: input.sessionID }).catch(() => {})
-
-    const [permissions, questions, forms] = await Promise.all([
-      input.client.permission.list({ sessionID: input.sessionID }).catch(() => undefined),
-      input.client.question.list({ sessionID: input.sessionID }).catch(() => undefined),
-      Promise.all(
-        (input.attached ? [input.sessionID] : [input.sessionID, GLOBAL_FORM_SESSION_ID]).map((sessionID) =>
-          input.client.form.list({ sessionID }).catch(() => undefined),
-        ),
-      ),
-    ])
-    await Promise.all([
-      ...(permissions ?? []).map(replyPermission),
-      ...(questions ?? []).map(rejectQuestion),
-      ...forms.flatMap((response) => response ?? []).map(cancelForm),
-    ])
-    await completed
-  } finally {
-    process.off("SIGINT", interrupt)
-    controller.abort()
-    await stream.return?.(undefined).catch(() => {})
-  }
-}
-
-function partID(eventID: string) {
-  return `prt_${eventID.replace(/^evt_/, "")}`
-}
-
-function fallbackTool(event: {
-  id: string
-  created: number
-  data: { assistantMessageID: string; callID: string }
-}): ToolState {
-  return {
-    id: partID(event.id),
-    timestamp: toMillis(event.created),
-    assistantMessageID: event.data.assistantMessageID,
-    tool: "tool",
-    input: {},
-  }
-}
-
-function toMillis(value: unknown) {
-  if (typeof value === "number") return value
-  if (typeof value === "string") return new Date(value).getTime()
-  return Date.now()
-}
-
-async function prepareFile(file: File) {
-  if (file.mime !== "text/plain") {
-    const uri = file.url.startsWith("data:")
-      ? file.url
-      : `data:${file.mime};base64,${Buffer.from(await Bun.file(new URL(file.url)).arrayBuffer()).toString("base64")}`
-    return { attachment: { uri, mime: file.mime, name: file.filename } }
-  }
-  const content = file.url.startsWith("data:")
-    ? Buffer.from(file.url.slice(file.url.indexOf(",") + 1), "base64").toString("utf8")
-    : await Bun.file(new URL(file.url)).text()
-  return { text: `<file name="${file.filename}">\n${content}\n</file>` }
-}

packages/cli/src/mini/run.ts

@@ -1,311 +0,0 @@
-import { NodeFileSystem } from "@effect/platform-node"
-import { OpenCode, type OpenCodeClient } from "@opencode-ai/client/promise"
-import { Global } from "@opencode-ai/core/global"
-import { FSUtil } from "@opencode-ai/core/fs-util"
-import type { ToolPart } from "@opencode-ai/sdk/v2"
-import { Effect } from "effect"
-import { open } from "node:fs/promises"
-import path from "node:path"
-import { Daemon } from "../daemon"
-import { Standalone } from "../services/standalone"
-import { loadRunAgents, waitForCatalogReady } from "./catalog.shared"
-import { runNonInteractivePrompt } from "./noninteractive"
-import { toolInlineInfo } from "./tool"
-import { UI } from "./ui"
-
-export type RunCommandInput = {
-  message: string[]
-  continue?: boolean
-  session?: string
-  fork?: boolean
-  model?: string
-  agent?: string
-  format: "default" | "json"
-  file: string[]
-  title?: string
-  server?: string
-  password?: string
-  username?: string
-  directory?: string
-  variant?: string
-  thinking?: boolean
-  dangerouslySkipPermissions?: boolean
-  standaloneCommand?: ReadonlyArray<string>
-}
-
-type FilePart = {
-  url: string
-  filename: string
-  mime: string
-}
-
-type Transport = { readonly url: string; readonly headers?: HeadersInit }
-
-type Prepared = {
-  directory?: string
-  message: string
-  files: FilePart[]
-}
-
-const ATTACH_FILE_MAX_BYTES = 10 * 1024 * 1024
-
-export function runNonInteractive(input: RunCommandInput) {
-  return run(input).catch((error) => reportError(input, error instanceof Error ? error.message : String(error)))
-}
-
-async function run(input: RunCommandInput) {
-  if (input.fork && !input.continue && !input.session) fail("--fork requires --continue or --session")
-  const root = process.env.PWD ?? process.cwd()
-  const directory = input.server ? input.directory : localDirectory(input.directory, root)
-  const message = mergeInput(formatMessage(input.message), process.stdin.isTTY ? undefined : await Bun.stdin.text())
-  if (!message?.trim()) fail("You must provide a message")
-  const files = await Promise.all(
-    input.file.map((file) => prepareFile(file, input.server ? root : (directory ?? root), input.server !== undefined)),
-  )
-  const prepared = { directory, message, files }
-  if (input.standaloneCommand)
-    return Effect.runPromise(
-      Effect.scoped(
-        Effect.gen(function* () {
-          const transport = yield* Standalone.transport({ command: input.standaloneCommand })
-          yield* Effect.promise(() => execute(input, prepared, transport))
-        }),
-      ),
-    )
-  const transport = await startTransport(input)
-  return execute(input, prepared, transport)
-}
-
-async function execute(input: RunCommandInput, prepared: Prepared, transport: Transport) {
-  const client = OpenCode.make({ baseUrl: transport.url, headers: transport.headers })
-  const requestedDirectory = prepared.directory ?? (await client.location.get()).directory
-  if (!requestedDirectory) fail("Failed to resolve server directory")
-  const session = await selectSession(client, requestedDirectory, input)
-  const cwd = session?.location.directory ?? requestedDirectory
-  const workspace = session?.location.workspaceID
-  const explicitModel = parseModel(input.model)
-  const sessionModel = session?.model ? { providerID: session.model.providerID, modelID: session.model.id } : undefined
-  const defaultModel =
-    !explicitModel && !sessionModel
-      ? await client.model
-          .default({ location: { directory: cwd, workspace } })
-          .then((result) =>
-            result.data ? { providerID: result.data.providerID, modelID: result.data.id } : undefined,
-          )
-      : undefined
-  const model = pickRunModel(explicitModel, input.variant, sessionModel, defaultModel)
-  if (input.variant && !model) return reportError(input, "Cannot select a variant before selecting a model", session?.id)
-  if (model) {
-    await waitForCatalogReady({ sdk: client, directory: cwd, workspace, model })
-    const available = await client.model.list({ location: { directory: cwd, workspace } })
-    if (!available.data.some((item) => item.providerID === model.providerID && item.id === model.modelID))
-      return reportError(input, `Model unavailable: ${model.providerID}/${model.modelID}`, session?.id)
-  }
-  const agent = await validateAgent(client, cwd, input.agent, input.server)
-  const selected =
-    session ??
-    (await client.session.create({
-      agent,
-      model: model ? { providerID: model.providerID, id: model.modelID, variant: input.variant } : undefined,
-      location: { directory: cwd },
-    }))
-  if (!session && input.title !== undefined) {
-    await client.session.rename({
-      sessionID: selected.id,
-      title:
-        input.title ||
-        prepared.message.slice(0, 50) + (prepared.message.length > 50 ? "..." : ""),
-    })
-  }
-
-  await runNonInteractivePrompt({
-    client,
-    sessionID: selected.id,
-    message: prepared.message,
-    files: prepared.files,
-    agent,
-    model,
-    variant: input.variant,
-    thinking: input.thinking ?? false,
-    format: input.format,
-    dangerouslySkipPermissions: input.dangerouslySkipPermissions ?? false,
-    attached: !input.standaloneCommand,
-    renderTool,
-    renderToolError,
-  }).catch((error) => reportError(input, error instanceof Error ? error.message : String(error), selected.id))
-}
-
-export function mergeInput(message: string | undefined, piped: string | undefined) {
-  if (!message) return piped || undefined
-  if (!piped) return message
-  return message + "\n" + piped
-}
-
-export function pickRunModel(
-  explicit: { providerID: string; modelID: string } | undefined,
-  variant: string | undefined,
-  session: { providerID: string; modelID: string } | undefined,
-  fallback: { providerID: string; modelID: string } | undefined,
-) {
-  if (explicit) return explicit
-  if (!variant) return
-  return session ?? fallback
-}
-
-function formatMessage(message: string[]) {
-  const value = message.map((part) => (part.includes(" ") ? `"${part.replace(/"/g, '\\"')}"` : part)).join(" ")
-  return value || undefined
-}
-
-function localDirectory(directory: string | undefined, root: string) {
-  try {
-    process.chdir(directory ? (path.isAbsolute(directory) ? directory : path.join(root, directory)) : root)
-    return process.cwd()
-  } catch {
-    fail(`Failed to change directory to ${directory}`)
-  }
-}
-
-function startTransport(input: RunCommandInput) {
-  if (input.server) {
-    return Effect.runPromise(
-      Daemon.transport({
-        mode: "attach",
-        url: input.server,
-        password: input.password,
-        username: input.username,
-      }),
-    )
-  }
-  return Effect.runPromise(
-    Daemon.transport({ mode: "shared" }).pipe(
-      Effect.provide(NodeFileSystem.layer),
-      Effect.provide(Global.layerWith({})),
-    ),
-  )
-}
-
-function parseModel(value?: string) {
-  if (!value) return
-  const [providerID, ...rest] = value.split("/")
-  const modelID = rest.join("/")
-  if (!providerID || !modelID) fail("--model must use the format provider/model")
-  return { providerID, modelID }
-}
-
-async function validateAgent(client: OpenCodeClient, directory: string, name?: string, server?: string) {
-  if (!name) return
-  const agents = await loadRunAgents(client, directory).catch(() => undefined)
-  if (!agents) {
-    warning(`failed to list agents${server ? ` from ${server}` : ""}. Falling back to default agent`)
-    return
-  }
-  const agent = agents.find((item) => item.name === name)
-  if (!agent) {
-    warning(`agent "${name}" not found. Falling back to default agent`)
-    return
-  }
-  if (agent.mode === "subagent") {
-    warning(`agent "${name}" is a subagent, not a primary agent. Falling back to default agent`)
-    return
-  }
-  return name
-}
-
-async function selectSession(client: OpenCodeClient, directory: string, input: RunCommandInput) {
-  const selected = input.session
-    ? await client.session.get({ sessionID: input.session }).catch(() => undefined)
-    : input.continue
-      ? await client.session
-          .list({ directory, parentID: null, limit: 1, order: "desc" })
-          .then((result) => result.data[0])
-      : undefined
-  if (input.session && !selected) fail("Session not found")
-  if (!selected || !input.fork) return selected
-  return client.session.fork({ sessionID: selected.id })
-}
-
-async function prepareFile(input: string, directory: string, remote: boolean): Promise<FilePart> {
-  const file = path.resolve(directory, input)
-  const handle = await open(file, "r").catch(() => fail(`File not found: ${input}`))
-  try {
-    const stat = await handle.stat()
-    if (remote && stat.isDirectory()) fail(`Cannot attach local directory without a shared filesystem: ${input}`)
-    if (!stat.isFile() || stat.size > ATTACH_FILE_MAX_BYTES)
-      fail(`Cannot attach a directory, special file, or file larger than 10 MiB: ${input}`)
-    const content = Buffer.alloc(Number(stat.size))
-    let offset = 0
-    while (offset < content.length) {
-      const read = await handle.read(content, offset, content.length - offset, offset)
-      if (read.bytesRead === 0) break
-      offset += read.bytesRead
-    }
-    const bytes = content.subarray(0, offset)
-    const detected = FSUtil.mimeType(file)
-    const text = bytes.toString("utf8")
-    const mime =
-      detected.startsWith("image/") || detected === "application/pdf"
-        ? detected
-        : !isBinaryContent(bytes) && Buffer.from(text, "utf8").equals(bytes)
-          ? "text/plain"
-          : detected
-    return {
-      url: `data:${mime};base64,${bytes.toString("base64")}`,
-      filename: path.basename(file),
-      mime,
-    }
-  } finally {
-    await handle.close()
-  }
-}
-
-function isBinaryContent(bytes: Uint8Array) {
-  if (bytes.length === 0) return false
-  if (bytes.includes(0)) return true
-  return bytes.reduce((count, byte) => count + Number(byte < 9 || (byte > 13 && byte < 32)), 0) / bytes.length > 0.3
-}
-
-async function renderTool(part: ToolPart) {
-  const info = toolInlineInfo(part)
-  if (info.mode === "block") {
-    UI.empty()
-    UI.println(UI.Style.TEXT_NORMAL + info.icon, UI.Style.TEXT_NORMAL + info.title)
-    if (info.body?.trim()) UI.println(info.body)
-    UI.empty()
-    return
-  }
-  UI.println(
-    UI.Style.TEXT_NORMAL + info.icon,
-    UI.Style.TEXT_NORMAL + info.title,
-    info.description ? UI.Style.TEXT_DIM + info.description + UI.Style.TEXT_NORMAL : "",
-  )
-}
-
-async function renderToolError(part: ToolPart) {
-  const info = toolInlineInfo(part)
-  UI.println(UI.Style.TEXT_NORMAL + "✗", UI.Style.TEXT_NORMAL + `${info.title} failed`)
-}
-
-function warning(message: string) {
-  UI.println(UI.Style.TEXT_WARNING_BOLD + "!", UI.Style.TEXT_NORMAL, message)
-}
-
-function reportError(input: RunCommandInput, message: string, sessionID?: string) {
-  process.exitCode = 1
-  if (input.format === "json") {
-    process.stdout.write(
-      JSON.stringify({
-        type: "error",
-        timestamp: Date.now(),
-        sessionID: sessionID ?? "",
-        error: { type: "unknown", message },
-      }) + "\n",
-    )
-    return
-  }
-  UI.error(message)
-}
-
-function fail(message: string): never {
-  throw new Error(message)
-}

packages/cli/src/mini/stream-v2.subagent.ts

@@ -1,735 +0,0 @@
-// Current-native subagent (child Session) tracking for the mini transport.
-//
-// Discovers child Sessions of the active parent from four current sources:
-//   1. projected subagent tool output (`structured.sessionID`) during hydration
-//   2. the current session list filtered by `parentID` during hydration
-//   3. the process-local active-session map during hydration
-//   4. live events from unknown sessions whose `parentID` matches the parent
-//
-// Tracks one footer tab per child and a detail transcript for the selected
-// child, reduced from the same current live event stream the parent uses.
-// Detail transcripts rebuild from projected messages on discovery, selection,
-// and reconnect, then continue from live deltas using the same
-// projected-prefix dedup the parent transport uses.
-//
-// Per-child interruption uses `v2.session.interrupt(childID)`. Per-child
-// backgrounding is intentionally absent: subagent jobs block the parent
-// session, so only whole-session `v2.session.background(parentID)` exists.
-import type { EventSubscribeOutput, OpenCodeClient } from "@opencode-ai/client/promise"
-import type { SessionMessage, SessionMessageAssistantTool, ToolPart } from "@opencode-ai/sdk/v2"
-import { Locale } from "@opencode-ai/tui/util/locale"
-import type { FooterSubagentDetail, FooterSubagentState, FooterSubagentTab, StreamCommit } from "./types"
-
-const CHILD_MESSAGE_LIMIT = 80
-const CHILD_FRAME_LIMIT = 80
-const CHILD_EVENT_BUFFER_LIMIT = 64
-const FAMILY_LIST_LIMIT = 100
-const FALLBACK_LABEL = "Subagent"
-
-type V2Event = EventSubscribeOutput
-
-export function outputText(content: ReadonlyArray<{ type: string; text?: string }>) {
-  return content.flatMap((item) => (item.type === "text" && item.text ? [item.text] : [])).join("\n")
-}
-
-export function legacyTool(input: {
-  sessionID: string
-  messageID: string
-  callID: string
-  name: string
-  state: SessionMessageAssistantTool["state"]
-  time: SessionMessageAssistantTool["time"]
-  provider?: SessionMessageAssistantTool["provider"]
-}): ToolPart {
-  const base = {
-    id: `prt_${input.callID}`,
-    sessionID: input.sessionID,
-    messageID: input.messageID,
-    type: "tool" as const,
-    callID: input.callID,
-    tool: input.name,
-  }
-  if (input.state.status === "pending") {
-    return {
-      ...base,
-      state: { status: "pending", input: {}, raw: input.state.input },
-    }
-  }
-  if (input.state.status === "running") {
-    return {
-      ...base,
-      state: {
-        status: "running",
-        input: input.state.input,
-        title: input.name,
-        metadata: { structured: input.state.structured, content: input.state.content, providerCall: input.provider },
-        time: { start: input.time.ran ?? input.time.created },
-      },
-    }
-  }
-  if (input.state.status === "completed") {
-    return {
-      ...base,
-      state: {
-        status: "completed",
-        input: input.state.input,
-        output: outputText(input.state.content),
-        title: input.name,
-        metadata: {
-          structured: input.state.structured,
-          content: input.state.content,
-          outputPaths: input.state.outputPaths,
-          result: input.state.result,
-          providerCall: input.provider,
-        },
-        time: { start: input.time.ran ?? input.time.created, end: input.time.completed ?? input.time.created },
-      },
-    }
-  }
-  return {
-    ...base,
-    state: {
-      status: "error",
-      input: input.state.input,
-      error: input.state.error.message,
-      metadata: {
-        structured: input.state.structured,
-        content: input.state.content,
-        result: input.state.result,
-        providerCall: input.provider,
-      },
-      time: { start: input.time.ran ?? input.time.created, end: input.time.completed ?? input.time.created },
-    },
-  }
-}
-
-export function toolCommit(part: ToolPart, phase: "start" | "progress" | "final"): StreamCommit {
-  const status = part.state.status
-  const text =
-    status === "running"
-      ? part.tool === "task"
-        ? "running task"
-        : `running ${part.tool}`
-      : status === "completed"
-        ? part.state.output
-        : status === "error"
-          ? part.state.error
-          : ""
-  return {
-    kind: "tool",
-    source: "tool",
-    text,
-    phase,
-    messageID: part.messageID,
-    partID: part.id,
-    tool: part.tool,
-    part,
-    toolState: status === "error" ? "error" : status === "completed" ? "completed" : "running",
-    toolError: status === "error" ? part.state.error : undefined,
-  }
-}
-
-type Frame = {
-  key: string
-  commit: StreamCommit
-}
-
-type ToolTrack = {
-  name: string
-  input: Record<string, unknown>
-  started: number
-}
-
-type ChildState = {
-  sessionID: string
-  label: string
-  description: string
-  status: FooterSubagentTab["status"]
-  background: boolean
-  title?: string
-  callIDs: Set<string>
-  lastUpdatedAt: number
-  frames: Frame[]
-  text: Map<string, string>
-  projectedText: Map<string, string>
-  reasoning: Map<string, string>
-  projectedReasoning: Map<string, string>
-  tools: Map<string, ToolTrack>
-  finishedTools: Set<string>
-  messageIDs: Set<string>
-  prompts: Map<string, string>
-  hydrated: boolean
-}
-
-export type SubagentTrackerInput = {
-  sdk: OpenCodeClient
-  sessionID: string
-  thinking: boolean
-  emit: () => void
-}
-
-export type SubagentTracker = {
-  main(event: V2Event): void
-  foreign(sessionID: string, event: V2Event): void
-  hydrate(next: { messages: SessionMessage[]; active: Record<string, unknown> }): Promise<void>
-  select(sessionID: string | undefined): void
-  snapshot(): FooterSubagentState
-}
-
-function record(value: unknown): Record<string, unknown> | undefined {
-  if (typeof value === "object" && value !== null && !Array.isArray(value)) return value as Record<string, unknown>
-  return undefined
-}
-
-function text(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined
-  const next = value.trim()
-  return next || undefined
-}
-
-function childSessionID(structured: Record<string, unknown> | undefined) {
-  const sessionID = text(structured?.sessionID)
-  if (!sessionID || !sessionID.startsWith("ses")) return undefined
-  const status = structured?.status
-  if (status !== "running" && status !== "completed") return undefined
-  return { sessionID, running: status === "running" }
-}
-
-function tab(child: ChildState): FooterSubagentTab {
-  return {
-    sessionID: child.sessionID,
-    partID: `subagent:${child.sessionID}`,
-    callID: `subagent:${child.sessionID}`,
-    label: child.label,
-    description: child.description || child.title || "",
-    status: child.status,
-    background: child.background ? true : undefined,
-    title: child.title,
-    toolCalls: child.callIDs.size > 0 ? child.callIDs.size : undefined,
-    lastUpdatedAt: child.lastUpdatedAt,
-  }
-}
-
-export function createSubagentTracker(input: SubagentTrackerInput): SubagentTracker {
-  const children = new Map<string, ChildState>()
-  // Live subagent tool calls in the parent, so tool.success structured output
-  // can be joined with the call's input metadata.
-  const pendingCalls = new Map<string, Record<string, unknown>>()
-  // Foreign sessions already resolved through session.get. Non-children stay
-  // cached so unrelated concurrent sessions are checked at most once.
-  const checked = new Set<string>()
-  // Foreign events buffered while a session.get discovery is in flight, so a
-  // fast child (including its settled event) is not lost mid-discovery.
-  const pendingEvents = new Map<string, V2Event[]>()
-  const hydrationEvents = new Map<string, V2Event[]>()
-  const hydrationOverflow = new Set<string>()
-  const hydrations = new Map<string, Promise<void>>()
-  let selected: string | undefined
-
-  const ensureChild = (sessionID: string): ChildState => {
-    const existing = children.get(sessionID)
-    const child: ChildState = existing ?? {
-      sessionID,
-      label: FALLBACK_LABEL,
-      description: "",
-      status: "running",
-      background: false,
-      callIDs: new Set(),
-      lastUpdatedAt: Date.now(),
-      frames: [],
-      text: new Map(),
-      projectedText: new Map(),
-      reasoning: new Map(),
-      projectedReasoning: new Map(),
-      tools: new Map(),
-      finishedTools: new Set(),
-      messageIDs: new Set(),
-      prompts: new Map(),
-      hydrated: false,
-    }
-    if (!existing) children.set(sessionID, child)
-    // Adopting a child while its session.get discovery is still in flight:
-    // drain the buffered events now. They arrived before whatever the caller
-    // applies next, so replaying them first preserves bus order, and the
-    // resolved discovery can no longer replay stale events (e.g. step.started)
-    // after a terminal settled event was applied directly.
-    const buffered = pendingEvents.get(sessionID)
-    if (buffered) {
-      pendingEvents.delete(sessionID)
-      for (const event of buffered) reduce(child, event)
-    }
-    return child
-  }
-
-  const touch = (child: ChildState, timestamp?: number) => {
-    child.lastUpdatedAt = Math.max(child.lastUpdatedAt, timestamp ?? Date.now())
-  }
-
-  const notifyDetail = (child: ChildState) => {
-    if (child.sessionID === selected) input.emit()
-  }
-
-  const setFrame = (child: ChildState, key: string, commit: StreamCommit) => {
-    const index = child.frames.findIndex((item) => item.key === key)
-    if (index === -1) {
-      child.frames.push({ key, commit })
-      if (child.frames.length > CHILD_FRAME_LIMIT) child.frames.splice(0, child.frames.length - CHILD_FRAME_LIMIT)
-      return
-    }
-    child.frames[index] = { key, commit }
-  }
-
-  const applyMeta = (child: ChildState, meta: Record<string, unknown> | undefined) => {
-    if (!meta) return
-    const agent = text(meta.agent)
-    if (agent) child.label = Locale.titlecase(agent)
-    const description = text(meta.description)
-    if (description) child.description = description
-    if (meta.background === true) child.background = true
-  }
-
-  const userFrame = (child: ChildState, messageID: string, value: string) => {
-    if (child.messageIDs.has(messageID)) return false
-    child.messageIDs.add(messageID)
-    setFrame(child, `user:${messageID}`, {
-      kind: "user",
-      source: "system",
-      text: value,
-      phase: "start",
-      messageID,
-    })
-    return true
-  }
-
-  const childTool = (child: ChildState, item: SessionMessageAssistantTool, messageID: string) => {
-    const part = legacyTool({
-      sessionID: child.sessionID,
-      messageID,
-      callID: item.id,
-      name: item.name,
-      state: item.state,
-      time: item.time,
-      provider: item.provider,
-    })
-    if (item.state.status === "pending") return
-    child.callIDs.add(item.id)
-    if (item.state.status === "running") {
-      setFrame(child, `tool:${item.id}`, toolCommit(part, "start"))
-      return
-    }
-    child.finishedTools.add(item.id)
-    child.tools.delete(item.id)
-    setFrame(child, `tool:${item.id}`, toolCommit(part, "final"))
-  }
-
-  const rebuild = (child: ChildState, messages: SessionMessage[]) => {
-    child.frames = []
-    child.text.clear()
-    child.projectedText.clear()
-    child.reasoning.clear()
-    child.projectedReasoning.clear()
-    child.finishedTools.clear()
-    child.messageIDs.clear()
-    child.callIDs.clear()
-    for (const message of messages) {
-      if (message.type === "user") {
-        child.prompts.delete(message.id)
-        userFrame(child, message.id, message.text)
-        continue
-      }
-      if (message.type !== "assistant") continue
-      child.messageIDs.add(message.id)
-      for (const item of message.content) {
-        if (item.type === "text") {
-          child.text.set(item.id, item.text)
-          child.projectedText.set(item.id, item.text)
-          setFrame(child, `text:${item.id}`, {
-            kind: "assistant",
-            source: "assistant",
-            text: item.text,
-            phase: "progress",
-            messageID: message.id,
-            partID: item.id,
-          })
-          continue
-        }
-        if (item.type === "reasoning") {
-          child.reasoning.set(item.id, item.text)
-          child.projectedReasoning.set(item.id, item.text)
-          if (input.thinking)
-            setFrame(child, `reasoning:${item.id}`, {
-              kind: "reasoning",
-              source: "reasoning",
-              text: `Thinking: ${item.text}`,
-              phase: "progress",
-              messageID: message.id,
-              partID: item.id,
-            })
-          continue
-        }
-        childTool(child, item, message.id)
-      }
-      if (message.error) {
-        setFrame(child, `error:${message.id}`, {
-          kind: "error",
-          source: "system",
-          text: message.error.message,
-          phase: "start",
-          messageID: message.id,
-        })
-      }
-    }
-  }
-
-  const hydrateChild = (child: ChildState): Promise<void> => {
-    const existing = hydrations.get(child.sessionID)
-    if (existing) return existing
-    const pendingPrompts = new Map(child.prompts)
-    const pendingTools = new Map(child.tools)
-    let retry = false
-    const task = input.sdk.message
-      .list({ sessionID: child.sessionID, limit: CHILD_MESSAGE_LIMIT, order: "desc" })
-      .then((response) => {
-        const buffered = hydrationEvents.get(child.sessionID) ?? []
-        hydrationEvents.delete(child.sessionID)
-        if (hydrationOverflow.delete(child.sessionID)) {
-          child.hydrated = false
-          retry = true
-          notifyDetail(child)
-          return
-        }
-        for (const [id, prompt] of pendingPrompts) {
-          if (!child.prompts.has(id)) child.prompts.set(id, prompt)
-        }
-        rebuild(child, structuredClone(response.data).toReversed() as SessionMessage[])
-        for (const [id, tool] of pendingTools) {
-          if (!child.finishedTools.has(id) && !child.tools.has(id)) child.tools.set(id, tool)
-        }
-        for (const event of buffered) reduce(child, event)
-        child.hydrated = true
-        notifyDetail(child)
-      })
-      .catch(() => {
-        hydrationEvents.delete(child.sessionID)
-        hydrationOverflow.delete(child.sessionID)
-      })
-      .finally(() => {
-        hydrations.delete(child.sessionID)
-        if (retry) queueMicrotask(() => void hydrateChild(child))
-      })
-    hydrations.set(child.sessionID, task)
-    return task
-  }
-
-  const discover = (sessionID: string) => {
-    if (checked.has(sessionID) || children.has(sessionID) || sessionID === input.sessionID) return
-    checked.add(sessionID)
-    if (!pendingEvents.has(sessionID)) pendingEvents.set(sessionID, [])
-    void input.sdk.session
-      .get({ sessionID })
-      .then((session) => {
-        const buffered = pendingEvents.get(sessionID) ?? []
-        pendingEvents.delete(sessionID)
-        if (session.parentID !== input.sessionID) return
-        const child = ensureChild(sessionID)
-        if (session.agent) child.label = Locale.titlecase(session.agent)
-        child.title = session.title
-        for (const event of buffered) reduce(child, event)
-        touch(child)
-        input.emit()
-        void hydrateChild(child)
-      })
-      .catch(() => {
-        // Allow a later event to retry discovery after transient failures.
-        pendingEvents.delete(sessionID)
-        checked.delete(sessionID)
-      })
-  }
-
-  const reduce = (child: ChildState, event: V2Event) => {
-    if (event.type === "session.prompt.admitted") {
-      child.prompts.set(event.data.inputID, event.data.prompt.text)
-      return
-    }
-    if (event.type === "session.prompt.promoted") {
-      const prompt = child.prompts.get(event.data.inputID) ?? ""
-      child.prompts.delete(event.data.inputID)
-      if (userFrame(child, event.data.inputID, prompt)) {
-        touch(child, event.created)
-        notifyDetail(child)
-      }
-      return
-    }
-    if (event.type === "session.step.started") {
-      touch(child, event.created)
-      if (child.label === FALLBACK_LABEL && event.data.agent) child.label = Locale.titlecase(event.data.agent)
-      if (child.status !== "running") child.status = "running"
-      input.emit()
-      return
-    }
-    if (event.type === "session.text.delta") {
-      const projected = child.projectedText.get(event.data.textID)
-      const covered = projected?.indexOf(event.data.delta) ?? -1
-      if (projected && covered >= 0) {
-        child.projectedText.set(event.data.textID, projected.slice(covered + event.data.delta.length))
-        return
-      }
-      const next = (child.text.get(event.data.textID) ?? "") + event.data.delta
-      child.text.set(event.data.textID, next)
-      setFrame(child, `text:${event.data.textID}`, {
-        kind: "assistant",
-        source: "assistant",
-        text: next,
-        phase: "progress",
-        messageID: event.data.assistantMessageID,
-        partID: event.data.textID,
-      })
-      touch(child, event.created)
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.text.ended") {
-      child.text.set(event.data.textID, event.data.text)
-      child.projectedText.delete(event.data.textID)
-      setFrame(child, `text:${event.data.textID}`, {
-        kind: "assistant",
-        source: "assistant",
-        text: event.data.text,
-        phase: "progress",
-        messageID: event.data.assistantMessageID,
-        partID: event.data.textID,
-      })
-      touch(child, event.created)
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.reasoning.delta") {
-      const projected = child.projectedReasoning.get(event.data.reasoningID)
-      const covered = projected?.indexOf(event.data.delta) ?? -1
-      if (projected && covered >= 0) {
-        child.projectedReasoning.set(event.data.reasoningID, projected.slice(covered + event.data.delta.length))
-        return
-      }
-      const next = (child.reasoning.get(event.data.reasoningID) ?? "") + event.data.delta
-      child.reasoning.set(event.data.reasoningID, next)
-      if (!input.thinking) return
-      setFrame(child, `reasoning:${event.data.reasoningID}`, {
-        kind: "reasoning",
-        source: "reasoning",
-        text: `Thinking: ${next}`,
-        phase: "progress",
-        messageID: event.data.assistantMessageID,
-        partID: event.data.reasoningID,
-      })
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.reasoning.ended") {
-      child.reasoning.set(event.data.reasoningID, event.data.text)
-      child.projectedReasoning.delete(event.data.reasoningID)
-      if (!input.thinking) return
-      setFrame(child, `reasoning:${event.data.reasoningID}`, {
-        kind: "reasoning",
-        source: "reasoning",
-        text: `Thinking: ${event.data.text}`,
-        phase: "progress",
-        messageID: event.data.assistantMessageID,
-        partID: event.data.reasoningID,
-      })
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.tool.input.started") {
-      if (child.finishedTools.has(event.data.callID)) return
-      child.tools.set(event.data.callID, { name: event.data.name, input: {}, started: event.created })
-      return
-    }
-    if (event.type === "session.tool.called") {
-      if (child.finishedTools.has(event.data.callID)) return
-      const current = child.tools.get(event.data.callID)
-      child.tools.set(event.data.callID, {
-        name: event.data.tool,
-        input: event.data.input,
-        started: current?.started ?? event.created,
-      })
-      childTool(
-        child,
-        structuredClone({
-          type: "tool",
-          id: event.data.callID,
-          name: event.data.tool,
-          provider: event.data.provider,
-          state: { status: "running", input: event.data.input, structured: {}, content: [] },
-          time: { created: current?.started ?? event.created, ran: event.created },
-        }) as SessionMessageAssistantTool,
-        event.data.assistantMessageID,
-      )
-      touch(child, event.created)
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.tool.success" || event.type === "session.tool.failed") {
-      if (child.finishedTools.has(event.data.callID)) return
-      const current = child.tools.get(event.data.callID)
-      const failed = event.type === "session.tool.failed"
-      childTool(
-        child,
-        structuredClone({
-          type: "tool",
-          id: event.data.callID,
-          name: current?.name ?? "tool",
-          provider: event.data.provider,
-          state: failed
-            ? {
-                status: "error",
-                input: current?.input ?? {},
-                structured: {},
-                content: [],
-                error: event.data.error,
-                result: event.data.result,
-              }
-            : {
-                status: "completed",
-                input: current?.input ?? {},
-                structured: event.data.structured,
-                content: event.data.content,
-                outputPaths: event.data.outputPaths,
-                result: event.data.result,
-              },
-          time: {
-            created: current?.started ?? event.created,
-            ran: current?.started,
-            completed: event.created,
-          },
-        }) as SessionMessageAssistantTool,
-        event.data.assistantMessageID,
-      )
-      touch(child, event.created)
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.step.failed") {
-      setFrame(child, `error:step:${event.data.assistantMessageID}`, {
-        kind: "error",
-        source: "system",
-        text: event.data.error.message,
-        phase: "start",
-        messageID: event.data.assistantMessageID,
-      })
-      touch(child, event.created)
-      notifyDetail(child)
-      return
-    }
-    if (event.type === "session.execution.settled") {
-      child.status =
-        event.data.outcome === "success" ? "completed" : event.data.outcome === "interrupted" ? "cancelled" : "error"
-      touch(child, event.created)
-      input.emit()
-    }
-  }
-
-  const mainTool = (item: SessionMessageAssistantTool, active?: Record<string, unknown>) => {
-    if (item.name !== "subagent" || item.state.status !== "completed") return
-    const found = childSessionID(record(item.state.structured))
-    if (!found) return
-    const child = ensureChild(found.sessionID)
-    applyMeta(child, record(item.state.input))
-    if (found.running) child.background = true
-    if (child.status === "running") {
-      const running = found.running && (!active || found.sessionID in active)
-      child.status = running ? "running" : "completed"
-    }
-    touch(child, item.time.completed ?? item.time.created)
-  }
-
-  return {
-    main(event) {
-      if (event.type === "session.tool.called") {
-        if (event.data.tool === "subagent") pendingCalls.set(event.data.callID, event.data.input)
-        return
-      }
-      if (event.type === "session.tool.failed") {
-        pendingCalls.delete(event.data.callID)
-        return
-      }
-      if (event.type !== "session.tool.success") return
-      const pending = pendingCalls.get(event.data.callID)
-      pendingCalls.delete(event.data.callID)
-      const found = childSessionID(record(event.data.structured))
-      if (!found) return
-      const child = ensureChild(found.sessionID)
-      applyMeta(child, pending)
-      if (found.running) {
-        child.background = true
-        child.status = "running"
-      }
-      if (!found.running && child.status === "running") child.status = "completed"
-      touch(child, event.created)
-      input.emit()
-      if (!child.hydrated) void hydrateChild(child)
-    },
-    foreign(sessionID, event) {
-      const child = children.get(sessionID)
-      if (child) {
-        if (hydrations.has(sessionID)) {
-          const buffered = hydrationEvents.get(sessionID) ?? []
-          if (buffered.length < CHILD_EVENT_BUFFER_LIMIT) buffered.push(event)
-          else hydrationOverflow.add(sessionID)
-          hydrationEvents.set(sessionID, buffered)
-        }
-        reduce(child, event)
-        return
-      }
-      discover(sessionID)
-      const buffered = pendingEvents.get(sessionID)
-      if (buffered && buffered.length < CHILD_EVENT_BUFFER_LIMIT) buffered.push(event)
-    },
-    async hydrate(next) {
-      for (const message of next.messages) {
-        if (message.type !== "assistant") continue
-        for (const item of message.content) {
-          if (item.type === "tool") mainTool(item, next.active)
-        }
-      }
-      // Family index: adopt children directly from the current session list so
-      // historical subagents beyond the projected message window still get tabs.
-      const family = await input.sdk.session
-        .list({ parentID: input.sessionID, limit: FAMILY_LIST_LIMIT, order: "desc" })
-        .then((response) => response.data)
-        .catch(() => [])
-      for (const session of family) {
-        const child = ensureChild(session.id)
-        if (session.agent && child.label === FALLBACK_LABEL) child.label = Locale.titlecase(session.agent)
-        if (!child.title) child.title = session.title
-        touch(child, session.time.updated)
-      }
-      for (const sessionID of Object.keys(next.active)) discover(sessionID)
-      for (const child of children.values()) {
-        // Reconnect can miss a child's settled event; the active map is the
-        // authoritative live signal for still-running children.
-        if (child.status === "running" && !(child.sessionID in next.active)) child.status = "completed"
-      }
-      const current = selected ? children.get(selected) : undefined
-      if (current) await hydrateChild(current)
-      if (children.size > 0) input.emit()
-    },
-    select(sessionID) {
-      selected = sessionID
-      const child = sessionID ? children.get(sessionID) : undefined
-      if (child && !child.hydrated) void hydrateChild(child)
-      input.emit()
-    },
-    snapshot() {
-      const tabs = [...children.values()].map(tab).toSorted((a, b) => {
-        const active = Number(b.status === "running") - Number(a.status === "running")
-        if (active !== 0) return active
-        return b.lastUpdatedAt - a.lastUpdatedAt
-      })
-      const child = selected ? children.get(selected) : undefined
-      const details: Record<string, FooterSubagentDetail> = child
-        ? { [child.sessionID]: { sessionID: child.sessionID, commits: child.frames.map((item) => item.commit) } }
-        : {}
-      return { tabs, details, permissions: [], questions: [] }
-    },
-  }
-}

packages/cli/src/mini/turn-summary.ts

@@ -1,21 +0,0 @@
-import type { StreamCommit } from "./types"
-
-export function turnSummaryCommit(input: {
-  agent: string
-  model: string
-  duration: string
-  messageID?: string
-}): StreamCommit {
-  return {
-    kind: "system",
-    text: `${input.agent} · ${input.model} · ${input.duration}`,
-    phase: "final",
-    source: "system",
-    summary: {
-      agent: input.agent,
-      model: input.model,
-      duration: input.duration,
-    },
-    messageID: input.messageID,
-  }
-}

packages/cli/src/mini/ui.ts

@@ -1,27 +0,0 @@
-import { EOL } from "node:os"
-
-export const Style = {
-  TEXT_DIM: "\x1b[90m",
-  TEXT_NORMAL: "\x1b[0m",
-  TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
-  TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
-}
-
-export function println(...message: string[]) {
-  process.stderr.write(message.join(" ") + EOL)
-}
-
-let blank = false
-
-export function empty() {
-  if (blank) return
-  println(Style.TEXT_NORMAL)
-  blank = true
-}
-
-export function error(message: string) {
-  if (message.startsWith("Error: ")) message = message.slice("Error: ".length)
-  println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
-}
-
-export * as UI from "./ui"

packages/cli/src/server-process.ts

@@ -1,134 +0,0 @@
-export * as ServerProcess from "./server-process"
-
-import { NodeServices } from "@effect/platform-node"
-import { Service } from "@opencode-ai/client/effect"
-import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
-import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { Global } from "@opencode-ai/core/global"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import { AppProcess } from "@opencode-ai/core/process"
-import { Flock } from "@opencode-ai/core/util/flock"
-import { start } from "@opencode-ai/server/process"
-import { randomBytes, randomUUID } from "node:crypto"
-import path from "node:path"
-import { Effect, FileSystem, Logger, Option, Redacted, Schedule, Schema } from "effect"
-import { HttpServer } from "effect/unstable/http"
-import { Env } from "./env"
-import { ServiceConfig } from "./services/service-config"
-import { Updater } from "./services/updater"
-
-export type Mode = "default" | "service" | "stdio"
-
-export type Options = {
-  readonly mode: Mode
-  readonly hostname?: string
-  readonly port?: number
-}
-
-export const run = Effect.fn("cli.server-process.run")((options: Options) =>
-  processEffect(options).pipe(
-    Effect.provide(Updater.layer),
-    Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node]))),
-    Effect.provide(NodeServices.layer),
-  ),
-)
-
-const processEffect = Effect.fnUntraced(function* (options: Options) {
-  if (options.mode === "service") yield* Effect.sync(() => process.chdir(Global.Path.home))
-  return yield* Effect.scoped(
-    Effect.gen(function* () {
-      if (options.mode === "service") {
-        const service = yield* ServiceConfig.options()
-        yield* Flock.effect(path.basename(service.file, ".json") + "-process", {
-          dir: path.dirname(service.file),
-          staleMs: 3_000,
-          timeoutMs: 15_000,
-        })
-      }
-      const environmentPassword = yield* Env.password
-      // Keep the lease credential out of the environment inherited by tools.
-      if (options.mode === "stdio") {
-        delete process.env.OPENCODE_PASSWORD
-        delete process.env.OPENCODE_SERVER_PASSWORD
-      }
-      const config = options.mode === "service" ? yield* ServiceConfig.read() : {}
-      const password =
-        options.mode === "service"
-          ? yield* ServiceConfig.password()
-          : environmentPassword
-            ? Redacted.value(environmentPassword)
-            : randomBytes(32).toString("base64url")
-      if (!password) return yield* Effect.fail(new Error("Missing server password"))
-      const address = yield* start({
-        hostname: options.hostname ?? config.hostname ?? "127.0.0.1",
-        port: Option.fromNullishOr(options.port ?? config.port),
-        password,
-      }).pipe(Effect.provide(Logger.layer([], { mergeWithExisting: false })))
-      if (options.mode === "service") yield* register(address, password)
-      const url = HttpServer.formatAddress(address)
-      console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
-      if (options.mode === "default" && !environmentPassword) console.log(`server password ${password}`)
-      const updater = yield* Updater.Service
-      yield* updater.check().pipe(Effect.schedule(Schedule.spaced("10 minutes")), Effect.forkScoped)
-      return yield* options.mode === "stdio" ? waitForStdinClose() : Effect.never
-    }).pipe(Effect.annotateLogs({ role: "server" })),
-  )
-})
-
-// The latest atomic registration wins. A displaced process notices the new id,
-// exits, and cannot remove its successor's registration from its finalizer.
-const infoJson = Schema.fromJsonString(Service.Info)
-const encodeInfo = Schema.encodeEffect(infoJson)
-const decodeInfo = Schema.decodeUnknownEffect(infoJson)
-
-const register = Effect.fnUntraced(function* (address: HttpServer.Address, password: string) {
-  const fs = yield* FileSystem.FileSystem
-  const options = yield* ServiceConfig.options()
-  const id = randomUUID()
-  const temp = options.file + "." + id + ".tmp"
-  yield* fs.makeDirectory(path.dirname(options.file), { recursive: true })
-  const encoded = yield* encodeInfo({
-    id,
-    version: InstallationVersion,
-    url: HttpServer.formatAddress(address),
-    pid: process.pid,
-    password,
-  })
-  yield* fs.writeFileString(temp, encoded, { mode: 0o600 })
-  yield* fs.rename(temp, options.file)
-  const currentID = fs.readFileString(options.file).pipe(
-    Effect.flatMap(decodeInfo),
-    Effect.map((info) => info.id),
-    Effect.orElseSucceed(() => undefined),
-  )
-  yield* currentID.pipe(
-    Effect.flatMap((current) =>
-      current === id
-        ? Effect.void
-        : Effect.try({ try: () => process.kill(process.pid, "SIGTERM"), catch: (cause) => cause }).pipe(Effect.ignore),
-    ),
-    Effect.repeat(Schedule.spaced("10 seconds")),
-    Effect.forkScoped,
-  )
-  yield* Effect.addFinalizer(() =>
-    currentID.pipe(
-      Effect.flatMap((current) => (current === id ? fs.remove(options.file) : Effect.void)),
-      Effect.ignore,
-    ),
-  )
-})
-
-function waitForStdinClose() {
-  return Effect.callback<void>((resume) => {
-    const close = () => resume(Effect.void)
-    process.stdin.once("end", close)
-    process.stdin.once("close", close)
-    process.stdin.resume()
-    if (process.stdin.readableEnded || process.stdin.destroyed) close()
-    return Effect.sync(() => {
-      process.stdin.off("end", close)
-      process.stdin.off("close", close)
-      process.stdin.pause()
-    })
-  })
-}

packages/cli/src/services/daemon.ts

@@ -0,0 +1,323 @@
+import { Global } from "@opencode-ai/core/global"
+import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/installation/version"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
+import { ServerAuth } from "@opencode-ai/server/auth"
+import { Context, Effect, FileSystem, Layer, Option, Schedule, Schema, Scope } from "effect"
+import { HttpServer } from "effect/unstable/http"
+import { randomBytes, randomUUID } from "crypto"
+import { spawn } from "node:child_process"
+import path from "path"
+
+export interface Interface {
+  readonly client: () => Effect.Effect<ReturnType<typeof createOpencodeClient>, unknown>
+  readonly transport: () => Effect.Effect<{ url: string; headers: RequestInit["headers"] }, unknown>
+  readonly start: () => Effect.Effect<string, Error>
+  readonly status: () => Effect.Effect<string | undefined>
+  readonly stop: () => Effect.Effect<void, unknown>
+  readonly password: (value?: string) => Effect.Effect<string, unknown>
+  readonly config: () => Effect.Effect<ServiceConfig, unknown>
+  readonly get: (key?: string) => Effect.Effect<string, unknown>
+  readonly set: (key: string, value: string) => Effect.Effect<void, unknown>
+  readonly unset: (key: string) => Effect.Effect<void, unknown>
+  readonly register: (address: HttpServer.Address) => Effect.Effect<void, unknown, Scope.Scope>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Daemon") {}
+
+const Registration = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  url: Schema.String,
+  pid: Schema.Int.check(Schema.isGreaterThan(0)),
+})
+type Registration = typeof Registration.Type
+
+const ServiceConfig = Schema.Struct({
+  hostname: Schema.optional(Schema.String),
+  port: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(65_535))),
+  password: Schema.optional(Schema.String),
+  autostart: Schema.optional(Schema.Boolean),
+})
+export type ServiceConfig = typeof ServiceConfig.Type
+
+const serviceConfigKeys = ["hostname", "port", "password", "autostart"] as const
+type ServiceConfigKey = (typeof serviceConfigKeys)[number]
+
+function serviceConfigKey(key: string): ServiceConfigKey {
+  if (serviceConfigKeys.includes(key as ServiceConfigKey)) return key as ServiceConfigKey
+  throw new Error(`Unknown service config key: ${key}`)
+}
+
+function sameRegistration(left: Registration, right: Registration) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
+}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const global = yield* Global.Service
+    const directory = global.state
+    const filename = InstallationChannel === "local" ? "service-local.json" : "service.json"
+    const file = path.join(directory, filename)
+    const configFile = path.join(global.config, filename)
+    const decodeRegistration = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
+    const decodeServiceConfig = Schema.decodeUnknownEffect(Schema.fromJsonString(ServiceConfig))
+
+    const config = Effect.fn("cli.daemon.config")(function* () {
+      return yield* fs.readFileString(configFile).pipe(
+        Effect.flatMap(decodeServiceConfig),
+        Effect.catch(() => Effect.succeed({} as ServiceConfig)),
+      )
+    })
+
+    const writeConfig = Effect.fn("cli.daemon.writeConfig")(function* (value: ServiceConfig) {
+      const temp = configFile + ".tmp"
+      yield* fs.makeDirectory(path.dirname(configFile), { recursive: true })
+      yield* fs.writeFileString(temp, JSON.stringify(value, null, 2) + "\n", { mode: 0o600 })
+      yield* fs.rename(temp, configFile)
+    })
+
+    const password = Effect.fn("cli.daemon.password")(function* (value?: string) {
+      const existing = yield* config()
+      if (value === undefined && existing.password) return existing.password
+      const next = value ?? randomBytes(32).toString("base64url")
+
+      // Keep one private credential across server restarts so discovered clients
+      // can reconnect without exposing a password flag or environment variable.
+      yield* writeConfig({ ...existing, password: next })
+      return next
+    })
+
+    const get = Effect.fn("cli.daemon.get")(function* (key?: string) {
+      if (key === undefined) {
+        const { password: _password, ...safe } = yield* config()
+        return JSON.stringify(safe, null, 2)
+      }
+      switch (serviceConfigKey(key)) {
+        case "hostname": {
+          return (yield* config()).hostname ?? ""
+        }
+        case "port": {
+          const port = (yield* config()).port
+          return port === undefined ? "" : String(port)
+        }
+        case "password": {
+          return yield* password()
+        }
+        case "autostart": {
+          const autostart = (yield* config()).autostart
+          return autostart === undefined ? "" : String(autostart)
+        }
+      }
+    })
+
+    const set = Effect.fn("cli.daemon.set")(function* (key: string, value: string) {
+      switch (serviceConfigKey(key)) {
+        case "hostname": {
+          yield* stop()
+          yield* writeConfig({ ...(yield* config()), hostname: value })
+          return
+        }
+        case "port": {
+          const port = Number(value)
+          if (!Number.isInteger(port) || port < 1 || port > 65_535) throw new Error("Port must be between 1 and 65535")
+          yield* stop()
+          yield* writeConfig({ ...(yield* config()), port })
+          return
+        }
+        case "password": {
+          yield* stop()
+          yield* password(value)
+          return
+        }
+        case "autostart": {
+          if (value !== "true" && value !== "false") throw new Error("Autostart must be true or false")
+          yield* writeConfig({ ...(yield* config()), autostart: value === "true" })
+          return
+        }
+      }
+    })
+
+    const unset = Effect.fn("cli.daemon.unset")(function* (key: string) {
+      switch (serviceConfigKey(key)) {
+        case "hostname": {
+          yield* stop()
+          const { hostname: _hostname, ...next } = yield* config()
+          yield* writeConfig(next)
+          return
+        }
+        case "port": {
+          yield* stop()
+          const { port: _port, ...next } = yield* config()
+          yield* writeConfig(next)
+          return
+        }
+        case "password": {
+          yield* stop()
+          const { password: _password, ...next } = yield* config()
+          yield* writeConfig(next)
+          return
+        }
+        case "autostart": {
+          const { autostart: _autostart, ...next } = yield* config()
+          yield* writeConfig(next)
+          return
+        }
+      }
+    })
+
+    const registration = Effect.fnUntraced(function* () {
+      return yield* fs.readFileString(file).pipe(Effect.flatMap(decodeRegistration))
+    })
+
+    const createClient = Effect.fnUntraced(function* (url: string) {
+      return createOpencodeClient({ baseUrl: url, headers: ServerAuth.headers({ password: yield* password() }) })
+    })
+
+    const healthy = Effect.fnUntraced(function* () {
+      const info = yield* registration()
+      const client = yield* createClient(info.url)
+      const response = yield* Effect.tryPromise(() => client.v2.health.get({ signal: AbortSignal.timeout(2_000) }))
+      if (response.data?.healthy === true) return info
+      return yield* Effect.fail(new Error("Registered server is not healthy"))
+    })
+
+    const remoteTransport = Effect.fn("cli.daemon.remoteTransport")(function* (input: ServiceConfig) {
+      const url = serviceURL(input)
+      const headers = ServerAuth.headers({ password: input.password })
+      const response = yield* Effect.tryPromise(() =>
+        createOpencodeClient({ baseUrl: url, headers }).v2.health.get({ signal: AbortSignal.timeout(2_000) }),
+      )
+      if (response.data?.healthy === true) return { url, headers }
+      return yield* Effect.fail(new Error(`Server is not healthy: ${url}`))
+    })
+
+    const compatible = Effect.fnUntraced(function* () {
+      const info = yield* healthy()
+      if (info.version === InstallationVersion) return info
+      return yield* Effect.fail(new Error("Registered server version does not match the client"))
+    })
+
+    const signal = (pid: number, signal: NodeJS.Signals) =>
+      Effect.try({ try: () => process.kill(pid, signal), catch: (cause) => cause }).pipe(Effect.ignore)
+
+    const awaitStopped = Effect.fnUntraced(function* (pid: number) {
+      const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(
+        Effect.orElseSucceed(() => false),
+      )
+      if (!running) return true
+      return yield* Effect.fail(new Error(`Server process ${pid} is still running`))
+    })
+
+    const stopProcess = Effect.fnUntraced(function* (info: Registration) {
+      const current = yield* healthy().pipe(Effect.option)
+      if (Option.isNone(current) || !sameRegistration(current.value, info)) return
+
+      yield* signal(info.pid, "SIGTERM")
+      const stopped = yield* awaitStopped(info.pid).pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+        Effect.option,
+      )
+      if (Option.isSome(stopped)) return
+
+      const latest = yield* healthy().pipe(Effect.option)
+      if (Option.isNone(latest) || !sameRegistration(latest.value, info)) return
+      yield* signal(info.pid, "SIGKILL")
+      yield* awaitStopped(info.pid).pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+      )
+    })
+
+    const start = Effect.fn("cli.daemon.start")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      const found = Option.getOrUndefined(existing)
+      const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
+      if (found?.version === InstallationVersion) return found.url
+      if (found) yield* stopProcess(found).pipe(Effect.ignore)
+
+      const entrypoint = compiled ? undefined : process.argv[1]
+      if (!compiled && entrypoint === undefined)
+        return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
+      yield* Effect.try({
+        try: () => {
+          spawn(process.execPath, [...(entrypoint ? [entrypoint] : []), "serve", "--service"], {
+            detached: true,
+            stdio: "ignore",
+          }).unref()
+        },
+        catch: (cause) => new Error("Failed to start server", { cause }),
+      })
+
+      return yield* compatible().pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+        Effect.map((info) => info.url),
+        Effect.mapError(() => new Error("Failed to start server")),
+      )
+    })
+
+    const transport = Effect.fn("cli.daemon.transport")(function* () {
+      const current = yield* config()
+      if (current.autostart === false) return yield* remoteTransport(current)
+      return { url: yield* start(), headers: ServerAuth.headers({ password: yield* password() }) }
+    })
+
+    const client = Effect.fn("cli.daemon.client")(function* () {
+      const connection = yield* transport()
+      return createOpencodeClient({ baseUrl: connection.url, headers: connection.headers })
+    })
+
+    const status = Effect.fn("cli.daemon.status")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      const found = Option.getOrUndefined(existing)
+      if (found?.version === InstallationVersion) return found.url
+      if (found) return undefined
+      yield* fs.remove(file).pipe(Effect.ignore)
+      return undefined
+    })
+
+    const stop = Effect.fn("cli.daemon.stop")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      // A stale registration may point at a PID that has since been reused by
+      // another process. Only signal the PID after authenticating the server.
+      if (Option.isNone(existing)) return yield* fs.remove(file).pipe(Effect.ignore)
+      yield* stopProcess(existing.value)
+      yield* fs.remove(file).pipe(Effect.ignore)
+    })
+
+    const register = Effect.fn("cli.daemon.register")(function* (address: HttpServer.Address) {
+      const id = randomUUID()
+      const temp = file + "." + id + ".tmp"
+      yield* fs.makeDirectory(directory, { recursive: true })
+      yield* fs.writeFileString(
+        temp,
+        JSON.stringify({ id, version: InstallationVersion, url: HttpServer.formatAddress(address), pid: process.pid }),
+        { mode: 0o600 },
+      )
+      yield* fs.rename(temp, file)
+      yield* registration().pipe(
+        Effect.flatMap((info) => (info.id === id ? Effect.void : signal(process.pid, "SIGTERM"))),
+        Effect.catch(() => signal(process.pid, "SIGTERM")),
+        Effect.repeat(Schedule.spaced("10 seconds")),
+        Effect.forkScoped,
+      )
+      yield* Effect.addFinalizer(() =>
+        registration().pipe(
+          Effect.flatMap((info) => (info.id === id ? fs.remove(file) : Effect.void)),
+          Effect.ignore,
+        ),
+      )
+    })
+
+    return Service.of({ client, transport, start, status, stop, password, config, get, set, unset, register })
+  }),
+)
+
+function serviceURL(config: ServiceConfig) {
+  const hostname = config.hostname ?? "127.0.0.1"
+  const result = new URL(`http://${hostname.includes(":") && !hostname.startsWith("[") ? `[${hostname}]` : hostname}`)
+  result.port = String(config.port ?? 4096)
+  return result.toString()
+}
+
+export * as Daemon from "./daemon"

packages/cli/src/services/service-config.ts

@@ -1,143 +0,0 @@
-import { Global } from "@opencode-ai/core/global"
-import { InstallationChannel, InstallationVersion } from "@opencode-ai/core/installation/version"
-import { Service } from "@opencode-ai/client/effect"
-import { Effect, FileSystem, Schema } from "effect"
-import { randomBytes } from "crypto"
-import path from "path"
-
-// The CLI's service configuration file, plus the Service.Options binding that
-// points the client package's service operations at this CLI: which
-// registration file (by channel), which version, and how to spawn opencode.
-
-export const Info = Schema.Struct({
-  hostname: Schema.optional(Schema.String),
-  port: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(65_535))),
-  password: Schema.optional(Schema.String),
-})
-export type Info = typeof Info.Type
-
-const keys = ["hostname", "port", "password"] as const
-type Key = (typeof keys)[number]
-
-const decodeInfo = Schema.decodeUnknownEffect(Schema.fromJsonString(Info))
-
-function configKey(key: string): Key {
-  if (keys.includes(key as Key)) return key as Key
-  throw new Error(`Unknown service config key: ${key}`)
-}
-
-const env = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem
-  const global = yield* Global.Service
-  const filename = InstallationChannel === "local" ? "service-local.json" : "service.json"
-  return {
-    fs,
-    file: path.join(global.state, filename),
-    configFile: path.join(global.config, filename),
-  }
-})
-
-export const options = Effect.fnUntraced(function* () {
-  const { file } = yield* env
-  const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
-  const entrypoint = compiled ? undefined : process.argv[1]
-  if (!compiled && entrypoint === undefined) return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
-  return {
-    file,
-    version: InstallationVersion,
-    command: [process.execPath, ...(entrypoint ? [entrypoint] : []), "serve", "--service"],
-  }
-})
-
-export const read = Effect.fn("cli.service-config.read")(function* () {
-  const { fs, configFile } = yield* env
-  return yield* fs.readFileString(configFile).pipe(
-    Effect.flatMap(decodeInfo),
-    Effect.catch(() => Effect.succeed({} as Info)),
-  )
-})
-
-const write = Effect.fn("cli.service-config.write")(function* (value: Info) {
-  const { fs, configFile } = yield* env
-  const temp = configFile + ".tmp"
-  yield* fs.makeDirectory(path.dirname(configFile), { recursive: true })
-  yield* fs.writeFileString(temp, JSON.stringify(value, null, 2) + "\n", { mode: 0o600 })
-  yield* fs.rename(temp, configFile)
-})
-
-export const password = Effect.fn("cli.service-config.password")(function* (value?: string) {
-  const existing = yield* read()
-  if (value === undefined && existing.password) return existing.password
-  const next = value ?? randomBytes(32).toString("base64url")
-
-  // Keep one private credential across server restarts so discovered clients
-  // can reconnect without exposing a password flag or environment variable.
-  yield* write({ ...existing, password: next })
-  return next
-})
-
-export const get = Effect.fn("cli.service-config.get")(function* (key?: string) {
-  if (key === undefined) {
-    const { password: _password, ...safe } = yield* read()
-    return JSON.stringify(safe, null, 2)
-  }
-  switch (configKey(key)) {
-    case "hostname": {
-      return (yield* read()).hostname ?? ""
-    }
-    case "port": {
-      const port = (yield* read()).port
-      return port === undefined ? "" : String(port)
-    }
-    case "password": {
-      return yield* password()
-    }
-  }
-})
-
-export const set = Effect.fn("cli.service-config.set")(function* (key: string, value: string) {
-  switch (configKey(key)) {
-    case "hostname": {
-      yield* Service.stop(yield* options())
-      yield* write({ ...(yield* read()), hostname: value })
-      return
-    }
-    case "port": {
-      const port = Number(value)
-      if (!Number.isInteger(port) || port < 1 || port > 65_535) throw new Error("Port must be between 1 and 65535")
-      yield* Service.stop(yield* options())
-      yield* write({ ...(yield* read()), port })
-      return
-    }
-    case "password": {
-      yield* Service.stop(yield* options())
-      yield* password(value)
-      return
-    }
-  }
-})
-
-export const unset = Effect.fn("cli.service-config.unset")(function* (key: string) {
-  switch (configKey(key)) {
-    case "hostname": {
-      yield* Service.stop(yield* options())
-      const { hostname: _hostname, ...next } = yield* read()
-      yield* write(next)
-      return
-    }
-    case "port": {
-      yield* Service.stop(yield* options())
-      const { port: _port, ...next } = yield* read()
-      yield* write(next)
-      return
-    }
-    case "password": {
-      yield* Service.stop(yield* options())
-      const { password: _password, ...next } = yield* read()
-      yield* write(next)
-      return
-    }
-  }
-})
-
-export * as ServiceConfig from "./service-config"

packages/cli/src/services/standalone.ts

@@ -9,21 +9,13 @@ import path from "node:path"
 const Ready = Schema.Struct({ url: Schema.String })
 const decodeReady = Schema.decodeUnknownPromise(Schema.fromJsonString(Ready))
 
-type Options = {
-  readonly command?: ReadonlyArray<string>
-}
-
-function command(password: string, options: Options) {
+function command(password: string) {
   const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
   const entrypoint = compiled ? [] : process.argv[1] ? [process.argv[1]] : []
   if (!compiled && entrypoint.length === 0) throw new Error("Failed to resolve CLI entrypoint")
-  const [executable, ...args] = options.command ?? [process.execPath, ...entrypoint, "serve"]
-  if (!executable) throw new Error("Failed to resolve standalone server command")
-  return ChildProcess.make(executable, [...args, "--stdio", "--port", "0"], {
+  return ChildProcess.make(process.execPath, [...entrypoint, "serve", "--stdio", "--port", "0"], {
     cwd: process.cwd(),
-    // Explicit entry wins over anything inherited, so a user-exported
-    // OPENCODE_PASSWORD cannot shadow the child's lease credential.
-    env: { OPENCODE_PASSWORD: password },
+    env: { OPENCODE_SERVER_PASSWORD: password },
     extendEnv: true,
     // The server treats EOF on this pipe as the end of its ownership lease.
     // The OS closes it even when the TUI is killed before Effect finalizers run.
@@ -34,21 +26,17 @@ function command(password: string, options: Options) {
   })
 }
 
-const makeTransport = Effect.fn("cli.standalone.transport")(
-  function* (options: Options) {
+export const transport = Effect.fn("cli.standalone.transport")(
+  function* () {
     const password = randomBytes(32).toString("base64url")
     const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-    const proc = yield* spawner.spawn(command(password, options))
+    const proc = yield* spawner.spawn(command(password))
     const output = yield* proc.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.take(1), Stream.mkString)
     if (!output) return yield* Effect.fail(new Error("Standalone server exited before reporting readiness"))
     const ready = yield* Effect.tryPromise(() => decodeReady(output))
-    return { url: ready.url, headers: ServerAuth.headers({ password, username: "opencode" }), pid: proc.pid }
+    return { url: ready.url, headers: ServerAuth.headers({ password }), pid: proc.pid }
   },
   Effect.provide(AppNodeBuilder.build(CrossSpawnSpawner.node)),
 )
 
-export function transport(options: Options = {}) {
-  return makeTransport(options)
-}
-
 export * as Standalone from "./standalone"

packages/cli/src/tui.ts

@@ -4,17 +4,13 @@ import { Effect } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { Global } from "@opencode-ai/core/global"
 import { loadBuiltinPlugins } from "@opencode-ai/tui/builtins"
-import { OpenCode } from "@opencode-ai/client/promise"
-import type { Service } from "@opencode-ai/client/effect"
+import { OpenCode } from "@opencode-ai/client"
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
 import type { Args } from "@opencode-ai/tui/context/args"
 
-export function runTui(
-  transport: Service.Transport,
-  args: Args,
-  discover?: () => Promise<Service.Transport>,
-  reload?: () => Promise<void>,
-) {
+type Transport = { url: string; headers: RequestInit["headers"] }
+
+export function runTui(transport: Transport, args: Args, reload?: () => Promise<Transport>) {
   const config = TuiConfig.resolve({}, { terminalSuspend: false })
   let disposeSlots: (() => void) | undefined
   return Effect.gen(function* () {
@@ -29,16 +25,15 @@ export function runTui(
     return yield* run({
       client: createOpencodeClient({ ...options, directory }),
       api,
-      discover: discover
+      reload: reload
         ? async () => {
-            const next = await discover()
+            const next = await reload()
             return {
               client: createOpencodeClient({ baseUrl: next.url, headers: next.headers, directory }),
               api: OpenCode.make({ baseUrl: next.url, headers: next.headers }),
             }
           }
         : undefined,
-      reload,
       args,
       config,
       pluginHost: {

packages/cli/test/daemon.test.ts

@@ -5,19 +5,23 @@ import { Effect } from "effect"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
-import { ServiceConfig } from "../src/services/service-config"
+import { Daemon } from "../src/services/daemon"
 
 test("local channel stores service config with the local service filename", async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-"))
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-daemon-"))
   try {
     await Effect.runPromise(
-      ServiceConfig.set("hostname", "127.0.0.2").pipe(
+      Effect.gen(function* () {
+        const daemon = yield* Daemon.Service
+        yield* daemon.set("autostart", "false")
+      }).pipe(
+        Effect.provide(Daemon.layer),
         Effect.provide(Global.layerWith({ config: path.join(root, "config"), state: path.join(root, "state") })),
         Effect.provide(NodeFileSystem.layer),
       ),
     )
     expect(await Bun.file(path.join(root, "config", "service-local.json")).json()).toEqual({
-      hostname: "127.0.0.2",
+      autostart: false,
     })
     expect(await Bun.file(path.join(root, "config", "service.json")).exists()).toBe(false)
   } finally {

packages/cli/test/fixture/standalone-owner.ts

@@ -8,8 +8,7 @@ await Effect.runPromise(
   Effect.scoped(
     Effect.gen(function* () {
       const transport = yield* Standalone.transport()
-      const response = yield* Effect.promise(() => fetch(new URL("/api/health", transport.url), { headers: transport.headers }))
-      console.log(`${transport.pid} ${transport.url} ${response.status}`)
+      console.log(`${transport.pid} ${transport.url}`)
       return yield* Effect.never
     }),
   ),

packages/cli/test/mini.test.ts

@@ -1,142 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { InstallationVersion } from "@opencode-ai/core/installation/version"
-import path from "node:path"
-import { mergeInteractiveInput, mergeNonInteractiveInput, pickRunModel } from "../src/mini"
-
-async function cli(args: string[]) {
-  const child = Bun.spawn([process.execPath, "run", "src/index.ts", ...args], {
-    cwd: path.join(import.meta.dir, ".."),
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(child.stdout).text(),
-    new Response(child.stderr).text(),
-    child.exited,
-  ])
-  return { stdout, stderr, exitCode }
-}
-
-describe("mini command", () => {
-  test("uses piped stdin as the initial prompt", () => {
-    expect(mergeInteractiveInput("from stdin", undefined)).toBe("from stdin")
-    expect(mergeInteractiveInput("from stdin", "from flag")).toBe("from stdin\nfrom flag")
-  })
-
-  test("keeps run as mini's non-interactive input mode", () => {
-    expect(mergeNonInteractiveInput("from args", "from stdin")).toBe("from args\nfrom stdin")
-    expect(mergeNonInteractiveInput(undefined, "from stdin")).toBe("from stdin")
-  })
-
-  test("applies a variant to a resumed session's model", () => {
-    expect(
-      pickRunModel(
-        undefined,
-        "high",
-        { providerID: "session-provider", modelID: "session-model" },
-        { providerID: "default-provider", modelID: "default-model" },
-      ),
-    ).toEqual({ providerID: "session-provider", modelID: "session-model" })
-  })
-
-  test("is registered in the preview CLI", async () => {
-    const result = await cli(["--help"])
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain("mini       Start the minimal interactive interface")
-    expect(result.stdout).toContain("run        Run OpenCode with a message")
-  })
-
-  test("exposes run without legacy attach or command modes", async () => {
-    const result = await cli(["run", "--help"])
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain("--server string")
-    expect(result.stdout).not.toContain("--attach")
-    expect(result.stdout).not.toContain("--command")
-  })
-
-  test("keeps option-like prompt text after the argument separator", async () => {
-    const result = await cli(["run", "--server", "http://127.0.0.1:1", "--", "--foo"])
-
-    expect(result.exitCode).toBe(1)
-    expect(result.stderr).not.toContain("You must provide a message")
-  })
-
-  test("preserves a run failure exit code", async () => {
-    let modelRequests = 0
-    const server = Bun.serve({
-      port: 0,
-      fetch(request) {
-        const url = new URL(request.url)
-        if (url.pathname === "/api/health")
-          return Response.json({ healthy: true, version: InstallationVersion, pid: process.pid })
-        if (url.pathname === "/api/model") {
-          modelRequests++
-          return Response.json({
-            location: { directory: process.cwd(), project: { id: "global", directory: process.cwd() } },
-            data: modelRequests === 1 ? [{ id: "missing", providerID: "definitely" }] : [],
-          })
-        }
-        return new Response(undefined, { status: 404 })
-      },
-    })
-
-    try {
-      const result = await cli([
-        "run",
-        "--server",
-        server.url.toString(),
-        "--dir",
-        process.cwd(),
-        "--model",
-        "definitely/missing",
-        "hi",
-      ])
-
-      expect(result.exitCode).toBe(1)
-      expect(result.stderr).toContain("Model unavailable: definitely/missing")
-    } finally {
-      server.stop(true)
-    }
-  })
-
-  test("reports pre-admission errors as JSON", async () => {
-    const server = Bun.serve({
-      port: 0,
-      fetch() {
-        return Response.json({ healthy: true, version: "incompatible", pid: process.pid })
-      },
-    })
-
-    try {
-      const result = await cli(["run", "--format", "json", "--server", server.url.toString(), "hi"])
-
-      expect(result.exitCode).toBe(1)
-      expect(JSON.parse(result.stdout)).toMatchObject({
-        type: "error",
-        sessionID: "",
-        error: { type: "unknown", message: "Failed to resolve server directory" },
-      })
-    } finally {
-      server.stop(true)
-    }
-  })
-
-  test("uses the shared V2 server option instead of an attach command", async () => {
-    const result = await cli(["mini", "--help"])
-
-    expect(result.exitCode).toBe(0)
-    expect(result.stdout).toContain("--server string")
-    expect(result.stdout).not.toContain("SUBCOMMANDS")
-  })
-
-  test("routes local and explicit-server invocations into mini", async () => {
-    for (const args of [["mini"], ["mini", "--server", "http://127.0.0.1:1"]]) {
-      const result = await cli(args)
-
-      expect(result.exitCode).toBe(1)
-      expect(result.stderr).toContain("opencode mini requires a TTY stdout")
-    }
-  })
-})

packages/cli/test/standalone.test.ts

@@ -4,19 +4,18 @@ import path from "node:path"
 test("standalone server exits when its owner is killed", async () => {
   const owner = Bun.spawn([process.execPath, path.join(import.meta.dir, "fixture/standalone-owner.ts")], {
     cwd: path.join(import.meta.dir, ".."),
-    env: { ...process.env, OPENCODE_SERVER_USERNAME: "custom" },
+    env: process.env,
     stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
   })
   const line = await Promise.race([readLine(owner.stdout), Bun.sleep(10_000).then(() => undefined)])
-  const [rawPID, url, status] = line?.split(" ") ?? []
+  const [rawPID, url] = line?.split(" ") ?? []
   const pid = Number(rawPID)
 
   try {
     expect(pid).toBeGreaterThan(0)
     expect(url).toStartWith("http://127.0.0.1:")
-    expect(status).toBe("200")
     expect(running(pid)).toBe(true)
 
     owner.kill("SIGKILL")

packages/client/package.json

@@ -1,30 +1,16 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode-ai/client",
-  "version": "1.17.13",
+  "private": true,
   "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git",
-    "directory": "packages/client"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist"
-  ],
   "exports": {
-    "./promise": "./src/promise/index.ts",
-    "./promise/api": "./src/promise/api.ts",
-    "./effect": "./src/effect/index.ts",
-    "./effect/api": "./src/effect/api.ts"
+    ".": "./src/index.ts",
+    "./effect": "./src/effect.ts"
   },
   "scripts": {
-    "build": "bun run script/build-package.ts",
     "generate": "bun run script/build.ts",
-    "check:generated": "bun run generate && git diff --exit-code -- src/promise/generated src/effect/generated src/effect/api",
+    "check:generated": "bun run generate && git diff --exit-code -- src/generated src/generated-effect",
     "test": "bun test --timeout 5000",
     "typecheck": "tsgo --noEmit"
   },
@@ -42,7 +28,9 @@
   },
   "devDependencies": {
     "@effect/platform-node": "catalog:",
+    "@opencode-ai/core": "workspace:*",
     "@opencode-ai/httpapi-codegen": "workspace:*",
+    "@opencode-ai/server": "workspace:*",
     "@tsconfig/bun": "catalog:",
     "@types/bun": "catalog:",
     "@typescript/native-preview": "catalog:",

packages/client/script/build-package.ts

@@ -1,9 +0,0 @@
-#!/usr/bin/env bun
-
-import { $ } from "bun"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-await $`rm -rf dist`
-await $`bun tsc -p tsconfig.build.json`

packages/client/script/build.ts

@@ -25,15 +25,15 @@ await Effect.runPromise(
             },
           },
         }),
-        fileURLToPath(new URL("../src/promise/generated", import.meta.url)),
+        fileURLToPath(new URL("../src/generated", import.meta.url)),
       ),
       write(
-        emitEffectImported(effectContract, { module: "../../contract", api: "ClientApi" }),
-        fileURLToPath(new URL("../src/effect/generated", import.meta.url)),
+        emitEffectImported(effectContract, { module: "../contract", api: "ClientApi" }),
+        fileURLToPath(new URL("../src/generated-effect", import.meta.url)),
       ),
       write(
-        emitEffectShape(effectContract, { module: "../../contract", api: "ClientApi" }),
-        fileURLToPath(new URL("../src/effect/api", import.meta.url)),
+        emitEffectShape(effectContract, { module: "@opencode-ai/protocol/client", api: "ClientApi" }),
+        fileURLToPath(new URL("../../plugin/src/v2/effect/generated", import.meta.url)),
       ),
     ],
     { concurrency: 3, discard: true },

packages/client/script/publish.ts

@@ -1,45 +0,0 @@
-#!/usr/bin/env bun
-
-import { Script } from "@opencode-ai/script"
-import { $ } from "bun"
-import { rm } from "node:fs/promises"
-import { fileURLToPath } from "node:url"
-
-process.chdir(fileURLToPath(new URL("..", import.meta.url)))
-
-const originalText = await Bun.file("package.json").text()
-const pkg = JSON.parse(originalText) as {
-  name: string
-  version: string
-  exports: Record<string, string | { import: string; types: string }>
-}
-const tarball = `${pkg.name.replace("@", "").replace("/", "-")}-${pkg.version}.tgz`
-
-if ((await $`npm view ${pkg.name}@${pkg.version} version`.nothrow()).exitCode === 0) {
-  console.log(`already published ${pkg.name}@${pkg.version}`)
-  process.exit(0)
-}
-
-try {
-  await $`bun run typecheck`
-  await $`bun run build`
-  pkg.exports = Object.fromEntries(
-    Object.entries(pkg.exports).map(([key, value]) => {
-      if (typeof value !== "string") return [key, value]
-      return [
-        key,
-        {
-          import: value.replace("./src/", "./dist/").replace(/\.ts$/, ".js"),
-          types: value.replace("./src/", "./dist/").replace(/\.ts$/, ".d.ts"),
-        },
-      ]
-    }),
-  )
-  await Bun.write("package.json", JSON.stringify(pkg, null, 2) + "\n")
-  await rm(tarball, { force: true })
-  await $`bun pm pack`
-  await $`npm publish ${tarball} --tag ${Script.channel} --access public`
-} finally {
-  await Bun.write("package.json", originalText)
-  await rm(tarball, { force: true })
-}

packages/client/src/effect.ts

@@ -1,30 +1,10 @@
 // TODO: Keep additional network capabilities inside Schema and Protocol as the client grows; /effect must never import
 // Core or Server. Preserve these datatype exports so internal model reorganizations do not require caller migrations.
-import type { Effect } from "effect"
-
-export * from "./generated/index"
-export type {
-  AgentApi,
-  AppApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  IntegrationApi,
-  ModelApi,
-  PluginApi,
-  ProviderApi,
-  ReferenceApi,
-  SessionApi,
-  SkillApi,
-} from "./api.js"
-export { Service } from "./service.js"
+export * from "./generated-effect/index"
 export { Agent } from "@opencode-ai/schema/agent"
 export { Command } from "@opencode-ai/schema/command"
 export { Credential } from "@opencode-ai/schema/credential"
-export { Event } from "@opencode-ai/schema/event"
-export { EventLog } from "@opencode-ai/schema/event-log"
 export { FileSystem } from "@opencode-ai/schema/filesystem"
-export { Form } from "@opencode-ai/schema/form"
 export { Integration } from "@opencode-ai/schema/integration"
 export { Location } from "@opencode-ai/schema/location"
 export { Model } from "@opencode-ai/schema/model"
@@ -43,4 +23,3 @@ export { SessionMessage } from "@opencode-ai/schema/session-message"
 export { Skill } from "@opencode-ai/schema/skill"
 export { Prompt } from "@opencode-ai/schema/prompt"
 export type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
-export type OpenCodeClient = Effect.Success<ReturnType<typeof import("./generated/client").make>>

packages/client/src/effect/api.ts

@@ -1,8 +0,0 @@
-import type { ModelApi, ProviderApi } from "./api/api.js"
-
-export type * from "./api/api.js"
-
-export interface CatalogApi<E = never> {
-  readonly provider: ProviderApi<E>
-  readonly model: ModelApi<E>
-}

packages/client/src/effect/service.ts

@@ -1,194 +0,0 @@
-import { Effect, FileSystem, Option, Schedule, Schema } from "effect"
-import { spawn } from "node:child_process"
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-// Find, start, and stop the local opencode background service.
-//
-// The service daemon advertises itself through a registration file in the
-// user's state directory: url, pid, version, and the private password, with
-// 0600 permissions. That file is the complete discovery contract — reading it
-// is all a client needs to connect. The daemon's own configuration (port,
-// persisted password) is CLI-owned and never read here.
-
-export type Transport = {
-  readonly url: string
-  readonly headers?: RequestInit["headers"]
-}
-
-export type Options = {
-  // Absolute path to the service registration file. Defaults to
-  // opencode/service.json in the XDG state directory.
-  readonly file?: string
-  // When set, discovery only returns a server reporting this exact version,
-  // and start() replaces a healthy server whose version differs.
-  readonly version?: string
-  // Argv used to spawn the service. Defaults to ["opencode", "serve",
-  // "--service"] resolved from PATH.
-  readonly command?: ReadonlyArray<string>
-}
-
-// Read-only lookup: registration file plus health check and version gate.
-// Never spawns; escalation to start() is the caller's policy.
-export const discover = Effect.fn("service.discover")(function* (options: Options = {}) {
-  return (yield* discoverLocal(options))?.transport
-})
-
-const discoverLocal = Effect.fnUntraced(function* (options: Options) {
-  const info = yield* read(options.file)
-  if (info === undefined) return undefined
-  if (options.version !== undefined && info.version !== options.version) return undefined
-  return yield* probe(info, options.version)
-})
-
-// Idempotent ensure-running: reuses a healthy compatible server, replaces a
-// version-mismatched one, and otherwise spawns the service command detached.
-export const start = Effect.fn("service.start")(function* (options: Options = {}) {
-  const compatible = yield* discover(options)
-  if (compatible !== undefined) return compatible
-  const mismatched = yield* find(options)
-  if (mismatched !== undefined) yield* kill(mismatched.info, options).pipe(Effect.ignore)
-
-  const [command, ...args] = options.command ?? ["opencode", "serve", "--service"]
-  if (command === undefined) return yield* Effect.fail(new Error("Missing service command"))
-  const child = yield* Effect.try({
-    try: () => {
-      const child = spawn(command, args, { detached: true, stdio: "ignore" })
-      child.unref()
-      return child
-    },
-    catch: (cause) => new Error("Failed to start server", { cause }),
-  })
-
-  return yield* discoverLocal(options).pipe(
-    Effect.flatMap((found) =>
-      found === undefined ? Effect.fail(new Error("Server is not ready")) : Effect.succeed(found),
-    ),
-    Effect.retry(poll),
-    Effect.tap((found) =>
-      found.info.pid === child.pid
-        ? Effect.void
-        : Effect.sync(() => {
-            child.kill("SIGTERM")
-          }),
-    ),
-    Effect.map((found) => found.transport),
-    Effect.tapError(() => Effect.try({ try: () => child.kill("SIGTERM"), catch: () => undefined }).pipe(Effect.ignore)),
-    Effect.mapError(() => new Error("Failed to start server")),
-  )
-})
-
-export const stop = Effect.fn("service.stop")(function* (options: Options = {}) {
-  const fs = yield* FileSystem.FileSystem
-  const existing = yield* find(options)
-  if (existing !== undefined) yield* kill(existing.info, options)
-  yield* fs.remove(options.file ?? fallback()).pipe(Effect.ignore)
-})
-
-function fallback() {
-  const state = process.env["XDG_STATE_HOME"] ?? join(homedir(), ".local", "state")
-  return join(state, "opencode", "service.json")
-}
-
-function auth(password: string): RequestInit["headers"] {
-  return { authorization: "Basic " + btoa("opencode:" + password) }
-}
-
-export const Info = Schema.Struct({
-  id: Schema.optional(Schema.String),
-  version: Schema.optional(Schema.String),
-  url: Schema.String,
-  pid: Schema.Int.check(Schema.isGreaterThan(0)),
-  password: Schema.optional(Schema.String),
-})
-export type Info = typeof Info.Type
-
-const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(Info))
-const decodeHealth = Schema.decodeUnknownOption(
-  Schema.Struct({ healthy: Schema.Literal(true), version: Schema.String, pid: Schema.Int }),
-)
-const decodeLegacyHealth = Schema.decodeUnknownOption(Schema.Struct({ healthy: Schema.Literal(true) }))
-
-// A missing or corrupt file means no valid info; callers treat both
-// the same (the registering server self-evicts, clients rediscover).
-const read = Effect.fnUntraced(function* (file?: string) {
-  const fs = yield* FileSystem.FileSystem
-  const text = yield* fs.readFileString(file ?? fallback()).pipe(Effect.option)
-  if (Option.isNone(text)) return undefined
-  return yield* decode(text.value).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-})
-
-type LocalService = {
-  readonly info: Info
-  readonly transport: Transport
-}
-
-const probe = Effect.fnUntraced(function* (info: Info, version?: string, allowLegacy = false) {
-  const headers = info.password === undefined ? undefined : auth(info.password)
-  const response = yield* Effect.tryPromise(() =>
-    fetch(new URL("/api/health", info.url), {
-      headers,
-      signal: AbortSignal.timeout(2_000),
-    }),
-  ).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-  if (response === undefined || !response.ok) return undefined
-  const body = yield* Effect.tryPromise(() => response.json()).pipe(Effect.option, Effect.map(Option.getOrUndefined))
-  const health = decodeHealth(body)
-  if (Option.isSome(health)) {
-    if (health.value.pid !== info.pid) return undefined
-    if (info.version !== undefined && health.value.version !== info.version) return undefined
-    if (version !== undefined && health.value.version !== version) return undefined
-    return { info, transport: { url: info.url, headers } } satisfies LocalService
-  }
-  if (
-    !allowLegacy ||
-    Option.isNone(decodeLegacyHealth(body)) ||
-    (typeof body === "object" && body !== null && ("version" in body || "pid" in body))
-  )
-    return undefined
-  return { info, transport: { url: info.url, headers } } satisfies LocalService
-})
-
-// Health-checked lookup without the version gate: lifecycle operations must be
-// able to see (and replace or stop) a server from a different version.
-const find = Effect.fnUntraced(function* (options: Options) {
-  const info = yield* read(options.file)
-  if (info === undefined) return undefined
-  return yield* probe(info, undefined, true)
-})
-
-// 50ms cadence bounded at ~5s, shared by stop escalation and start readiness.
-const poll = Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))
-
-const signal = (pid: number, name: NodeJS.Signals) =>
-  Effect.try({ try: () => process.kill(pid, name), catch: (cause) => cause }).pipe(Effect.ignore)
-
-const stopped = Effect.fnUntraced(function* (pid: number) {
-  const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(
-    Effect.orElseSucceed(() => false),
-  )
-  if (!running) return true
-  return yield* Effect.fail(new Error(`Server process ${pid} is still running`))
-})
-
-function same(left: Info, right: Info) {
-  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
-}
-
-const kill = Effect.fnUntraced(function* (info: Info, options: Options) {
-  // A stale registration may point at a PID that has since been reused by
-  // another process. Only signal the PID after authenticating the server.
-  const current = yield* find(options)
-  if (current === undefined || !same(current.info, info)) return
-
-  yield* signal(info.pid, "SIGTERM")
-  const done = yield* stopped(info.pid).pipe(Effect.retry(poll), Effect.option)
-  if (Option.isSome(done)) return
-
-  const latest = yield* find(options)
-  if (latest === undefined || !same(latest.info, info)) return
-  yield* signal(info.pid, "SIGKILL")
-  yield* stopped(info.pid).pipe(Effect.retry(poll))
-})
-
-export * as Service from "./service.js"

packages/client/src/generated/client.ts

@@ -23,14 +23,8 @@ import type {
   SessionRenameOutput,
   SessionPromptInput,
   SessionPromptOutput,
-  SessionCommandInput,
-  SessionCommandOutput,
   SessionSkillInput,
   SessionSkillOutput,
-  SessionSyntheticInput,
-  SessionSyntheticOutput,
-  SessionShellInput,
-  SessionShellOutput,
   SessionCompactInput,
   SessionCompactOutput,
   SessionWaitInput,
@@ -43,14 +37,10 @@ import type {
   SessionRevertCommitOutput,
   SessionContextInput,
   SessionContextOutput,
-  SessionListContextEntriesInput,
-  SessionListContextEntriesOutput,
-  SessionPutContextEntryInput,
-  SessionPutContextEntryOutput,
-  SessionRemoveContextEntryInput,
-  SessionRemoveContextEntryOutput,
-  SessionLogInput,
-  SessionLogOutput,
+  SessionHistoryInput,
+  SessionHistoryOutput,
+  SessionEventsInput,
+  SessionEventsOutput,
   SessionInterruptInput,
   SessionInterruptOutput,
   SessionBackgroundInput,
@@ -61,8 +51,6 @@ import type {
   MessageListOutput,
   ModelListInput,
   ModelListOutput,
-  ModelDefaultInput,
-  ModelDefaultOutput,
   GenerateTextInput,
   GenerateTextOutput,
   ProviderListInput,
@@ -89,25 +77,10 @@ import type {
   CredentialUpdateOutput,
   CredentialRemoveInput,
   CredentialRemoveOutput,
-  ProjectListOutput,
   ProjectCurrentInput,
   ProjectCurrentOutput,
   ProjectDirectoriesInput,
   ProjectDirectoriesOutput,
-  FormListRequestsInput,
-  FormListRequestsOutput,
-  FormListInput,
-  FormListOutput,
-  FormCreateInput,
-  FormCreateOutput,
-  FormGetInput,
-  FormGetOutput,
-  FormStateInput,
-  FormStateOutput,
-  FormReplyInput,
-  FormReplyOutput,
-  FormCancelInput,
-  FormCancelOutput,
   PermissionListRequestsInput,
   PermissionListRequestsOutput,
   PermissionListSavedInput,
@@ -169,11 +142,6 @@ import type {
   ProjectCopyRemoveOutput,
   ProjectCopyRefreshInput,
   ProjectCopyRefreshOutput,
-  VcsStatusInput,
-  VcsStatusOutput,
-  VcsDiffInput,
-  VcsDiffOutput,
-  DebugLocationOutput,
 } from "./types"
 import { ClientError } from "./client-error"
 
@@ -371,7 +339,6 @@ export function make(options: ClientOptions) {
               limit: input?.["limit"],
               order: input?.["order"],
               search: input?.["search"],
-              parentID: input?.["parentID"],
               directory: input?.["directory"],
               project: input?.["project"],
               subpath: input?.["subpath"],
@@ -482,28 +449,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      command: (input: SessionCommandInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionCommandOutput }>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
-            body: {
-              id: input["id"],
-              command: input["command"],
-              arguments: input["arguments"],
-              agent: input["agent"],
-              model: input["model"],
-              files: input["files"],
-              agents: input["agents"],
-              delivery: input["delivery"],
-              resume: input["resume"],
-            },
-            successStatus: 200,
-            declaredStatuses: [409, 404, 500, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
       skill: (input: SessionSkillInput, requestOptions?: RequestOptions) =>
         request<SessionSkillOutput>(
           {
@@ -516,30 +461,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      synthetic: (input: SessionSyntheticInput, requestOptions?: RequestOptions) =>
-        request<SessionSyntheticOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
-            body: { text: input["text"], description: input["description"], metadata: input["metadata"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      shell: (input: SessionShellInput, requestOptions?: RequestOptions) =>
-        request<SessionShellOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
-            body: { id: input["id"], command: input["command"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
       compact: (input: SessionCompactInput, requestOptions?: RequestOptions) =>
         request<SessionCompactOutput>(
           {
@@ -607,46 +528,24 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ).then((value) => value.data),
-      listContextEntries: (input: SessionListContextEntriesInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: SessionListContextEntriesOutput }>(
+      history: (input: SessionHistoryInput, requestOptions?: RequestOptions) =>
+        request<SessionHistoryOutput>(
           {
             method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/context-entry`,
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/history`,
+            query: { limit: input["limit"], after: input["after"] },
             successStatus: 200,
             declaredStatuses: [404, 400, 401],
             empty: false,
           },
           requestOptions,
-        ).then((value) => value.data),
-      putContextEntry: (input: SessionPutContextEntryInput, requestOptions?: RequestOptions) =>
-        request<SessionPutContextEntryOutput>(
-          {
-            method: "PUT",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/context-entry/${encodeURIComponent(input.key)}`,
-            body: { value: input["value"] },
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
         ),
-      removeContextEntry: (input: SessionRemoveContextEntryInput, requestOptions?: RequestOptions) =>
-        request<SessionRemoveContextEntryOutput>(
-          {
-            method: "DELETE",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/context-entry/${encodeURIComponent(input.key)}`,
-            successStatus: 204,
-            declaredStatuses: [404, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      log: (input: SessionLogInput, requestOptions?: RequestOptions): AsyncIterable<SessionLogOutput> =>
-        sse<SessionLogOutput>(
+      events: (input: SessionEventsInput, requestOptions?: RequestOptions): AsyncIterable<SessionEventsOutput> =>
+        sse<SessionEventsOutput>(
           {
             method: "GET",
-            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
-            query: { after: input["after"], follow: input["follow"] },
+            path: `/api/session/${encodeURIComponent(input.sessionID)}/event`,
+            query: { after: input["after"] },
             successStatus: 200,
             declaredStatuses: [404, 400, 401],
             empty: false,
@@ -714,18 +613,6 @@ export function make(options: ClientOptions) {
           },
           requestOptions,
         ),
-      default: (input?: ModelDefaultInput, requestOptions?: RequestOptions) =>
-        request<ModelDefaultOutput>(
-          {
-            method: "GET",
-            path: `/api/model/default`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [503, 401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
     },
     generate: {
       text: (input: GenerateTextInput, requestOptions?: RequestOptions) =>
@@ -899,11 +786,6 @@ export function make(options: ClientOptions) {
         ),
     },
     project: {
-      list: (requestOptions?: RequestOptions) =>
-        request<ProjectListOutput>(
-          { method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [401, 400], empty: false },
-          requestOptions,
-        ),
       current: (input?: ProjectCurrentInput, requestOptions?: RequestOptions) =>
         request<ProjectCurrentOutput>(
           {
@@ -929,95 +811,6 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
-    form: {
-      listRequests: (input?: FormListRequestsInput, requestOptions?: RequestOptions) =>
-        request<FormListRequestsOutput>(
-          {
-            method: "GET",
-            path: `/api/form/request`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      list: (input: FormListInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: FormListOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      create: (input: FormCreateInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: FormCreateOutput }>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
-            body: {
-              id: input["id"],
-              title: input["title"],
-              metadata: input["metadata"],
-              mode: input["mode"],
-              fields: input["fields"],
-              url: input["url"],
-            },
-            successStatus: 200,
-            declaredStatuses: [404, 409, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      get: (input: FormGetInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: FormGetOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      state: (input: FormStateInput, requestOptions?: RequestOptions) =>
-        request<{ readonly data: FormStateOutput }>(
-          {
-            method: "GET",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/state`,
-            successStatus: 200,
-            declaredStatuses: [404, 400, 401],
-            empty: false,
-          },
-          requestOptions,
-        ).then((value) => value.data),
-      reply: (input: FormReplyInput, requestOptions?: RequestOptions) =>
-        request<FormReplyOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
-            body: { answer: input["answer"] },
-            successStatus: 204,
-            declaredStatuses: [404, 409, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-      cancel: (input: FormCancelInput, requestOptions?: RequestOptions) =>
-        request<FormCancelOutput>(
-          {
-            method: "POST",
-            path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/cancel`,
-            successStatus: 204,
-            declaredStatuses: [404, 409, 400, 401],
-            empty: true,
-          },
-          requestOptions,
-        ),
-    },
     permission: {
       listRequests: (input?: PermissionListRequestsInput, requestOptions?: RequestOptions) =>
         request<PermissionListRequestsOutput>(
@@ -1423,45 +1216,6 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
-    vcs: {
-      status: (input?: VcsStatusInput, requestOptions?: RequestOptions) =>
-        request<VcsStatusOutput>(
-          {
-            method: "GET",
-            path: `/api/vcs/status`,
-            query: { location: input?.["location"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-      diff: (input: VcsDiffInput, requestOptions?: RequestOptions) =>
-        request<VcsDiffOutput>(
-          {
-            method: "GET",
-            path: `/api/vcs/diff`,
-            query: { location: input["location"], mode: input["mode"], context: input["context"] },
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
-    debug: {
-      location: (requestOptions?: RequestOptions) =>
-        request<DebugLocationOutput>(
-          {
-            method: "GET",
-            path: `/api/debug/location`,
-            successStatus: 200,
-            declaredStatuses: [401, 400],
-            empty: false,
-          },
-          requestOptions,
-        ),
-    },
   }
 }
 
@@ -1470,11 +1224,7 @@ function encodePath(value: string): string {
 }
 
 function appendQuery(params: URLSearchParams, key: string, value: unknown): void {
-  if (value === undefined) return
-  if (value === null) {
-    params.append(key, "null")
-    return
-  }
+  if (value === undefined || value === null) return
   if (Array.isArray(value)) {
     for (const item of value) appendQuery(params, key, item)
     return

packages/client/src/index.ts

@@ -1,16 +1,3 @@
 export * from "./generated/index"
-export type {
-  AgentApi,
-  CatalogApi,
-  CommandApi,
-  EventApi,
-  IntegrationApi,
-  ModelApi,
-  PluginApi,
-  ProviderApi,
-  ReferenceApi,
-  SessionApi,
-  SkillApi,
-} from "./api.js"
 export type { EventSubscribeOutput as OpenCodeEvent } from "./generated/types"
 export type OpenCodeClient = ReturnType<typeof import("./generated/client").make>

packages/client/src/promise/api.ts

@@ -1,41 +0,0 @@
-import type {
-  AgentApi as EffectAgentApi,
-  CommandApi as EffectCommandApi,
-  EventApi as EffectEventApi,
-  IntegrationApi as EffectIntegrationApi,
-  ModelApi as EffectModelApi,
-  PluginApi as EffectPluginApi,
-  ProviderApi as EffectProviderApi,
-  ReferenceApi as EffectReferenceApi,
-  SessionApi as EffectSessionApi,
-  SkillApi as EffectSkillApi,
-} from "../effect/api/api.js"
-import type { Effect, Stream } from "effect"
-
-type PromisifyOperation<Operation> = Operation extends (
-  ...args: infer Args
-) => Effect.Effect<infer Success, unknown, unknown>
-  ? (...args: Args) => Promise<Success>
-  : Operation extends (...args: infer Args) => Stream.Stream<infer Success, unknown, unknown>
-    ? (...args: Args) => AsyncIterable<Success>
-    : Operation
-
-type PromisifyApi<Api> = {
-  readonly [Name in keyof Api]: PromisifyOperation<Api[Name]>
-}
-
-export type AgentApi = PromisifyApi<EffectAgentApi<unknown>>
-export type CommandApi = PromisifyApi<EffectCommandApi<unknown>>
-export type EventApi = PromisifyApi<EffectEventApi<unknown>>
-export type IntegrationApi = PromisifyApi<EffectIntegrationApi<unknown>>
-export type ModelApi = PromisifyApi<EffectModelApi<unknown>>
-export type PluginApi = PromisifyApi<EffectPluginApi<unknown>>
-export type ProviderApi = PromisifyApi<EffectProviderApi<unknown>>
-export type ReferenceApi = PromisifyApi<EffectReferenceApi<unknown>>
-export type SessionApi = PromisifyApi<EffectSessionApi<unknown>>
-export type SkillApi = PromisifyApi<EffectSkillApi<unknown>>
-
-export interface CatalogApi {
-  readonly provider: ProviderApi
-  readonly model: ModelApi
-}

packages/client/test/api.types.ts

@@ -1,10 +0,0 @@
-import { Effect } from "effect"
-import { OpenCode as EffectOpenCode, type AppApi as EffectApi } from "../src/effect"
-
-type EffectClient = Effect.Success<ReturnType<typeof EffectOpenCode.make>>
-
-declare const effectClient: EffectClient
-
-const effectApi: EffectApi<unknown> = effectClient
-
-void effectApi

packages/client/test/effect.test.ts

@@ -1,19 +1,7 @@
 import { expect, test } from "bun:test"
 import { DateTime, Effect, Stream } from "effect"
 import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import {
-  AbsolutePath,
-  Agent,
-  Event,
-  Location,
-  Model,
-  OpenCode,
-  Prompt,
-  Session,
-  SessionMessage,
-} from "../src/effect/index"
-
-const synced = { type: "log.synced" as const, aggregateID: "ses_test", seq: Event.Seq.make(1) }
+import { AbsolutePath, Agent, Location, Model, OpenCode, Prompt, Session, SessionMessage } from "../src/effect"
 
 test("session.get returns the decoded Effect projection", async () => {
   const httpClient = HttpClient.make((request) =>
@@ -33,7 +21,7 @@ test("event.subscribe exposes and decodes the native Effect event stream", async
       HttpClientResponse.fromWeb(
         request,
         new Response(
-          `data: ${JSON.stringify({ id: "evt_connected", created: 0, type: "server.connected", data: {} })}\n\n` +
+          `data: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
             `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
           { headers: { "content-type": "text/event-stream" } },
         ),
@@ -45,10 +33,10 @@ test("event.subscribe exposes and decodes the native Effect event stream", async
     return yield* client.event.subscribe().pipe(Stream.runCollect)
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
-  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.model.selected"])
+  expect(Array.from(events).map((event) => event.type)).toEqual(["server.connected", "session.next.model.switched"])
   const durable = events[1]
-  if (durable?.type !== "session.model.selected") throw new Error("Expected model event")
-  expect(DateTime.toEpochMillis(durable.created)).toBe(1_717_171_717_000)
+  if (durable?.type !== "session.next.model.switched") throw new Error("Expected model event")
+  expect(DateTime.toEpochMillis(durable.data.timestamp)).toBe(1_717_171_717_000)
   expect(durable.durable).toEqual({ aggregateID: "ses_test", seq: 1, version: 1 })
 })
 
@@ -72,20 +60,32 @@ test("event.subscribe terminates on Effect protocol decode failures", async () =
 })
 
 test("session methods retain decoded Effect inputs and outputs", async () => {
-  const logQueries: Array<Record<string, string>> = []
+  const historyQueries: Array<Record<string, string>> = []
+  let historyPage = 0
   const httpClient = HttpClient.make((request) => {
     const url = request.url
-    if (url.includes("/log")) {
-      logQueries.push(Object.fromEntries(request.urlParams.params))
+    if (url.includes("/event")) {
       return Effect.succeed(
         HttpClientResponse.fromWeb(
           request,
-          new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\ndata: ${JSON.stringify(synced)}\n\n`, {
+          new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\n`, {
             headers: { "content-type": "text/event-stream" },
           }),
         ),
       )
     }
+    if (url.includes("/history")) {
+      historyPage++
+      historyQueries.push(Object.fromEntries(request.urlParams.params))
+      return Effect.succeed(
+        HttpClientResponse.fromWeb(
+          request,
+          Response.json(
+            historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
+          ),
+        ),
+      )
+    }
     if (url.includes("/prompt")) {
       return Effect.succeed(HttpClientResponse.fromWeb(request, Response.json(admission)))
     }
@@ -97,10 +97,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     }
     if (url.endsWith("/api/session/active")) {
       return Effect.succeed(
-        HttpClientResponse.fromWeb(
-          request,
-          Response.json({ data: { ses_test: { type: "running" } } }),
-        ),
+        HttpClientResponse.fromWeb(request, Response.json({ data: { ses_test: { type: "running" } } })),
       )
     }
     if (request.method === "POST" && url.endsWith("/api/session")) {
@@ -110,10 +107,7 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
       return Effect.succeed(HttpClientResponse.fromWeb(request, new Response(null, { status: 204 })))
     }
     return Effect.succeed(
-      HttpClientResponse.fromWeb(
-        request,
-        Response.json({ data: [session.data], cursor: { next: "next" } }),
-      ),
+      HttpClientResponse.fromWeb(request, Response.json({ data: [session.data], cursor: { next: "next" } })),
     )
   })
   const result = await Effect.gen(function* () {
@@ -136,15 +130,27 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
     yield* client.session.compact({ sessionID: Session.ID.make("ses_test") })
     yield* client.session.wait({ sessionID: Session.ID.make("ses_test") })
     const context = yield* client.session.context({ sessionID: Session.ID.make("ses_test") })
-    const log = yield* client.session
-      .log({ sessionID: Session.ID.make("ses_test"), after: Event.Seq.make(0) })
+    const history = yield* client.session.history({
+      sessionID: Session.ID.make("ses_test"),
+      after: 0,
+      limit: 1,
+    })
+    const historyNext = history.hasMore
+      ? yield* client.session.history({
+          sessionID: Session.ID.make("ses_test"),
+          after: history.data.at(-1)?.durable?.seq,
+          limit: 2,
+        })
+      : undefined
+    const events = yield* client.session
+      .events({ sessionID: Session.ID.make("ses_test"), after: 0 })
       .pipe(Stream.runCollect)
     yield* client.session.interrupt({ sessionID: Session.ID.make("ses_test") })
     const message = yield* client.session.message({
       sessionID: Session.ID.make("ses_test"),
       messageID: SessionMessage.ID.make("msg_model"),
     })
-    return { page, active, created, admitted, context, log, message }
+    return { page, active, created, admitted, context, history, historyNext, events, message }
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
   expect(DateTime.toEpochMillis(result.page.data[0].time.created)).toBe(1_717_171_717_000)
@@ -156,17 +162,16 @@ test("session methods retain decoded Effect inputs and outputs", async () => {
   expect(Object.getPrototypeOf(result.admitted.prompt)).toBe(Object.prototype)
   expect(DateTime.toEpochMillis(result.admitted.timeCreated)).toBe(1_717_171_717_000)
   expect(result.context).toEqual([])
-  expect(logQueries[0]).toEqual({ after: "0" })
-  const logged = Array.from(result.log)
-  expect(logged.map((item) => item.type)).toEqual(["session.model.selected", "log.synced"])
-  expect(logged[0]?.type === "session.model.selected" && DateTime.toEpochMillis(logged[0].created)).toBe(
-    1_717_171_717_000,
-  )
-  expect(logged.at(-1)).toEqual(synced)
+  expect(DateTime.toEpochMillis(result.history.data[0].data.timestamp)).toBe(1_717_171_717_000)
+  expect(result.history).toEqual(expect.objectContaining({ hasMore: true }))
+  expect(result.historyNext).toEqual({ data: [], hasMore: false })
+  expect(historyQueries[0]).toEqual({ limit: "1", after: "0" })
+  expect(historyQueries[1]).toEqual({ limit: "2", after: "1" })
+  expect(DateTime.toEpochMillis(result.events[0].data.timestamp)).toBe(1_717_171_717_000)
   expect(result.message).toEqual(expect.objectContaining({ id: "msg_model", type: "model-switched" }))
 })
 
-test("session.log retains the typed SessionNotFoundError", async () => {
+test("session.history retains the typed SessionNotFoundError", async () => {
   const httpClient = HttpClient.make((request) =>
     Effect.succeed(
       HttpClientResponse.fromWeb(
@@ -180,7 +185,11 @@ test("session.log retains the typed SessionNotFoundError", async () => {
   )
   const error = await Effect.gen(function* () {
     const client = yield* OpenCode.make({ baseUrl: "http://localhost:3000" })
-    return yield* client.session.log({ sessionID: Session.ID.make("ses_missing") }).pipe(Stream.runCollect, Effect.flip)
+    return yield* client.session
+      .history({
+        sessionID: Session.ID.make("ses_missing"),
+      })
+      .pipe(Effect.flip)
   }).pipe(Effect.provideService(HttpClient.HttpClient, httpClient), Effect.runPromise)
 
   expect(error._tag).toBe("SessionNotFoundError")
@@ -226,11 +235,12 @@ const modelSwitchedMessage = {
 
 const modelSwitchedEvent = {
   id: "evt_model",
-  created: 1_717_171_717_000,
-  type: "session.model.selected",
+  type: "session.next.model.switched",
   durable: { aggregateID: "ses_test", seq: 1, version: 1 },
   data: {
+    timestamp: 1_717_171_717_000,
     sessionID: "ses_test",
+    messageID: "msg_model",
     model: { id: "claude", providerID: "anthropic" },
   },
 }

packages/client/test/import-boundaries.test.ts

@@ -12,7 +12,7 @@ const server = resolve(import.meta.dir, "../../server")
 
 describe("public import boundaries", () => {
   test("isolates each public entrypoint", async () => {
-    const root = await bundleInputs("@opencode-ai/client/promise", "browser")
+    const root = await bundleInputs("@opencode-ai/client", "browser")
 
     expect(within(root, effect)).toEqual([])
     expect(within(root, schema)).toEqual([])
@@ -20,9 +20,7 @@ describe("public import boundaries", () => {
     expect(within(root, core)).toEqual([])
     expect(within(root, server)).toEqual([])
 
-    // The effect entry includes local service lifecycle (node spawn/fs), so it
-    // bundles for bun; the boundary assertions below are what matter.
-    const network = await bundleInputs("@opencode-ai/client/effect", "bun")
+    const network = await bundleInputs("@opencode-ai/client/effect", "browser")
 
     expect(within(network, effect).length).toBeGreaterThan(0)
     expect(within(network, schema).length).toBeGreaterThan(0)

packages/client/test/promise.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test"
-import { isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src/promise/index"
+import { isSessionNotFoundError, isUnauthorizedError, OpenCode } from "../src"
 
 test("exposes every standard HTTP API group", () => {
   const client = OpenCode.make({ baseUrl: "http://localhost:3000" })
@@ -8,17 +8,14 @@ test("exposes every standard HTTP API group", () => {
     "health",
     "location",
     "agent",
-    "plugin",
     "session",
     "message",
     "model",
     "generate",
     "provider",
     "integration",
-    "server.mcp",
     "credential",
     "project",
-    "form",
     "permission",
     "file",
     "command",
@@ -29,10 +26,7 @@ test("exposes every standard HTTP API group", () => {
     "question",
     "reference",
     "projectCopy",
-    "vcs",
-    "debug",
   ])
-  expect(Object.keys(client.debug)).toEqual(["location"])
   expect(Object.keys(client.message)).toEqual(["list"])
   expect(Object.keys(client.integration)).toEqual([
     "list",
@@ -44,10 +38,9 @@ test("exposes every standard HTTP API group", () => {
     "attemptCancel",
   ])
   expect(Object.keys(client.file)).toEqual(["read", "list", "find"])
-  expect(Object.keys(client.vcs)).toEqual(["status", "diff"])
   expect(Object.keys(client.pty)).toEqual(["list", "create", "get", "update", "remove"])
   expect(Object.keys(client.shell)).toEqual(["list", "create", "get", "output", "remove"])
-  expect(Object.keys(client.project)).toEqual(["list", "current", "directories"])
+  expect(Object.keys(client.project)).toEqual(["current", "directories"])
 })
 
 test("file.read returns binary content from the public HTTP contract", async () => {
@@ -153,7 +146,7 @@ test("event.subscribe exposes the Promise event stream wire projection", async (
     baseUrl: "http://localhost:3000",
     fetch: async () =>
       new Response(
-        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", created: 0, type: "server.connected", data: {} })}\n\n` +
+        `: heartbeat\n\ndata: ${JSON.stringify({ id: "evt_connected", type: "server.connected", data: {} })}\n\n` +
           `data: ${JSON.stringify(modelSwitchedEvent)}\n\n`,
         { headers: { "content-type": "text/event-stream" } },
       ),
@@ -161,8 +154,8 @@ test("event.subscribe exposes the Promise event stream wire projection", async (
   const events = []
   for await (const event of client.event.subscribe()) events.push(event)
 
-  expect(events).toEqual([{ id: "evt_connected", created: 0, type: "server.connected", data: {} }, modelSwitchedEvent])
-  expect(events[1]?.type === "session.model.selected" && events[1].created).toBe(1_717_171_717_000)
+  expect(events).toEqual([{ id: "evt_connected", type: "server.connected", data: {} }, modelSwitchedEvent])
+  expect(events[1]?.type === "session.next.model.switched" && events[1].data.timestamp).toBe(1_717_171_717_000)
 })
 
 test("event.subscribe terminates on malformed Promise SSE data", async () => {
@@ -179,6 +172,7 @@ test("event.subscribe terminates on malformed Promise SSE data", async () => {
 
 test("session methods use the public HTTP contract", async () => {
   const requests: Array<{ url: string; init?: RequestInit }> = []
+  let historyPage = 0
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",
     fetch: async (input, init) => {
@@ -189,23 +183,23 @@ test("session methods use the public HTTP contract", async () => {
           headers: { "content-type": "text/event-stream" },
         })
       }
-      if (url.includes("/log")) {
-        return new Response(`data: ${JSON.stringify(modelSwitchedEvent)}\n\ndata: ${JSON.stringify(synced)}\n\n`, {
-          headers: { "content-type": "text/event-stream" },
-        })
+      if (url.includes("/history")) {
+        historyPage++
+        return Response.json(
+          historyPage === 1 ? { data: [modelSwitchedEvent], hasMore: true } : { data: [], hasMore: false },
+        )
       }
       if (url.includes("/prompt")) return Response.json(admission)
       if (url.includes("/context")) return Response.json({ data: [] })
       if (url.includes("/message/")) return Response.json({ data: modelSwitchedMessage })
-      if (url.endsWith("/api/session/active"))
-        return Response.json({ data: { ses_test: { type: "running" } } })
+      if (url.endsWith("/api/session/active")) return Response.json({ data: { ses_test: { type: "running" } } })
       if (init?.method === "POST" && url.endsWith("/api/session")) return Response.json(session)
       if (init?.method === "POST") return new Response(null, { status: 204 })
       return Response.json({ data: [session.data], cursor: { next: "next" } })
     },
   })
 
-  const page = await client.session.list({ limit: 10, order: "desc", parentID: null })
+  const page = await client.session.list({ limit: 10, order: "desc" })
   const active = await client.session.active()
   const created = await client.session.create({ location: { directory: "/tmp/project" } })
   await client.session.switchAgent({ sessionID: "ses_test", agent: "build" })
@@ -221,8 +215,13 @@ test("session methods use the public HTTP contract", async () => {
   await client.session.compact({ sessionID: "ses_test" })
   await client.session.wait({ sessionID: "ses_test" })
   const context = await client.session.context({ sessionID: "ses_test" })
-  const log = []
-  for await (const item of client.session.log({ sessionID: "ses_test", after: 0 })) log.push(item)
+  const history = await client.session.history({ sessionID: "ses_test", after: 0, limit: 1 })
+  const historyAfter = history.data.at(-1)?.durable?.seq
+  const historyNext = history.hasMore
+    ? await client.session.history({ sessionID: "ses_test", after: historyAfter, limit: 2 })
+    : undefined
+  const events = []
+  for await (const event of client.session.events({ sessionID: "ses_test", after: 0 })) events.push(event)
   await client.session.interrupt({ sessionID: "ses_test" })
   const message = await client.session.message({ sessionID: "ses_test", messageID: "msg_model" })
 
@@ -231,10 +230,12 @@ test("session methods use the public HTTP contract", async () => {
   expect(created.id).toBe("ses_test")
   expect(admitted.id).toBe("msg_test")
   expect(context).toEqual([])
-  expect(log).toEqual([modelSwitchedEvent, synced])
+  expect(history).toEqual({ data: [modelSwitchedEvent], hasMore: true })
+  expect(historyNext).toEqual({ data: [], hasMore: false })
+  expect(events).toEqual([modelSwitchedEvent])
   expect(message).toEqual(modelSwitchedMessage)
   expect(requests.map((request) => [request.init?.method, request.url])).toEqual([
-    ["GET", "http://localhost:3000/api/session?limit=10&order=desc&parentID=null"],
+    ["GET", "http://localhost:3000/api/session?limit=10&order=desc"],
     ["GET", "http://localhost:3000/api/session/active"],
     ["POST", "http://localhost:3000/api/session"],
     ["POST", "http://localhost:3000/api/session/ses_test/agent"],
@@ -243,7 +244,9 @@ test("session methods use the public HTTP contract", async () => {
     ["POST", "http://localhost:3000/api/session/ses_test/compact"],
     ["POST", "http://localhost:3000/api/session/ses_test/wait"],
     ["GET", "http://localhost:3000/api/session/ses_test/context"],
-    ["GET", "http://localhost:3000/api/experimental/session/ses_test/log?after=0"],
+    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=1&after=0"],
+    ["GET", "http://localhost:3000/api/session/ses_test/history?limit=2&after=1"],
+    ["GET", "http://localhost:3000/api/session/ses_test/event?after=0"],
     ["POST", "http://localhost:3000/api/session/ses_test/interrupt"],
     ["GET", "http://localhost:3000/api/session/ses_test/message/msg_model"],
   ])
@@ -270,7 +273,7 @@ test("middleware errors remain declared client errors", async () => {
   }
 })
 
-test("session.log decodes SessionNotFoundError", async () => {
+test("session.history decodes SessionNotFoundError", async () => {
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",
     fetch: async () =>
@@ -281,7 +284,7 @@ test("session.log decodes SessionNotFoundError", async () => {
   })
 
   try {
-    await client.session.log({ sessionID: "ses_missing" })[Symbol.asyncIterator]().next()
+    await client.session.history({ sessionID: "ses_missing" })
     throw new Error("Expected request to fail")
   } catch (error) {
     expect(isSessionNotFoundError(error)).toBe(true)
@@ -326,15 +329,14 @@ const modelSwitchedMessage = {
   model: { id: "claude", providerID: "anthropic" },
 }
 
-const synced = { type: "log.synced", aggregateID: "ses_test", seq: 1 }
-
 const modelSwitchedEvent = {
   id: "evt_model",
-  created: 1_717_171_717_000,
-  type: "session.model.selected",
+  type: "session.next.model.switched",
   durable: { aggregateID: "ses_test", seq: 1, version: 1 },
   data: {
+    timestamp: 1_717_171_717_000,
     sessionID: "ses_test",
+    messageID: "msg_model",
     model: { id: "claude", providerID: "anthropic" },
   },
 }

packages/client/tsconfig.build.json

@@ -1,11 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "noEmit": false,
-    "declaration": true
-  },
-  "include": ["src"]
-}

packages/client/tsconfig.json

@@ -3,8 +3,6 @@
   "extends": "@tsconfig/bun/tsconfig.json",
   "compilerOptions": {
     "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "allowImportingTsExtensions": false,
-    "allowJs": false,
     "noUncheckedIndexedAccess": false
   },
   "include": ["src"]

packages/codemode/AGENTS.md

@@ -1,23 +0,0 @@
-# @opencode-ai/codemode
-
-- This local package owns confined execution over explicit schema-described tools. Applications own authorization, persistence, external authority, and tool-specific delivery semantics.
-- Do not add a speculative generic permission or approval policy. A host omits tools it does not expose and enforces domain authorization inside each provided tool.
-- Keep Code Mode unaware of host session, channel, and conversation models. The hosting application supplies trusted execution scope around it.
-- Tool schemas are the model-facing Interface. Keep arguments minimal and natural to the operation; never add unrelated IDs as ambient capability tokens.
-
-## OpenAPI
-
-- Generate an operation only when its transport semantics are supported; otherwise return a precise `skipped` reason.
-- Never guess parameter serialization or malformed security semantics. Unsupported serialization is skipped and malformed security fails closed.
-- Render unresolved schema constructs as `unknown`, never as invented TypeScript names.
-- Keep network reads bounded and map expected encoding, transport, and decoding failures to model-safe `ToolError` values.
-- Test supported behavior directly; do not reproduce adapter algorithms in tests.
-
-## Future Design Notes
-
-- If a captured user-visible output channel returns (an earlier `output.text`/`output.file`/`output.image` API was removed from v1), keep `output` as its name, distinct from the program return value: `return` stays the structured result for the model, while `output.*` describes artifacts the host may render into a conversation or UI after execution. Keep this host-neutral and let applications decide how captured output is delivered. In v1, hosts collect media host-side (outside the sandbox) instead.
-- Improve the sandbox failure taxonomy. Distinguish parse/compile mistakes, unsupported syntax, user-thrown errors, invalid returned data, tool refusal, tool internal failure, timeout, and genuine runtime defects so agents can recover accurately instead of treating everything as a generic execution failure.
-- Preserve the public/private error split. Tool authors should be able to return a safe model-visible message while retaining a private cause for host diagnostics. Unknown host failures must remain sanitized by default.
-- Think deliberately about richer binary boundaries before allowing `Blob`, `File`, `ArrayBuffer`, streams, or typed arrays beyond today's JSON-like values. If CodeMode supports binary tool args/results, use explicit tagged data shapes and clear size limits rather than relying on ambient runtime serialization.
-- Keep host capabilities explicit. Globals such as `fetch`, `crypto`, filesystem handles, extra modules, or network clients should be opt-in runtime capabilities with obvious policy defaults, not ambient authority. Default to unavailable unless a host deliberately provides the capability.
-- If `fetch` is added, model it as a host-provided outbound capability with policy controls: allowed origins, methods, headers, response size, timeout, and whether response bodies may be returned, emitted, or only summarized through a tool.

packages/codemode/README.md

@@ -1,369 +0,0 @@
-# @opencode-ai/codemode
-
-Effect-native confined code execution over explicit, schema-described tools.
-
-CodeMode lets a model write a small JavaScript program that can call only the tools supplied by the host. The program can sequence calls, transform plain data, branch, loop, and run independent calls in parallel without receiving ambient filesystem, process, network, module, or application authority.
-
-The package is currently private to this workspace. Its API is designed around one-shot and reusable execution:
-
-```ts
-// One execution
-yield * CodeMode.execute({ tools, code })
-
-// A reusable runtime
-const runtime = CodeMode.make({ tools, limits })
-yield * runtime.execute(code)
-```
-
-## Install
-
-Within this workspace:
-
-```json
-{
-  "dependencies": {
-    "@opencode-ai/codemode": "workspace:*"
-  }
-}
-```
-
-Hosts interact with CodeMode through `effect` (tool `run` implementations, `Effect`-typed results), so they should depend on `effect` themselves.
-
-## Quick Start
-
-Define tools with Effect Schema, then place them in the object tree exposed to programs as `tools`:
-
-```ts
-import { CodeMode, Tool } from "@opencode-ai/codemode"
-import { Effect, Schema } from "effect"
-
-const lookupOrder = Tool.make({
-  description: "Look up an order by ID",
-  input: Schema.Struct({ id: Schema.String }),
-  output: Schema.Struct({ id: Schema.String, status: Schema.String }),
-  run: ({ id }) => Effect.succeed({ id, status: "open" }),
-})
-
-const runtime = CodeMode.make({
-  tools: {
-    orders: {
-      lookup: lookupOrder,
-    },
-  },
-})
-
-const result =
-  yield *
-  runtime.execute(`
-  const order = await tools.orders.lookup({ id: "order_42" })
-  return { id: order.id, needsAttention: order.status !== "complete" }
-`)
-```
-
-`result` is always a `CodeMode.Result`. Program, validation, limit, and tool failures are returned as diagnostics rather than failing the Effect. Host interruption remains interruption.
-
-Successful result values are JSON-safe data. A program that returns `undefined`, including by reaching the end without `return`, produces `null`; nested `undefined` values are normalized to `null` as well.
-
-## API
-
-### `Tool.make`
-
-```ts
-const tool = Tool.make({
-  description,
-  input, // Effect Schema (validating) or JSON Schema (render-only)
-  output, // optional; same choice
-  run,
-})
-```
-
-`input` and `output` each accept a validating Effect Schema or a render-only JSON Schema document (the natural shape for adapter-provided tools whose schemas arrive as JSON Schema, e.g. MCP definitions). Effect Schema input is decoded before `run` is invoked, and `run` returns the encoded representation of an Effect Schema `output`, which CodeMode decodes and copies before exposing it to the program. JSON Schemas only shape the model-visible signature; values pass through unvalidated (they still cross the plain-data boundary).
-
-`output` is optional. Without it the tool's signature advertises `Promise<unknown>` and the host result is exposed as-is.
-
-The description and schemas are part of the model-visible tool contract. Keep descriptions concrete and put authorization in `run` or in the service it calls.
-
-Public tool types are grouped under the same namespace: `Tool.Definition`, `Tool.Options`, `Tool.SchemaType`, and `Tool.JsonSchema`.
-
-### `CodeMode.execute`
-
-Use `CodeMode.execute` for a single execution:
-
-```ts
-const result =
-  yield *
-  CodeMode.execute({
-    tools: { orders: { lookup: lookupOrder } },
-    code: `return await tools.orders.lookup({ id: "order_42" })`,
-    limits: { maxToolCalls: 10 },
-    onToolCallStart: (call) => Effect.logDebug("CodeMode tool started", call),
-    onToolCallEnd: (call) => Effect.logDebug("CodeMode tool settled", call),
-  })
-```
-
-The Effect environment is inferred from the supplied tools. CodeMode does not erase service requirements introduced by tool implementations.
-
-### `CodeMode.make`
-
-Use `CodeMode.make` when the tool set and execution policy are reused:
-
-```ts
-const runtime = CodeMode.make({
-  tools: { orders: { lookup: lookupOrder } },
-  limits: { timeoutMs: 30_000 },
-})
-
-runtime.catalog() // structured tool descriptions
-runtime.instructions() // model-facing syntax and tool guide
-runtime.execute(source) // CodeMode.Result
-```
-
-`CodeMode.Input`, `CodeMode.Result`, `CodeMode.Success`, `CodeMode.Failure`, `CodeMode.Diagnostic`, and `CodeMode.DiagnosticKind` are both Effect schemas and their inferred TypeScript types. Hosts can combine `CodeMode.Input` and `CodeMode.Result` with `runtime.instructions()` and `runtime.execute()` when constructing a framework-specific agent tool.
-
-All other CodeMode types use the same namespace: `CodeMode.Options`, `CodeMode.ExecuteOptions`, `CodeMode.Runtime`, `CodeMode.ExecutionLimits`, `CodeMode.DiscoveryOptions`, `CodeMode.DataValue`, `CodeMode.ToolDescription`, and the `CodeMode.ToolCall*` observation types.
-
-### Results
-
-```ts
-type Result = Success | Failure
-
-interface Success {
-  readonly ok: true
-  readonly value: CodeMode.DataValue
-  readonly logs?: ReadonlyArray<string>
-  readonly truncated?: boolean
-  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
-}
-
-interface Failure {
-  readonly ok: false
-  readonly error: CodeMode.Diagnostic
-  readonly logs?: ReadonlyArray<string>
-  readonly truncated?: boolean
-  readonly toolCalls: ReadonlyArray<CodeMode.ToolCall>
-}
-```
-
-`toolCalls` contains the names of calls admitted by the runtime in call order. It is retained on failure so hosts can audit partial execution without exposing inputs or host failures. `truncated` is present when the value or logs were cut to fit `maxOutputBytes` (see Execution Limits).
-
-### Tool-call hooks
-
-`onToolCallStart` receives `{ index, name, input }` after input decoding and before tool execution. The input is decoded host-side data and may include values produced by schema transformations; applications should avoid logging sensitive tool arguments indiscriminately.
-
-`onToolCallEnd` receives `{ index, name, input, durationMs, outcome, message? }` when an admitted call settles. `outcome` is `"success"` or `"failure"`; `message` is the model-safe failure message and is present only on failure. Interrupted calls (for example when the execution timeout fires) do not produce an end event. Both hooks are Effect-returning and must not fail.
-
-### OpenAPI tools
-
-`OpenAPI.fromSpec` turns an OpenAPI 3.x document into a tool subtree - one tool per operation. Dotted `operationId` values form namespaces such as `v2.session.get`. Missing IDs receive a flat method/path fallback such as `getUsersById`; names are sanitized and deduplicated. The host places the subtree under a key in its `tools` tree; that key is the model-visible namespace.
-
-```ts
-import { CodeMode, OpenAPI } from "@opencode-ai/codemode"
-import { Effect } from "effect"
-import { FetchHttpClient } from "effect/unstable/http"
-
-const api = OpenAPI.fromSpec({
-  spec: await Bun.file("openapi.json").json(), // parsed document (no YAML)
-  auth: {
-    resolve: ({ name, scopes, operation }) =>
-      name === "BearerAuth" ? Effect.succeed({ type: "bearer", token }) : Effect.succeed(undefined),
-  },
-})
-
-const runtime = CodeMode.make({ tools: { opencode: api.tools } })
-const result = await Effect.runPromise(runtime.execute(code).pipe(Effect.provide(FetchHttpClient.layer)))
-```
-
-`fromSpec` is synchronous and returns `{ tools, skipped }`. The initial adapter supports query `form`/`deepObject`, path/header `simple`, JSON request bodies, JSON responses, and text responses; unsupported parameter encodings, non-JSON request bodies, binary responses, and streaming operations land in `skipped` instead of producing broken tools. Operation and path servers take precedence over document servers unless `baseUrl` explicitly overrides all of them. Tool inputs flatten path, query, header, and closed object-body fields into one model-facing object while retaining their HTTP locations internally. Cross-location name collisions receive a location prefix such as `path_id` and `query_id`; composed, nullable, dictionary, conditionally-required, and non-object JSON bodies remain under `body`. Auth is never model-visible. Responses are limited to 50 MiB, and non-2xx responses become safe tool failures carrying the status and a size-capped body summary. Deferred capabilities are tracked in `src/openapi/TODO.md`.
-
-Supported bearer, basic, header, and query authentication follows OpenAPI `security` semantics and is resolved host-side via `auth.resolve` - credential storage, OAuth flows, and token refresh never enter the compiler. Cookie authentication alternatives are discarded; an operation is skipped when it has no supported alternative. See the option docstrings in `src/openapi/types.ts` for the full semantics. Generated tools require `HttpClient.HttpClient` (from `effect/unstable/http`) in the Effect environment - provide `FetchHttpClient.layer` or a custom/test client layer at execution. The supplied client owns redirect policy; credentialed hosts should reject redirects or strip credentials when the origin changes.
-
-## Discovery
-
-The agent-tool instructions use a budgeted catalog. Every tool namespace is always listed with its tool count regardless of budget, and as many complete, JSDoc-annotated tool signatures (each with a one-line description) as fit an estimated-token budget are inlined. Schema field descriptions and tags are part of each signature's measured cost. Selection is round-robin across namespaces for fairness: in each round (namespaces alphabetical), every namespace still holding un-inlined tools attempts to place its next-cheapest signature against the shared budget, and a namespace whose next signature does not fit drops out while the others keep going - so every namespace gets some representation before any namespace gets everything. The instructions state exactly how comprehensive the list is, both overall (`COMPLETE list` vs `PARTIAL - N of M shown`) and per namespace (`(3 tools)`, `(3 tools, 1 shown)`, `(3 tools, none shown)`).
-
-The catalog-entry budget defaults to 2,000 estimated tokens (characters / 4, the same heuristic OpenCode uses). It applies only to full tool entries shown in the catalog; fixed instructions and namespace summaries are not counted. Override it when constructing a runtime:
-
-```ts
-const runtime = CodeMode.make({
-  tools,
-  discovery: { catalogBudget: 6_000 },
-})
-```
-
-The budget must be a non-negative safe integer.
-
-The runtime search tool is always registered - including when the catalog is fully inlined - so a speculative `tools.$codemode.search` call never fails as an unknown tool. It is only advertised in the instructions when the inlined list is partial:
-
-```ts
-const matches = await tools.$codemode.search({
-  query: "order status",
-  namespace: "orders", // optional: scope to one top-level namespace
-  limit: 10,
-  offset: 0,
-})
-```
-
-`search` performs deterministic, additive field-weighted matching. The query is tokenized (camelCase boundaries split; every non-alphanumeric character is a separator; empties and `*` are dropped), and each term scores every tool: exact path or path-segment match (20), path substring (8), description substring (4), and searchable-text substring (2). Each term also carries naive singular variants (trailing `s`/`es` stripped), and a field check passes when the term or any variant matches - so a plural query term (`issues`) still finds a tool whose text only says `issue`, without changing the weights. The searchable text also includes the input schema's property names and their description strings, so a query naming a parameter finds its tool, and substring matching means partial words match. Scores sum across terms; matches are sorted by score (ties broken alphabetically by path), then sliced from the zero-based `offset` (default 0) to the configured `limit` (default 10). `remaining` counts matches after the current page. `next` is `{ offset }` when another page exists and `null` on the final page; spread it into the original request to preserve its query, namespace, and limit.
-
-```ts
-const request = { query: "order status", namespace: "orders", limit: 10 }
-const page = await tools.$codemode.search(request)
-const nextPage = page.next ? await tools.$codemode.search({ ...request, ...page.next }) : undefined
-```
-
-Each result contains the path, description, and the same generated TypeScript signature used by the inline catalog, so no second lookup is needed. Signatures use the JSDoc-annotated multiline form: each described input/output field carries its schema `description` as a `/** ... */` comment, and constraints TypeScript cannot express ride along as tags (`@deprecated`, `@default`, `@format`, `@minItems`, `@maxItems`).
-
-```ts
-tools.github.list_issues(input: {
-  /** Repository owner */
-  owner: string,
-  /** Cursor from the previous response's pageInfo */
-  after?: string,
-  /**
-   * Results per page
-   * @default 30
-   */
-  perPage?: number,
-}): Promise<unknown>
-```
-
-Result paths are rendered as JavaScript expressions rooted at `tools` (`tools.orders.lookup`, or `tools.context7["resolve-library-id"]` for non-identifier segments), so each `path` is directly usable as the call site. An empty query browses the catalog alphabetically by path; combined with `namespace` (`{ query: "", namespace: "orders" }`) it lists everything in that namespace. A query that names one tool path exactly (canonical path, `tools.`-prefixed path, or rendered JavaScript expression) is treated as a lookup and returns that tool alone.
-
-The instructions are structured markdown, ordered so the workflow sits at the top and the catalog at the bottom: a `## Workflow` section with numbered steps (find a tool via search when the catalog is partial, or pick from the inlined list when it is complete; call the exact path as-is; return only the needed fields), a `## Rules` section holding only guidance the workflow does not already cover (only listed/search-result Code Mode tools and internal runtime tools exist inside `tools`; filter and aggregate collections in code; narrow `Promise<unknown>` results at runtime; run independent calls through `Promise.all`; enumerate `tools` with `Object.keys`/`for...in`; browse a namespace and paginate search results when search is advertised), a short `## Language` section that identifies the runtime as a restricted JavaScript orchestration language and names its major unavailable capabilities, and the budgeted `## Available tools` catalog. Example call forms use explicit `<namespace>.<tool>`/`<field>` placeholders - never a real or fabricated tool name.
-
-A host cannot define its own `$codemode` top-level namespace.
-
-## Supported Programs
-
-CodeMode executes a deliberately bounded JavaScript subset. It supports:
-
-- Plain data literals, property access, assignment, and destructuring.
-- `if`, conditional expressions, `switch`, `for`, `for...of` (arrays, strings, Maps, Sets), `for...in` (own keys of plain objects, index strings of arrays, and namespace/tool names of `tools` references - anything else is an error suggesting `for...of` or `Object.keys`, rather than real JS's surprising behavior of indices for strings and zero iterations for Maps/Sets), `while`, and `do...while`.
-- Arrow functions and function declarations with closures, defaults, rest parameters, and destructuring.
-- Optional chaining, nullish coalescing, templates, spread (arrays, strings, Maps, Sets), and `try`/`catch`.
-- Common array, string, number, `Object`, `Math`, and `JSON` operations. Mutating array methods include `push`/`pop`/`shift`/`unshift`/`splice` (removes in place and returns the removed elements)/`fill`/`copyWithin`; array `keys`/`values`/`entries` return **arrays** (matching the Map/Set convention) and work with `for...of` and spread. String methods include `localeCompare` (locale/options arguments ignored), `normalize`, and the `trimLeft`/`trimRight` aliases. `Object.keys` also accepts arrays (index strings, as in JS) and tool references: `Object.keys(tools)` lists the top-level namespaces, including `$codemode`, and `Object.keys(tools.ns)` lists the names at that node (a callable tool enumerates as `[]`; an unknown path is an `UnknownTool` diagnostic). `Object.values`/`Object.entries` on a tool reference fail with a pointer at `Object.keys(tools)` and `tools.$codemode.search`.
-- `Date` - `Date.now()`/`Date.parse()`/`Date.UTC()`, `new Date(...)`, the getter methods, and date arithmetic/comparison via the time value. Dates stringify as ISO (`toString` included, for determinism across host timezones).
-- Regular expressions - `/literals/` and `new RegExp(...)` with `test`/`exec` (stateful `lastIndex` for `g`), plus string `match`/`matchAll`/`replace`/`replaceAll`/`split`/`search` with patterns. Match results are arrays carrying `index` and named `groups` as own properties (`input` is omitted). `replace` and `replaceAll` accept function replacers with captures, offset, input, and named groups; callbacks run sequentially, may await tool calls, and have their results coerced to strings. Invalid patterns, invalid flags, and missing-`g` calls fail with catchable errors that say what was wrong and how to fix it (escaping hints, the exact `/pattern/g` to write). Patterns run on the host engine, so pathological backtracking is bounded only by the execution timeout.
-- `Map` and `Set` - construction from entries/arrays/strings, `get`/`set`/`add`/`has`/`delete`/`clear`/`size`/`forEach`, and `keys`/`values`/`entries` returning **arrays** (not iterators).
-- URL helpers - `URL` resolution and mutation, linked `URLSearchParams`, `URL.canParse`/`URL.parse`, URI and URI-component encoding/decoding, and query parameter construction, lookup, mutation, sorting, callbacks, and materialization. URLSearchParams iteration methods return arrays, matching the Map/Set convention.
-- First-class promises - an un-awaited `tools.ns.tool(...)` is a promise value whose call starts immediately on a supervised fiber; `await` resolves it (awaiting a non-promise value is a no-op, and `return tools.ns.tool(...)` resolves like an async-function return). `Promise.all`, `Promise.allSettled`, and `Promise.race` accept any array mixing promises and plain values (built inline, beforehand, or via spread); `Promise.resolve`/`Promise.reject` construct settled promises. `Promise.allSettled` rejection reasons are the same plain `{ name?, message }` data a `catch` binding sees, and `Promise.race` interrupts its losing in-flight calls. At most 8 tool calls run concurrently. When a program completes, still-running un-awaited calls are awaited before the execution ends; a failure from a call that was never awaited surfaces as an unhandled-rejection diagnostic.
-- `throw value` and `throw new Error(message)` for explicit program failure. `Error` (and `TypeError`/`RangeError`/`SyntaxError`/`ReferenceError`/`EvalError`/`URIError`) are real constructors, callable with or without `new`; error values are plain `{ name, message }` data that additionally satisfy `instanceof Error` (a specific type matches itself and `Error`, as in JS). Every caught failure - thrown errors, interpreter runtime errors, and tool failures - is `instanceof Error` in a `catch` block; a thrown non-error value (`throw "text"`) is not, matching JS. Caught failures carry the `name` the equivalent real-JS failure would have - `JSON.parse` and invalid regex patterns produce a `SyntaxError` (satisfying `instanceof SyntaxError`), an unknown identifier a `ReferenceError`, assigning to a constant a `TypeError`, a bad `normalize` form a `RangeError`; failures with no specific analogue (including tool failures) are named `"Error"`. `instanceof` also recognizes `Date`, `RegExp`, `Map`, `Set`, `URL`, `URLSearchParams`, `Array`, `Object`, and `Promise`; any other right-hand side is a catchable error.
-
-Inside a program, standard-library values stay live everywhere: the internal data checkpoints (`Object.*` helpers, spread, coercion inputs) preserve the instances, so `Object.values({ d: date })[0].getTime()` and a spread copy of an object holding a Map keep working. Only at the host boundary (final result, tool arguments, `JSON.stringify`) do they serialize exactly as `JSON.stringify` would: Date and URL become strings (an invalid Date becomes `null`), while RegExp, Map, Set, and URLSearchParams become `{}`. Promise values never cross a data boundary: an un-awaited promise in a result or tool argument produces a diagnostic that says to await it, instead of serializing to `{}`.
-
-It does not expose `eval`, dynamic imports, modules, classes, generators, timers, host globals, prototype mutation, custom promise constructors (`new Promise`), promise chaining (`.then`/`.catch`/`.finally` - `await` with `try`/`catch` is the supported style), or arbitrary method calls. Unsupported syntax returns an `UnsupportedSyntax` diagnostic with a source location when available.
-
-CodeMode is an orchestration language, not a general JavaScript runtime.
-
-## Execution Limits
-
-The limits are exactly three knobs:
-
-| Limit            |              Default | Bounds                                                               |
-| ---------------- | -------------------: | -------------------------------------------------------------------- |
-| `timeoutMs`      |    none - no timeout | Wall-clock execution time.                                           |
-| `maxToolCalls`   |     none - unlimited | Tool calls admitted during the execution.                            |
-| `maxOutputBytes` | none - no truncation | Model-facing output: the serialized result value plus captured logs. |
-
-No limit has a default, on purpose: execution budgets are host policy, not library policy - a host that wants a bound sets one; a host that can interrupt the execution fiber (as OpenCode does on user cancel) may set no timeout, and a host with its own tool-output truncation (as OpenCode has) may leave `maxOutputBytes` unset. A host with neither should set `maxOutputBytes`, or oversized results silently flood model context.
-
-Pass only the overrides you need:
-
-```ts
-const runtime = CodeMode.make({
-  tools,
-  limits: {
-    maxToolCalls: 20,
-    timeoutMs: 60_000,
-  },
-})
-```
-
-Limits are safe integers. `timeoutMs` must be at least `1`; the others may be `0`. Invalid configuration throws a `RangeError` when `CodeMode.make` or `CodeMode.execute` is called. An explicitly `undefined` value is the same as leaving the limit unset.
-
-Exceeding a configured `maxOutputBytes` never fails the execution. An oversized result value is replaced by its truncated serialized text plus an explanatory marker, logs are kept from the start until the remaining budget is exhausted (with a final marker line noting the cut), and the result carries `truncated: true`.
-
-When configured, the timeout interrupts in-flight tool Effects, including eagerly started calls the program has not awaited (their fibers are supervised by the execution). The interpreter yields cooperatively between steps, so the timeout also interrupts pure busy loops (`while (true) {}`) - no separate work budget exists. Tool implementations remain responsible for making their external operations interruptible or independently bounded.
-
-Two interpreter internals are fixed constants rather than knobs: at most 8 tool calls run concurrently, and values crossing a data boundary may nest at most 32 levels deep (deeper values fail as `InvalidDataValue`, which reads better than a native stack-overflow error). Neither is part of the public contract.
-
-## Diagnostics
-
-Failures are data:
-
-| Kind                    | Meaning                                                                                                  |
-| ----------------------- | -------------------------------------------------------------------------------------------------------- |
-| `ParseError`            | Source is empty or cannot be parsed.                                                                     |
-| `UnsupportedSyntax`     | Parsed JavaScript is outside the supported subset.                                                       |
-| `UnknownTool`           | A program referenced a tool the host did not provide.                                                    |
-| `InvalidToolInput`      | Tool input failed schema decoding or safe-data copying.                                                  |
-| `InvalidToolOutput`     | Tool output failed schema decoding or safe-data copying.                                                 |
-| `InvalidDataValue`      | Program data violated the plain-data contract (depth, circularity, blocked properties, non-data values). |
-| `ToolCallLimitExceeded` | Calls exceeded `maxToolCalls`.                                                                           |
-| `TimeoutExceeded`       | Execution exceeded `timeoutMs`.                                                                          |
-| `ToolFailure`           | A tool refused or failed.                                                                                |
-| `ExecutionFailure`      | The program threw or another execution error occurred.                                                   |
-
-Unknown host failures, defects, invalid outputs, and copying failures are sanitized. To return a safe operational refusal, fail with `toolError`:
-
-```ts
-import { toolError } from "@opencode-ai/codemode"
-
-run: ({ id }) => (authorized(id) ? loadOrder(id) : Effect.fail(toolError("Order is unavailable")))
-```
-
-Only the supplied message is model-visible. The optional cause is never returned in `CodeMode.Result`; hosts should perform any required internal logging before crossing this boundary.
-
-## Authority Boundary
-
-CodeMode confines programs to the supplied tool tree, but it does not decide what those tools may do.
-
-The host owns:
-
-- Authentication and authorization.
-- Tool selection and immutable scope.
-- Credentials and network clients.
-- Persistence, idempotency, approval, and durable side effects.
-- Logging and redaction policy.
-
-CodeMode owns:
-
-- Parsing and interpreting the supported subset without `eval`.
-- Schema boundaries around tool calls.
-- Plain-data copying and blocked prototype members.
-- Resource limits, call accounting, and normalized diagnostics.
-- Model-facing tool discovery and instructions.
-
-A program cannot gain authority through prose or generated code. It can only exercise authority already present in the supplied tools. Do not expose a broad tool and expect the prompt to restrict it.
-
-## Laws
-
-The public contract is guided by these equivalences:
-
-- `CodeMode.execute({ ...options, code })` is equivalent to `CodeMode.make(options).execute(code)`.
-- A tool implementation is not invoked unless its input has decoded successfully.
-- A tool result is not visible to the program unless its output has decoded and crossed the plain-data boundary successfully.
-- Unknown host failures do not become model-visible diagnostics; `ToolError` is the explicit safe-message channel.
-- Host interruption remains interruption rather than a `CodeMode.Failure`.
-
-## Non-Goals
-
-- Generic permission prompts or approval workflows.
-- Durable pause/resume, replay, or storage adapters.
-- Exactly-once external side effects.
-- Application authorization or product policy.
-- A filesystem or process sandbox for arbitrary JavaScript.
-- Compatibility with the full JavaScript language or npm ecosystem.
-
-Applications that need approval or durable consequences should model those above CodeMode and expose only the currently authorized tools.
-
-## Testing
-
-From the package directory:
-
-```sh
-bun test
-bun run typecheck
-```
-
-The direct suite covers public projections, discovery, schema boundaries, diagnostic sanitization, resource limits, tool-call observation, and interruption.

packages/codemode/codemode.md

@@ -1,172 +0,0 @@
-# CodeMode Design and Status
-
-This is the living design and status document for `@opencode-ai/codemode` and its existing V2 OpenCode adapter.
-It records current behavior, intentional boundaries, durable rationale, and material remaining work.
-
-Completed implementation history, branch names, test counts, and closed findings belong in git, not here. Remove
-completed work instead of preserving checked-off chronology.
-
-Detailed package API documentation lives in [README.md](./README.md). OpenAPI-specific follow-ups live in
-[src/openapi/TODO.md](./src/openapi/TODO.md).
-
-## How CodeMode Works
-
-### Purpose
-
-CodeMode gives a model one `execute` tool backed by a confined JavaScript interpreter. Inside the program, the model
-can call an explicit tree of schema-described tools, sequence dependent work, run independent calls concurrently,
-and filter or aggregate results before returning them to the agent loop.
-
-The goals are:
-
-- Reduce model context consumed by large tool catalogs.
-- Avoid an agent round-trip between every dependent tool call.
-- Keep large intermediate results inside the program instead of sending them through model context.
-- Give generated code only the authority explicitly supplied by the host.
-
-CodeMode is an orchestration language, not a general JavaScript runtime or an application authorization system.
-
-### Runtime
-
-The generic runtime lives in `packages/codemode` and is host-neutral:
-
-1. The host builds a tree of `Tool.make(...)` definitions and calls `CodeMode.make(...)` or `CodeMode.execute(...)`.
-2. CodeMode generates model instructions, a budgeted inline catalog, and the internal `$codemode.search` tool.
-3. TypeScript syntax is transpiled away, Acorn parses the resulting JavaScript, and an owned tree-walking interpreter
-   executes it without `eval`.
-4. Tool inputs and outputs cross schema and plain-data boundaries before they become visible on either side.
-5. Execution returns `CodeMode.Result`. Expected program and tool failures are diagnostic data; host interruption
-   remains Effect interruption.
-
-Effect Schemas validate and transform tool inputs and outputs. JSON Schemas render model-facing signatures but do not
-validate values; adapter-provided values still cross the plain-data boundary. A tool without an output schema is
-advertised as `Promise<unknown>`.
-
-### Discovery and model workflow
-
-The model sees a token-budgeted catalog. Every namespace remains visible, and complete signatures are selected
-round-robin across namespaces so one large namespace cannot starve the others. `$codemode.search` is always callable
-and is advertised when the inline catalog is partial.
-
-The intended workflow is:
-
-1. Pick an exact signature from the inline catalog, or return `$codemode.search(...)` results and use a selected path
-   in the next execution.
-2. Call the exact returned path without guessing or normalizing segments.
-3. Narrow `Promise<unknown>` results before reading fields.
-4. Start independent calls together and await them with `Promise.all`.
-5. Filter and aggregate inside the program, then return only the data needed by the model.
-
-Search returns directly usable JavaScript paths, descriptions, and complete TypeScript signatures. It supports exact
-path lookup, namespace browsing, deterministic ranking, and pagination.
-
-### Tool execution
-
-Calling a tool starts its Effect eagerly on a supervised fiber. The returned sandbox promise is run-once and can be
-awaited directly or through the supported `Promise` combinators. At most eight tool calls execute concurrently.
-Unfinished calls are drained before successful program completion, and an unhandled call failure becomes a diagnostic.
-
-The public execution-policy knobs are `timeoutMs`, `maxToolCalls`, and `maxOutputBytes`. The package supplies no
-defaults because budgets are host policy. The interpreter also enforces fixed internal boundaries for tool-call
-concurrency and data nesting depth.
-
-### Data, files, and failures
-
-Program results and tool arguments are JSON-like data. Dates become ISO strings at host boundaries; RegExp, Map, and
-Set values become `{}` as they do under JSON serialization. Promise and runtime reference values cannot cross the
-boundary.
-
-Unknown host failures and invalid outputs are sanitized. `ToolError` is the explicit channel for a safe message that a
-tool wants the model to see. Diagnostic categories distinguish parsing, unsupported syntax, unknown tools, invalid
-data, tool failures, limits, timeouts, and execution failures.
-
-Files and other attachment content stay outside the interpreter. A host may collect them while child tools execute and
-attach them to the outer result, but the program receives only the structured tool output.
-
-### V2 OpenCode adapter
-
-CodeMode is integrated into V2 through `packages/core/src/tool/registry.ts` and
-`packages/core/src/tool/execute.ts`:
-
-- Core has one canonical `Tool` representation. Location-scoped producers register direct or deferred tools through
-  `Tools.Service`.
-- Each model step snapshots effective registrations, applies catalog visibility filtering, and exposes direct tools
-  normally.
-- When visible deferred tools exist, Core reserves and materializes one `execute` tool. Grouped deferred tools become
-  CodeMode namespaces instead of flattened model-facing names.
-- Each nested call checks that its captured registration is still current before dispatching it.
-- Authorization and side-effect ordering remain responsibilities of the leaf tool. Catalog visibility is not execution
-  authorization.
-- Structured child output enters the interpreter. File parts are collected host-side and attached to the outer result.
-- Nested call statuses are returned as final `execute` metadata for the TUI.
-- `execute` is the one model-facing tool invocation. Nested calls reuse its invocation context and do not independently
-  run registry hooks or model-output bounding; this keeps complete intermediate structured values available for
-  in-program filtering. The outer `execute` settlement is the single model-output bounding boundary.
-- Core supplies no CodeMode timeout or tool-call limit. User cancellation interrupts the outer invocation and its
-  supervised children; the outer settlement applies Core's normal output-retention policy.
-
-MCP tools use this canonical path: they register as grouped tools and are deferred while CodeMode is enabled. Existing
-output schemas are preserved in generated signatures. Direct Core tools remain direct and are not ambient globals
-inside CodeMode.
-
-## Intentionally Unsupported
-
-These are product boundaries rather than DSL backlog:
-
-- Ambient filesystem, process, environment, network, credential, or application access. External work must go through
-  supplied tools.
-- Modules, imports, dynamic imports, `eval`, arbitrary host globals, npm packages, and prototype mutation.
-- Generic permission prompts, authorization policy, durable pause/resume, replay, storage, or exactly-once external
-  side effects. Hosts and tools own those concerns.
-- Heuristic parsing of text tool results as JSON. A result should not silently change type based on its contents.
-
-The OpenAPI adapter may gain more transports and encodings, but it must continue skipping operations it cannot
-represent accurately rather than guessing semantics.
-
-## Decisions and Rationale
-
-| Decision | Rationale |
-| --- | --- |
-| Keep an owned tree-walking interpreter. | The product need is bounded tool orchestration, not arbitrary JavaScript. Owning the language surface keeps authority and behavior explicit. |
-| Treat schemas as the model-facing interface. | Signatures drive correct calls; Effect Schema also provides the runtime validation boundary, while JSON Schema supports adapter interoperability. |
-| Keep authority host-owned. | CodeMode can only confine programs to supplied tools. The host chooses those tools, and each tool enforces its own authorization and side-effect policy. |
-| Use progressive catalog disclosure plus search. | Large tool sets should not consume the prompt, but every namespace must remain discoverable and speculative search calls should remain valid. |
-| Start tool promises eagerly and supervise them. | This preserves normal call-time parallelism while giving each call run-once settlement and interruption safety. |
-| Keep files outside the sandbox value space. | Models should compose structured data without routing binary payloads through generated code or context. |
-| Treat `execute` as the model-facing invocation boundary. | Nested calls are implementation details of one orchestration program. Reusing the outer context and bounding only the final result preserves complete intermediate data without inventing durable child-call identities. |
-| Return expected failures as data. | Models need actionable diagnostics without exposing private host causes; host interruption and defects must still propagate correctly. |
-| Leave execution-limit defaults to hosts. | Appropriate budgets depend on the surrounding product and its own cancellation, retention, and output-bounding policies. |
-| Skip unsupported OpenAPI operations. | Incorrect parameter encoding, authentication, or transport behavior is worse than a precise `skipped` reason. |
-
-## Remaining Work
-
-Keep only material unresolved work here. Small isolated defects should be GitHub issues; adapter-only work belongs in
-the adapter TODO. Delete entries when completed.
-
-### DSL expansion
-
-The supported JavaScript subset should grow when common model-generated code improves tool orchestration. These are
-current omissions to implement, not intentional product boundaries.
-
-- [ ] Design proper multi-stage promise pipelines. Supporting `.then`, `.catch`, and `.finally` should preserve promise
-      assimilation, cancellation, failure handling, and concurrent per-item pipelines rather than adding syntax-only
-      shims. Consider `Promise.any` in the same pass.
-- [ ] Support async iteration and `for await...of`. Define behavior first for the runtime's supported promise and
-      collection values, then extend it to bounded host streams when a stream boundary exists.
-- [ ] Support callback-bearing standard-library variants that models commonly generate: the mapper argument to
-      `Array.from(...)` and replacers for `JSON.stringify(...)`, including Effect-aware callbacks where needed.
-- [ ] Close basic `Object` parity gaps: let `Object.values`/`Object.entries` accept arrays, make `Object.assign` validate
-      and mutate its target, add `Object.is`, and let `Object.fromEntries` consume every supported iterable.
-- [ ] Add deterministic modern collection conveniences where they improve orchestration: `Object.groupBy`, Set
-      composition methods, and `Array.prototype.toSpliced`.
-- [ ] Complete the deterministic `Math` surface beyond the current arithmetic, rounding, root, power, and logarithm
-      helpers. Decide separately whether nondeterministic `Math.random` belongs in the runtime.
-- [ ] Refine diagnostics so user throws, expected tool failures, unexpected host/tool defects, and genuine interpreter
-      defects are distinguishable without leaking private causes.
-
-### Tool and result contracts
-
-- [ ] Design explicit tagged representations and size rules before allowing Blob, File, ArrayBuffer, typed arrays, or
-      host streams to cross the sandbox boundary.
-- [ ] Define one consistent policy for tool path segments named `__proto__`, `constructor`, or `prototype`. They must
-      either be safely callable, rejected before catalog generation, or use one documented escaping rule.

packages/codemode/package.json

@@ -1,26 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "name": "@opencode-ai/codemode",
-  "version": "0.0.1",
-  "description": "Effect-native confined code execution over schema-described tools",
-  "private": true,
-  "type": "module",
-  "license": "MIT",
-  "exports": {
-    ".": "./src/index.ts"
-  },
-  "scripts": {
-    "typecheck": "tsgo --noEmit",
-    "test": "bun test"
-  },
-  "dependencies": {
-    "acorn": "8.15.0",
-    "effect": "catalog:",
-    "typescript": "catalog:"
-  },
-  "devDependencies": {
-    "@tsconfig/bun": "catalog:",
-    "@types/bun": "catalog:",
-    "@typescript/native-preview": "catalog:"
-  }
-}

packages/codemode/src/codemode.ts

@@ -1,164 +0,0 @@
-import { Effect, Schema } from "effect"
-import { executeWithLimits } from "./interpreter/runtime.js"
-import {
-  type HostTools,
-  type Services,
-  type ToolDescription,
-  ToolRuntime,
-} from "./tool-runtime.js"
-import type { Definition } from "./tool.js"
-
-/** A tool call admitted during an execution. */
-export type { ToolCall, ToolCallEnded, ToolCallHooks, ToolCallStarted, ToolDescription } from "./tool-runtime.js"
-
-/** Resource budgets enforced independently during each CodeMode program execution. */
-export type ExecutionLimits = {
-  /** Maximum wall-clock execution time in milliseconds. No default: absent means no timeout. */
-  readonly timeoutMs?: number
-  /** Maximum number of tool calls admitted by the runtime. No default: absent means unlimited. */
-  readonly maxToolCalls?: number
-  /** Maximum UTF-8 bytes of model-facing output. No default: absent means no truncation. */
-  readonly maxOutputBytes?: number
-}
-
-/** Controls how much of the tool catalog is inlined in agent instructions. */
-export type DiscoveryOptions = {
-  /** Approximate token budget (chars/4, default 2000) for full catalog entries. */
-  readonly catalogBudget?: number
-}
-
-type ToolTree<R = never> = {
-  readonly [name: string]: Definition<R> | ToolTree<R>
-}
-
-export type ResolvedExecutionLimits = {
-  readonly timeoutMs: number | undefined
-  readonly maxToolCalls: number | undefined
-  readonly maxOutputBytes: number | undefined
-}
-
-/** Options for one CodeMode execution. */
-export type ExecuteOptions<Tools extends Record<string, unknown> = {}> = {
-  /** Source for one program in the supported JavaScript subset. */
-  code: string
-  /** Explicit tool tree exposed to the program as `tools`. */
-  tools?: Tools & ToolTree<Services<Tools>>
-  /** Per-execution overrides for the default resource limits. */
-  limits?: ExecutionLimits
-  /** Observes decoded tool input immediately before tool execution. */
-  onToolCallStart?: (call: ToolRuntime.ToolCallStarted) => Effect.Effect<void, never, Services<Tools>>
-  /** Observes each admitted tool call as it settles, with outcome and duration. */
-  onToolCallEnd?: (call: ToolRuntime.ToolCallEnded) => Effect.Effect<void, never, Services<Tools>>
-}
-
-/** A JSON value that can cross the confined interpreter boundary. */
-export type DataValue = Schema.Json
-
-/** Configuration shared by `CodeMode.make` and `CodeMode.execute`. */
-export type Options<Tools extends Record<string, unknown> = {}> = Omit<ExecuteOptions<Tools>, "code"> & {
-  /** Progressive-disclosure configuration for the agent-facing tool catalog. */
-  readonly discovery?: DiscoveryOptions
-}
-
-/** Schema for a host tool input containing CodeMode source. */
-export const Input = Schema.Struct({ code: Schema.String })
-export type Input = typeof Input.Type
-
-export const DiagnosticKind = Schema.Literals([
-  "ParseError",
-  "UnsupportedSyntax",
-  "UnknownTool",
-  "InvalidToolInput",
-  "InvalidToolOutput",
-  "InvalidDataValue",
-  "ToolCallLimitExceeded",
-  "TimeoutExceeded",
-  "ToolFailure",
-  "ExecutionFailure",
-])
-/** Stable categories produced by program, schema, tool, and limit failures. */
-export type DiagnosticKind = typeof DiagnosticKind.Type
-
-export const Diagnostic = Schema.Struct({
-  kind: DiagnosticKind,
-  message: Schema.String,
-  location: Schema.optionalKey(Schema.Struct({ line: Schema.Number, column: Schema.Number })),
-  suggestions: Schema.optionalKey(Schema.Array(Schema.String)),
-})
-/** A normalized program diagnostic safe to return across an agent tool boundary. */
-export type Diagnostic = typeof Diagnostic.Type
-
-const ToolCallSchema = Schema.Struct({ name: Schema.String })
-export const Success = Schema.Struct({
-  ok: Schema.Literal(true),
-  value: Schema.Json,
-  logs: Schema.optionalKey(Schema.Array(Schema.String)),
-  truncated: Schema.optionalKey(Schema.Boolean),
-  toolCalls: Schema.Array(ToolCallSchema),
-})
-/** Successful execution after the result has crossed the plain-data boundary. */
-export type Success = typeof Success.Type
-
-export const Failure = Schema.Struct({
-  ok: Schema.Literal(false),
-  error: Diagnostic,
-  logs: Schema.optionalKey(Schema.Array(Schema.String)),
-  truncated: Schema.optionalKey(Schema.Boolean),
-  toolCalls: Schema.Array(ToolCallSchema),
-})
-/** Failed execution with calls admitted before the diagnostic was produced. */
-export type Failure = typeof Failure.Type
-
-/** Schema for the structured success or diagnostic returned by CodeMode execution. */
-export const Result = Schema.Union([Success, Failure])
-/** Result of executing a CodeMode program. Program failures are data, not Effect failures. */
-export type Result = typeof Result.Type
-
-/** Reusable confined runtime over one explicit tool tree. */
-export type Runtime<R = never> = {
-  readonly catalog: () => ReadonlyArray<ToolDescription>
-  readonly instructions: () => string
-  readonly execute: (code: string) => Effect.Effect<Result, never, R>
-}
-
-const validateLimit = <Value extends number | undefined>(
-  name: keyof ExecutionLimits,
-  value: Value,
-  minimum: number,
-): Value => {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value < minimum)) {
-    throw new RangeError(`${name} must be a safe integer greater than or equal to ${minimum}.`)
-  }
-  return value
-}
-
-const resolveExecutionLimits = (limits?: ExecutionLimits): ResolvedExecutionLimits => ({
-  timeoutMs: validateLimit("timeoutMs", limits?.timeoutMs, 1),
-  maxToolCalls: validateLimit("maxToolCalls", limits?.maxToolCalls, 0),
-  maxOutputBytes: validateLimit("maxOutputBytes", limits?.maxOutputBytes, 0),
-})
-
-/** Executes one Effect-native CodeMode program without constructing a reusable runtime. */
-export const execute = <const Tools extends Record<string, unknown>>(
-  options: ExecuteOptions<Tools>,
-): Effect.Effect<Result, never, Services<Tools>> => {
-  const tools = (options.tools ?? {}) as HostTools<Services<Tools>>
-  ToolRuntime.assertValidTools(tools)
-  return executeWithLimits(options, resolveExecutionLimits(options.limits), ToolRuntime.searchIndex(tools))
-}
-
-/** Creates an Effect-native runtime over explicit, schema-described tools. */
-export const make = <const Tools extends Record<string, unknown> = {}>(
-  options: Options<Tools> = {} as Options<Tools>,
-): Runtime<Services<Tools>> => {
-  const tools = (options.tools ?? {}) as HostTools<Services<Tools>>
-  ToolRuntime.assertValidTools(tools)
-  const limits = resolveExecutionLimits(options.limits)
-  const prepared = ToolRuntime.prepare(tools, options.discovery?.catalogBudget)
-
-  return {
-    catalog: () => prepared.catalog,
-    instructions: () => prepared.instructions,
-    execute: (code) => executeWithLimits<Tools>({ ...options, code }, limits, prepared.searchIndex),
-  }
-}

packages/codemode/src/index.ts

@@ -1,4 +0,0 @@
-export * as CodeMode from "./codemode.js"
-export * as Tool from "./tool.js"
-export * as OpenAPI from "./openapi/index.js"
-export { ToolError, toolError } from "./tool-error.js"

packages/codemode/src/interpreter/model.ts

@@ -1,200 +0,0 @@
-import type { SafeObject } from "../tool-runtime.js"
-import type { SandboxURL } from "../values.js"
-
-export type SourcePosition = {
-  line: number
-  column: number
-}
-
-export type SourceLocation = {
-  start: SourcePosition
-  end: SourcePosition
-}
-
-export type AstNode = {
-  type: string
-  loc?: SourceLocation
-  [key: string]: unknown
-}
-
-export type ProgramNode = AstNode & {
-  type: "Program"
-  body: Array<AstNode>
-}
-
-export type Binding = {
-  mutable: boolean
-  value: unknown
-  initialized?: boolean
-}
-
-export type StatementResult =
-  | { kind: "none" }
-  | { kind: "value"; value: unknown }
-  | { kind: "return"; value: unknown }
-  | { kind: "break" }
-  | { kind: "continue" }
-
-export type MemberReference = {
-  target: SafeObject | Array<unknown> | SandboxURL
-  key: string | number
-}
-
-export class CodeModeFunction {
-  constructor(
-    readonly parameters: ReadonlyArray<AstNode>,
-    readonly body: AstNode,
-    readonly capturedScopes: ReadonlyArray<Map<string, Binding>>,
-  ) {}
-}
-
-export class IntrinsicReference {
-  constructor(
-    readonly receiver: unknown,
-    readonly name: string,
-  ) {}
-}
-
-export class ComputedValue {
-  constructor(readonly value: unknown) {}
-}
-
-export class PromiseNamespace {}
-
-export type PromiseMethodName = "all" | "allSettled" | "race" | "resolve" | "reject"
-
-export class PromiseMethodReference {
-  constructor(readonly name: PromiseMethodName) {}
-}
-
-export type GlobalNamespaceName =
-  | "Object"
-  | "Math"
-  | "JSON"
-  | "Array"
-  | "console"
-  | "Date"
-  | "RegExp"
-  | "Map"
-  | "Set"
-  | "URL"
-  | "URLSearchParams"
-
-export class GlobalNamespace {
-  constructor(readonly name: GlobalNamespaceName) {}
-}
-
-export class GlobalMethodReference {
-  constructor(
-    readonly namespace: GlobalNamespaceName | "Number" | "String",
-    readonly name: string,
-  ) {}
-}
-
-export class CoercionFunction {
-  constructor(readonly name: "Number" | "String" | "Boolean" | "parseInt" | "parseFloat") {}
-}
-
-export class UriFunction {
-  constructor(readonly name: "encodeURI" | "encodeURIComponent" | "decodeURI" | "decodeURIComponent") {}
-}
-
-export class ProgramThrow {
-  constructor(readonly value: unknown) {}
-}
-
-export class ErrorConstructorReference {
-  constructor(readonly name: string) {}
-}
-
-export type DiagnosticKind =
-  | "ParseError"
-  | "UnsupportedSyntax"
-  | "UnknownTool"
-  | "InvalidToolInput"
-  | "InvalidToolOutput"
-  | "InvalidDataValue"
-  | "ToolCallLimitExceeded"
-  | "TimeoutExceeded"
-  | "ToolFailure"
-  | "ExecutionFailure"
-
-export const OptionalShortCircuit: unique symbol = Symbol("codemode.optional-short-circuit")
-
-export const supportedSyntaxMessage =
-  "Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, and Promise.all/allSettled/race/resolve/reject over arrays mixing promises and plain values for parallel tool calls (promise chaining with .then/.catch is not supported - use await with try/catch)."
-
-export class InterpreterRuntimeError extends Error {
-  readonly node?: AstNode
-  errorName: string = "Error"
-
-  constructor(
-    message: string,
-    node?: AstNode,
-    readonly kind: DiagnosticKind = "ExecutionFailure",
-    readonly suggestions?: ReadonlyArray<string>,
-  ) {
-    super(message)
-    this.name = "InterpreterRuntimeError"
-    if (node) this.node = node
-  }
-
-  as(errorName: string): this {
-    this.errorName = errorName
-    return this
-  }
-}
-
-export const unsupportedSyntax = (kind: string, node: AstNode): InterpreterRuntimeError =>
-  new InterpreterRuntimeError(
-    `Syntax '${kind}' is not supported in CodeMode. ${supportedSyntaxMessage}`,
-    node,
-    "UnsupportedSyntax",
-    [supportedSyntaxMessage],
-  )
-
-export const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null
-
-export const asNode = (value: unknown, context: string): AstNode => {
-  if (!isRecord(value) || typeof value.type !== "string") {
-    throw new InterpreterRuntimeError(`Invalid AST node while reading ${context}.`)
-  }
-  return value as AstNode
-}
-
-export const getArray = (node: AstNode, key: string): Array<unknown> => {
-  const value = node[key]
-  if (!Array.isArray(value)) throw new InterpreterRuntimeError(`Expected '${key}' to be an array.`, node)
-  return value
-}
-
-export const getString = (node: AstNode, key: string): string => {
-  const value = node[key]
-  if (typeof value !== "string") throw new InterpreterRuntimeError(`Expected '${key}' to be a string.`, node)
-  return value
-}
-
-export const getBoolean = (node: AstNode, key: string): boolean => {
-  const value = node[key]
-  if (typeof value !== "boolean") throw new InterpreterRuntimeError(`Expected '${key}' to be a boolean.`, node)
-  return value
-}
-
-export const getOptionalNode = (node: AstNode, key: string): AstNode | undefined => {
-  const value = node[key]
-  if (value === undefined || value === null) return undefined
-  return asNode(value, key)
-}
-
-export const getNode = (node: AstNode, key: string): AstNode => asNode(node[key], key)
-
-export const sourceLocation = (node: AstNode): { readonly line: number; readonly column: number } => ({
-  line: Math.max(1, (node.loc?.start.line ?? 2) - 1),
-  column: Math.max(1, (node.loc?.start.column ?? 4) - 3),
-})
-
-export const formatLocation = (node?: AstNode): string => {
-  if (!node?.loc) return ""
-  const location = sourceLocation(node)
-  return ` (line ${location.line}, col ${location.column})`
-}

packages/codemode/src/openapi/TODO.md

@@ -1,19 +0,0 @@
-# OpenAPI Follow-ups
-
-The initial adapter intentionally skips operations it cannot execute correctly. Future work may add:
-
-- Cookie parameters, authentication, and cookie-header merging.
-- Matrix, label, space-delimited, pipe-delimited, `allowReserved`, and parameter `content` serialization.
-- External references and complete nested `$defs` support.
-- Relative or templated server URLs and server variables.
-- Base URLs containing query strings or fragments.
-- Runtime response-schema validation and full content negotiation.
-- Binary response values and explicit byte-oriented return types.
-- Request/response projection for `readOnly` and `writeOnly` properties.
-- SSE, WebSocket, and other streaming transports.
-- Recovery of responses rejected by a status-filtering `HttpClient`.
-- Configurable request and response size limits.
-- Adapter-enforced redirect policy independent of the supplied `HttpClient`.
-- Strict UTF-8 and empty-body validation for JSON responses.
-- Compile-time rejection of parameter schemas with nested values unsupported by their serialization style; runtime rejects them before auth resolution.
-- Complete malformed-security-scheme validation and broader auth-combination coverage.

packages/codemode/src/openapi/index.ts

@@ -1,130 +0,0 @@
-import { HttpClient } from "effect/unstable/http"
-import { make, type Definition } from "../tool.js"
-import { invoke } from "./runtime.js"
-import {
-  componentDefinitions,
-  inputSchema,
-  isRecord,
-  methods,
-  nonEmptyString,
-  operationInput,
-  operationOutput,
-  operationPath,
-  operationSecurityRequirements,
-  securityRequirements,
-  securitySchemes,
-  specServerUrl,
-  validateBaseUrl,
-} from "./spec.js"
-import type { Operation, Options, Result, Skipped, Tools } from "./types.js"
-
-export type {
-  AuthResolver,
-  Credential,
-  Document,
-  Operation,
-  Options,
-  Result,
-  SecurityScheme,
-  Skipped,
-  Tools,
-} from "./types.js"
-
-/**
- * Builds a CodeMode tool subtree from an OpenAPI 3.x document, one tool per
- * operation. Auth is resolved host-side via `auth.resolve` and never
- * model-visible. Tools require `HttpClient.HttpClient`; unrepresentable
- * operations land in `skipped`.
- */
-export const fromSpec = (options: Options): Result => {
-  const document = options.spec
-  const schemes = securitySchemes(document)
-  const defaultSecurity = securityRequirements(document.security)
-  const definitions = componentDefinitions(document)
-  const paths = isRecord(document.paths) ? document.paths : {}
-  const used = new Set<string>()
-  const namespaces = new Set<string>()
-  const skipped: Array<Skipped> = []
-  const tools = Object.create(null) as Tools
-
-  for (const [path, pathValue] of Object.entries(paths)) {
-    if (!isRecord(pathValue)) continue
-    for (const [method, operationValue] of Object.entries(pathValue)) {
-      if (!methods.has(method) || !isRecord(operationValue)) continue
-      const segments = operationPath(method, path, operationValue, used, namespaces)
-      const operation: Operation = {
-        operationId: nonEmptyString(operationValue.operationId),
-        method: method.toUpperCase(),
-        path,
-        summary: nonEmptyString(operationValue.summary),
-        description: nonEmptyString(operationValue.description),
-      }
-      const output = operationOutput(document, operationValue, definitions)
-      if (!output.ok) {
-        skipped.push({ method: operation.method, path, reason: output.reason })
-        continue
-      }
-
-      const resolvedBaseUrl = (() => {
-        if (options.baseUrl !== undefined) return validateBaseUrl(options.baseUrl)
-        if (operationValue.servers !== undefined) return specServerUrl(operationValue)
-        if (pathValue.servers !== undefined) return specServerUrl(pathValue)
-        return specServerUrl(document)
-      })()
-      if (!resolvedBaseUrl.ok) {
-        skipped.push({ method: operation.method, path, reason: resolvedBaseUrl.reason })
-        continue
-      }
-      const parsedInput = operationInput(document, pathValue, operationValue)
-      if (!parsedInput.ok) {
-        skipped.push({ method: operation.method, path, reason: parsedInput.reason })
-        continue
-      }
-      const input = parsedInput.value
-
-      const security = operationSecurityRequirements(operationValue.security, defaultSecurity, schemes)
-      if (!security.ok) {
-        skipped.push({ method: operation.method, path, reason: security.reason })
-        continue
-      }
-      const plan = {
-        operation,
-        url: `${resolvedBaseUrl.value.replace(/\/+$/, "")}${path}`,
-        fields: input.fields,
-        body: input.body,
-        security: security.value,
-        schemes,
-        auth: options.auth,
-        headers: options.headers ?? {},
-      }
-      used.add(segments.join("."))
-      for (const index of segments.slice(0, -1).keys()) namespaces.add(segments.slice(0, index + 1).join("."))
-      setTool(
-        tools,
-        segments,
-        make({
-          description: operation.description ?? operation.summary ?? `${operation.method} ${path}`,
-          input: inputSchema(input.fields, definitions),
-          output: output.value,
-          run: (input) => invoke(plan, input),
-        }),
-      )
-    }
-  }
-
-  return { tools, skipped }
-}
-
-const setTool = (tools: Tools, path: ReadonlyArray<string>, definition: Definition<HttpClient.HttpClient>): void => {
-  const [head, ...rest] = path
-  if (head === undefined) return
-  if (rest.length === 0) {
-    tools[head] = definition
-    return
-  }
-  const child = tools[head]
-  if (child === undefined || !isRecord(child) || child._tag === "CodeModeTool") {
-    tools[head] = Object.create(null) as Tools
-  }
-  setTool(tools[head] as Tools, rest, definition)
-}

packages/codemode/src/openapi/runtime.ts

@@ -1,324 +0,0 @@
-import { Effect, Option, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse, type HttpMethod } from "effect/unstable/http"
-import { ToolError, toolError } from "../tool-error.js"
-import { isRecord, own } from "./spec.js"
-import type { AppliedAuth, Credential, Plan, SecurityScheme } from "./types.js"
-
-const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString)
-const maxErrorBodyChars = 1_024
-const maxResponseBodyBytes = 50 * 1024 * 1024
-
-export const invoke = (plan: Plan, input: unknown): Effect.Effect<unknown, unknown, HttpClient.HttpClient> =>
-  Effect.gen(function* () {
-    const value = isRecord(input) ? input : {}
-
-    let request = yield* buildRequest(plan, value)
-
-    const auth = yield* resolveAuth(plan)
-    for (const [name, item] of Object.entries(auth.query)) {
-      request = HttpClientRequest.setUrlParam(request, name, item)
-    }
-    request = HttpClientRequest.setHeaders(request, auth.headers)
-
-    const client = yield* HttpClient.HttpClient
-    const response = yield* client
-      .execute(request)
-      .pipe(
-        Effect.catch((cause) =>
-          Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} failed: transport error`, cause)),
-        ),
-      )
-    const text = yield* readResponseBody(response, plan)
-    const mediaType = response.headers["content-type"]?.split(";")[0]?.trim().toLowerCase()
-    const json = mediaType === "application/json" || mediaType?.endsWith("+json") === true
-    const decoded = text === "" ? Option.some(null) : json ? decodeJson(text) : Option.none()
-    const parsed = json ? Option.getOrElse(decoded, () => text) : text === "" ? null : text
-    if (response.status < 200 || response.status >= 300) {
-      const rendered = typeof parsed === "string" ? parsed : (JSON.stringify(parsed) ?? "")
-      const summary =
-        rendered === "" || rendered === "null"
-          ? "no response body"
-          : rendered.length > maxErrorBodyChars
-            ? `${rendered.slice(0, maxErrorBodyChars)}...`
-            : rendered
-      return yield* Effect.fail(
-        toolError(`${plan.operation.method} ${plan.operation.path} failed with HTTP ${response.status}: ${summary}`),
-      )
-    }
-    if (json && Option.isNone(decoded)) {
-      return yield* Effect.fail(
-        toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`),
-      )
-    }
-    return parsed
-  })
-
-const buildRequest = (
-  plan: Plan,
-  input: Readonly<Record<string, unknown>>,
-): Effect.Effect<HttpClientRequest.HttpClientRequest, ToolError> =>
-  Effect.gen(function* () {
-    // Validate every model-controlled value before auth resolution, which may refresh tokens.
-    const url = buildUrl(plan, input)
-    if (url instanceof ToolError) return yield* Effect.fail(url)
-    const missing = plan.fields.find(
-      (field) => field.required && field.location !== "path" && own(input, field.inputName) === undefined,
-    )
-    if (missing !== undefined) {
-      const label = missing.location === "body" ? "body field" : `${missing.location} parameter`
-      return yield* Effect.fail(toolError(`Missing required ${label} '${missing.inputName}'.`))
-    }
-
-    let request = HttpClientRequest.make(plan.operation.method as HttpMethod.HttpMethod)(url)
-    for (const field of plan.fields) {
-      if (field.location !== "query") continue
-      const item = own(input, field.inputName)
-      if (item === undefined) continue
-      const serialized = serializeQuery(request, field, item)
-      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
-      request = serialized
-    }
-
-    // Host headers first, then declared header parameters.
-    request = HttpClientRequest.setHeaders(request, plan.headers)
-    for (const field of plan.fields) {
-      if (field.location !== "header") continue
-      const item = own(input, field.inputName)
-      if (item === undefined) continue
-      const serialized = serializeSimple(field, item, String)
-      if (serialized instanceof ToolError) return yield* Effect.fail(serialized)
-      request = HttpClientRequest.setHeader(request, field.name, serialized)
-    }
-
-    const setBody = (value: unknown, mediaType: string) =>
-      HttpClientRequest.bodyJson(request, value).pipe(
-        Effect.map((next) => HttpClientRequest.setHeader(next, "content-type", mediaType)),
-        Effect.mapError((cause) =>
-          toolError(`Invalid JSON body for ${plan.operation.method} ${plan.operation.path}.`, cause),
-        ),
-      )
-    if (plan.body?.mode === "value") {
-      const field = plan.fields.find((field) => field.location === "body")
-      const body = field === undefined ? undefined : own(input, field.inputName)
-      if (body !== undefined) request = yield* setBody(body, plan.body.mediaType)
-    }
-    if (plan.body?.mode === "object") {
-      const entries = plan.fields.flatMap((field) => {
-        if (field.location !== "body") return []
-        const item = own(input, field.inputName)
-        return item === undefined ? [] : [[field.name, item] as const]
-      })
-      if (plan.body.required || entries.length > 0) {
-        request = yield* setBody(Object.fromEntries(entries), plan.body.mediaType)
-      }
-    }
-    return request
-  })
-
-const resolveAuth = (plan: Plan): Effect.Effect<AppliedAuth, unknown> =>
-  Effect.gen(function* () {
-    const none: AppliedAuth = { headers: {}, query: {} }
-    if (plan.security.length === 0) return none
-
-    const unavailable: Array<string> = []
-    alternatives: for (const requirement of plan.security) {
-      const names = Object.keys(requirement)
-      if (names.length === 0) return none
-      const credentials: Array<readonly [string, SecurityScheme, Credential]> = []
-      for (const name of names) {
-        const scheme = own(plan.schemes, name)
-        if (scheme === undefined || plan.auth === undefined) {
-          unavailable.push(name)
-          continue alternatives
-        }
-        const credential = yield* plan.auth.resolve({
-          name,
-          definition: scheme,
-          scopes: requirement[name] ?? [],
-          operation: plan.operation,
-        })
-        if (credential === undefined) {
-          unavailable.push(name)
-          continue alternatives
-        }
-        credentials.push([name, scheme, credential])
-      }
-      const applied = applyCredentials(credentials)
-      return applied instanceof ToolError ? yield* Effect.fail(applied) : applied
-    }
-
-    return yield* Effect.fail(
-      toolError(
-        `${plan.operation.method} ${plan.operation.path} requires authentication; no credential available for: ${[...new Set(unavailable)].join(", ")}.`,
-      ),
-    )
-  })
-
-const applyCredentials = (
-  credentials: ReadonlyArray<readonly [string, SecurityScheme, Credential]>,
-): AppliedAuth | ToolError => {
-  const headers = new Map<string, string>()
-  const query = new Map<string, string>()
-  const add = (carrier: "header" | "query", name: string, value: string): ToolError | undefined => {
-    const target = carrier === "header" ? headers : query
-    if (target.has(name)) return toolError(`Authentication resolves multiple credentials for ${carrier} '${name}'.`)
-    target.set(name, value)
-  }
-  for (const [name, definition, credential] of credentials) {
-    if (credential.type === "bearer") {
-      const duplicate = add("header", "authorization", `Bearer ${credential.token}`)
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    if (credential.type === "basic") {
-      // Buffer instead of btoa: btoa throws on non-Latin-1 credentials.
-      const duplicate = add(
-        "header",
-        "authorization",
-        `Basic ${Buffer.from(`${credential.username}:${credential.password}`, "utf8").toString("base64")}`,
-      )
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    if (credential.type === "header") {
-      const duplicate = add("header", credential.name.toLowerCase(), credential.value)
-      if (duplicate !== undefined) return duplicate
-      continue
-    }
-    // apiKey: the carrier comes from the scheme declaration.
-    if (definition.type !== "apiKey") {
-      return toolError(
-        `Security scheme '${name}' is not an apiKey scheme; resolve a bearer, basic, or header credential for it.`,
-      )
-    }
-    if (definition.in === "cookie") return toolError(`Cookie authentication '${name}' is not supported.`)
-    const parameter = definition.in === "header" ? definition.name.toLowerCase() : definition.name
-    const duplicate = add(definition.in, parameter, credential.value)
-    if (duplicate !== undefined) return duplicate
-  }
-  return { headers: Object.fromEntries(headers), query: Object.fromEntries(query) }
-}
-
-const buildUrl = (plan: Plan, input: Readonly<Record<string, unknown>>): string | ToolError => {
-  let url = plan.url
-  for (const field of plan.fields) {
-    if (field.location !== "path") continue
-    const item = own(input, field.inputName)
-    if (item === undefined) {
-      return toolError(`Missing required path parameter '${field.inputName}'.`)
-    }
-    const fieldValue = serializeSimple(field, item, (value) =>
-      encodeURIComponent(value).replace(/[!'()*]/g, (character) =>
-        `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
-      ),
-    )
-    if (fieldValue instanceof ToolError) return fieldValue
-    // '.'/'..' survive encoding and URL normalization collapses them, letting a
-    // model-supplied value retarget the request to a different endpoint.
-    if (fieldValue === "" || fieldValue === "." || fieldValue === "..") {
-      return toolError(`Invalid path parameter '${field.inputName}'.`)
-    }
-    url = url.replaceAll(`{${field.name}}`, fieldValue)
-  }
-  const unresolved = url.match(/\{[^{}]+\}/)
-  if (unresolved !== null) return toolError(`Unresolved path parameter ${unresolved[0]}.`)
-  return url
-}
-
-const serializeSimple = (
-  field: Plan["fields"][number],
-  value: unknown,
-  encode: (value: string) => string,
-): string | ToolError => {
-  const scalar = (item: unknown): string | ToolError =>
-    item !== null && typeof item !== "string" && typeof item !== "number" && typeof item !== "boolean"
-      ? toolError(`Parameter '${field.inputName}' contains an unsupported nested value.`)
-      : encode(String(item))
-  if (Array.isArray(value)) {
-    const items = value.map(scalar)
-    const invalid = items.find((item): item is ToolError => item instanceof ToolError)
-    return invalid ?? items.join(",")
-  }
-  if (!isRecord(value)) return scalar(value)
-  const entries = Object.entries(value).flatMap<string | ToolError>(([name, item]) => {
-    const rendered = scalar(item)
-    if (rendered instanceof ToolError) return [rendered]
-    return field.explode ? [`${encode(name)}=${rendered}`] : [encode(name), rendered]
-  })
-  const invalid = entries.find((item): item is ToolError => item instanceof ToolError)
-  return invalid ?? entries.join(",")
-}
-
-const serializeQuery = (
-  request: HttpClientRequest.HttpClientRequest,
-  field: Plan["fields"][number],
-  value: unknown,
-): HttpClientRequest.HttpClientRequest | ToolError => {
-  if (field.style === "deepObject") {
-    if (!isRecord(value)) return toolError(`Deep-object parameter '${field.inputName}' must be an object.`)
-    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
-      if (current instanceof ToolError) return current
-      if (item === undefined || (item !== null && typeof item === "object")) {
-        return toolError(`Deep-object parameter '${field.inputName}' contains an unsupported nested value.`)
-      }
-      return HttpClientRequest.appendUrlParam(current, `${field.name}[${name}]`, String(item))
-    }, request)
-  }
-  if (Array.isArray(value)) {
-    const rendered = serializeSimple(field, value, String)
-    if (rendered instanceof ToolError) return rendered
-    if (!field.explode) return HttpClientRequest.appendUrlParam(request, field.name, rendered)
-    if (value.some((item) => item === undefined || (item !== null && typeof item === "object"))) {
-      return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
-    }
-    return value.reduce(
-      (current, item) => HttpClientRequest.appendUrlParam(current, field.name, String(item)),
-      request,
-    )
-  }
-  if (isRecord(value) && field.explode) {
-    return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
-      if (current instanceof ToolError) return current
-      if (item === undefined || (item !== null && typeof item === "object")) {
-        return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
-      }
-      return HttpClientRequest.appendUrlParam(current, name, String(item))
-    }, request)
-  }
-  const rendered = serializeSimple(field, value, String)
-  return rendered instanceof ToolError ? rendered : HttpClientRequest.appendUrlParam(request, field.name, rendered)
-}
-
-const readResponseBody = (response: HttpClientResponse.HttpClientResponse, plan: Plan): Effect.Effect<string, ToolError> =>
-  Effect.gen(function* () {
-    const contentLength = response.headers["content-length"]
-    const parsedSize = contentLength === undefined ? undefined : Number.parseInt(contentLength, 10)
-    const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
-    if (declaredSize !== undefined && declaredSize > maxResponseBodyBytes) {
-      return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
-    }
-    let body = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, declaredSize ?? 64 * 1024))
-    let size = 0
-    yield* Stream.runForEach(response.stream, (chunk) => {
-      if (size + chunk.byteLength > maxResponseBodyBytes) {
-        return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
-      }
-      if (size + chunk.byteLength > body.byteLength) {
-        const grown = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)))
-        body.copy(grown, 0, 0, size)
-        body = grown
-      }
-      body.set(chunk, size)
-      size += chunk.byteLength
-      return Effect.void
-    }).pipe(
-      Effect.catch((cause) => {
-        if (cause instanceof ToolError) return Effect.fail(cause)
-        if (cause.reason._tag === "EmptyBodyError") return Effect.void
-        return Effect.fail(
-          toolError(`${plan.operation.method} ${plan.operation.path} failed while reading the response body.`, cause),
-        )
-      }),
-    )
-    return new TextDecoder().decode(body.subarray(0, size))
-  })

packages/codemode/src/openapi/spec.ts

@@ -1,507 +0,0 @@
-import { fromSchemaOpenApi3_0, fromSchemaOpenApi3_1 } from "effect/JsonSchema"
-import type { JsonSchema } from "../tool.js"
-import { isBlockedMember } from "../tool-runtime.js"
-import type {
-  Body,
-  Document,
-  InputField,
-  OperationInput,
-  Parsed,
-  SecurityRequirement,
-  SecurityScheme,
-} from "./types.js"
-
-export const methods = new Set(["get", "put", "post", "delete", "options", "head", "patch", "trace"])
-const parameterLocations = ["path", "query", "header"] as const
-const ignoredHeaderParameters = new Set(["accept", "content-type", "authorization"])
-
-export const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value)
-
-const asArray = (value: unknown): ReadonlyArray<unknown> => (Array.isArray(value) ? value : [])
-
-export const nonEmptyString = (value: unknown): string | undefined =>
-  typeof value === "string" && value !== "" ? value : undefined
-
-// Guards record lookups keyed by spec- or model-controlled names against
-// prototype-inherited values (e.g. a parameter named `toString`).
-export const own = <T>(record: Readonly<Record<string, T>>, key: string): T | undefined =>
-  Object.hasOwn(record, key) ? record[key] : undefined
-
-export const resolve = (document: Document, value: unknown): unknown => {
-  const next = (current: unknown, seen: ReadonlySet<string>): unknown => {
-    if (!isRecord(current)) return current
-    const ref = nonEmptyString(current.$ref)
-    if (ref === undefined || !ref.startsWith("#/") || seen.has(ref)) return current
-    const target = ref
-      .slice(2)
-      .split("/")
-      .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
-      .reduce<unknown>((item, segment) => (isRecord(item) ? own(item, segment) : undefined), document)
-    return target === undefined ? current : next(target, new Set([...seen, ref]))
-  }
-  return next(value, new Set())
-}
-
-const projectSchema = (document: Document, value: unknown): JsonSchema => {
-  if (!isRecord(value)) return {}
-  const normalized = nonEmptyString(document.openapi)?.startsWith("3.0")
-    ? fromSchemaOpenApi3_0(value)
-    : fromSchemaOpenApi3_1(value)
-  return Object.keys(normalized.definitions).length === 0
-    ? normalized.schema
-    : { ...normalized.schema, $defs: normalized.definitions }
-}
-
-export const componentDefinitions = (document: Document): Readonly<Record<string, JsonSchema>> => {
-  const components = isRecord(document.components) ? document.components : {}
-  const schemas = isRecord(components.schemas) ? components.schemas : {}
-  return Object.fromEntries(Object.entries(schemas).map(([name, value]) => [name, projectSchema(document, value)]))
-}
-
-const withDefinitions = (schema: JsonSchema, definitions: Readonly<Record<string, JsonSchema>>): JsonSchema => {
-  if (Object.keys(definitions).length === 0) return schema
-  const local = isRecord(schema.$defs) ? schema.$defs : {}
-  return { ...schema, $defs: { ...definitions, ...local } }
-}
-
-const isJsonMediaType = (mediaType: string): boolean => {
-  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
-  return normalized === "application/json" || normalized.endsWith("+json")
-}
-
-const isBinaryMediaType = (document: Document, mediaType: string, value: unknown): boolean => {
-  const normalized = mediaType.split(";")[0]?.trim().toLowerCase() ?? ""
-  if (!isJsonMediaType(normalized) && !normalized.startsWith("text/")) return true
-  if (!isRecord(value)) return false
-  const schema = resolve(document, value.schema)
-  return isRecord(schema) && schema.format === "binary"
-}
-
-const jsonContent = (content: Record<string, unknown>): { readonly mediaType: string; readonly schema: unknown } | undefined => {
-  const entry = Object.entries(content).find(([mediaType]) => isJsonMediaType(mediaType))
-  return entry !== undefined && isRecord(entry[1]) ? { mediaType: entry[0], schema: entry[1].schema } : undefined
-}
-
-const isFlattenableObjectBody = (
-  schema: unknown,
-  requestRequired: boolean,
-): schema is Record<string, unknown> & { readonly properties: Record<string, unknown> } =>
-  isRecord(schema) &&
-  requestRequired &&
-  schema.type === "object" &&
-  isRecord(schema.properties) &&
-  schema.additionalProperties === false &&
-  schema.nullable !== true &&
-  schema.allOf === undefined &&
-  schema.anyOf === undefined &&
-  schema.oneOf === undefined
-
-type PlannedField = Omit<InputField, "inputName">
-
-const operationParameters = (
-  document: Document,
-  pathItem: Record<string, unknown>,
-  operation: Record<string, unknown>,
-): Parsed<ReadonlyArray<PlannedField>> => {
-  // Operation-level parameters override path-level ones sharing (location, name).
-  const declared = new Map<
-    string,
-    { readonly name: string; readonly location: string; readonly parameter: Record<string, unknown> }
-  >()
-  for (const raw of [...asArray(pathItem.parameters), ...asArray(operation.parameters)]) {
-    const resolved = resolve(document, raw)
-    if (!isRecord(resolved)) return { ok: false, reason: "parameter declaration is invalid or unresolved" }
-    const name = nonEmptyString(resolved.name)
-    const location = nonEmptyString(resolved.in)
-    if (name === undefined || location === undefined)
-      return { ok: false, reason: "parameter declaration is missing name or location" }
-    declared.set(`${location}:${name}`, { name, location, parameter: resolved })
-  }
-  const unordered: Array<PlannedField> = []
-  for (const item of declared.values()) {
-    const name = item.name
-    const location = item.location
-    const resolved = item.parameter
-    if (location === "cookie") return { ok: false, reason: `cookie parameter '${name}' is not supported` }
-    if (location !== "path" && location !== "query" && location !== "header") {
-      return { ok: false, reason: `parameter '${name}' uses unsupported location '${location}'` }
-    }
-    if (location === "header" && ignoredHeaderParameters.has(name.toLowerCase())) continue
-    if (resolved.schema === undefined && resolved.content === undefined) {
-      return { ok: false, reason: `parameter '${name}' declares neither schema nor content` }
-    }
-    if (resolved.content !== undefined)
-      return { ok: false, reason: `parameter '${name}' uses unsupported content encoding` }
-    if (resolved.style !== undefined && nonEmptyString(resolved.style) === undefined) {
-      return { ok: false, reason: `parameter '${name}' has an invalid style` }
-    }
-    if (resolved.explode !== undefined && typeof resolved.explode !== "boolean") {
-      return { ok: false, reason: `parameter '${name}' has an invalid explode value` }
-    }
-    if (resolved.allowReserved !== undefined && typeof resolved.allowReserved !== "boolean") {
-      return { ok: false, reason: `parameter '${name}' has an invalid allowReserved value` }
-    }
-    if (resolved.allowReserved === true)
-      return { ok: false, reason: `parameter '${name}' uses unsupported allowReserved encoding` }
-    const declaredStyle = nonEmptyString(resolved.style) ?? (location === "query" ? "form" : "simple")
-    if (location === "query" && declaredStyle !== "form" && declaredStyle !== "deepObject") {
-      return { ok: false, reason: `query parameter '${name}' uses unsupported style '${declaredStyle}'` }
-    }
-    if (location !== "query" && declaredStyle !== "simple") {
-      return { ok: false, reason: `${location} parameter '${name}' uses unsupported style '${declaredStyle}'` }
-    }
-    const style = declaredStyle === "deepObject" ? "deepObject" : declaredStyle === "form" ? "form" : "simple"
-    const explode = typeof resolved.explode === "boolean" ? resolved.explode : style === "form"
-    if (style === "deepObject" && !explode) {
-      return { ok: false, reason: `query parameter '${name}' uses deepObject with explode=false` }
-    }
-    const base = projectSchema(document, resolved.schema)
-    const description = nonEmptyString(resolved.description)
-    unordered.push({
-      name,
-      location,
-      required: resolved.required === true || location === "path",
-      style,
-      explode,
-      schema: {
-        ...base,
-        ...(base.description === undefined && description !== undefined ? { description } : {}),
-      },
-    })
-  }
-  return {
-    ok: true,
-    value: parameterLocations.flatMap((location) => unordered.filter((field) => field.location === location)),
-  }
-}
-
-const operationBody = (
-  document: Document,
-  operation: Record<string, unknown>,
-): Parsed<{ readonly fields: ReadonlyArray<PlannedField>; readonly body: Body | undefined }> => {
-  const resolved = resolve(document, operation.requestBody)
-  if (!isRecord(resolved)) return { ok: true, value: { fields: [], body: undefined } }
-  const content = isRecord(resolved.content) ? resolved.content : {}
-  const selected = jsonContent(content)
-  if (selected === undefined) {
-    return {
-      ok: false,
-      reason: `request body has no JSON content (declared: ${Object.keys(content).join(", ") || "none"})`,
-    }
-  }
-  const schema = resolve(document, selected.schema)
-  const required = resolved.required === true
-  if (!isFlattenableObjectBody(schema, required)) {
-    return {
-      ok: true,
-      value: {
-        fields: [
-          {
-            name: "body",
-            location: "body",
-            required,
-            schema: projectSchema(document, selected.schema),
-            style: undefined,
-            explode: undefined,
-          },
-        ],
-        body: { required, mode: "value", mediaType: selected.mediaType },
-      },
-    }
-  }
-  const requiredProperties = new Set(
-    Array.isArray(schema.required) ? schema.required.filter((item): item is string => typeof item === "string") : [],
-  )
-  return {
-    ok: true,
-    value: {
-      fields: Object.entries(schema.properties).map(([name, value]) => ({
-        name,
-        location: "body" as const,
-        required: required && requiredProperties.has(name),
-        schema: projectSchema(document, value),
-        style: undefined,
-        explode: undefined,
-      })),
-      body: { required, mode: "object", mediaType: selected.mediaType },
-    },
-  }
-}
-
-export const operationInput = (
-  document: Document,
-  pathItem: Record<string, unknown>,
-  operation: Record<string, unknown>,
-): Parsed<OperationInput> => {
-  const parameters = operationParameters(document, pathItem, operation)
-  if (!parameters.ok) return parameters
-  const requestBody = operationBody(document, operation)
-  if (!requestBody.ok) return requestBody
-  const fields = [...parameters.value, ...requestBody.value.fields]
-
-  const conflicts = new Set(
-    [...Map.groupBy(fields, (field) => field.name)]
-      .filter(([, matches]) => new Set(matches.map((field) => field.location)).size > 1)
-      .map(([name]) => name),
-  )
-  const used = new Set<string>()
-  return {
-    ok: true,
-    value: {
-      fields: fields.map((field) => {
-        const visibleName = isBlockedMember(field.name) ? `${field.name}_2` : field.name
-        const base = conflicts.has(field.name) ? `${field.location}_${visibleName}` : visibleName
-        const next = (index: number): string => {
-          const candidate = index === 1 ? base : `${base}_${index}`
-          return used.has(candidate) ? next(index + 1) : candidate
-        }
-        const inputName = next(1)
-        used.add(inputName)
-        return { ...field, inputName }
-      }),
-      body: requestBody.value.body,
-    },
-  }
-}
-
-export const inputSchema = (
-  fields: ReadonlyArray<InputField>,
-  definitions: Readonly<Record<string, JsonSchema>>,
-): JsonSchema => {
-  const required = fields.filter((field) => field.required).map((field) => field.inputName)
-  return withDefinitions(
-    {
-      type: "object",
-      properties: Object.fromEntries(fields.map((field) => [field.inputName, field.schema])),
-      ...(required.length === 0 ? {} : { required }),
-    },
-    definitions,
-  )
-}
-
-const successfulResponses = (
-  document: Document,
-  operation: Record<string, unknown>,
-): Parsed<ReadonlyArray<Record<string, unknown>>> => {
-  if (!isRecord(operation.responses)) return { ok: true, value: [] }
-  const entries = Object.entries(operation.responses)
-  const selected = [
-    ...entries.filter(([status]) => /^2\d\d$/.test(status)).sort(([a], [b]) => a.localeCompare(b)),
-    ...entries.filter(([status]) => status.toUpperCase() === "2XX"),
-  ]
-  const responses: Array<Record<string, unknown>> = []
-  for (const [, value] of selected) {
-    const resolved = resolve(document, value)
-    if (!isRecord(resolved) || nonEmptyString(resolved.$ref) !== undefined) {
-      return { ok: false, reason: "successful response declaration is invalid or unresolved" }
-    }
-    responses.push(resolved)
-  }
-  return { ok: true, value: responses }
-}
-
-export const operationOutput = (
-  document: Document,
-  operation: Record<string, unknown>,
-  definitions: Readonly<Record<string, JsonSchema>>,
-): Parsed<JsonSchema | undefined> => {
-  if (operation["x-websocket"] === true) return { ok: false, reason: "WebSocket operations are not supported" }
-  const responses = successfulResponses(document, operation)
-  if (!responses.ok) return responses
-  const streams = responses.value.some(
-    (response) =>
-      isRecord(response.content) &&
-      Object.keys(response.content).some(
-        (mediaType) => mediaType.split(";")[0]?.trim().toLowerCase() === "text/event-stream",
-      ),
-  )
-  if (streams) return { ok: false, reason: "SSE operations are not supported" }
-  const binary = responses.value.some(
-    (response) =>
-      isRecord(response.content) &&
-      Object.entries(response.content).some(([mediaType, value]) => isBinaryMediaType(document, mediaType, value)),
-  )
-  if (binary) return { ok: false, reason: "binary responses are not supported" }
-
-  const outcomes: Array<JsonSchema> = []
-  for (const response of responses.value) {
-    if (response.content !== undefined && !isRecord(response.content)) return { ok: true, value: undefined }
-    const content = isRecord(response.content) ? response.content : {}
-    if (Object.keys(content).length === 0) {
-      outcomes.push({ type: "null" })
-      continue
-    }
-    for (const [mediaType, value] of Object.entries(content)) {
-      if (!isJsonMediaType(mediaType)) {
-        outcomes.push({ type: "string" })
-        continue
-      }
-      if (!isRecord(value) || value.schema === undefined) return { ok: true, value: undefined }
-      outcomes.push(projectSchema(document, value.schema))
-    }
-  }
-  if (outcomes.length === 0) return { ok: true, value: undefined }
-  return {
-    ok: true,
-    value: withDefinitions(outcomes.length === 1 ? outcomes[0] ?? {} : { anyOf: outcomes }, definitions),
-  }
-}
-
-const sanitizeOperationSegment = (raw: string): string => {
-  const base =
-    raw
-      .replaceAll(/[^A-Za-z0-9_$]+/g, "_")
-      .replace(/^_+|_+$/g, "")
-      .replace(/^([0-9])/, "_$1") || "operation"
-  return isBlockedMember(base) ? `${base}_2` : base
-}
-
-const fallbackOperationId = (method: string, path: string): string =>
-  [
-    method,
-    ...path
-      .split("/")
-      .filter((part) => part !== "")
-      .flatMap((part) => (part.startsWith("{") && part.endsWith("}") ? ["by", part.slice(1, -1)] : [part]))
-      .flatMap((part) => part.split(/[^A-Za-z0-9]+/).filter((word) => word !== "")),
-  ]
-    .map((word, index) => {
-      const lower = word.toLowerCase()
-      return index === 0 ? lower : `${lower.charAt(0).toUpperCase()}${lower.slice(1)}`
-    })
-    .join("")
-
-export const operationPath = (
-  method: string,
-  path: string,
-  operation: Record<string, unknown>,
-  used: ReadonlySet<string>,
-  namespaces: ReadonlySet<string>,
-): ReadonlyArray<string> => {
-  const raw = nonEmptyString(operation.operationId)
-  const segments = (raw === undefined ? [fallbackOperationId(method, path)] : raw.split(".")).map(sanitizeOperationSegment)
-  if (isOperationPathAvailable(segments, used, namespaces)) return segments
-  const conflict = segments.slice(0, -1).findIndex((_, index) => used.has(segments.slice(0, index + 1).join(".")))
-  if (conflict >= 0 && conflict + 1 < segments.length) {
-    const collapsed = segments.flatMap((segment, index) => {
-      if (index === conflict) {
-        const next = segments[index + 1] ?? ""
-        return [`${segment}${next.charAt(0).toUpperCase()}${next.slice(1)}`]
-      }
-      return index === conflict + 1 ? [] : [segment]
-    })
-    if (isOperationPathAvailable(collapsed, used, namespaces)) return collapsed
-  }
-  const fallback = segments.join("_")
-  const next = (index: number): string => {
-    const candidate = `${fallback}_${index}`
-    return isOperationPathAvailable([candidate], used, namespaces) ? candidate : next(index + 1)
-  }
-  return [next(2)]
-}
-
-const isOperationPathAvailable = (
-  segments: ReadonlyArray<string>,
-  used: ReadonlySet<string>,
-  namespaces: ReadonlySet<string>,
-): boolean => {
-  const key = segments.join(".")
-  if (used.has(key) || namespaces.has(key)) return false
-  return segments.slice(0, -1).every((_, index) => !used.has(segments.slice(0, index + 1).join(".")))
-}
-
-export const specServerUrl = (source: Record<string, unknown>): Parsed<string> => {
-  const server = asArray(source.servers).find(isRecord)
-  const url = server === undefined ? undefined : nonEmptyString(server.url)
-  if (url === undefined) return { ok: false, reason: "spec declares no servers; pass baseUrl" }
-  if (/\{[^{}]+\}/.test(url)) {
-    return { ok: false, reason: `server URL '${url}' is not an absolute URL; pass baseUrl` }
-  }
-  return validateBaseUrl(url)
-}
-
-export const validateBaseUrl = (value: string): Parsed<string> => {
-  if (!/^https?:\/\//i.test(value)) return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
-  const url = URL.parse(value)
-  if (url === null || (url.protocol !== "http:" && url.protocol !== "https:")) {
-    return { ok: false, reason: `server URL '${value}' is not an absolute HTTP(S) URL` }
-  }
-  if (url.search !== "" || url.hash !== "") {
-    return { ok: false, reason: `server URL '${value}' contains an unsupported query string or fragment` }
-  }
-  return { ok: true, value }
-}
-
-export const securityRequirements = (value: unknown): Parsed<ReadonlyArray<SecurityRequirement>> => {
-  if (value === undefined) return { ok: true, value: [] }
-  if (!Array.isArray(value)) return { ok: false, reason: "security declaration is not an array" }
-  const requirements: Array<SecurityRequirement> = []
-  for (const item of value) {
-    if (!isRecord(item)) return { ok: false, reason: "security requirement is not an object" }
-    const requirement = Object.create(null) as Record<string, ReadonlyArray<string>>
-    for (const [name, scopes] of Object.entries(item)) {
-      if (!Array.isArray(scopes)) return { ok: false, reason: "security requirement scopes are not string arrays" }
-      const parsed = scopes.filter((scope): scope is string => typeof scope === "string")
-      if (parsed.length !== scopes.length) {
-        return { ok: false, reason: "security requirement scopes are not string arrays" }
-      }
-      requirement[name] = parsed
-    }
-    requirements.push(requirement)
-  }
-  return { ok: true, value: requirements }
-}
-
-export const operationSecurityRequirements = (
-  value: unknown,
-  defaults: Parsed<ReadonlyArray<SecurityRequirement>>,
-  schemes: Readonly<Record<string, SecurityScheme>>,
-): Parsed<ReadonlyArray<SecurityRequirement>> => {
-  const parsed = value === undefined ? defaults : securityRequirements(value)
-  if (!parsed.ok) return parsed
-  const supported = parsed.value.filter((requirement) =>
-    Object.keys(requirement).every((name) => {
-      const scheme = own(schemes, name)
-      return scheme !== undefined && !(scheme.type === "apiKey" && scheme.in === "cookie")
-    }),
-  )
-  if (parsed.value.length === 0 || supported.length > 0) return { ok: true, value: supported }
-
-  const names = [...new Set(parsed.value.flatMap((requirement) => Object.keys(requirement)))]
-  const cookieScheme = names.find((name) => {
-    const definition = own(schemes, name)
-    return definition?.type === "apiKey" && definition.in === "cookie"
-  })
-  return {
-    ok: false,
-    reason:
-      cookieScheme === undefined
-        ? `security requirement references missing or malformed scheme: ${names.join(", ")}`
-        : `cookie authentication '${cookieScheme}' is not supported`,
-  }
-}
-
-export const securitySchemes = (document: Document): Readonly<Record<string, SecurityScheme>> => {
-  const components = isRecord(document.components) ? document.components : {}
-  const declared = isRecord(components.securitySchemes) ? components.securitySchemes : {}
-  return Object.fromEntries(
-    Object.entries(declared).flatMap<readonly [string, SecurityScheme]>(([name, value]) => {
-      const resolved = resolve(document, value)
-      if (!isRecord(resolved)) return []
-      const type = nonEmptyString(resolved.type)
-      if (type === "apiKey") {
-        const carrier = nonEmptyString(resolved.in)
-        const parameter = nonEmptyString(resolved.name)
-        if (parameter === undefined || (carrier !== "header" && carrier !== "query" && carrier !== "cookie")) return []
-        return [[name, { type, name: parameter, in: carrier }] as const]
-      }
-      if (type === "http") {
-        const scheme = nonEmptyString(resolved.scheme)?.toLowerCase()
-        return scheme === undefined ? [] : [[name, { type, scheme }] as const]
-      }
-      if (type === "oauth2" || type === "openIdConnect") return [[name, { type }] as const]
-      return []
-    }),
-  )
-}

packages/codemode/src/openapi/types.ts

@@ -1,112 +0,0 @@
-import { Effect } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import type { Definition, JsonSchema } from "../tool.js"
-
-/** A parsed OpenAPI 3.x document. YAML must be parsed by the host. */
-export type Document = Record<string, unknown>
-
-/** The operation identity handed to auth resolution and errors. */
-export type Operation = {
-  readonly operationId: string | undefined
-  readonly method: string
-  readonly path: string
-  readonly summary: string | undefined
-  readonly description: string | undefined
-}
-
-/** A resolved OpenAPI security scheme from `components.securitySchemes`. */
-export type SecurityScheme =
-  | { readonly type: "apiKey"; readonly name: string; readonly in: "header" | "query" | "cookie" }
-  | { readonly type: "http"; readonly scheme: string }
-  | { readonly type: "oauth2" }
-  | { readonly type: "openIdConnect" }
-
-/**
- * Credential material returned by a host auth resolver. The carrier for `apiKey`
- * comes from the scheme definition, not the credential. `header` is the escape
- * hatch for nonstandard schemes.
- */
-export type Credential =
-  | { readonly type: "bearer"; readonly token: string }
-  | { readonly type: "basic"; readonly username: string; readonly password: string }
-  | { readonly type: "apiKey"; readonly value: string }
-  | { readonly type: "header"; readonly name: string; readonly value: string }
-
-/**
- * Resolves credential material for one named security scheme at call time.
- * `undefined` means unavailable, try the next OR alternative; a failure aborts
- * the call rather than falling through.
- */
-export type AuthResolver = (context: {
-  readonly name: string
-  readonly definition: SecurityScheme
-  readonly scopes: ReadonlyArray<string>
-  readonly operation: Operation
-}) => Effect.Effect<Credential | undefined, unknown>
-
-export type Options = {
-  readonly spec: Document
-  /** Overrides all document, path, and operation `servers`. Required when no applicable absolute server URL exists. */
-  readonly baseUrl?: string | undefined
-  /** Host credential resolution, keyed by security scheme name. */
-  readonly auth?: { readonly resolve: AuthResolver } | undefined
-  /** Static headers on every request. Not model-visible; declared header params may override them, auth always wins. */
-  readonly headers?: Readonly<Record<string, string>> | undefined
-}
-
-/** An operation that could not be represented as a tool, and why. */
-export type Skipped = {
-  readonly method: string
-  readonly path: string
-  readonly reason: string
-}
-
-export type Tools = { [name: string]: Definition<HttpClient.HttpClient> | Tools }
-
-export type Result = {
-  /** Tool subtree; the host places it under a key in its `tools` tree. */
-  readonly tools: Tools
-  readonly skipped: ReadonlyArray<Skipped>
-}
-
-export type Parsed<T> = { readonly ok: true; readonly value: T } | { readonly ok: false; readonly reason: string }
-
-export type InputLocation = "path" | "query" | "header" | "body"
-
-export type InputField = {
-  /** Model-visible field name after cross-location collision handling. */
-  readonly inputName: string
-  /** Original parameter or body-property name used on the wire. */
-  readonly name: string
-  readonly location: InputLocation
-  readonly required: boolean
-  readonly schema: JsonSchema
-  readonly style: "simple" | "form" | "deepObject" | undefined
-  readonly explode: boolean | undefined
-}
-
-export type Body = { readonly required: boolean; readonly mode: "object" | "value"; readonly mediaType: string }
-
-export type OperationInput = {
-  readonly fields: ReadonlyArray<InputField>
-  readonly body: Body | undefined
-}
-
-/** One OR alternative: scheme name -> required scopes. Empty object = unauthenticated is acceptable. */
-export type SecurityRequirement = Readonly<Record<string, ReadonlyArray<string>>>
-
-export type Plan = {
-  readonly operation: Operation
-  readonly url: string
-  readonly fields: ReadonlyArray<InputField>
-  readonly body: Body | undefined
-  readonly security: ReadonlyArray<SecurityRequirement>
-  readonly schemes: Readonly<Record<string, SecurityScheme>>
-  readonly auth: { readonly resolve: AuthResolver } | undefined
-  readonly headers: Readonly<Record<string, string>>
-}
-
-export type AppliedAuth = {
-  readonly headers: Readonly<Record<string, string>>
-  readonly query: Readonly<Record<string, string>>
-}

packages/codemode/src/stdlib/collections.ts

@@ -1,51 +0,0 @@
-export const arrayMethods = new Set([
-  "map",
-  "filter",
-  "find",
-  "findIndex",
-  "findLast",
-  "findLastIndex",
-  "some",
-  "every",
-  "includes",
-  "join",
-  "reduce",
-  "reduceRight",
-  "flatMap",
-  "forEach",
-  "sort",
-  "toSorted",
-  "slice",
-  "concat",
-  "indexOf",
-  "lastIndexOf",
-  "at",
-  "flat",
-  "reverse",
-  "toReversed",
-  "with",
-  "push",
-  "pop",
-  "shift",
-  "unshift",
-  "splice",
-  "fill",
-  "copyWithin",
-  "keys",
-  "values",
-  "entries",
-])
-
-export const mapMethods = new Set(["get", "set", "has", "delete", "clear", "forEach", "keys", "values", "entries"])
-
-export const setMethods = new Set(["add", "has", "delete", "clear", "forEach", "keys", "values", "entries"])
-
-export const spreadItems = (value: unknown): Array<unknown> | undefined => {
-  if (Array.isArray(value)) return value
-  if (typeof value === "string") return Array.from(value)
-  if (value instanceof SandboxMap) return Array.from(value.map.entries(), ([key, item]) => [key, item])
-  if (value instanceof SandboxSet) return Array.from(value.set.values())
-  if (value instanceof SandboxURLSearchParams) return Array.from(value.params.entries(), ([key, item]) => [key, item])
-  return undefined
-}
-import { SandboxMap, SandboxSet, SandboxURLSearchParams } from "../values.js"

packages/codemode/src/stdlib/console.ts

@@ -1,4 +0,0 @@
-export const consoleMethods = new Set(["log", "info", "debug", "warn", "error", "dir", "table"])
-
-/** Console formatting recursion ceiling; deeper values render as "...". */
-export const MAX_CONSOLE_DEPTH = 32

packages/codemode/src/stdlib/date.ts

@@ -1,94 +0,0 @@
-export const dateMethods = new Set([
-  "getTime",
-  "valueOf",
-  "toISOString",
-  "toJSON",
-  "toString",
-  "getFullYear",
-  "getMonth",
-  "getDate",
-  "getDay",
-  "getHours",
-  "getMinutes",
-  "getSeconds",
-  "getMilliseconds",
-  "getUTCFullYear",
-  "getUTCMonth",
-  "getUTCDate",
-  "getUTCDay",
-  "getUTCHours",
-  "getUTCMinutes",
-  "getUTCSeconds",
-  "getUTCMilliseconds",
-  "getTimezoneOffset",
-])
-
-export const dateStatics = new Set(["now", "parse", "UTC"])
-
-export const invokeDateStatic = (name: string, args: Array<unknown>, node: AstNode): number => {
-  switch (name) {
-    case "now":
-      return Date.now()
-    case "parse":
-      return Date.parse(coerceToString(args[0]))
-    case "UTC":
-      return Date.UTC(...(args.map((arg) => coerceToNumber(arg)) as Parameters<typeof Date.UTC>))
-    default:
-      throw new InterpreterRuntimeError(`Date.${name} is not available in CodeMode.`, node)
-  }
-}
-
-export const invokeDateMethod = (value: SandboxDate, name: string, node: AstNode): unknown => {
-  const hosted = new Date(value.time)
-  switch (name) {
-    case "getTime":
-    case "valueOf":
-      return value.time
-    case "toISOString":
-      if (!Number.isFinite(value.time)) throw new InterpreterRuntimeError("Invalid time value.", node)
-      return hosted.toISOString()
-    case "toJSON":
-      return Number.isFinite(value.time) ? hosted.toISOString() : null
-    case "toString":
-      return coerceToString(value)
-    case "getFullYear":
-      return hosted.getFullYear()
-    case "getMonth":
-      return hosted.getMonth()
-    case "getDate":
-      return hosted.getDate()
-    case "getDay":
-      return hosted.getDay()
-    case "getHours":
-      return hosted.getHours()
-    case "getMinutes":
-      return hosted.getMinutes()
-    case "getSeconds":
-      return hosted.getSeconds()
-    case "getMilliseconds":
-      return hosted.getMilliseconds()
-    case "getUTCFullYear":
-      return hosted.getUTCFullYear()
-    case "getUTCMonth":
-      return hosted.getUTCMonth()
-    case "getUTCDate":
-      return hosted.getUTCDate()
-    case "getUTCDay":
-      return hosted.getUTCDay()
-    case "getUTCHours":
-      return hosted.getUTCHours()
-    case "getUTCMinutes":
-      return hosted.getUTCMinutes()
-    case "getUTCSeconds":
-      return hosted.getUTCSeconds()
-    case "getUTCMilliseconds":
-      return hosted.getUTCMilliseconds()
-    case "getTimezoneOffset":
-      return hosted.getTimezoneOffset()
-    default:
-      throw new InterpreterRuntimeError(`Date method '${name}' is not available in CodeMode.`, node)
-  }
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { SandboxDate } from "../values.js"
-import { coerceToNumber, coerceToString } from "./value.js"

packages/codemode/src/stdlib/json.ts

@@ -1,42 +0,0 @@
-import {
-  type AstNode,
-  CodeModeFunction,
-  InterpreterRuntimeError,
-  supportedSyntaxMessage,
-} from "../interpreter/model.js"
-import { copyIn, copyOut } from "../tool-runtime.js"
-
-export const jsonStatics = new Set(["stringify", "parse"])
-
-export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  if (!jsonStatics.has(name)) throw new InterpreterRuntimeError(`JSON.${name} is not available in CodeMode.`, node)
-  switch (name) {
-    case "stringify": {
-      const replacer = args[1]
-      if (Array.isArray(replacer) || replacer instanceof CodeModeFunction) {
-        throw new InterpreterRuntimeError(
-          "JSON.stringify replacers are not supported in CodeMode.",
-          node,
-          "UnsupportedSyntax",
-          [supportedSyntaxMessage],
-        )
-      }
-      const space = args[2]
-      const indent = typeof space === "number" || typeof space === "string" ? space : undefined
-      return JSON.stringify(copyOut(copyIn(args[0], "JSON.stringify value")), null, indent)
-    }
-    case "parse": {
-      const text = args[0]
-      if (typeof text !== "string") throw new InterpreterRuntimeError("JSON.parse expects a string.", node)
-      try {
-        return copyIn(JSON.parse(text), "JSON.parse result")
-      } catch (error) {
-        throw new InterpreterRuntimeError(
-          `JSON.parse received invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
-          node,
-        ).as("SyntaxError")
-      }
-    }
-  }
-  throw new InterpreterRuntimeError(`JSON.${name} is not available in CodeMode.`, node)
-}

packages/codemode/src/stdlib/math.ts

@@ -1,65 +0,0 @@
-export const mathConstants = new Set(["PI", "E", "LN2", "LN10", "LOG2E", "LOG10E", "SQRT2", "SQRT1_2"])
-
-export const mathMethods = new Set([
-  "max",
-  "min",
-  "abs",
-  "floor",
-  "ceil",
-  "round",
-  "trunc",
-  "sign",
-  "sqrt",
-  "cbrt",
-  "pow",
-  "hypot",
-  "log",
-  "log2",
-  "log10",
-  "exp",
-])
-
-export const invokeMathMethod = (name: string, args: Array<unknown>, node: AstNode): number => {
-  if (!mathMethods.has(name)) throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node)
-  const nums = args.map((arg) => {
-    if (typeof arg !== "number") throw new InterpreterRuntimeError(`Math.${name} expects number arguments.`, node)
-    return arg
-  })
-  const [a = Number.NaN, b = Number.NaN] = nums
-  switch (name) {
-    case "max":
-      return Math.max(...nums)
-    case "min":
-      return Math.min(...nums)
-    case "abs":
-      return Math.abs(a)
-    case "floor":
-      return Math.floor(a)
-    case "ceil":
-      return Math.ceil(a)
-    case "round":
-      return Math.round(a)
-    case "trunc":
-      return Math.trunc(a)
-    case "sign":
-      return Math.sign(a)
-    case "sqrt":
-      return Math.sqrt(a)
-    case "cbrt":
-      return Math.cbrt(a)
-    case "pow":
-      return Math.pow(a, b)
-    case "hypot":
-      return Math.hypot(...nums)
-    case "log":
-      return Math.log(a)
-    case "log2":
-      return Math.log2(a)
-    case "log10":
-      return Math.log10(a)
-    case "exp":
-      return Math.exp(a)
-  }
-  throw new InterpreterRuntimeError(`Math.${name} is not available in CodeMode.`, node)
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"

packages/codemode/src/stdlib/number.ts

@@ -1,66 +0,0 @@
-export const numberMethods = new Set(["toFixed", "toPrecision", "toExponential", "toString"])
-
-export const numberConstants = new Set(["MAX_SAFE_INTEGER", "MIN_SAFE_INTEGER", "MAX_VALUE", "MIN_VALUE", "EPSILON"])
-
-export const numberStatics = new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseInt", "parseFloat"])
-
-export const invokeNumberMethod = (value: number, name: string, args: Array<unknown>, node: AstNode): unknown => {
-  const optNum = (index: number): number | undefined => {
-    const arg = args[index]
-    if (arg === undefined) return undefined
-    if (typeof arg !== "number") throw new InterpreterRuntimeError(`Number.${name} expects a number argument.`, node)
-    return arg
-  }
-  let result: unknown
-  switch (name) {
-    case "toFixed":
-      result = value.toFixed(optNum(0))
-      break
-    case "toExponential":
-      result = value.toExponential(optNum(0))
-      break
-    case "toPrecision": {
-      const digits = optNum(0)
-      result = digits === undefined ? value.toString() : value.toPrecision(digits)
-      break
-    }
-    case "toString": {
-      const radix = optNum(0)
-      if (radix !== undefined && (radix < 2 || radix > 36)) {
-        throw new InterpreterRuntimeError("Number.toString radix must be between 2 and 36.", node)
-      }
-      result = value.toString(radix)
-      break
-    }
-    default:
-      throw new InterpreterRuntimeError(`Number method '${name}' is not available in CodeMode.`, node)
-  }
-  return boundedData(result, `Number.${name} result`)
-}
-
-export const invokeNumberStatic = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  const value = args[0]
-  switch (name) {
-    case "isInteger":
-      return Number.isInteger(value)
-    case "isFinite":
-      return Number.isFinite(value)
-    case "isNaN":
-      return Number.isNaN(value)
-    case "isSafeInteger":
-      return Number.isSafeInteger(value)
-    case "parseInt": {
-      const radix = args[1]
-      if (radix !== undefined && typeof radix !== "number") {
-        throw new InterpreterRuntimeError("Number.parseInt expects a numeric radix.", node)
-      }
-      return parseInt(coerceToString(value), radix)
-    }
-    case "parseFloat":
-      return parseFloat(coerceToString(value))
-    default:
-      throw new InterpreterRuntimeError(`Number.${name} is not available in CodeMode.`, node)
-  }
-}
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { boundedData, coerceToString } from "./value.js"

packages/codemode/src/stdlib/object.ts

@@ -1,77 +0,0 @@
-import { type AstNode, InterpreterRuntimeError } from "../interpreter/model.js"
-import { isBlockedMember } from "../tool-runtime.js"
-import { isSandboxValue, SandboxMap, SandboxURLSearchParams } from "../values.js"
-import { boundedData, coerceToString } from "./value.js"
-
-export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "assign", "fromEntries"])
-
-export const invokeObjectMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
-  if (!objectStatics.has(name)) throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
-  const requireObject = (): Record<string, unknown> => {
-    const value = boundedData(args[0], `Object.${name} input`)
-    if (isSandboxValue(value)) return {}
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-      throw new InterpreterRuntimeError(`Object.${name} expects a data object.`, node)
-    }
-    return value as Record<string, unknown>
-  }
-  const guardedSet = (out: Record<string, unknown>, key: string, item: unknown): void => {
-    if (isBlockedMember(key)) throw new InterpreterRuntimeError(`Property '${key}' is not available in CodeMode.`, node)
-    out[key] = item
-  }
-  switch (name) {
-    case "keys": {
-      const value = boundedData(args[0], "Object.keys input")
-      if (isSandboxValue(value)) return []
-      if (Array.isArray(value)) return Object.keys(value)
-      if (value === null || typeof value !== "object") {
-        throw new InterpreterRuntimeError("Object.keys expects a data object or array.", node)
-      }
-      return Object.keys(value)
-    }
-    case "values":
-      return Object.values(requireObject())
-    case "entries":
-      return Object.entries(requireObject()).map(([key, item]) => [key, item])
-    case "hasOwn":
-      return Object.hasOwn(requireObject(), String(args[1]))
-    case "assign": {
-      const out: Record<string, unknown> = Object.create(null)
-      for (const source of args) {
-        if (source === null || source === undefined) continue
-        const value = boundedData(source, "Object.assign input")
-        if (isSandboxValue(value)) continue
-        if (value === null || typeof value !== "object" || Array.isArray(value)) {
-          throw new InterpreterRuntimeError("Object.assign expects data objects.", node)
-        }
-        for (const [key, item] of Object.entries(value)) guardedSet(out, key, item)
-      }
-      return out
-    }
-    case "fromEntries": {
-      if (args[0] instanceof SandboxMap) {
-        const out: Record<string, unknown> = Object.create(null)
-        for (const [key, item] of args[0].map.entries()) guardedSet(out, coerceToString(key), item)
-        return out
-      }
-      if (args[0] instanceof SandboxURLSearchParams) {
-        const out: Record<string, unknown> = Object.create(null)
-        for (const [key, value] of args[0].params.entries()) guardedSet(out, key, value)
-        return out
-      }
-      const pairs = boundedData(args[0], "Object.fromEntries input")
-      if (!Array.isArray(pairs)) {
-        throw new InterpreterRuntimeError("Object.fromEntries expects an array of [key, value] pairs.", node)
-      }
-      const out: Record<string, unknown> = Object.create(null)
-      for (const pair of pairs) {
-        if (!Array.isArray(pair)) {
-          throw new InterpreterRuntimeError("Object.fromEntries expects [key, value] pairs.", node)
-        }
-        guardedSet(out, String(pair[0]), pair[1])
-      }
-      return out
-    }
-  }
-  throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
-}