chore(sdk): regenerate persistent pty client

.changeset/promise-plugin-adapter.md

@@ -1,5 +0,0 @@
----
-"@opencode-ai/plugin": patch
----
-
-Derive Promise plugin API request and response conversion from the canonical protocol schemas.

.opencode/command/ai-deps.md

@@ -2,7 +2,7 @@
 description: "Bump AI sdk dependencies minor / patch versions only"
 ---
 
-Please read @package.json and @packages/core/package.json.
+Please read @package.json and @packages/opencode/package.json.
 
 Your job is to look into AI SDK dependencies, figure out if they have versions that can be upgraded (minor or patch versions ONLY no major ignore major changes).
 

.opencode/command/commit.md

@@ -6,7 +6,15 @@ subtask: true
 
 commit and push
 
-Use `type(scope): summary` with one of these types: `feat`, `fix`, `docs`, `chore`, `refactor`, or `test`. The scope is optional.
+make sure it includes a prefix like
+docs:
+tui:
+core:
+ci:
+ignore:
+wip:
+
+For anything in the packages/web use the docs: prefix.
 
 prefer to explain WHY something was done from an end user perspective instead of
 WHAT was done.

.opencode/command/rmslop.md

@@ -2,7 +2,7 @@
 description: Remove AI code slop
 ---
 
-Check the diff against `origin/v2`, and remove all AI generated slop introduced in this branch.
+Check the diff against dev, and remove all AI generated slop introduced in this branch.
 
 This includes:
 

.opencode/skills/effect/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: effect
-description: Work with Effect v4 TypeScript code in this repo
+description: Work with Effect v4 / effect-smol TypeScript code in this repo
 ---
 
 # Effect
@@ -9,10 +9,10 @@ This codebase uses Effect for typed, composable TypeScript services, schemas, an
 
 ## Source Of Truth
 
-Use the current Effect v4 source, not memory or older Effect v2/v3 examples.
+Use the current Effect v4 / effect-smol source, not memory or older Effect v2/v3 examples.
 
-1. If `.opencode/references/effect` is missing, clone `https://github.com/Effect-TS/effect` there. Do this in the project, not in the skill folder.
-2. Search `.opencode/references/effect` for exact APIs, examples, tests, and naming patterns before answering or implementing Effect-specific code.
+1. If `.opencode/references/effect-smol` is missing, clone `https://github.com/Effect-TS/effect-smol` there. Do this in the project, not in the skill folder.
+2. Search `.opencode/references/effect-smol` for exact APIs, examples, tests, and naming patterns before answering or implementing Effect-specific code.
 3. Also inspect existing repo code for local house style before introducing new patterns.
 4. Prefer answers and implementations backed by specific source files or nearby repo examples.
 
@@ -27,12 +27,12 @@ Use the current Effect v4 source, not memory or older Effect v2/v3 examples.
 - Keep layer composition explicit. Avoid broad hidden provisioning that makes missing dependencies hard to see.
 - In tests, prefer the repo's existing Effect test helpers and live tests for filesystem, git, child process, locks, or timing behavior.
 - Do not introduce `any`, non-null assertions, unchecked casts, or older Effect APIs just to satisfy types.
-- Do not answer from memory. Verify against `.opencode/references/effect` or nearby code first.
+- Do not answer from memory. Verify against `.opencode/references/effect-smol` or nearby code first.
 
 ## Testing Patterns
 
-- Use `testEffect(...)` from `packages/core/test/lib/effect.ts` for tests that exercise Effect services, layers, runtime context, scoped resources, or platform integrations.
+- Use `testEffect(...)` from `packages/opencode/test/lib/effect.ts` for tests that exercise Effect services, layers, runtime context, scoped resources, or platform integrations.
 - Use `it.live(...)` for filesystem, git repositories, HTTP servers, sockets, child processes, locks, real time, and other live platform behavior.
-- Run tests from package directories such as `packages/core`; never run package tests from the repo root.
+- Run tests from package directories such as `packages/opencode`; never run package tests from the repo root.
 - Prefer explicit test layers over ad hoc managed runtimes. Keep dependency provisioning visible in the test file.
 - Use scoped fixtures and finalizers for resources that must be cleaned up, including temporary directories, flags, databases, fibers, servers, and global state.

AGENTS.md

@@ -1,6 +1,6 @@
-- After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit generated client files directly.
+- After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`. Do not edit `src/generated` or `src/generated-effect` directly.
 - Keep runtime dependencies directed from Schema to Core and Protocol, then from Core and Protocol to Server. Client runtime code may depend on Schema and Protocol but never Core or Server; `sdk-next` composes Client, Core, and Server.
-- Current implementation changes belong in `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
+- Do not modify `packages/opencode` unless the user explicitly asks for V1 work. `packages/opencode` is the V1 implementation and is present for reference only. New implementation changes should land in the V2 package set: `packages/core`, `packages/cli`, `packages/server`, `packages/protocol`, `packages/schema`, and related generated client surfaces when required.
 - The default branch in this repo is `v2`.
 - Base all new branches and worktrees on `v2`, or `origin/v2` when the local `v2` ref is unavailable. Do not base them on `dev`.
 - Local `main` ref may not exist; use `v2` or `origin/v2` for diffs.
@@ -166,23 +166,23 @@ const table = sqliteTable("session", {
 
 - Avoid mocks as much as possible, you shouldn't be using globalThis.\* at all unless it's the only option.
 - Test actual implementation, do not duplicate logic into tests
-- Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package directories such as `packages/core`.
+- Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package dirs like `packages/opencode`.
 
 ## Type Checking
 
-- Always run `bun typecheck` from package directories (for example, `packages/core`), never `tsc` directly.
+- Always run `bun typecheck` from package directories (e.g., `packages/opencode`), never `tsc` directly.
 
 ## 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. `Session.prompt(...)` publishes `session.inbox.enqueued`, whose projection inserts one durable `session_inbox` row, before scheduling advisory `SessionExecution.wake(sessionID)` unless `resume: false` requests admit-only behavior. Delivery publishes `session.inbox.delivered`; its projection consumes the inbox row and inserts the visible message in the same transaction. `session_inbox` stores only unconsumed work.
-- Reusing a Session ID adopts the existing Session. While a user or synthetic inbox item is pending, reusing its ID reconciles only when Session, type, complete payload, metadata, and delivery match; conflicting reuse fails. Once delivered, retry reconciliation for those message-producing items uses the projected message and does not require retained enqueue history or the original delivery mode. Control items keep their operation-specific conflict behavior.
+- Keep durable prompt admission separate from model execution. `SessionV2.prompt(...)` admits one durable `session_pending` 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, consuming the pending row in the same event transaction; `session_pending` stores only unconsumed work.
+- 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. Retry of an already-promoted input reconciles against the projected message and the durable admitted event rather than a retained row.
 - 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; interruption of a known but idle or locally unowned Session is a no-op, while the public API rejects an unknown Session.
 - 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 Physical Attempt and reload projected history before durable continuation. A logical Step may use generic pre-output retries, one full-context retry after continuation rejection, incomplete-stream continuation, or one overflow-compaction rebuild. Generic retries retain the logical step number and do not consume another agent-step allowance. Do not 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. A write-ahead execution claim marks a process-local busy period for restart recovery: terminal completion, failure, or user interruption releases it, while shutdown interruption and process death preserve it. Startup recovery resumes claimed top-level Sessions with durable per-execution attempt accounting. The claim is a recovery marker, not clustered ownership, fencing, or an exactly-once guarantee.
-- Keep delivery vocabulary explicit. Prompts steer by default. Steers deliver in enqueue order at safe step boundaries, stopping before compaction or move control items. At an idle boundary, steers take priority; otherwise exactly one queued item delivers before the runner reevaluates continuation. Inbox items may be cancelled or changed between queue and steer before delivery. Promoting new user input resets the selected agent's step allowance; a batch of steers resets it once.
+- Preserve one explicit `llm.stream(request)` call per Physical Attempt and reload projected history before durable continuation. Most Steps have one Physical Attempt; overflow-triggered compaction recovery may rebuild one Step for a second attempt. 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 event replay ownership separate from clustered Session execution ownership.
+- Keep EventV2 replay owner claims separate from clustered Session execution ownership.
 - Keep the Instructions algebra and built-ins in `src/instructions`; keep instruction producers with their observed domains, and keep Session History selection plus `InstructionState` and `InstructionEntry` persistence Session-owned. `InstructionDiscovery` observes ambient global and upward-project instructions. The runner composes built-ins, discovery, guidance, and entries explicitly in `loadInstructions`; there is no instruction registry.
-- `session.instructions.updated` stores changed source keys and content hashes and may freeze rendered chronological update text. Blob values live once in `instruction_blob`; the projected `instruction_state` row is the normal boundary-processing source of current and initial values. Request assembly renders the epoch baseline from stored values, while later frozen updates enter history as durable System messages. Completed compaction moves the instruction epoch; Session movement retains it so destination instruction changes are chronological, while committed revert clears it. Forks adopt the parent's newest instruction values even when copied message history ends at an earlier boundary. Unavailable sources retain the last value and block only the initial complete delta.
+- `session.instructions.updated` stores only changed source keys and content hashes. Blob values live once in `instruction_blob`; `instruction_state` is a rebuildable fold cache, never primary state. Render initial instructions and chronological updates from values during request assembly. Completed compaction moves the instruction epoch; Session movement retains it so destination instruction changes are chronological, while committed revert clears it. Unavailable sources retain the last value and block only the initial complete delta.

CONTRIBUTING.md

@@ -1,112 +1,272 @@
 # Contributing to OpenCode
 
-The changes most likely to be accepted are:
+We want to make it easy for you to contribute to OpenCode. Here are the most common type of changes that get merged:
 
 - Bug fixes
-- Additional LSPs and formatters
-- LLM performance improvements
-- Environment-specific fixes
+- Additional LSPs / Formatters
+- Improvements to LLM performance
+- Support for new providers
+- Fixes for environment-specific quirks
 - Missing standard behavior
 - Documentation improvements
 
-UI and core product features require design review before implementation. If you are unsure whether a change fits, ask a maintainer or choose an issue labeled [`help wanted`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Ahelp-wanted), [`good first issue`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22good%20first%20issue%22), [`bug`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug), or [`perf`](https://github.com/anomalyco/opencode/issues?q=is%3Aopen%20is%3Aissue%20label%3A%22perf%22).
+However, any UI or core product feature must go through a design review with the core team before implementation.
 
-Want to take on an issue? Leave a comment and a maintainer may assign it unless it is already being worked on.
+If you are unsure if a PR would be accepted, feel free to ask a maintainer or look for issues with any of the following labels:
+
+- [`help wanted`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Ahelp-wanted)
+- [`good first issue`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22good%20first%20issue%22)
+- [`bug`](https://github.com/anomalyco/opencode/issues?q=is%3Aissue%20state%3Aopen%20label%3Abug)
+- [`perf`](https://github.com/anomalyco/opencode/issues?q=is%3Aopen%20is%3Aissue%20label%3A%22perf%22)
 
 > [!NOTE]
 > PRs that ignore these guardrails will likely be closed.
 
-## Adding Providers
+Want to take on an issue? Leave a comment and a maintainer may assign it to you unless it is something we are already working on.
 
-New providers should rarely require OpenCode changes. Add the provider to [models.dev](https://github.com/anomalyco/models.dev) first.
+## Adding New Providers
 
-## Development
+New providers shouldn't require many if ANY code changes, but if you want to add support for a new provider first make a PR to:
+https://github.com/anomalyco/models.dev
 
-OpenCode requires Bun 1.3 or newer. From the repository root:
+## Developing OpenCode
+
+- Requirements: Bun 1.3+
+- Install dependencies and start the dev server from the repo root:
+
+  ```bash
+  bun install
+  bun dev
+  ```
+
+### Running against a different directory
+
+By default, `bun dev` runs OpenCode in the `packages/opencode` directory. To run it against a different directory or repository:
 
 ```bash
-bun install
-bun dev [directory]
+bun dev <directory>
 ```
 
-`bun dev` runs the V2 CLI and TUI. Pass a directory to open another project, or `.` to open this repository.
-
-To test a development TUI against your installed OpenCode V2 background service and live sessions:
+To run OpenCode in the root of the opencode repo itself:
 
 ```bash
-bun run dev:live [directory]
+bun dev .
 ```
 
-For web development, run the backend and app in separate terminals. Other interfaces have root scripts:
+### Building a "localcode"
+
+To compile a standalone executable:
 
 ```bash
-bun dev serve --port 4096
-bun run dev:web
-bun run dev:desktop
-bun run dev:www
+./packages/opencode/script/build.ts --single
 ```
 
-### Packages
-
-- `packages/schema`: shared wire and storage contracts
-- `packages/core`: domain behavior and persistence
-- `packages/protocol`: public API definitions
-- `packages/server`: HTTP server and runtime composition
-- `packages/client`: generated TypeScript clients
-- `packages/cli`: command-line entrypoint and service lifecycle
-- `packages/tui`: terminal interface
-- `packages/app`: shared web interface
-- `packages/desktop`: Electron desktop application
-- `packages/plugin`: plugin API
-
-### Verification
-
-Run typechecks, and tests where defined, from the affected package rather than the repository root:
+Then run it with:
 
 ```bash
-cd packages/core
-bun run test
-bun typecheck
+./packages/opencode/dist/opencode-<platform>/bin/opencode
 ```
 
-Follow package-specific instructions in nearby `AGENTS.md` files. After changing the public Protocol or Server `HttpApi`, run `bun run generate` from `packages/client`; never edit generated client files directly.
+Replace `<platform>` with your platform (e.g., `darwin-arm64`, `linux-x64`).
 
-Follow the repository [style guide](./AGENTS.md).
+- Core pieces:
+  - `packages/opencode`: OpenCode core business logic & server.
+  - `packages/opencode/src/cli/cmd/tui/`: The TUI code, written in SolidJS with [opentui](https://github.com/sst/opentui)
+  - `packages/app`: The shared web UI components, written in SolidJS
+  - `packages/desktop`: The native desktop app, built with Electron (wraps `packages/app`)
+  - `packages/plugin`: Source for `@opencode-ai/plugin`
 
-## Pull Requests
+### Understanding bun dev vs opencode
 
-### Link Issues When Required
+During development, `bun dev` is the local equivalent of the built `opencode` command. Both run the same CLI interface:
 
-Bug fixes, chores, and tests must reference an existing issue. Documentation, refactor, and feature PRs are exempt from the automated linked-issue check. When required, use `Fixes #123` or `Closes #123` in the PR description.
+```bash
+# Development (from project root)
+bun dev --help           # Show all available commands
+bun dev serve            # Start headless API server
+bun dev web              # Start server + open web interface
+bun dev <directory>      # Start TUI in specific directory
 
-Before implementing new functionality, open a feature request describing the problem, why it belongs in OpenCode, and your proposed approach if you have one. Wait for design approval before opening the implementation PR.
+# Production
+opencode --help          # Show all available commands
+opencode serve           # Start headless API server
+opencode web             # Start server + open web interface
+opencode <directory>     # Start TUI in specific directory
+```
 
-Base branches on `v2`, not `dev`, and complete the provided pull request template.
+### Running the API Server
 
-### Keep It Focused
+To start the OpenCode headless API server:
 
-- Keep PRs small and focused.
-- Explain the problem and why the change fixes it.
-- Check whether the functionality already exists.
-- For UI changes, include before-and-after screenshots or video.
-- For logic changes, explain what you tested and how a reviewer can verify it.
+```bash
+bun dev serve
+```
 
-### Keep It Brief
+This starts the headless server on port 4096 by default. You can specify a different port:
 
-Long, AI-generated PR descriptions and issues may be ignored. Write a short explanation in your own words. If the change cannot be explained briefly, the PR may be too large.
+```bash
+bun dev serve --port 8080
+```
 
-### Use Conventional Titles
+### Running the Web App
 
-Use `type(scope): summary`. Supported types are `feat`, `fix`, `docs`, `chore`, `refactor`, and `test`. The scope is optional.
+To test UI changes during development:
+
+1. **First, start the OpenCode server** (see [Running the API Server](#running-the-api-server) section above)
+2. **Then run the web app:**
+
+```bash
+bun run --cwd packages/app dev
+```
+
+This starts a local dev server at http://localhost:5173 (or similar port shown in output). Most UI changes can be tested here, but the server must be running for full functionality.
+
+### Running the Desktop App
+
+The desktop app is an Electron application that wraps the web UI.
+
+To run the desktop app in development:
+
+```bash
+bun run --cwd packages/desktop dev
+```
+
+To create a production build and package the app:
+
+```bash
+bun run --cwd packages/desktop build
+bun run --cwd packages/desktop package
+```
+
+> [!NOTE]
+> If you make changes to the API or SDK (e.g. `packages/opencode/src/server/server.ts`), run `./script/generate.ts` to regenerate the SDK and related files.
+
+Please try to follow the [style guide](./AGENTS.md)
+
+### Setting up a Debugger
+
+Bun debugging is currently rough around the edges. We hope this guide helps you get set up and avoid some pain points.
+
+The most reliable way to debug OpenCode is to run it manually in a terminal via `bun run --inspect=<url> dev ...` and attach
+your debugger via that URL. Other methods can result in breakpoints being mapped incorrectly, at least in VSCode (YMMV).
+
+Caveats:
+
+- If you want to run the OpenCode TUI and have breakpoints triggered in the server code, you might need to run `bun dev spawn` instead of
+  the usual `bun dev`. This is because `bun dev` runs the server in a worker thread and breakpoints might not work there.
+- If `spawn` does not work for you, you can debug the server separately:
+  - Debug server: `bun run --inspect=ws://localhost:6499/ --cwd packages/opencode ./src/index.ts serve --port 4096`,
+    then attach TUI with `opencode attach http://localhost:4096`
+  - Debug TUI: `bun run --inspect=ws://localhost:6499/ --cwd packages/opencode --conditions=browser ./src/index.ts`
+
+Other tips and tricks:
+
+- You might want to use `--inspect-wait` or `--inspect-brk` instead of `--inspect`, depending on your workflow
+- Specifying `--inspect=ws://localhost:6499/` on every invocation can be tiresome, you may want to `export BUN_OPTIONS=--inspect=ws://localhost:6499/` instead
+
+#### VSCode Setup
+
+If you use VSCode, you can use our example configurations [.vscode/settings.example.json](.vscode/settings.example.json) and [.vscode/launch.example.json](.vscode/launch.example.json).
+
+Some debug methods that can be problematic:
+
+- Debug configurations with `"request": "launch"` can have breakpoints incorrectly mapped and thus unusable
+- The same problem arises when running OpenCode in the VSCode `JavaScript Debug Terminal`
+
+With that said, you may want to try these methods, as they might work for you.
+
+## Pull Request Expectations
+
+### Issue First Policy
+
+**All PRs must reference an existing issue.** Before opening a PR, open an issue describing the bug or feature. This helps maintainers triage and prevents duplicate work. PRs without a linked issue may be closed without review.
+
+- Use `Fixes #123` or `Closes #123` in your PR description to link the issue
+- For small fixes, a brief issue is fine - just enough context for maintainers to understand the problem
+
+### General Requirements
+
+- Keep pull requests small and focused
+- Explain the issue and why your change fixes it
+- Before adding new functionality, ensure it doesn't already exist elsewhere in the codebase
+
+### UI Changes
+
+If your PR includes UI changes, please include screenshots or videos showing the before and after. This helps maintainers review faster and gives you quicker feedback.
+
+### Logic Changes
+
+For non-UI changes (bug fixes, new features, refactors), explain **how you verified it works**:
+
+- What did you test?
+- How can a reviewer reproduce/confirm the fix?
+
+### No AI-Generated Walls of Text
+
+Long, AI-generated PR descriptions and issues are not acceptable and may be ignored. Respect the maintainers' time:
+
+- Write short, focused descriptions
+- Explain what changed and why in your own words
+- If you can't explain it briefly, your PR might be too large
+
+### PR Titles
+
+PR titles should follow conventional commit standards:
+
+- `feat:` new feature or functionality
+- `fix:` bug fix
+- `docs:` documentation or README changes
+- `chore:` maintenance tasks, dependency updates, etc.
+- `refactor:` code refactoring without changing behavior
+- `test:` adding or updating tests
+
+You can optionally include a scope to indicate which package is affected:
+
+- `feat(app):` feature in the app package
+- `fix(desktop):` bug fix in the desktop package
+- `chore(opencode):` maintenance in the opencode package
 
 Examples:
 
-- `docs: update contributing guide`
-- `fix(tui): restore scroll position`
-- `feat(app): add workspace search`
+- `docs: update contributing guidelines`
+- `fix: resolve crash on startup`
+- `feat: add dark mode support`
+- `feat(app): add dark mode support`
+- `fix(desktop): resolve crash on startup`
+- `chore: bump dependency versions`
 
-## Issues
+### Style Preferences
 
-Bug reports and feature requests must use their issue templates. Blank issues are not allowed; ask support and how-to questions in the [Discord community](https://discord.gg/opencode).
+These are not strictly enforced, they are just general guidelines:
 
-Automated checks flag missing templates, placeholder text, AI-generated walls of text, and missing meaningful content. You have two hours to correct a flagged issue before it closes automatically. Ask a maintainer if an issue was flagged incorrectly.
+- **Functions:** Keep logic within a single function unless breaking it out adds clear reuse or composition benefits.
+- **Destructuring:** Do not do unnecessary destructuring of variables.
+- **Control flow:** Avoid `else` statements.
+- **Error handling:** Prefer `.catch(...)` instead of `try`/`catch` when possible.
+- **Types:** Reach for precise types and avoid `any`.
+- **Variables:** Stick to immutable patterns and avoid `let`.
+- **Naming:** Choose concise single-word identifiers when they remain descriptive.
+- **Runtime APIs:** Use Bun helpers such as `Bun.file()` when they fit the use case.
+
+## Feature Requests
+
+For net-new functionality, start with a design conversation. Open an issue describing the problem, your proposed approach (optional), and why it belongs in OpenCode. The core team will help decide whether it should move forward; please wait for that approval instead of opening a feature PR directly.
+
+## Issue Requirements
+
+All issues **must** use one of our issue templates:
+
+- **Bug report** — for reporting bugs (requires a description)
+- **Feature request** — for suggesting enhancements (requires verification checkbox and description)
+- **Question** — for asking questions (requires the question)
+
+Blank issues are not allowed. When a new issue is opened, an automated check verifies that it follows a template and meets our contributing guidelines. If an issue doesn't meet the requirements, you'll receive a comment explaining what needs to be fixed and have **2 hours** to edit the issue. After that, it will be automatically closed.
+
+Issues may be flagged for:
+
+- Not using a template
+- Required fields left empty or filled with placeholder text
+- AI-generated walls of text
+- Missing meaningful content
+
+If you believe your issue was incorrectly flagged, let a maintainer know.

bun.lock

@@ -568,7 +568,6 @@
         "@ai-sdk/provider": "3.0.8",
         "@opencode-ai/ai": "workspace:*",
         "@opencode-ai/client": "workspace:*",
-        "@opencode-ai/protocol": "workspace:*",
         "@opencode-ai/schema": "workspace:*",
         "@opencode-ai/sdk": "1.18.5",
         "@standard-schema/spec": "catalog:",

docs/design/service-lifecycle.md

@@ -27,9 +27,8 @@ exits before expensive server boot. The design does not require clients to
 agree on a single initiator.
 
 This proposal does not introduce a supervisor process, warm candidate server,
-protocol negotiation, idle background restart, or clustered or exactly-once
-execution recovery. Session execution separately provides bounded local recovery
-through durable write-ahead claims.
+protocol negotiation, idle background restart, or general execution-recovery
+framework.
 
 ## Architecture at a Glance
 
@@ -177,9 +176,9 @@ This design gives each concept one authority.
 - Adding a permanent steward, proxy, or supervisor process.
 - Zero-downtime worker handoff or automatic rollback.
 - Application protocol negotiation or automatic TUI self-restart.
-- Exactly-once recovery for provider attempts, tools, shells, sub-agents,
-  permissions, questions, or background jobs. Top-level Session continuation
-  after process death is handled separately through durable execution claims.
+- General hard-crash recovery for active Sessions.
+- Defining recovery semantics for provider attempts, tools, shells, sub-agents,
+  permissions, questions, or background jobs.
 - Automatically killing a frozen owner.
 - Bounding concurrent location cold boots after clients reconnect.
 - Multi-machine or clustered service placement.
@@ -203,10 +202,9 @@ This design gives each concept one authority.
    diagnosed, non-retryable cause.
 8. **Clients do not kill an unresponsive owner automatically.** Destructive
    recovery requires the explicit `service restart` command.
-9. **Lifecycle does not promise exactly-once execution.** A successor invokes
-   the Session execution-claim sweep, which resumes from durable history.
-   Provider-attempt identity and tool-side-effect fencing belong to separate
-   designs.
+9. **Lifecycle does not promise execution semantics.** Graceful replacement
+   invokes Session suspension and resumption hooks, but tool-level continuity
+   belongs to a separate design.
 
 ## System Model
 
@@ -487,20 +485,23 @@ The UI derives text from status:
 | `ready`                  | Normal TUI                          |
 
 ## Graceful Session Continuity
-
+
 Version-mismatch replacement uses the existing graceful Session suspension and
-its runner starts. Success, failure, and user interruption release the claim;
-shutdown interruption and process death leave it intact. The
-successor sweeps claimed top-level Sessions, durably counts a recovery attempt,
-appends a continuation instruction, and resumes from projected history. The same
-mechanism covers graceful replacement, crash, SIGKILL, and runtime eviction.
-
+resumption hooks:
+
 1. The old server snapshots active Session IDs during graceful teardown.
-does not prove whether an interrupted provider request or external operation
-already took effect. It does not replay the exact interrupted tool, preserve an
-in-memory form, recover process-local background work, or guarantee exactly-once
-provider or tool behavior.
-
+2. The successor schedules those Sessions for continuation.
+3. The runner reloads durable Session history before continuing.
+
+This lifecycle design does not define what an interrupted physical provider
+attempt or tool invocation means. It does not promise that external side effects
+did not occur, replay the exact interrupted tool, preserve an in-memory form, or
+recover process-local background work.
+
+Those concerns require a separate execution-continuity design covering tools,
+shells, sub-agents, permissions, questions, provider attempts, and hard-crash
+recovery.
+
 ## Unresponsive Owner
 
 An unreachable registration does not prove that the owner is dead. A contender
@@ -530,15 +531,13 @@ Automatic frozen-owner recovery is deferred.
 1. The old service installs vNext but keeps running.
 2. A fresh vNext TUI finds the healthy vOld service and requests graceful stop.
 3. The old service reports `stopping`, suspends active Sessions, and exits.
-   the execution claims already written by active Sessions.
-4. Open TUIs enter their indefinite status loops.
+4. Open TUIs enter their indefinite status loops.
 5. One or more clients spawn contenders.
 6. One contender acquires the service lock. Losers exit before heavy boot.
 7. The winner binds and registers the lifecycle shell as `starting`.
 8. Clients stop spawning and wait on the observable winner.
 9. The winner initializes the application and reports `ready`.
-   and reports `ready`.
-10. TUIs rebuild clients, reconcile state, and resume.
+10. TUIs rebuild clients, reconcile state, and resume.
 
 ### Server crashes while ready
 
@@ -547,9 +546,7 @@ Automatic frozen-owner recovery is deferred.
 3. Process death has released the service lock.
 4. One contender wins, replaces registration, and starts normally.
 5. Detailed active-execution recovery is outside this design.
-   them with bounded attempt accounting. External side effects remain
-   potentially ambiguous.
-
+
 ### Winner crashes during startup
 
 1. Clients observed `starting` and remain alive.
@@ -653,9 +650,8 @@ was the observed incident cost.
 6. **Codify launch versus reconnect.** Fresh launch enforces installed version;
    reconnect never activates replacement.
 7. **Integrate graceful replacement.** Preserve current background-install and
-   fresh-launch activation behavior while invoking startup execution-claim
-   recovery.
-8. **Harden explicit recovery.** Verify exact process identity during explicit
+   fresh-launch activation behavior while invoking Session continuity hooks.
+8. **Harden explicit recovery.** Verify exact process identity during explicit
    `service restart`; never automatically kill an unresponsive owner.
 9. **Run the full multi-process suite.** Include repeated restart cycles and
    assert that no contender or child process remains afterward.
@@ -681,8 +677,7 @@ was the observed incident cost.
 - Idle background update activation with an admission fence.
 - Application protocol compatibility and automatic local TUI re-exec.
 - Durable execution recovery for provider attempts and tools.
-  idempotency or fencing, and clustered ownership.
-- Shell, sub-agent, permission, question, and background-job continuity.
+- Shell, sub-agent, permission, question, and background-job continuity.
 - Automatic recovery for a positively identified frozen owner.
 - Cold-boot concurrency limits and interaction-prioritized location loading.
 - A steward or socket-handoff architecture if zero-downtime replacement becomes

docs/design/v1-v2-database-migration.md

@@ -0,0 +1,298 @@
+# V1 to V2 Database Migration
+
+## Approach
+
+- Use the `dev` branch database schema and migration registry as the V1 baseline.
+- Remove migrations that exist only on the V2 branch.
+- Generate one canonical migration from the `dev` schema to the final V2 schema.
+- Keep the canonical migration focused on schema changes and dropping obsolete tables.
+- Run the V1 history backfill through an experimental server endpoint invoked by the CLI before it opens the TUI.
+- Show committed session progress while the endpoint runs.
+
+Expose `GET /api/experimental/migration/v1` for status and a blocking `POST /api/experimental/migration/v1` to run or
+resume the backfill. The status is `required`, `running`, or `completed`. On startup, the CLI checks status first and
+renders no migration UI when it is already complete. For required or running status, it shows a spinner and waits for the
+blocking POST without a request timeout. While migration runs, poll GET once per second and render completed and total
+session counts. GET derives total from all session rows and completed from rows through the stored cursor; the count
+advances only after a session transaction commits. The POST returns `{ status: "completed" }`. Do not add a background
+job or streaming progress protocol. Interrupted calls resume from the stored cursor.
+Initially, only interactive TUI startup performs this check; noninteractive run, ACP, raw API, service, health, version,
+and help flows do not trigger the backfill.
+
+Keep migration behavior in Core: status, semaphore, checkpointing, V1 decoding, transformation, and database writes.
+Protocol owns the experimental GET/POST contracts, Server handlers delegate to Core, and the interactive CLI owns only
+the status check and spinner presentation.
+
+Guard the endpoint with one process-local Effect `Semaphore`. Concurrent callers wait; after the active call completes,
+waiting callers acquire the permit, observe the completion key, and return immediately. No distributed lock is required
+for the current single elected server process.
+
+## Preserve
+
+The canonical V1 data remains in its existing tables. In particular, preserve `session`, `message`, and `part` rows.
+
+Preserve `workspace` rows and existing `session.workspace_id` values unchanged. The migration must not clear or rebuild
+workspace relationships.
+
+Preserve existing non-null `session.agent` and `session.model` selections. Fill missing values from the latest ordinary
+V1 user message ordered by `time_created` and `id`, excluding compaction and subtask-only messages. Copy agent, provider
+ID, model ID, and variant, normalizing an absent variant to `default`.
+
+Recompute session usage aggregates from all canonical V1 assistant messages, including compaction or other internal
+assistants omitted from the V2 projection. Overwrite session cost and input, output, reasoning, cache-read, and
+cache-write token totals with those sums.
+
+Clear persisted `session.revert` state. A staged revert is transient operational state and may refer to omitted projection
+rows or unavailable snapshots; it must not resume automatically after upgrading. Preserve the underlying messages,
+parts, and file history.
+
+Clear `session.time_compacting`, leave the new `time_suspended` column as `NULL`, and preserve session creation, update,
+and archive timestamps. Preserve project `time_initialized`; it is unrelated durable state.
+
+Keep the legacy `todo` table and its data physically unchanged, but do not include it in the final V2 Drizzle schema.
+After generation, remove the generated `DROP TABLE todo` statement from the canonical migration so the table remains as
+unmanaged legacy storage.
+
+## Per-Session Replacement
+
+Do not truncate `event`, `event_sequence`, or `session_message` globally before the backfill. A whole-table delete can
+hold SQLite's writer lock long enough to block the running TUI.
+
+Replace each legacy session's V2 state inside that session's checkpointed migration transaction. Delete `event` rows for
+the session aggregate, delete its `session_message` rows, rebuild its projection from canonical V1 `message` and `part`
+rows, and overwrite its `event_sequence` watermark. If migration of that session fails, all replacements roll back and
+the durable cursor remains at the previously committed session. Rows owned by sessions outside the legacy migration set
+remain untouched.
+
+## Message Backfill
+
+Backfill canonical V1 history from `message` and `part` into `session_message`. This is the main data transformation in
+the migration. Preserving the V1 tables alone keeps the data safe but does not make existing history visible through the
+V2 session APIs, which read `session_message`.
+
+Do not fail the whole migration when a V1 message or part payload cannot be decoded. Skip an undecodable message's V2
+projection and log its session and message IDs. Skip an undecodable part while continuing to map its message, and perform
+special-message pairing only with decoded rows. Assign sequences after filtering. Leave every malformed source row
+untouched in the V1 tables.
+
+Skip and log orphan parts whose source message does not exist and parts with unknown or unsupported types. Continue
+migrating the owning message and other valid parts. Include session, message, part ID, and observed type in warnings, and
+leave skipped source rows unchanged.
+
+Reuse each V1 `message.id` as the corresponding `session_message.id`. Stable IDs keep the migration deterministic and
+avoid rewriting other persisted state that may refer to a message.
+
+For ordinary user and assistant rows, preserve source `message.time_created` and `message.time_updated`. Entirely
+synthetic messages preserve their source timestamps, and synthetic rows split from mixed messages use the source user
+timestamps. A collapsed compaction uses the compaction user creation time and the later update time of the compaction
+user and summary assistant. Keep payload creation/completion times consistent with row timestamps.
+
+Within each session, order V1 messages by `time_created` and then `id`, matching the existing V1 message index. Assign
+contiguous `session_message.seq` values starting at `0`.
+
+Map ordinary V1 messages one-to-one by role. Each ordinary V1 user message becomes one V2 `user` row, and each ordinary
+V1 assistant message becomes one V2 `assistant` row. Fold the source message's ordered V1 parts into that row's V2
+payload.
+
+Keep ordinary messages even when their transformed payload becomes empty after filtering. Preserve an empty V2 user row
+with `text: ""` and an empty V2 assistant row with `content: []` so IDs, chronology, and conversation structure remain
+stable. Omit only explicitly dropped internal concepts and undecodable messages.
+
+Handle semantic marker parts before applying the ordinary mapping. In particular, a V1 user message containing a
+`compaction` part and its paired assistant summary represent one compaction operation, not two ordinary messages. Special
+part mappings must be decided explicitly before implementing the backfill.
+
+Do not carry the V1 subtask concept into the V2 projection. Omit user messages containing only `subtask` parts and omit
+the paired assistant task-tool messages generated from those markers. For mixed user messages, ignore the `subtask`
+parts while preserving ordinary content, and still omit assistant task-tool messages generated by the skipped subtasks.
+Keep all source rows unchanged in the V1 `message` and `part` tables.
+
+Map ordinary V1 assistant `text` and `reasoning` parts into the V2 assistant `content` array in part order. Preserve text,
+including empty assistant text parts used as structural separators. Map V1 part metadata to optional V2 provider state.
+For reasoning, map `time.start` to `time.created` and optional `time.end` to `time.completed`.
+
+Preserve V1 tool parts that are `pending` or `running`, but convert them to terminal V2 tool error states. Preserve the
+call ID, tool name, parsed input, metadata, and available start time. Use the assistant message creation time when the V1
+state has no start time. Set the error to type `tool.interrupted` with message
+`Tool execution was interrupted before V2 migration`. Never resume migrated tool executions.
+
+For a completed V1 tool part, use `callID` as the V2 tool content ID and preserve the tool name and parsed input. Set the
+state to `completed`. Convert V1 output into the first text content item and convert stored output attachments into
+following file content items with their URI, MIME type, and filename. Preserve state metadata. Map `time.start` to
+`time.created` and `time.end` to `time.completed`. When `time.compacted` exists, use
+`[Old tool result content cleared]` as the only output and omit attachments.
+
+For a failed V1 tool part, preserve the call ID, tool name, parsed input, metadata, and timestamps, and set the V2 state
+to `error`. Convert the V1 error string to a structured error with type `tool.execution`. If V1 metadata contains a string
+`output`, preserve it as optional V2 text content. Map `time.start` to `time.created` and `time.end` to `time.completed`.
+
+For an ordinary V1 assistant message, preserve agent, provider ID, model ID, optional variant, creation and completion
+times, cost, and input/output/reasoning/cache token counts. Use `default` when the V1 variant is absent. Ignore V1
+`tokens.total` because it is derivable and V2 does not persist it.
+
+Use V1 assistant `parentID` only while pairing compactions and skipped subtasks with their originating user messages. Do
+not persist it in ordinary V2 assistant rows; V2 uses ordered history rather than user/assistant parent links.
+
+Ignore the optional V1 assistant `structured` output value. V2 has no equivalent top-level assistant field, and visible
+text and tool content are migrated separately. Retain the original structured value only in the V1 `message` row.
+
+Ignore V1 assistant `mode` and historical `path` (`cwd` and `root`). Mode is redundant with the preserved assistant
+agent, and historical filesystem paths do not belong to the V2 assistant message contract. Retain them only in the V1
+`message` row.
+
+For assistant finish reasons, preserve `stop`, `length`, `tool-calls`, `content-filter`, `error`, and `unknown`. Map every
+other nonempty V1 finish value to `unknown`, and leave the field absent when V1 omitted it. Do not retain unrecognized raw
+finish values in metadata.
+
+Map V1 assistant errors into the current V2 `{ type, message }` storage shape. Normalize Auth, content-filter, context
+overflow, structured-output, output-length, aborted, API, and unknown errors to the established V2 string conventions,
+preserve the message, and discard V1-only retryability and raw provider details.
+
+Ignore V1 `retry` parts. Do not populate the V2 assistant `retry` field during migration; historical retry state is not
+useful enough to preserve. The original retry rows remain in the V1 `part` table.
+
+Do not emit V2 assistant content for V1 `step-start` and `step-finish` parts. Use the first available
+`step-start.snapshot` as `assistant.snapshot.start` and the last available `step-finish.snapshot` as
+`assistant.snapshot.end`. Continue to source finish, cost, and tokens from the assistant message itself. Ignore step
+markers without snapshots.
+
+Do not emit assistant content for standalone V1 `snapshot` or `patch` parts. If no start snapshot came from `step-start`,
+use the first standalone snapshot value, then the first patch hash as a final fallback. Only `step-finish.snapshot` may
+populate the end snapshot. Merge patch file lists into `assistant.snapshot.files` in first-seen order with duplicates
+removed.
+
+V2 follow-up: replace the open `SessionError.Error` string shape with a properly typed persisted error union. This is not
+a blocker for the V1 migration, which should target the current storage contract.
+
+V1 synthetic content is represented by user text parts with `synthetic: true`, not by a separate message role. A V1 user
+message whose visible text parts are all synthetic should become a V2 `synthetic` message. If a V1 user message mixes
+ordinary and synthetic content, preserve the ordinary content in the V2 `user` row and emit the synthetic content as an
+adjacent V2 `synthetic` row. Ignore text parts marked `ignored`, matching V1 model-history behavior.
+
+For an ordinary V2 user message, take visible V1 text parts that are neither ignored nor synthetic, preserve part order,
+and join their text with `"\n\n"`. Use an empty string when the message contains attachments but no ordinary text.
+
+Ignore the optional V1 user-message `system` override. Do not create a V2 system message or preserve the override in
+metadata. The original value remains in the V1 `message` row.
+
+Ignore the optional V1 user-message `tools` map. It represented request-time tool enablement for a historical step and
+must not affect future V2 execution. The original value remains in the V1 `message` row.
+
+Ignore the optional V1 user-message `format` field and its schema. It controlled structured-output behavior for a
+historical request and must not affect future V2 runs. Preserve visible assistant text normally; retain the original
+format only in the V1 `message` row.
+
+Ignore V1 user-message `summary` metadata, including title, body, and diffs. V2 user messages have no equivalent field,
+and session-level summary data is already persisted separately. Retain the original summary only in the V1 `message`
+row.
+
+Map V1 `agent` parts into the V2 user message's `agents` array in part order. Preserve `name`. When the V1 part has
+`source`, map its `value`, `start`, and `end` into the V2 attachment's `mention.text`, `mention.start`, and `mention.end`.
+Omit `agents` when there are no agent parts.
+
+Do not read the filesystem or network while migrating V1 file attachments. Attachment migration must be deterministic
+from database contents alone. Convert persisted `data:` URLs; represent non-embedded `file:`, HTTP, and other external
+URLs with deterministic text rather than fetching them. Keep the original V1 `part` rows unchanged.
+
+For a V1 file backed by a `data:` URL, decode the URL and normalize its payload to base64 for the V2 attachment's `data`.
+Preserve `mime` and optional `filename` as `name`. Use a V2 `uri` source with the original URI for a V1 resource source;
+otherwise use an `inline` source. When V1 source text metadata exists, map its `value`, `start`, and `end` into the V2
+attachment mention. Leave `description` unset and preserve file-part order in the V2 `files` array.
+
+For a non-embedded V1 file, do not create a V2 file attachment. Append
+`[Attachment unavailable after migration: <name-or-url> (<mime>)]` to the V2 user text in original part order, separated
+by blank lines. Prefer the V1 filename, then resource URI, then part URL for the label. The original URL remains only in
+the preserved V1 `part` row.
+
+For a synthetic row split from a mixed user message, derive a generated-looking ID from the source message ID. Preserve
+the source ID's 12-character timestamp component and replace its 14-character random component with a deterministic
+base-62 encoding of a hash of `v1-synthetic:` plus the source message ID. If that candidate collides with an existing or
+derived message ID, deterministically retry with an incrementing salt. Place the synthetic row immediately after its
+source user row. Entirely synthetic messages continue to reuse their original message ID.
+
+Use the V1 compaction user message ID as the ID of the collapsed V2 compaction message. This matches V2's use of the
+admitted compaction input ID and preserves references to the initiating message.
+
+For a completed compaction, create one V2 `compaction` row with `status: "completed"`. Set `reason` from the V1
+compaction part's `auto` flag, join the paired summary assistant's nonempty text parts with blank lines for `summary`, and
+serialize the retained V1 tail beginning at `tail_start_id` for `recent`. Use an empty `recent` value when no tail was
+retained, and use the compaction user message creation time. Do not emit the paired summary assistant as a separate V2
+assistant row.
+
+Do not project incomplete or failed V1 compactions into `session_message`. Omit both the internal compaction user marker
+and its paired summary assistant when no successful summary was completed. Assign final sequence numbers after filtering
+so omitted compactions leave no gaps. Their source rows remain preserved in the V1 `message` and `part` tables.
+
+After rebuilding a session's `session_message`, replace its `event_sequence` watermark with that session's maximum
+backfilled `session_message.seq`. This prevents new V2 events from reusing sequence numbers or sorting before migrated
+history. The migrated session's prior `event` rows are removed in the same transaction.
+
+## Drop
+
+Drop these pre-launch V2 tables without preserving or transforming their rows:
+
+- `session_input`
+- `session_context_epoch`
+- `data_migration`
+
+Do not transfer `session_input` rows into `session_pending`.
+
+## Create Empty
+
+Let the generated migration create these tables empty:
+
+- `instruction_blob`
+- `instruction_entry`
+- `instruction_state`
+- `session_pending`
+- `kv`
+
+V1 has no canonical data to backfill into these tables. V2 initializes their state as it runs.
+
+## Fork Storage
+
+V1 has no fork-boundary state to backfill. New V2 forks use a required message boundary and persist it in
+`session.fork_boundary`. The durable fork event contains no parent sequence. Its resolved boundary is one of:
+
+- `before`: copy messages before the identified message.
+- `through`: copy messages through the identified message.
+
+Forking an empty session is not supported. `session.fork_seq` and `session.fork_message_id` are not part of the final V2
+schema.
+
+New nullable session columns, including `fork_session_id`, `fork_boundary`, and `time_suspended`, require no explicit
+backfill. Existing rows naturally receive `NULL` when the generated migration adds the columns.
+
+## Execution
+
+Before transforming V1 rows, look for `opencode-next.db` in the data directory. This file was used by pre-launch V2
+builds. Open it read-only with Bun SQLite and copy its `project`, `session`, and `session_message` rows directly into the
+current `project`, `session_v2`, and `session_message` tables. Existing current projects and Sessions win ID collisions.
+Do not copy its durable events or runtime caches; initialize each imported Session's `event_sequence` watermark from its
+maximum message sequence. Commit each imported Session independently and leave the source database untouched.
+
+The previous V2 import is part of this migration and uses the same completion marker. It needs no source-specific cursor:
+the destination Session row is the per-Session idempotency boundary, so a retry skips transactions that already committed.
+
+Store V1 backfill state in `kv`; do not retain a dedicated `data_migration` table. Store the last successfully migrated
+session ID under `migration.v1-v2.session.cursor` and write `migration.v1-v2.completed` with value `true` after every
+session finishes. Delete the cursor key on completion and return immediately on later calls when the completion key
+exists.
+
+Absence of the completion key means migration is required, including on a fresh database. Running the endpoint against a
+database with no sessions completes immediately and writes the completion key; fresh database initialization does not
+seed migration state specially.
+
+Process sessions in stable ID order. Rebuild one session in one transaction, including its `session_message` rows,
+session-level backfills, `event_sequence` watermark, and cursor update. If interrupted during a session, that transaction
+rolls back and the next endpoint call retries the same session. If it committed, the next call continues after the stored
+cursor. Mark the migration complete after the final session and return immediately on later calls.
+
+Ensure the global project exists using the current platform's filesystem root as its worktree. Process every `session`
+row, including archived, root, child, and empty sessions, as well as sessions whose messages are all skipped or internal.
+Reassign beta and V1 Sessions whose referenced project row is missing to the global project and log a warning. Each
+successfully committed session advances the cursor.
+
+## Testing
+
+Detailed migration test design is deferred until after the canonical migration is implemented.

packages/ai/AGENTS.md

@@ -23,9 +23,14 @@ Per-type constructors live on the type, not as top-level re-exports. Use `Messag
 
 This package is an Effect Schema-first LLM core. The Schema classes in `src/schema/` are the canonical runtime data model. Convenience functions in `src/llm.ts` are thin constructors that return those same Schema class instances; they should improve callsites without creating a second model.
 
-Session integration lives in `packages/core/src/session`: `runner/llm.ts` owns orchestration, `model-request.ts` lowers Session state into `LLMRequest`, and `model-transport.ts` selects transport behavior.
+Primary in-repo integration point:
 
-Keep this package independent of Session concerns. Session auth, permissions, plugins, telemetry headers, and runtime selection belong in Core.
+- `packages/opencode/src/session/llm.ts` is the session-owned orchestration layer that decides whether a request uses AI SDK or this package's native route runtime.
+- `packages/opencode/src/session/llm/native-request.ts` is the lowering adapter from opencode's session/AI SDK-shaped data into this package's `LLMRequest` model.
+- `packages/opencode/src/session/llm/native-runtime.ts` is the execution adapter that calls raw `LLMClient.stream(request)` and bridges one provider turn of opencode tool calls through this package's typed dispatcher.
+- `packages/opencode/src/session/llm/ai-sdk.ts` keeps the default AI SDK path compatible by converting AI SDK stream parts into this package's shared `LLMEvent`s.
+
+Keep this package independent of session concerns. Session auth, permissions, plugins, telemetry headers, and runtime selection belong in `packages/opencode/src/session/llm.ts` and its local adapters.
 
 ### Request Flow
 

packages/app/AGENTS.md

@@ -11,7 +11,7 @@
 
 - `opencode dev web` proxies `https://app.opencode.ai`, so local UI/CSS changes will not show there.
 - For local UI changes, run the backend and app dev servers separately.
-- Backend (from the repository root): `bun dev serve --port 4096`
+- Backend (from `packages/opencode`): `bun run --conditions=browser ./src/index.ts serve --port 4096`
 - App (from `packages/app`): `bun dev -- --port 4444`
 - Open `http://localhost:4444` to verify UI changes (it targets the backend at `http://localhost:4096`).
 

packages/app/e2e/utils/mock-server.ts

@@ -278,7 +278,7 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
     }
     if (path === "/api/project/current")
       return json(route, { id: (config.project as { id?: string }).id, directory: config.directory })
-    const worktree = path.match(/^\/api\/worktree\/([^/]+)$/)?.[1]
+    const worktree = path.match(/^\/api\/experimental\/project\/([^/]+)\/worktree$/)?.[1]
     if (worktree && route.request().method() === "GET")
       return json(route, [
         { directory: config.directory },
@@ -294,7 +294,7 @@ export async function mockOpenCodeServer(page: Page, config: MockServerConfig) {
     }
     if (worktree && route.request().method() === "DELETE")
       return route.fulfill({ status: 204, headers: { "access-control-allow-origin": "*" } })
-    if (/^\/api\/worktree\/[^/]+\/refresh$/.test(path))
+    if (/^\/api\/experimental\/project\/[^/]+\/worktree\/refresh$/.test(path))
       return route.fulfill({ status: 204, headers: { "access-control-allow-origin": "*" } })
     if (path === "/api/permission/request")
       return json(route, {

packages/app/src/pages/new-session/new-session-workspace-controller.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test"
 import {
   normalizeNewSessionWorktree,
   resolveNewSessionBranch,
-  resolveNewSessionGit,
   resolveNewSessionWorktree,
 } from "./new-session-workspace-controller"
 
@@ -48,10 +47,4 @@ describe("new session workspace selection", () => {
     )
     expect(resolveNewSessionBranch({ worktree: "/missing", local: "dev", worktreeBranch: branch })).toBe("dev")
   })
-
-  test("uses location VCS state when the project inventory is stale", () => {
-    expect(resolveNewSessionGit({ branch: "dev" })).toBe(true)
-    expect(resolveNewSessionGit({ projectVcs: "git" })).toBe(true)
-    expect(resolveNewSessionGit({})).toBe(false)
-  })
 })

packages/app/src/pages/new-session/new-session-workspace-controller.ts

@@ -39,10 +39,6 @@ export function resolveNewSessionBranch(input: {
   return input.worktreeBranch(input.worktree) ?? input.local
 }
 
-export function resolveNewSessionGit(input: { projectVcs?: string; branch?: string }) {
-  return input.projectVcs === "git" || input.branch !== undefined
-}
-
 export function createNewSessionWorkspaceController(input: {
   selected: () => string | undefined
   setSelected: (worktree: string | undefined) => void
@@ -53,10 +49,7 @@ export function createNewSessionWorkspaceController(input: {
   const serverSDK = useServerSDK()
   const serverSync = useServerSync()
   const settings = useSettings()
-  const localVcs = createMemo(() => serverSync.child(sdk().directory)[0].vcs)
-  const visible = createMemo(() =>
-    resolveNewSessionGit({ projectVcs: sync().project?.vcs, branch: localVcs()?.branch }),
-  )
+  const visible = createMemo(() => sync().project?.vcs === "git")
   const selected = createMemo(() => {
     const project = sync().project
     const worktree = input.selected()
@@ -117,7 +110,7 @@ export function createNewSessionWorkspaceController(input: {
         const project = sync().project
         return project ? workspaceDirectories(project) : []
       },
-      git: visible,
+      git: () => sync().project?.vcs === "git",
       openAll: input.onViewAll,
     },
     bar: {

packages/cli/AGENTS.md

@@ -1,4 +1,7 @@
-# CLI and TUI development guide
+# V2 CLI and TUI development guide
 
-- Use `@opencode-ai/client` and the location-scoped data in `packages/tui/src/context/data.tsx` instead of adding dependencies on legacy sync state.
+## Migration context
+
+- The TUI is being ported from legacy APIs to the new V2 APIs. New and migrated TUI behavior should use `sdk.client.v2` and the location-scoped data in `packages/tui/src/context/data.tsx` instead of adding dependencies on legacy sync state.
 - Preserve established TUI behavior unless the task intentionally changes it.
+- Load the `opencode-dev` skill before interactively running, debugging, or verifying opencode's V2 CLI, TUI, or server.

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

@@ -4,11 +4,13 @@ import { Service } from "@opencode-ai/client/effect/service"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
+import { ServerConnection } from "../../../services/server-connection"
 
 export default Runtime.handler(
   Commands.commands.service.commands.restart,
   Effect.fn("cli.service.restart")(function* () {
     const options = yield* ServiceConfig.options()
+    yield* ServerConnection.shutdownPersistentPty(options).pipe(Effect.ignore)
     yield* Service.stop(options)
     const transport = yield* Service.ensure(options)
     process.stdout.write(transport.url + EOL)

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

@@ -3,10 +3,13 @@ import { Service } from "@opencode-ai/client/effect/service"
 import { Commands } from "../../commands"
 import { Runtime } from "../../../framework/runtime"
 import { ServiceConfig } from "../../../services/service-config"
+import { ServerConnection } from "../../../services/server-connection"
 
 export default Runtime.handler(
   Commands.commands.service.commands.stop,
   Effect.fn("cli.service.stop")(function* () {
-    yield* Service.stop(yield* ServiceConfig.options())
+    const options = yield* ServiceConfig.options()
+    yield* ServerConnection.shutdownPersistentPty(options).pipe(Effect.ignore)
+    yield* Service.stop(options)
   }),
 )

packages/cli/src/services/server-connection.ts

@@ -56,12 +56,22 @@ function managedService(options: EnsureOptions) {
     reconnect: () => Service.ensure(reconnectOptions),
     restart: () =>
       Effect.gen(function* () {
+        yield* shutdownPersistentPty(options).pipe(Effect.ignore)
         yield* Service.stop(options)
         yield* Service.ensure(reconnectOptions)
       }),
   }
 }
 
+export const shutdownPersistentPty = Effect.fn("cli.server-connection.shutdown-persistent-pty")(function* (
+  options: EnsureOptions,
+) {
+  const endpoint = yield* Service.discover({ ...options, version: undefined })
+  if (!endpoint) return
+  const client = OpenCode.make({ baseUrl: endpoint.url, headers: Service.headers(endpoint) })
+  yield* Effect.tryPromise(() => client["server.persistentPty"].shutdown())
+})
+
 const resolveManaged = Effect.fnUntraced(function* (options: EnsureOptions, mismatch: NonNullable<Args["mismatch"]>) {
   if (mismatch === "replace") return yield* Service.ensure(options)
   if (mismatch === "ignore") return yield* Service.ensure({ ...options, version: undefined })

packages/cli/test/debug-config.test.ts

@@ -30,6 +30,7 @@ describe("debug config command", () => {
           ],
         },
       },
+      { type: "file", path: path.join(project, "opencode.json") },
     ]
     let requested: URL | undefined
     const authorization: Array<string | null> = []

packages/client/src/effect/api/api.ts

@@ -32,6 +32,7 @@ import type { FileSystem } from "@opencode-ai/schema/filesystem"
 import type { Command } from "@opencode-ai/schema/command"
 import type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
 import type { Pty } from "@opencode-ai/schema/pty"
+import type { PtyTicket } from "@opencode-ai/schema/pty-ticket"
 import type { Reference } from "@opencode-ai/schema/reference"
 import type { Worktree } from "@opencode-ai/schema/worktree"
 import type { Vcs } from "@opencode-ai/schema/vcs"
@@ -1435,44 +1436,249 @@ export interface PtyApi<E = never> {
   readonly remove: PtyRemoveOperation<E>
 }
 
-export type Endpoint21_0Input = {
-  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
-}
-export type Endpoint21_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Shell.Info> }
-export type ShellListOperation<E = never> = (input?: Endpoint21_0Input) => Effect.Effect<Endpoint21_0Output, E>
+export type Endpoint21_0Output = ReadonlyArray<{
+  readonly id: string & Brand.Brand<"GroupID">
+  readonly items: ReadonlyArray<
+    { readonly type: "session"; readonly id: Session.ID } | { readonly type: "terminal"; readonly id: Pty.ID }
+  >
+}>
+export type ServerPersistentPtyGroupListOperation<E = never> = () => Effect.Effect<Endpoint21_0Output, E>
 
 export type Endpoint21_1Input = {
+  readonly items?:
+    | ReadonlyArray<
+        { readonly type: "session"; readonly id: Session.ID } | { readonly type: "terminal"; readonly id: Pty.ID }
+      >
+    | undefined
+}
+export type Endpoint21_1Output = {
+  readonly id: string & Brand.Brand<"GroupID">
+  readonly items: ReadonlyArray<
+    { readonly type: "session"; readonly id: Session.ID } | { readonly type: "terminal"; readonly id: Pty.ID }
+  >
+}
+export type ServerPersistentPtyGroupCreateOperation<E = never> = (
+  input?: Endpoint21_1Input,
+) => Effect.Effect<Endpoint21_1Output, E>
+
+export type Endpoint21_2Input = { readonly groupID: string & Brand.Brand<"GroupID"> }
+export type Endpoint21_2Output = {
+  readonly id: string & Brand.Brand<"GroupID">
+  readonly items: ReadonlyArray<
+    { readonly type: "session"; readonly id: Session.ID } | { readonly type: "terminal"; readonly id: Pty.ID }
+  >
+}
+export type ServerPersistentPtyGroupGetOperation<E = never> = (
+  input: Endpoint21_2Input,
+) => Effect.Effect<Endpoint21_2Output, E>
+
+export type Endpoint21_3Input = {
+  readonly groupID: string & Brand.Brand<"GroupID">
+  readonly items: ReadonlyArray<
+    { readonly type: "session"; readonly id: Session.ID } | { readonly type: "terminal"; readonly id: Pty.ID }
+  >
+}
+export type Endpoint21_3Output = {
+  readonly id: string & Brand.Brand<"GroupID">
+  readonly items: ReadonlyArray<
+    { readonly type: "session"; readonly id: Session.ID } | { readonly type: "terminal"; readonly id: Pty.ID }
+  >
+}
+export type ServerPersistentPtyGroupSetOperation<E = never> = (
+  input: Endpoint21_3Input,
+) => Effect.Effect<Endpoint21_3Output, E>
+
+export type Endpoint21_4Input = { readonly groupID: string & Brand.Brand<"GroupID"> }
+export type Endpoint21_4Output = void
+export type ServerPersistentPtyGroupRemoveOperation<E = never> = (
+  input: Endpoint21_4Input,
+) => Effect.Effect<Endpoint21_4Output, E>
+
+export type Endpoint21_5Input = { readonly groupID: string & Brand.Brand<"GroupID"> }
+export type Endpoint21_5Output = ReadonlyArray<{
+  readonly id: Pty.ID
+  readonly title: string
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd: string
+  readonly status: "running" | "exited"
+  readonly pid: number
+  readonly exitCode?: number | undefined
+  readonly groupID: string & Brand.Brand<"GroupID">
+  readonly size: { readonly cols: number; readonly rows: number }
+  readonly output: { readonly head: number; readonly tail: number }
+}>
+export type ServerPersistentPtyListOperation<E = never> = (
+  input: Endpoint21_5Input,
+) => Effect.Effect<Endpoint21_5Output, E>
+
+export type Endpoint21_6Input = {
+  readonly groupID: string & Brand.Brand<"GroupID">
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd: string
+  readonly title: string
+  readonly env: { readonly [x: string]: string }
+  readonly size?: { readonly cols: number; readonly rows: number } | undefined
+}
+export type Endpoint21_6Output = {
+  readonly id: Pty.ID
+  readonly title: string
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd: string
+  readonly status: "running" | "exited"
+  readonly pid: number
+  readonly exitCode?: number | undefined
+  readonly groupID: string & Brand.Brand<"GroupID">
+  readonly size: { readonly cols: number; readonly rows: number }
+  readonly output: { readonly head: number; readonly tail: number }
+}
+export type ServerPersistentPtyCreateOperation<E = never> = (
+  input: Endpoint21_6Input,
+) => Effect.Effect<Endpoint21_6Output, E>
+
+export type Endpoint21_7Output = void
+export type ServerPersistentPtyShutdownOperation<E = never> = () => Effect.Effect<Endpoint21_7Output, E>
+
+export type Endpoint21_8Input = { readonly ptyID: Pty.ID }
+export type Endpoint21_8Output = {
+  readonly id: Pty.ID
+  readonly title: string
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd: string
+  readonly status: "running" | "exited"
+  readonly pid: number
+  readonly exitCode?: number | undefined
+  readonly groupID: string & Brand.Brand<"GroupID">
+  readonly size: { readonly cols: number; readonly rows: number }
+  readonly output: { readonly head: number; readonly tail: number }
+}
+export type ServerPersistentPtyGetOperation<E = never> = (
+  input: Endpoint21_8Input,
+) => Effect.Effect<Endpoint21_8Output, E>
+
+export type Endpoint21_9Input = {
+  readonly ptyID: Pty.ID
+  readonly attachmentID?: string | undefined
+  readonly size: { readonly cols: number; readonly rows: number }
+}
+export type Endpoint21_9Output = {
+  readonly id: Pty.ID
+  readonly title: string
+  readonly command: string
+  readonly args: ReadonlyArray<string>
+  readonly cwd: string
+  readonly status: "running" | "exited"
+  readonly pid: number
+  readonly exitCode?: number | undefined
+  readonly groupID: string & Brand.Brand<"GroupID">
+  readonly size: { readonly cols: number; readonly rows: number }
+  readonly output: { readonly head: number; readonly tail: number }
+}
+export type ServerPersistentPtyUpdateOperation<E = never> = (
+  input: Endpoint21_9Input,
+) => Effect.Effect<Endpoint21_9Output, E>
+
+export type Endpoint21_10Input = { readonly ptyID: Pty.ID }
+export type Endpoint21_10Output = {
+  readonly info: {
+    readonly id: Pty.ID
+    readonly title: string
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly status: "running" | "exited"
+    readonly pid: number
+    readonly exitCode?: number | undefined
+    readonly groupID: string & Brand.Brand<"GroupID">
+    readonly size: { readonly cols: number; readonly rows: number }
+    readonly output: { readonly head: number; readonly tail: number }
+  }
+  readonly text: string
+  readonly checkpoint: globalThis.Uint8Array
+  readonly cursor: { readonly x: number; readonly y: number }
+}
+export type ServerPersistentPtySnapshotOperation<E = never> = (
+  input: Endpoint21_10Input,
+) => Effect.Effect<Endpoint21_10Output, E>
+
+export type Endpoint21_11Input = { readonly ptyID: Pty.ID }
+export type Endpoint21_11Output = void
+export type ServerPersistentPtyRemoveOperation<E = never> = (
+  input: Endpoint21_11Input,
+) => Effect.Effect<Endpoint21_11Output, E>
+
+export type Endpoint21_12Input = { readonly ptyID: Pty.ID }
+export type Endpoint21_12Output = PtyTicket.ConnectToken
+export type ServerPersistentPtyConnectTokenOperation<E = never> = (
+  input: Endpoint21_12Input,
+) => Effect.Effect<Endpoint21_12Output, E>
+
+export type Endpoint21_13Input = { readonly ptyID: Pty.ID }
+export type Endpoint21_13Output = boolean
+export type ServerPersistentPtyConnectOperation<E = never> = (
+  input: Endpoint21_13Input,
+) => Effect.Effect<Endpoint21_13Output, E>
+
+export interface ServerPersistentPtyApi<E = never> {
+  readonly group: {
+    readonly list: ServerPersistentPtyGroupListOperation<E>
+    readonly create: ServerPersistentPtyGroupCreateOperation<E>
+    readonly get: ServerPersistentPtyGroupGetOperation<E>
+    readonly set: ServerPersistentPtyGroupSetOperation<E>
+    readonly remove: ServerPersistentPtyGroupRemoveOperation<E>
+  }
+  readonly list: ServerPersistentPtyListOperation<E>
+  readonly create: ServerPersistentPtyCreateOperation<E>
+  readonly shutdown: ServerPersistentPtyShutdownOperation<E>
+  readonly get: ServerPersistentPtyGetOperation<E>
+  readonly update: ServerPersistentPtyUpdateOperation<E>
+  readonly snapshot: ServerPersistentPtySnapshotOperation<E>
+  readonly remove: ServerPersistentPtyRemoveOperation<E>
+  readonly connectToken: ServerPersistentPtyConnectTokenOperation<E>
+  readonly connect: ServerPersistentPtyConnectOperation<E>
+}
+
+export type Endpoint22_0Input = {
+  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
+}
+export type Endpoint22_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Shell.Info> }
+export type ShellListOperation<E = never> = (input?: Endpoint22_0Input) => Effect.Effect<Endpoint22_0Output, E>
+
+export type Endpoint22_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly command: string
   readonly cwd?: string | undefined
   readonly timeout: number
   readonly metadata?: { readonly [x: string]: unknown } | undefined
 }
-export type Endpoint21_1Output = { readonly location: Location.Info; readonly data: Shell.Info }
-export type ShellCreateOperation<E = never> = (input: Endpoint21_1Input) => Effect.Effect<Endpoint21_1Output, E>
+export type Endpoint22_1Output = { readonly location: Location.Info; readonly data: Shell.Info }
+export type ShellCreateOperation<E = never> = (input: Endpoint22_1Input) => Effect.Effect<Endpoint22_1Output, E>
 
-export type Endpoint21_2Input = {
+export type Endpoint22_2Input = {
   readonly id: Shell.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint21_2Output = { readonly location: Location.Info; readonly data: Shell.Info }
-export type ShellGetOperation<E = never> = (input: Endpoint21_2Input) => Effect.Effect<Endpoint21_2Output, E>
+export type Endpoint22_2Output = { readonly location: Location.Info; readonly data: Shell.Info }
+export type ShellGetOperation<E = never> = (input: Endpoint22_2Input) => Effect.Effect<Endpoint22_2Output, E>
 
-export type Endpoint21_3Input = {
+export type Endpoint22_3Input = {
   readonly id: Shell.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly timeout: number
 }
-export type Endpoint21_3Output = { readonly location: Location.Info; readonly data: Shell.Info }
-export type ShellTimeoutOperation<E = never> = (input: Endpoint21_3Input) => Effect.Effect<Endpoint21_3Output, E>
+export type Endpoint22_3Output = { readonly location: Location.Info; readonly data: Shell.Info }
+export type ShellTimeoutOperation<E = never> = (input: Endpoint22_3Input) => Effect.Effect<Endpoint22_3Output, E>
 
-export type Endpoint21_4Input = {
+export type Endpoint22_4Input = {
   readonly id: Shell.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly cursor?: number | undefined
   readonly limit?: number | undefined
 }
-export type Endpoint21_4Output = {
+export type Endpoint22_4Output = {
   readonly location: Location.Info
   readonly data: {
     readonly output: string
@@ -1481,14 +1687,14 @@ export type Endpoint21_4Output = {
     readonly truncated: boolean
   }
 }
-export type ShellOutputOperation<E = never> = (input: Endpoint21_4Input) => Effect.Effect<Endpoint21_4Output, E>
+export type ShellOutputOperation<E = never> = (input: Endpoint22_4Input) => Effect.Effect<Endpoint22_4Output, E>
 
-export type Endpoint21_5Input = {
+export type Endpoint22_5Input = {
   readonly id: Shell.ID
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint21_5Output = void
-export type ShellRemoveOperation<E = never> = (input: Endpoint21_5Input) => Effect.Effect<Endpoint21_5Output, E>
+export type Endpoint22_5Output = void
+export type ShellRemoveOperation<E = never> = (input: Endpoint22_5Input) => Effect.Effect<Endpoint22_5Output, E>
 
 export interface ShellApi<E = never> {
   readonly list: ShellListOperation<E>
@@ -1499,41 +1705,41 @@ export interface ShellApi<E = never> {
   readonly remove: ShellRemoveOperation<E>
 }
 
-export type Endpoint22_0Input = {
+export type Endpoint23_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint22_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Reference.Info> }
-export type ReferenceListOperation<E = never> = (input?: Endpoint22_0Input) => Effect.Effect<Endpoint22_0Output, E>
+export type Endpoint23_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Reference.Info> }
+export type ReferenceListOperation<E = never> = (input?: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>
 
 export interface ReferenceApi<E = never> {
   readonly list: ReferenceListOperation<E>
 }
 
-export type Endpoint23_0Input = { readonly projectID: Project.ID }
-export type Endpoint23_0Output = Worktree.List
-export type WorktreeListOperation<E = never> = (input: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>
+export type Endpoint24_0Input = { readonly projectID: Project.ID }
+export type Endpoint24_0Output = Worktree.List
+export type WorktreeListOperation<E = never> = (input: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>
 
-export type Endpoint23_1Input = {
+export type Endpoint24_1Input = {
   readonly projectID: Project.ID
   readonly strategy: Worktree.StrategyID
   readonly from?: AbsolutePath | undefined
   readonly directory: AbsolutePath
   readonly name?: string | undefined
 }
-export type Endpoint23_1Output = Worktree.Info
-export type WorktreeCreateOperation<E = never> = (input: Endpoint23_1Input) => Effect.Effect<Endpoint23_1Output, E>
+export type Endpoint24_1Output = Worktree.Info
+export type WorktreeCreateOperation<E = never> = (input: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>
 
-export type Endpoint23_2Input = {
+export type Endpoint24_2Input = {
   readonly projectID: Project.ID
   readonly directory: AbsolutePath
   readonly force: boolean
 }
-export type Endpoint23_2Output = void
-export type WorktreeRemoveOperation<E = never> = (input: Endpoint23_2Input) => Effect.Effect<Endpoint23_2Output, E>
+export type Endpoint24_2Output = void
+export type WorktreeRemoveOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>
 
-export type Endpoint23_3Input = { readonly projectID: Project.ID }
-export type Endpoint23_3Output = void
-export type WorktreeRefreshOperation<E = never> = (input: Endpoint23_3Input) => Effect.Effect<Endpoint23_3Output, E>
+export type Endpoint24_3Input = { readonly projectID: Project.ID }
+export type Endpoint24_3Output = void
+export type WorktreeRefreshOperation<E = never> = (input: Endpoint24_3Input) => Effect.Effect<Endpoint24_3Output, E>
 
 export interface WorktreeApi<E = never> {
   readonly list: WorktreeListOperation<E>
@@ -1542,25 +1748,25 @@ export interface WorktreeApi<E = never> {
   readonly refresh: WorktreeRefreshOperation<E>
 }
 
-export type Endpoint24_0Input = {
+export type Endpoint25_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint24_0Output = { readonly location: Location.Info; readonly data: Vcs.Info }
-export type VcsGetOperation<E = never> = (input?: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>
+export type Endpoint25_0Output = { readonly location: Location.Info; readonly data: Vcs.Info }
+export type VcsGetOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>
 
-export type Endpoint24_1Input = {
+export type Endpoint25_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint24_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
-export type VcsStatusOperation<E = never> = (input?: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>
+export type Endpoint25_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
+export type VcsStatusOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
 
-export type Endpoint24_2Input = {
+export type Endpoint25_2Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly mode: Vcs.Mode
   readonly context?: number | undefined
 }
-export type Endpoint24_2Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
-export type VcsDiffOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>
+export type Endpoint25_2Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
+export type VcsDiffOperation<E = never> = (input: Endpoint25_2Input) => Effect.Effect<Endpoint25_2Output, E>
 
 export interface VcsApi<E = never> {
   readonly get: VcsGetOperation<E>
@@ -1568,20 +1774,20 @@ export interface VcsApi<E = never> {
   readonly diff: VcsDiffOperation<E>
 }
 
-export type Endpoint25_0Output = ReadonlyArray<Location.Ref>
-export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint25_0Output, E>
+export type Endpoint26_0Output = ReadonlyArray<Location.Ref>
+export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>
 
-export type Endpoint25_1Input = {
+export type Endpoint26_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint25_1Output = void
-export type DebugLocationEvictOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>
+export type Endpoint26_1Output = void
+export type DebugLocationEvictOperation<E = never> = (input?: Endpoint26_1Input) => Effect.Effect<Endpoint26_1Output, E>
 
 export interface DebugApi<E = never> {
   readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
 }
 
-export type Endpoint26_0Output =
+export type Endpoint27_0Output =
   | { readonly status: "required" | "completed" }
   | {
       readonly status: "running"
@@ -1592,36 +1798,36 @@ export type Endpoint26_0Output =
       }
     }
   | { readonly status: "error"; readonly error: string }
-export type MigrationV1StatusOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>
+export type MigrationV1StatusOperation<E = never> = () => Effect.Effect<Endpoint27_0Output, E>
 
 export interface MigrationApi<E = never> {
   readonly v1: { readonly status: MigrationV1StatusOperation<E> }
 }
 
-export type Endpoint27_0Input = {
+export type Endpoint28_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint27_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<WebSearch.Provider> }
-export type WebsearchProvidersOperation<E = never> = (input?: Endpoint27_0Input) => Effect.Effect<Endpoint27_0Output, E>
+export type Endpoint28_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<WebSearch.Provider> }
+export type WebsearchProvidersOperation<E = never> = (input?: Endpoint28_0Input) => Effect.Effect<Endpoint28_0Output, E>
 
-export type Endpoint27_1Input = {
+export type Endpoint28_1Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
   readonly query: string
   readonly providerID?: WebSearch.ID | undefined
 }
-export type Endpoint27_1Output = { readonly location: Location.Info; readonly data: WebSearch.Response }
-export type WebsearchQueryOperation<E = never> = (input: Endpoint27_1Input) => Effect.Effect<Endpoint27_1Output, E>
+export type Endpoint28_1Output = { readonly location: Location.Info; readonly data: WebSearch.Response }
+export type WebsearchQueryOperation<E = never> = (input: Endpoint28_1Input) => Effect.Effect<Endpoint28_1Output, E>
 
 export interface WebsearchApi<E = never> {
   readonly providers: WebsearchProvidersOperation<E>
   readonly query: WebsearchQueryOperation<E>
 }
 
-export type Endpoint28_0Input = {
+export type Endpoint29_0Input = {
   readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
 }
-export type Endpoint28_0Output = ReadonlyArray<Config.Entry>
-export type ConfigGetOperation<E = never> = (input?: Endpoint28_0Input) => Effect.Effect<Endpoint28_0Output, E>
+export type Endpoint29_0Output = ReadonlyArray<Config.Entry>
+export type ConfigGetOperation<E = never> = (input?: Endpoint29_0Input) => Effect.Effect<Endpoint29_0Output, E>
 
 export interface ConfigApi<E = never> {
   readonly get: ConfigGetOperation<E>
@@ -1649,6 +1855,7 @@ export interface AppApi<E = never> {
   readonly skill: SkillApi<E>
   readonly event: EventApi<E>
   readonly pty: PtyApi<E>
+  readonly "server.persistentPty": ServerPersistentPtyApi<E>
   readonly shell: ShellApi<E>
   readonly reference: ReferenceApi<E>
   readonly worktree: WorktreeApi<E>

packages/client/src/effect/generated/client.ts

@@ -186,7 +186,6 @@ import type {
   Endpoint20_3Output,
   Endpoint20_4Input,
   Endpoint20_4Output,
-  Endpoint21_0Input,
   Endpoint21_0Output,
   Endpoint21_1Input,
   Endpoint21_1Output,
@@ -198,32 +197,59 @@ import type {
   Endpoint21_4Output,
   Endpoint21_5Input,
   Endpoint21_5Output,
+  Endpoint21_6Input,
+  Endpoint21_6Output,
+  Endpoint21_7Output,
+  Endpoint21_8Input,
+  Endpoint21_8Output,
+  Endpoint21_9Input,
+  Endpoint21_9Output,
+  Endpoint21_10Input,
+  Endpoint21_10Output,
+  Endpoint21_11Input,
+  Endpoint21_11Output,
+  Endpoint21_12Input,
+  Endpoint21_12Output,
+  Endpoint21_13Input,
+  Endpoint21_13Output,
   Endpoint22_0Input,
   Endpoint22_0Output,
+  Endpoint22_1Input,
+  Endpoint22_1Output,
+  Endpoint22_2Input,
+  Endpoint22_2Output,
+  Endpoint22_3Input,
+  Endpoint22_3Output,
+  Endpoint22_4Input,
+  Endpoint22_4Output,
+  Endpoint22_5Input,
+  Endpoint22_5Output,
   Endpoint23_0Input,
   Endpoint23_0Output,
-  Endpoint23_1Input,
-  Endpoint23_1Output,
-  Endpoint23_2Input,
-  Endpoint23_2Output,
-  Endpoint23_3Input,
-  Endpoint23_3Output,
   Endpoint24_0Input,
   Endpoint24_0Output,
   Endpoint24_1Input,
   Endpoint24_1Output,
   Endpoint24_2Input,
   Endpoint24_2Output,
+  Endpoint24_3Input,
+  Endpoint24_3Output,
+  Endpoint25_0Input,
   Endpoint25_0Output,
   Endpoint25_1Input,
   Endpoint25_1Output,
+  Endpoint25_2Input,
+  Endpoint25_2Output,
   Endpoint26_0Output,
-  Endpoint27_0Input,
+  Endpoint26_1Input,
+  Endpoint26_1Output,
   Endpoint27_0Output,
-  Endpoint27_1Input,
-  Endpoint27_1Output,
   Endpoint28_0Input,
   Endpoint28_0Output,
+  Endpoint28_1Input,
+  Endpoint28_1Output,
+  Endpoint29_0Input,
+  Endpoint29_0Output,
 } from "../api/api.js"
 import { ClientError } from "./client-error.js"
 
@@ -1097,28 +1123,158 @@ const adaptGroup20 = (raw: RawClient["server.pty"]) => ({
   remove: Endpoint20_4(raw),
 })
 
-const Endpoint21_0 = (raw: RawClient["server.shell"]) => (input?: Endpoint21_0Input) =>
+const Endpoint21_0 = (raw: RawClient["server.persistentPty"]) => () =>
   preserveEffect<Endpoint21_0Output>()(
+    raw["persistentPty.group.list"]({}).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_1 = (raw: RawClient["server.persistentPty"]) => (input?: Endpoint21_1Input) =>
+  preserveEffect<Endpoint21_1Output>()(
+    raw["persistentPty.group.create"]({ payload: { items: input?.["items"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_2 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_2Input) =>
+  preserveEffect<Endpoint21_2Output>()(
+    raw["persistentPty.group.get"]({ params: { groupID: input["groupID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_3 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_3Input) =>
+  preserveEffect<Endpoint21_3Output>()(
+    raw["persistentPty.group.set"]({ params: { groupID: input["groupID"] }, payload: { items: input["items"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_4 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_4Input) =>
+  preserveEffect<Endpoint21_4Output>()(
+    raw["persistentPty.group.remove"]({ params: { groupID: input["groupID"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
+const Endpoint21_5 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_5Input) =>
+  preserveEffect<Endpoint21_5Output>()(
+    raw["persistentPty.list"]({ params: { groupID: input["groupID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_6 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_6Input) =>
+  preserveEffect<Endpoint21_6Output>()(
+    raw["persistentPty.create"]({
+      params: { groupID: input["groupID"] },
+      payload: {
+        command: input["command"],
+        args: input["args"],
+        cwd: input["cwd"],
+        title: input["title"],
+        env: input["env"],
+        size: input["size"],
+      },
+    }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_7 = (raw: RawClient["server.persistentPty"]) => () =>
+  preserveEffect<Endpoint21_7Output>()(raw["persistentPty.shutdown"]({}).pipe(Effect.mapError(mapClientError)))
+
+const Endpoint21_8 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_8Input) =>
+  preserveEffect<Endpoint21_8Output>()(
+    raw["persistentPty.get"]({ params: { ptyID: input["ptyID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_9 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_9Input) =>
+  preserveEffect<Endpoint21_9Output>()(
+    raw["persistentPty.update"]({
+      params: { ptyID: input["ptyID"] },
+      payload: { attachmentID: input["attachmentID"], size: input["size"] },
+    }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_10 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_10Input) =>
+  preserveEffect<Endpoint21_10Output>()(
+    raw["persistentPty.snapshot"]({ params: { ptyID: input["ptyID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_11 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_11Input) =>
+  preserveEffect<Endpoint21_11Output>()(
+    raw["persistentPty.remove"]({ params: { ptyID: input["ptyID"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
+const Endpoint21_12 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_12Input) =>
+  preserveEffect<Endpoint21_12Output>()(
+    raw["persistentPty.connectToken"]({ params: { ptyID: input["ptyID"] } }).pipe(
+      Effect.mapError(mapClientError),
+      Effect.map((value) => value.data),
+    ),
+  )
+
+const Endpoint21_13 = (raw: RawClient["server.persistentPty"]) => (input: Endpoint21_13Input) =>
+  preserveEffect<Endpoint21_13Output>()(
+    raw["persistentPty.connect"]({ params: { ptyID: input["ptyID"] } }).pipe(Effect.mapError(mapClientError)),
+  )
+
+const adaptGroup21 = (raw: RawClient["server.persistentPty"]) => ({
+  group: {
+    list: Endpoint21_0(raw),
+    create: Endpoint21_1(raw),
+    get: Endpoint21_2(raw),
+    set: Endpoint21_3(raw),
+    remove: Endpoint21_4(raw),
+  },
+  list: Endpoint21_5(raw),
+  create: Endpoint21_6(raw),
+  shutdown: Endpoint21_7(raw),
+  get: Endpoint21_8(raw),
+  update: Endpoint21_9(raw),
+  snapshot: Endpoint21_10(raw),
+  remove: Endpoint21_11(raw),
+  connectToken: Endpoint21_12(raw),
+  connect: Endpoint21_13(raw),
+})
+
+const Endpoint22_0 = (raw: RawClient["server.shell"]) => (input?: Endpoint22_0Input) =>
+  preserveEffect<Endpoint22_0Output>()(
     raw["shell.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint21_1 = (raw: RawClient["server.shell"]) => (input: Endpoint21_1Input) =>
-  preserveEffect<Endpoint21_1Output>()(
+const Endpoint22_1 = (raw: RawClient["server.shell"]) => (input: Endpoint22_1Input) =>
+  preserveEffect<Endpoint22_1Output>()(
     raw["shell.create"]({
       query: { location: input["location"] },
       payload: { command: input["command"], cwd: input["cwd"], timeout: input["timeout"], metadata: input["metadata"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint21_2 = (raw: RawClient["server.shell"]) => (input: Endpoint21_2Input) =>
-  preserveEffect<Endpoint21_2Output>()(
+const Endpoint22_2 = (raw: RawClient["server.shell"]) => (input: Endpoint22_2Input) =>
+  preserveEffect<Endpoint22_2Output>()(
     raw["shell.get"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const Endpoint21_3 = (raw: RawClient["server.shell"]) => (input: Endpoint21_3Input) =>
-  preserveEffect<Endpoint21_3Output>()(
+const Endpoint22_3 = (raw: RawClient["server.shell"]) => (input: Endpoint22_3Input) =>
+  preserveEffect<Endpoint22_3Output>()(
     raw["shell.timeout"]({
       params: { id: input["id"] },
       query: { location: input["location"] },
@@ -1126,134 +1282,134 @@ const Endpoint21_3 = (raw: RawClient["server.shell"]) => (input: Endpoint21_3Inp
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint21_4 = (raw: RawClient["server.shell"]) => (input: Endpoint21_4Input) =>
-  preserveEffect<Endpoint21_4Output>()(
+const Endpoint22_4 = (raw: RawClient["server.shell"]) => (input: Endpoint22_4Input) =>
+  preserveEffect<Endpoint22_4Output>()(
     raw["shell.output"]({
       params: { id: input["id"] },
       query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint21_5 = (raw: RawClient["server.shell"]) => (input: Endpoint21_5Input) =>
-  preserveEffect<Endpoint21_5Output>()(
+const Endpoint22_5 = (raw: RawClient["server.shell"]) => (input: Endpoint22_5Input) =>
+  preserveEffect<Endpoint22_5Output>()(
     raw["shell.remove"]({ params: { id: input["id"] }, query: { location: input["location"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const adaptGroup21 = (raw: RawClient["server.shell"]) => ({
-  list: Endpoint21_0(raw),
-  create: Endpoint21_1(raw),
-  get: Endpoint21_2(raw),
-  timeout: Endpoint21_3(raw),
-  output: Endpoint21_4(raw),
-  remove: Endpoint21_5(raw),
+const adaptGroup22 = (raw: RawClient["server.shell"]) => ({
+  list: Endpoint22_0(raw),
+  create: Endpoint22_1(raw),
+  get: Endpoint22_2(raw),
+  timeout: Endpoint22_3(raw),
+  output: Endpoint22_4(raw),
+  remove: Endpoint22_5(raw),
 })
 
-const Endpoint22_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint22_0Input) =>
-  preserveEffect<Endpoint22_0Output>()(
+const Endpoint23_0 = (raw: RawClient["server.reference"]) => (input?: Endpoint23_0Input) =>
+  preserveEffect<Endpoint23_0Output>()(
     raw["reference.list"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup22 = (raw: RawClient["server.reference"]) => ({ list: Endpoint22_0(raw) })
+const adaptGroup23 = (raw: RawClient["server.reference"]) => ({ list: Endpoint23_0(raw) })
 
-const Endpoint23_0 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_0Input) =>
-  preserveEffect<Endpoint23_0Output>()(
+const Endpoint24_0 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_0Input) =>
+  preserveEffect<Endpoint24_0Output>()(
     raw["worktree.list"]({ params: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint23_1 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_1Input) =>
-  preserveEffect<Endpoint23_1Output>()(
+const Endpoint24_1 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_1Input) =>
+  preserveEffect<Endpoint24_1Output>()(
     raw["worktree.create"]({
       params: { projectID: input["projectID"] },
       payload: { strategy: input["strategy"], from: input["from"], directory: input["directory"], name: input["name"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint23_2 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_2Input) =>
-  preserveEffect<Endpoint23_2Output>()(
+const Endpoint24_2 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_2Input) =>
+  preserveEffect<Endpoint24_2Output>()(
     raw["worktree.remove"]({
       params: { projectID: input["projectID"] },
       payload: { directory: input["directory"], force: input["force"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint23_3 = (raw: RawClient["server.worktree"]) => (input: Endpoint23_3Input) =>
-  preserveEffect<Endpoint23_3Output>()(
+const Endpoint24_3 = (raw: RawClient["server.worktree"]) => (input: Endpoint24_3Input) =>
+  preserveEffect<Endpoint24_3Output>()(
     raw["worktree.refresh"]({ params: { projectID: input["projectID"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup23 = (raw: RawClient["server.worktree"]) => ({
-  list: Endpoint23_0(raw),
-  create: Endpoint23_1(raw),
-  remove: Endpoint23_2(raw),
-  refresh: Endpoint23_3(raw),
+const adaptGroup24 = (raw: RawClient["server.worktree"]) => ({
+  list: Endpoint24_0(raw),
+  create: Endpoint24_1(raw),
+  remove: Endpoint24_2(raw),
+  refresh: Endpoint24_3(raw),
 })
 
-const Endpoint24_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint24_0Input) =>
-  preserveEffect<Endpoint24_0Output>()(
+const Endpoint25_0 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_0Input) =>
+  preserveEffect<Endpoint25_0Output>()(
     raw["vcs.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint24_1 = (raw: RawClient["server.vcs"]) => (input?: Endpoint24_1Input) =>
-  preserveEffect<Endpoint24_1Output>()(
+const Endpoint25_1 = (raw: RawClient["server.vcs"]) => (input?: Endpoint25_1Input) =>
+  preserveEffect<Endpoint25_1Output>()(
     raw["vcs.status"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint24_2 = (raw: RawClient["server.vcs"]) => (input: Endpoint24_2Input) =>
-  preserveEffect<Endpoint24_2Output>()(
+const Endpoint25_2 = (raw: RawClient["server.vcs"]) => (input: Endpoint25_2Input) =>
+  preserveEffect<Endpoint25_2Output>()(
     raw["vcs.diff"]({ query: { location: input["location"], mode: input["mode"], context: input["context"] } }).pipe(
       Effect.mapError(mapClientError),
     ),
   )
 
-const adaptGroup24 = (raw: RawClient["server.vcs"]) => ({
-  get: Endpoint24_0(raw),
-  status: Endpoint24_1(raw),
-  diff: Endpoint24_2(raw),
+const adaptGroup25 = (raw: RawClient["server.vcs"]) => ({
+  get: Endpoint25_0(raw),
+  status: Endpoint25_1(raw),
+  diff: Endpoint25_2(raw),
 })
 
-const Endpoint25_0 = (raw: RawClient["server.debug"]) => () =>
-  preserveEffect<Endpoint25_0Output>()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)))
+const Endpoint26_0 = (raw: RawClient["server.debug"]) => () =>
+  preserveEffect<Endpoint26_0Output>()(raw["debug.location"]({}).pipe(Effect.mapError(mapClientError)))
 
-const Endpoint25_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint25_1Input) =>
-  preserveEffect<Endpoint25_1Output>()(
+const Endpoint26_1 = (raw: RawClient["server.debug"]) => (input?: Endpoint26_1Input) =>
+  preserveEffect<Endpoint26_1Output>()(
     raw["debug.location.evict"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup25 = (raw: RawClient["server.debug"]) => ({
-  location: { list: Endpoint25_0(raw), evict: Endpoint25_1(raw) },
+const adaptGroup26 = (raw: RawClient["server.debug"]) => ({
+  location: { list: Endpoint26_0(raw), evict: Endpoint26_1(raw) },
 })
 
-const Endpoint26_0 = (raw: RawClient["server.migration"]) => () =>
-  preserveEffect<Endpoint26_0Output>()(raw["migration.v1.status"]({}).pipe(Effect.mapError(mapClientError)))
+const Endpoint27_0 = (raw: RawClient["server.migration"]) => () =>
+  preserveEffect<Endpoint27_0Output>()(raw["migration.v1.status"]({}).pipe(Effect.mapError(mapClientError)))
 
-const adaptGroup26 = (raw: RawClient["server.migration"]) => ({ v1: { status: Endpoint26_0(raw) } })
+const adaptGroup27 = (raw: RawClient["server.migration"]) => ({ v1: { status: Endpoint27_0(raw) } })
 
-const Endpoint27_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint27_0Input) =>
-  preserveEffect<Endpoint27_0Output>()(
+const Endpoint28_0 = (raw: RawClient["server.websearch"]) => (input?: Endpoint28_0Input) =>
+  preserveEffect<Endpoint28_0Output>()(
     raw["websearch.providers"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const Endpoint27_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint27_1Input) =>
-  preserveEffect<Endpoint27_1Output>()(
+const Endpoint28_1 = (raw: RawClient["server.websearch"]) => (input: Endpoint28_1Input) =>
+  preserveEffect<Endpoint28_1Output>()(
     raw["websearch.query"]({
       query: { location: input["location"] },
       payload: { query: input["query"], providerID: input["providerID"] },
     }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup27 = (raw: RawClient["server.websearch"]) => ({
-  providers: Endpoint27_0(raw),
-  query: Endpoint27_1(raw),
+const adaptGroup28 = (raw: RawClient["server.websearch"]) => ({
+  providers: Endpoint28_0(raw),
+  query: Endpoint28_1(raw),
 })
 
-const Endpoint28_0 = (raw: RawClient["server.config"]) => (input?: Endpoint28_0Input) =>
-  preserveEffect<Endpoint28_0Output>()(
+const Endpoint29_0 = (raw: RawClient["server.config"]) => (input?: Endpoint29_0Input) =>
+  preserveEffect<Endpoint29_0Output>()(
     raw["config.get"]({ query: { location: input?.["location"] } }).pipe(Effect.mapError(mapClientError)),
   )
 
-const adaptGroup28 = (raw: RawClient["server.config"]) => ({ get: Endpoint28_0(raw) })
+const adaptGroup29 = (raw: RawClient["server.config"]) => ({ get: Endpoint29_0(raw) })
 
 const adaptClient = (raw: RawClient) => ({
   health: adaptGroup0(raw["server.health"]),
@@ -1277,14 +1433,15 @@ const adaptClient = (raw: RawClient) => ({
   skill: adaptGroup18(raw["server.skill"]),
   event: adaptGroup19(raw["server.event"]),
   pty: adaptGroup20(raw["server.pty"]),
-  shell: adaptGroup21(raw["server.shell"]),
-  reference: adaptGroup22(raw["server.reference"]),
-  worktree: adaptGroup23(raw["server.worktree"]),
-  vcs: adaptGroup24(raw["server.vcs"]),
-  debug: adaptGroup25(raw["server.debug"]),
-  migration: adaptGroup26(raw["server.migration"]),
-  websearch: adaptGroup27(raw["server.websearch"]),
-  config: adaptGroup28(raw["server.config"]),
+  "server.persistentPty": adaptGroup21(raw["server.persistentPty"]),
+  shell: adaptGroup22(raw["server.shell"]),
+  reference: adaptGroup23(raw["server.reference"]),
+  worktree: adaptGroup24(raw["server.worktree"]),
+  vcs: adaptGroup25(raw["server.vcs"]),
+  debug: adaptGroup26(raw["server.debug"]),
+  migration: adaptGroup27(raw["server.migration"]),
+  websearch: adaptGroup28(raw["server.websearch"]),
+  config: adaptGroup29(raw["server.config"]),
 })
 
 export const make = (options?: { readonly baseUrl?: URL | string }) =>

packages/client/src/promise/generated/client.ts

@@ -182,6 +182,32 @@ import type {
   PtyUpdateOutput,
   PtyRemoveInput,
   PtyRemoveOutput,
+  ServerPersistentPtyGroupListOutput,
+  ServerPersistentPtyGroupCreateInput,
+  ServerPersistentPtyGroupCreateOutput,
+  ServerPersistentPtyGroupGetInput,
+  ServerPersistentPtyGroupGetOutput,
+  ServerPersistentPtyGroupSetInput,
+  ServerPersistentPtyGroupSetOutput,
+  ServerPersistentPtyGroupRemoveInput,
+  ServerPersistentPtyGroupRemoveOutput,
+  ServerPersistentPtyListInput,
+  ServerPersistentPtyListOutput,
+  ServerPersistentPtyCreateInput,
+  ServerPersistentPtyCreateOutput,
+  ServerPersistentPtyShutdownOutput,
+  ServerPersistentPtyGetInput,
+  ServerPersistentPtyGetOutput,
+  ServerPersistentPtyUpdateInput,
+  ServerPersistentPtyUpdateOutput,
+  ServerPersistentPtySnapshotInput,
+  ServerPersistentPtySnapshotOutput,
+  ServerPersistentPtyRemoveInput,
+  ServerPersistentPtyRemoveOutput,
+  ServerPersistentPtyConnectTokenInput,
+  ServerPersistentPtyConnectTokenOutput,
+  ServerPersistentPtyConnectInput,
+  ServerPersistentPtyConnectOutput,
   ShellListInput,
   ShellListOutput,
   ShellCreateInput,
@@ -1571,6 +1597,175 @@ export function make(options: ClientOptions) {
           requestOptions,
         ),
     },
+    "server.persistentPty": {
+      group: {
+        list: (requestOptions?: RequestOptions) =>
+          request<{ readonly data: ServerPersistentPtyGroupListOutput }>(
+            {
+              method: "GET",
+              path: `/api/pty-group`,
+              successStatus: 200,
+              declaredStatuses: [400, 503, 401],
+              empty: false,
+            },
+            requestOptions,
+          ).then((value) => value.data),
+        create: (input?: ServerPersistentPtyGroupCreateInput, requestOptions?: RequestOptions) =>
+          request<{ readonly data: ServerPersistentPtyGroupCreateOutput }>(
+            {
+              method: "POST",
+              path: `/api/pty-group`,
+              body: { items: input?.["items"] },
+              successStatus: 200,
+              declaredStatuses: [400, 503, 401],
+              empty: false,
+            },
+            requestOptions,
+          ).then((value) => value.data),
+        get: (input: ServerPersistentPtyGroupGetInput, requestOptions?: RequestOptions) =>
+          request<{ readonly data: ServerPersistentPtyGroupGetOutput }>(
+            {
+              method: "GET",
+              path: `/api/pty-group/${encodeURIComponent(input.groupID)}`,
+              successStatus: 200,
+              declaredStatuses: [400, 503, 401],
+              empty: false,
+            },
+            requestOptions,
+          ).then((value) => value.data),
+        set: (input: ServerPersistentPtyGroupSetInput, requestOptions?: RequestOptions) =>
+          request<{ readonly data: ServerPersistentPtyGroupSetOutput }>(
+            {
+              method: "PUT",
+              path: `/api/pty-group/${encodeURIComponent(input.groupID)}`,
+              body: { items: input["items"] },
+              successStatus: 200,
+              declaredStatuses: [400, 503, 401],
+              empty: false,
+            },
+            requestOptions,
+          ).then((value) => value.data),
+        remove: (input: ServerPersistentPtyGroupRemoveInput, requestOptions?: RequestOptions) =>
+          request<ServerPersistentPtyGroupRemoveOutput>(
+            {
+              method: "DELETE",
+              path: `/api/pty-group/${encodeURIComponent(input.groupID)}`,
+              successStatus: 204,
+              declaredStatuses: [400, 503, 401],
+              empty: true,
+            },
+            requestOptions,
+          ),
+      },
+      list: (input: ServerPersistentPtyListInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: ServerPersistentPtyListOutput }>(
+          {
+            method: "GET",
+            path: `/api/pty-group/${encodeURIComponent(input.groupID)}/terminal`,
+            successStatus: 200,
+            declaredStatuses: [400, 503, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      create: (input: ServerPersistentPtyCreateInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: ServerPersistentPtyCreateOutput }>(
+          {
+            method: "POST",
+            path: `/api/pty-group/${encodeURIComponent(input.groupID)}/terminal`,
+            body: {
+              command: input["command"],
+              args: input["args"],
+              cwd: input["cwd"],
+              title: input["title"],
+              env: input["env"],
+              size: input["size"],
+            },
+            successStatus: 200,
+            declaredStatuses: [400, 503, 401],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      shutdown: (requestOptions?: RequestOptions) =>
+        request<ServerPersistentPtyShutdownOutput>(
+          {
+            method: "POST",
+            path: `/api/persistent-pty/shutdown`,
+            successStatus: 204,
+            declaredStatuses: [503, 401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      get: (input: ServerPersistentPtyGetInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: ServerPersistentPtyGetOutput }>(
+          {
+            method: "GET",
+            path: `/api/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+            successStatus: 200,
+            declaredStatuses: [404, 503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      update: (input: ServerPersistentPtyUpdateInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: ServerPersistentPtyUpdateOutput }>(
+          {
+            method: "PUT",
+            path: `/api/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+            body: { attachmentID: input["attachmentID"], size: input["size"] },
+            successStatus: 200,
+            declaredStatuses: [404, 503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      snapshot: (input: ServerPersistentPtySnapshotInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: ServerPersistentPtySnapshotOutput }>(
+          {
+            method: "GET",
+            path: `/api/persistent-pty/${encodeURIComponent(input.ptyID)}/snapshot`,
+            successStatus: 200,
+            declaredStatuses: [404, 503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      remove: (input: ServerPersistentPtyRemoveInput, requestOptions?: RequestOptions) =>
+        request<ServerPersistentPtyRemoveOutput>(
+          {
+            method: "DELETE",
+            path: `/api/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+            successStatus: 204,
+            declaredStatuses: [404, 503, 401, 400],
+            empty: true,
+          },
+          requestOptions,
+        ),
+      connectToken: (input: ServerPersistentPtyConnectTokenInput, requestOptions?: RequestOptions) =>
+        request<{ readonly data: ServerPersistentPtyConnectTokenOutput }>(
+          {
+            method: "POST",
+            path: `/api/persistent-pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+            successStatus: 200,
+            declaredStatuses: [403, 404, 503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ).then((value) => value.data),
+      connect: (input: ServerPersistentPtyConnectInput, requestOptions?: RequestOptions) =>
+        request<ServerPersistentPtyConnectOutput>(
+          {
+            method: "GET",
+            path: `/api/persistent-pty/${encodeURIComponent(input.ptyID)}/connect`,
+            successStatus: 200,
+            declaredStatuses: [403, 404, 503, 401, 400],
+            empty: false,
+          },
+          requestOptions,
+        ),
+    },
     shell: {
       list: (input?: ShellListInput, requestOptions?: RequestOptions) =>
         request<ShellListOutput>(
@@ -1671,7 +1866,7 @@ export function make(options: ClientOptions) {
         request<WorktreeListOutput>(
           {
             method: "GET",
-            path: `/api/worktree/${encodeURIComponent(input.projectID)}`,
+            path: `/api/experimental/project/${encodeURIComponent(input.projectID)}/worktree`,
             successStatus: 200,
             declaredStatuses: [401, 400],
             empty: false,
@@ -1682,7 +1877,7 @@ export function make(options: ClientOptions) {
         request<WorktreeCreateOutput>(
           {
             method: "POST",
-            path: `/api/worktree/${encodeURIComponent(input.projectID)}`,
+            path: `/api/experimental/project/${encodeURIComponent(input.projectID)}/worktree`,
             body: {
               strategy: input["strategy"],
               from: input["from"],
@@ -1699,7 +1894,7 @@ export function make(options: ClientOptions) {
         request<WorktreeRemoveOutput>(
           {
             method: "DELETE",
-            path: `/api/worktree/${encodeURIComponent(input.projectID)}`,
+            path: `/api/experimental/project/${encodeURIComponent(input.projectID)}/worktree`,
             body: { directory: input["directory"], force: input["force"] },
             successStatus: 204,
             declaredStatuses: [400, 401],
@@ -1711,7 +1906,7 @@ export function make(options: ClientOptions) {
         request<WorktreeRefreshOutput>(
           {
             method: "POST",
-            path: `/api/worktree/${encodeURIComponent(input.projectID)}/refresh`,
+            path: `/api/experimental/project/${encodeURIComponent(input.projectID)}/worktree/refresh`,
             successStatus: 204,
             declaredStatuses: [400, 401],
             empty: true,

packages/client/src/promise/generated/types.ts

@@ -328,6 +328,8 @@ export type FormMetadata1 = { [x: string]: any }
 
 export type FormWhen1 = { key: string; op: "eq" | "neq"; value: string | number | boolean }
 
+export type GroupItem = { type: "session"; id: string } | { type: "terminal"; id: string }
+
 export type SessionStatus =
   | { type: "idle" }
   | {
@@ -339,6 +341,22 @@ export type SessionStatus =
     }
   | { type: "busy" }
 
+export type PersistentPtyInfo = {
+  id: string
+  title: string
+  command: string
+  args: Array<string>
+  cwd: string
+  status: "running" | "exited"
+  pid: number
+  exitCode?: number
+  groupID: string
+  size: { cols: number; rows: number }
+  output: { head: number; tail: number }
+}
+
+export type PtyTicketConnectToken = { ticket: string; expires_in: number }
+
 export type ShellInfo1 = {
   id: string
   status: "running" | "exited" | "timeout" | "killed"
@@ -1475,6 +1493,26 @@ export type FormMultiselectField1 = {
   default?: Array<string>
 }
 
+export type GroupItemAdded = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "group.item.added"
+  location?: LocationRef
+  data: { groupID: string; item: GroupItem }
+}
+
+export type GroupItemRemoved = {
+  id: string
+  created: number
+  metadata?: { [x: string]: any }
+  type: "group.item.removed"
+  location?: LocationRef
+  data: { groupID: string; item: GroupItem }
+}
+
+export type GroupInfo = { id: string; items: Array<GroupItem> }
+
 export type SessionStatus2 = {
   id: string
   created: number
@@ -1484,6 +1522,13 @@ export type SessionStatus2 = {
   data: { sessionID: string; status: SessionStatus }
 }
 
+export type PersistentPtySnapshot = {
+  info: PersistentPtyInfo
+  text: string
+  checkpoint: string
+  cursor: { x: number; y: number }
+}
+
 export type ReferenceSource = ReferenceLocalSource | ReferenceGitSource
 
 export type WorktreeList = Array<WorktreeDirectory>
@@ -1787,7 +1832,7 @@ export type ConfigEntry =
             | { repository: string; branch?: string; description?: string; hidden?: boolean }
             | { path: string; description?: string; hidden?: boolean }
         }
-        websearch?: false | { provider: "random" | (string & {}) }
+        websearch?: { provider: string }
         plugins?: Array<string | { package: string; options?: { [x: string]: JsonValue } }>
         warming?: boolean | { prompt?: string; interval?: string; duration?: string }
         providers?: {
@@ -1842,6 +1887,7 @@ export type ConfigEntry =
       }
     }
   | { type: "directory"; path: string }
+  | { type: "file"; path: string }
   | { type: "agents"; path: string }
   | { type: "claude"; path: string }
 
@@ -2074,6 +2120,8 @@ export type V2Event =
   | FormCreated
   | FormReplied
   | FormCancelled
+  | GroupItemAdded
+  | GroupItemRemoved
   | WebsearchUpdated
   | SessionStatus2
   | SessionIdle
@@ -2246,6 +2294,10 @@ export type PtyNotFoundError = { readonly _tag: "PtyNotFoundError"; readonly pty
 export const isPtyNotFoundError = (value: unknown): value is PtyNotFoundError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PtyNotFoundError"
 
+export type ForbiddenError = { readonly _tag: "ForbiddenError"; readonly message: string }
+export const isForbiddenError = (value: unknown): value is ForbiddenError =>
+  typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ForbiddenError"
+
 export type ShellNotFoundError = { readonly _tag: "ShellNotFoundError"; readonly id: string; readonly message: string }
 export const isShellNotFoundError = (value: unknown): value is ShellNotFoundError =>
   typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ShellNotFoundError"
@@ -5434,6 +5486,133 @@ export type PtyRemoveInput = {
 
 export type PtyRemoveOutput = void
 
+export type ServerPersistentPtyGroupListOutput = { data: Array<GroupInfo> }["data"]
+
+export type ServerPersistentPtyGroupCreateInput = {
+  readonly items?: {
+    readonly items?:
+      | ReadonlyArray<
+          { readonly type: "session"; readonly id: string } | { readonly type: "terminal"; readonly id: string }
+        >
+      | undefined
+  }["items"]
+}
+
+export type ServerPersistentPtyGroupCreateOutput = { data: GroupInfo }["data"]
+
+export type ServerPersistentPtyGroupGetInput = { readonly groupID: { readonly groupID: string }["groupID"] }
+
+export type ServerPersistentPtyGroupGetOutput = { data: GroupInfo }["data"]
+
+export type ServerPersistentPtyGroupSetInput = {
+  readonly groupID: { readonly groupID: string }["groupID"]
+  readonly items: {
+    readonly items: ReadonlyArray<
+      { readonly type: "session"; readonly id: string } | { readonly type: "terminal"; readonly id: string }
+    >
+  }["items"]
+}
+
+export type ServerPersistentPtyGroupSetOutput = { data: GroupInfo }["data"]
+
+export type ServerPersistentPtyGroupRemoveInput = { readonly groupID: { readonly groupID: string }["groupID"] }
+
+export type ServerPersistentPtyGroupRemoveOutput = void
+
+export type ServerPersistentPtyListInput = { readonly groupID: { readonly groupID: string }["groupID"] }
+
+export type ServerPersistentPtyListOutput = { data: Array<PersistentPtyInfo> }["data"]
+
+export type ServerPersistentPtyCreateInput = {
+  readonly groupID: { readonly groupID: string }["groupID"]
+  readonly command: {
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly title: string
+    readonly env: { readonly [x: string]: string }
+    readonly size?: { readonly cols: number; readonly rows: number }
+  }["command"]
+  readonly args: {
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly title: string
+    readonly env: { readonly [x: string]: string }
+    readonly size?: { readonly cols: number; readonly rows: number }
+  }["args"]
+  readonly cwd: {
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly title: string
+    readonly env: { readonly [x: string]: string }
+    readonly size?: { readonly cols: number; readonly rows: number }
+  }["cwd"]
+  readonly title: {
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly title: string
+    readonly env: { readonly [x: string]: string }
+    readonly size?: { readonly cols: number; readonly rows: number }
+  }["title"]
+  readonly env: {
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly title: string
+    readonly env: { readonly [x: string]: string }
+    readonly size?: { readonly cols: number; readonly rows: number }
+  }["env"]
+  readonly size?: {
+    readonly command: string
+    readonly args: ReadonlyArray<string>
+    readonly cwd: string
+    readonly title: string
+    readonly env: { readonly [x: string]: string }
+    readonly size?: { readonly cols: number; readonly rows: number }
+  }["size"]
+}
+
+export type ServerPersistentPtyCreateOutput = { data: PersistentPtyInfo }["data"]
+
+export type ServerPersistentPtyShutdownOutput = void
+
+export type ServerPersistentPtyGetInput = { readonly ptyID: { readonly ptyID: string }["ptyID"] }
+
+export type ServerPersistentPtyGetOutput = { data: PersistentPtyInfo }["data"]
+
+export type ServerPersistentPtyUpdateInput = {
+  readonly ptyID: { readonly ptyID: string }["ptyID"]
+  readonly attachmentID?: {
+    readonly attachmentID?: string
+    readonly size: { readonly cols: number; readonly rows: number }
+  }["attachmentID"]
+  readonly size: {
+    readonly attachmentID?: string
+    readonly size: { readonly cols: number; readonly rows: number }
+  }["size"]
+}
+
+export type ServerPersistentPtyUpdateOutput = { data: PersistentPtyInfo }["data"]
+
+export type ServerPersistentPtySnapshotInput = { readonly ptyID: { readonly ptyID: string }["ptyID"] }
+
+export type ServerPersistentPtySnapshotOutput = { data: PersistentPtySnapshot }["data"]
+
+export type ServerPersistentPtyRemoveInput = { readonly ptyID: { readonly ptyID: string }["ptyID"] }
+
+export type ServerPersistentPtyRemoveOutput = void
+
+export type ServerPersistentPtyConnectTokenInput = { readonly ptyID: { readonly ptyID: string }["ptyID"] }
+
+export type ServerPersistentPtyConnectTokenOutput = { data: PtyTicketConnectToken }["data"]
+
+export type ServerPersistentPtyConnectInput = { readonly ptyID: { readonly ptyID: string }["ptyID"] }
+
+export type ServerPersistentPtyConnectOutput = boolean
+
 export type ShellListInput = {
   readonly location?: {
     readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined

packages/client/test/promise.test.ts

@@ -66,6 +66,7 @@ test("config.get returns ordered config entries for a location", async () => {
         ],
       },
     },
+    { type: "file" as const, path: "/tmp/project/opencode.json" },
   ]
   const client = OpenCode.make({
     baseUrl: "http://localhost:3000",
@@ -282,10 +283,10 @@ test("worktree methods use the global project contract", async () => {
   await client.worktree.refresh({ projectID: "proj_test" })
 
   expect(requests.map((request) => [request.method, request.url])).toEqual([
-    ["GET", "http://localhost:3000/api/worktree/proj_test"],
-    ["POST", "http://localhost:3000/api/worktree/proj_test"],
-    ["DELETE", "http://localhost:3000/api/worktree/proj_test"],
-    ["POST", "http://localhost:3000/api/worktree/proj_test/refresh"],
+    ["GET", "http://localhost:3000/api/experimental/project/proj_test/worktree"],
+    ["POST", "http://localhost:3000/api/experimental/project/proj_test/worktree"],
+    ["DELETE", "http://localhost:3000/api/experimental/project/proj_test/worktree"],
+    ["POST", "http://localhost:3000/api/experimental/project/proj_test/worktree/refresh"],
   ])
   expect(await requests[1]?.json()).toEqual({
     strategy: "git",

packages/core/src/config.ts

@@ -4,14 +4,13 @@ import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import path from "path"
 import { isDeepStrictEqual } from "node:util"
 import { type ParseError, parse } from "jsonc-parser"
-import { applyEdits, modify } from "jsonc-parser"
 import { Context, Effect, Layer, Option, PubSub, Ref, Schema, Semaphore, Stream } from "effect"
-import { produce, type Draft } from "immer"
 import {
   AgentsDirectory,
   ClaudeDirectory,
   Directory,
   Document,
+  File,
   Info,
   type Entry,
   Event,
@@ -37,8 +36,6 @@ export function latest<K extends keyof Info>(entries: readonly Entry[], key: K):
 export interface Interface {
   /** Returns location config documents and discovery sources from lowest to highest priority. */
   readonly entries: () => Effect.Effect<Entry[]>
-  /** Updates the first file-backed configuration document. */
-  readonly update: (update: (draft: Draft<Info>) => void) => Effect.Effect<Info, UpdateError>
   /**
    * Streams raw filesystem updates under config roots. Config owns root
    * topology and watch reconciliation; domain owners filter this feed for the
@@ -47,11 +44,6 @@ export interface Interface {
   readonly changes: () => Stream.Stream<Watcher.Update>
 }
 
-export class UpdateError extends Schema.TaggedErrorClass<UpdateError>()("Config.UpdateError", {
-  message: Schema.String,
-  cause: Schema.optional(Schema.Defect()),
-}) {}
-
 export const Options = Schema.Struct({
   project: Schema.optional(Schema.Boolean),
   file: Schema.optional(Schema.String),
@@ -78,19 +70,6 @@ export const testLayer = (initial: Entry[] = []) =>
       const updates = yield* PubSub.unbounded<Watcher.Update>()
       const service = Test.of({
         entries: () => Ref.get(entries),
-        update: (update) =>
-          Effect.gen(function* () {
-            const current = yield* Ref.get(entries)
-            const index = current.findIndex((entry) => entry.type === "document" && entry.path !== undefined)
-            if (index === -1)
-              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
-            const entry = current[index]
-            if (!entry || entry.type !== "document")
-              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
-            const info = produce(entry.info, update)
-            yield* Ref.set(entries, current.with(index, new Document({ type: "document", path: entry.path, info })))
-            return info
-          }),
         changes: () => Stream.fromPubSub(updates),
         setEntries: (next) => Ref.set(entries, next),
         emitChange: (update) => PubSub.publish(updates, update).pipe(Effect.asVoid),
@@ -112,7 +91,6 @@ export const layer = (options?: Options) =>
       const wellknown = yield* WellKnown.Service
       const names = ["opencode.json", "opencode.jsonc"]
       const reloadLock = Semaphore.makeUnsafe(1)
-      const fileTargets = new Set<AbsolutePath>()
       const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" } as const
       const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions)
       const parseInfo = Effect.fn("Config.parseInfo")(function* (text: string, source: string) {
@@ -153,7 +131,7 @@ export const layer = (options?: Options) =>
         const substituted = yield* ConfigVariable.substitute({ type: "path", path: filepath, text })
         const info = yield* parseInfo(substituted, filepath)
         if (!info) return
-        return new Document({ type: "document", path: AbsolutePath.make(filepath), info })
+        return new Document({ type: "document", path: filepath, info })
       })
 
       const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
@@ -246,18 +224,25 @@ export const layer = (options?: Options) =>
         const directPaths = discovered
           .filter((item) => ![".agents", ".claude", ".opencode"].includes(path.basename(item)))
           .toReversed()
-        fileTargets.clear()
-        directPaths.forEach((filepath) => fileTargets.add(AbsolutePath.make(filepath)))
-        const direct = yield* Effect.forEach(directPaths, (filepath) => loadFile(filepath)).pipe(
+        const direct = yield* Effect.forEach(directPaths, (filepath) =>
+          loadFile(filepath).pipe(
+            Effect.map((config) => [
+              ...(config ? [config] : []),
+              new File({ type: "file", path: AbsolutePath.make(filepath) }),
+            ]),
+          ),
+        ).pipe(
           Effect.orDie,
-          Effect.map((entries) => entries.filter((entry): entry is Document => entry !== undefined)),
+          Effect.map((entries) => entries.flat()),
         )
 
         const file = options?.file
-        if (file) fileTargets.add(AbsolutePath.make(path.resolve(file)))
         const explicit = file
           ? yield* loadFile(path.resolve(file)).pipe(
-              Effect.map((config) => (config ? [config] : [])),
+              Effect.map((config) => [
+                ...(config ? [config] : []),
+                new File({ type: "file", path: AbsolutePath.make(path.resolve(file)) }),
+              ]),
               Effect.orDie,
             )
           : []
@@ -300,10 +285,7 @@ export const layer = (options?: Options) =>
       const watched = new Set<string>()
       const reconcile = Effect.fn("Config.reconcileWatches")(function* (entries: readonly Entry[]) {
         const directories = entries.flatMap((entry) => (entry.type === "directory" ? [entry.path] : []))
-        const files = [
-          ...entries.flatMap((entry) => (entry.type === "document" && entry.path ? [entry.path] : [])),
-          ...fileTargets,
-        ]
+        const files = entries.flatMap((entry) => (entry.type === "file" ? [entry.path] : []))
         const targets = [
           ...directories.map((path) => ({ path, type: "directory" as const, ignore })),
           ...files
@@ -326,9 +308,9 @@ export const layer = (options?: Options) =>
         reloadLock.withPermit(
           Effect.gen(function* () {
             const next = yield* discover()
-            yield* reconcile(next)
             if (isDeepStrictEqual(configs, next)) return
             configs = next
+            yield* reconcile(next)
             yield* bus.publish(Event.Updated, {})
           }),
         ),
@@ -382,54 +364,10 @@ export const layer = (options?: Options) =>
       )
       yield* reconcile(initial)
 
-      const update = Effect.fn("Config.update")((mutate: (draft: Draft<Info>) => void) =>
-        reloadLock.withPermit(
-          Effect.gen(function* () {
-            // TODO: Replace entry-order selection with an explicit config scope/target model.
-            const document = configs.find((entry) => entry.type === "document" && entry.path !== undefined)
-            if (!document || document.type !== "document" || !document.path)
-              return yield* Effect.fail(new UpdateError({ message: "No editable config document found" }))
-            const next = yield* Effect.try({
-              try: () => produce(document.info, mutate),
-              catch: (cause) => new UpdateError({ message: "Config update failed", cause }),
-            })
-            const edits = changes(document.info, next)
-            if (!edits.length) return document.info
-            const text = yield* fs
-              .readFileString(document.path)
-              .pipe(
-                Effect.mapError(
-                  (cause) => new UpdateError({ message: `Failed to read config: ${document.path}`, cause }),
-                ),
-              )
-            const updated = edits.reduce(
-              (text, edit) =>
-                applyEdits(
-                  text,
-                  modify(text, edit.path, edit.value, { formattingOptions: { tabSize: 2, insertSpaces: true } }),
-                ),
-              text,
-            )
-            const info = yield* parseInfo(updated, document.path)
-            if (!info)
-              return yield* Effect.fail(new UpdateError({ message: `Invalid config update: ${document.path}` }))
-            const temporary = document.path + ".tmp"
-            yield* fs.writeFileString(temporary, updated.endsWith("\n") ? updated : updated + "\n").pipe(
-              Effect.andThen(fs.rename(temporary, document.path)),
-              Effect.mapError(
-                (cause) => new UpdateError({ message: `Failed to write config: ${document.path}`, cause }),
-              ),
-            )
-            return info
-          }),
-        ),
-      )
-
       return Service.of({
         entries: Effect.fn("Config.entries")(function* () {
           return configs
         }),
-        update,
         changes: () => Stream.fromPubSub(updates),
       })
     }),
@@ -444,26 +382,3 @@ export function configured(options?: Options) {
 }
 
 export const node = configured()
-
-type Edit = { readonly path: (string | number)[]; readonly value: unknown }
-
-function changes(before: unknown, after: unknown, path: (string | number)[] = []): Edit[] {
-  if (Object.is(before, after)) return []
-  if (
-    before !== null &&
-    after !== null &&
-    typeof before === "object" &&
-    typeof after === "object" &&
-    !Array.isArray(before) &&
-    !Array.isArray(after)
-  ) {
-    const previous = before as Record<string, unknown>
-    const next = after as Record<string, unknown>
-    return [...new Set([...Object.keys(previous), ...Object.keys(next)])].flatMap((key) => {
-      if (!(key in next)) return [{ path: [...path, key], value: undefined }]
-      if (!(key in previous)) return [{ path: [...path, key], value: next[key] }]
-      return changes(previous[key], next[key], [...path, key])
-    })
-  }
-  return [{ path, value: after }]
-}

packages/core/src/config/plugin/agent.ts

@@ -16,7 +16,6 @@ import { Permission } from "../../permission.js"
 import type { LocationMutation } from "../../location-mutation.js"
 import type { ReadTool } from "../../tool/plugin/read.js"
 import type { EditTool } from "../../tool/plugin/edit.js"
-import { AbsolutePath } from "../../schema.js"
 
 const legacySources = [
   { pattern: "{agent,agents}/**/*.md", primary: false },
@@ -211,5 +210,5 @@ function decode(file: { directory: string; filepath: string; primary: boolean },
     }),
   )
   if (!info) return
-  return new Document({ type: "document", path: AbsolutePath.make(file.filepath), info })
+  return new Document({ type: "document", path: file.filepath, info })
 }

packages/core/src/config/plugin/websearch.ts

@@ -10,9 +10,8 @@ export const Plugin = define({
     const config = yield* Config.Service
     const loaded = { entries: yield* config.entries() }
     yield* ctx.websearch.transform((websearch) => {
-      const selection = Config.latest(loaded.entries, "websearch")
-      if (selection === false) websearch.default.set(false)
-      if (selection) websearch.default.set(selection.provider)
+      const providerID = Config.latest(loaded.entries, "websearch")?.provider
+      if (providerID) websearch.default.set(providerID)
     })
     yield* ctx.event.subscribe().pipe(
       Stream.filter((event) => event.type === "config.updated"),

packages/core/src/persistent-pty.ts

@@ -0,0 +1,2 @@
+export { PersistentPty } from "./persistent-pty/index.js"
+export { Group } from "./persistent-pty/group.js"

packages/core/src/persistent-pty/group.ts

@@ -0,0 +1,103 @@
+export * as Group from "./group.js"
+
+import { Group } from "@opencode-ai/schema/group"
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
+import { Context, Effect, Layer, Schema, Semaphore } from "effect"
+import { Bus } from "../bus.js"
+import { KV } from "../kv.js"
+
+export const ID = Group.ID
+export type ID = Group.ID
+export const Item = Group.Item
+export type Item = Group.Item
+export const Info = Group.Info
+export type Info = Group.Info
+export const Event = Group.Event
+
+export interface Interface {
+  readonly list: () => Effect.Effect<ReadonlyArray<Info>>
+  readonly get: (id: ID) => Effect.Effect<Info | undefined>
+  readonly create: (items?: ReadonlyArray<Item>) => Effect.Effect<Info>
+  readonly set: (group: Info) => Effect.Effect<void>
+  readonly remove: (id: ID) => Effect.Effect<void>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/Group") {}
+
+const key = "group:v1"
+const Document = Schema.Array(Info)
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const kv = yield* KV.Service
+    const bus = yield* Bus.Service
+    const lock = Semaphore.makeUnsafe(1)
+
+    const list = Effect.fn("Group.list")(function* () {
+      const value = yield* kv.get(key)
+      return Schema.is(Document)(value) ? value : []
+    })
+
+    return Service.of({
+      list,
+      get: Effect.fn("Group.get")(function* (id) {
+        return (yield* list()).find((group) => group.id === id)
+      }),
+      create: Effect.fn("Group.create")(function* (items = []) {
+        return yield* lock.withPermit(
+          Effect.gen(function* () {
+            const group = Info.make({ id: ID.create(), items: Array.from(items) })
+            yield* kv.set(key, (yield* list()).concat(group))
+            return group
+          }),
+        )
+      }),
+      set: Effect.fn("Group.set")(function* (group) {
+        yield* lock.withPermit(
+          Effect.gen(function* () {
+            const groups = yield* list()
+            const index = groups.findIndex((item) => item.id === group.id)
+            yield* kv.set(
+              key,
+              index === -1 ? groups.concat(group) : groups.map((item) => (item.id === group.id ? group : item)),
+            )
+            const previous = groups[index]
+            if (!previous) return
+            yield* Effect.forEach(
+              group.items.filter(
+                (item) => !previous.items.some((current) => current.type === item.type && current.id === item.id),
+              ),
+              (item) => bus.publish(Event.ItemAdded, { groupID: group.id, item }),
+              { discard: true },
+            )
+            yield* Effect.forEach(
+              previous.items.filter(
+                (item) => !group.items.some((next) => next.type === item.type && next.id === item.id),
+              ),
+              (item) => bus.publish(Event.ItemRemoved, { groupID: group.id, item }),
+              { discard: true },
+            )
+          }),
+        )
+      }),
+      remove: Effect.fn("Group.remove")(function* (id) {
+        yield* lock.withPermit(
+          Effect.gen(function* () {
+            const groups = yield* list()
+            const group = groups.find((group) => group.id === id)
+            yield* kv.set(key, groups.filter((group) => group.id !== id))
+            if (!group) return
+            yield* Effect.forEach(
+              group.items,
+              (item) => bus.publish(Event.ItemRemoved, { groupID: id, item }),
+              { discard: true },
+            )
+          }),
+        )
+      }),
+    })
+  }),
+)
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [KV.node, Bus.node] })

packages/core/src/persistent-pty/index.ts

@@ -0,0 +1,736 @@
+export * as PersistentPty from "./index.js"
+
+import { spawn } from "node:child_process"
+import { createHash } from "node:crypto"
+import { readFile } from "node:fs/promises"
+import net from "node:net"
+import os from "node:os"
+import path from "node:path"
+import { setTimeout } from "node:timers/promises"
+import { Context, Effect, Layer, Schema } from "effect"
+import { makeGlobalNode } from "@opencode-ai/util/effect/app-node"
+import { Group } from "./group.js"
+import { Database } from "../database/database.js"
+import { Pty } from "@opencode-ai/schema/pty"
+
+const ProtocolVersion = 4
+const MaxFrameBytes = 8 * 1024 * 1024
+
+const Lifecycle = Schema.Union([
+  Schema.Struct({ status: Schema.Literal("running") }),
+  Schema.Struct({ status: Schema.Literal("exited"), exit_code: Schema.NullOr(Schema.Number) }),
+  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String }),
+])
+
+const WireTerminal = Schema.Struct({
+  id: Schema.Number,
+  pid: Schema.NullOr(Schema.Number),
+  title: Schema.String,
+  group_id: Schema.String,
+  command: Schema.Array(Schema.String),
+  cwd: Schema.String,
+  cols: Schema.Number,
+  rows: Schema.Number,
+  lifecycle: Lifecycle,
+  output_head: Schema.Number,
+  output_tail: Schema.Number,
+})
+
+const Registration = Schema.Struct({
+  instance_id: Schema.String,
+  pid: Schema.Number,
+  protocol: Schema.Number,
+  socket: Schema.String,
+  token: Schema.String,
+})
+
+const Response = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("pong"),
+    instance_id: Schema.String,
+    pid: Schema.Number,
+    protocol: Schema.Number,
+  }),
+  Schema.Struct({ type: Schema.Literal("created"), terminal: WireTerminal }),
+  Schema.Struct({ type: Schema.Literal("terminals"), terminals: Schema.Array(WireTerminal) }),
+  Schema.Struct({ type: Schema.Literal("ok") }),
+  Schema.Struct({
+    type: Schema.Literal("snapshot"),
+    terminal: WireTerminal,
+    text: Schema.String,
+    checkpoint_base64: Schema.String,
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("attached"),
+    terminal: WireTerminal,
+    role: Schema.Literals(["controller", "observer"]),
+    generation: Schema.Number,
+    requested_offset: Schema.Number,
+    available_offset: Schema.Number,
+    end_offset: Schema.Number,
+    truncated: Schema.Boolean,
+    replay_base64: Schema.String,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("resized"),
+    cols: Schema.Number,
+    rows: Schema.Number,
+    generation: Schema.Number,
+    checkpoint_base64: Schema.String,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("exited"),
+    exit_code: Schema.NullOr(Schema.Number),
+    final_offset: Schema.Number,
+  }),
+  Schema.Struct({
+    type: Schema.Literal("controller_changed"),
+    attachment_id: Schema.NullOr(Schema.String),
+    generation: Schema.Number,
+  }),
+  Schema.Struct({ type: Schema.Literal("error"), message: Schema.String }),
+])
+
+type WireTerminal = typeof WireTerminal.Type
+type WireResponse = typeof Response.Type
+type Registration = typeof Registration.Type
+
+export type Role = "controller" | "observer"
+
+export type Info = Pty.Info & {
+  readonly groupID: Group.ID
+  readonly size: { readonly cols: number; readonly rows: number }
+  readonly output: { readonly head: number; readonly tail: number }
+}
+
+export type Snapshot = {
+  readonly info: Info
+  readonly text: string
+  readonly checkpoint: Uint8Array
+  readonly cursor: { readonly x: number; readonly y: number }
+}
+
+export type StreamEvent =
+  | { readonly type: "output"; readonly start: number; readonly end: number; readonly data: Uint8Array }
+  | {
+      readonly type: "resized"
+      readonly cols: number
+      readonly rows: number
+      readonly generation: number
+      readonly checkpoint: Uint8Array
+    }
+  | { readonly type: "exited"; readonly exitCode?: number; readonly finalOffset: number }
+  | { readonly type: "controller_changed"; readonly attachmentID?: string; readonly generation: number }
+
+export type Attachment = {
+  readonly info: Info
+  readonly role: Role
+  readonly generation: number
+  readonly replay: {
+    readonly requestedOffset: number
+    readonly availableOffset: number
+    readonly endOffset: number
+    readonly truncated: boolean
+    readonly data: Uint8Array
+  }
+  readonly activate: () => void
+  readonly detach: () => void
+}
+
+export class UnavailableError extends Schema.TaggedErrorClass<UnavailableError>()("PersistentPty.UnavailableError", {
+  message: Schema.String,
+}) {}
+
+export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("PersistentPty.NotFoundError", {
+  ptyID: Pty.ID,
+}) {}
+
+export class GroupNotFoundError extends Schema.TaggedErrorClass<GroupNotFoundError>()(
+  "PersistentPty.GroupNotFoundError",
+  { groupID: Group.ID },
+) {}
+
+export interface Interface {
+  readonly list: (groupID?: Group.ID) => Effect.Effect<Info[], UnavailableError>
+  readonly get: (id: Pty.ID) => Effect.Effect<Info, NotFoundError | UnavailableError>
+  readonly create: (
+    groupID: Group.ID,
+    input: {
+      readonly command: string
+      readonly args: readonly string[]
+      readonly cwd: string
+      readonly title: string
+      readonly env: Readonly<Record<string, string>>
+      readonly cols?: number
+      readonly rows?: number
+    },
+  ) => Effect.Effect<Info, GroupNotFoundError | UnavailableError>
+  readonly write: (
+    id: Pty.ID,
+    data: string,
+    attachmentID?: string,
+  ) => Effect.Effect<void, NotFoundError | UnavailableError>
+  readonly resize: (
+    id: Pty.ID,
+    cols: number,
+    rows: number,
+    attachmentID?: string,
+  ) => Effect.Effect<void, NotFoundError | UnavailableError>
+  readonly control: (
+    id: Pty.ID,
+    attachmentID: string,
+    cols: number,
+    rows: number,
+  ) => Effect.Effect<void, NotFoundError | UnavailableError>
+  readonly input: (
+    id: Pty.ID,
+    attachmentID: string,
+    cols: number,
+    rows: number,
+    data: Uint8Array,
+  ) => Effect.Effect<void, NotFoundError | UnavailableError>
+  readonly snapshot: (id: Pty.ID) => Effect.Effect<Snapshot, NotFoundError | UnavailableError>
+  readonly remove: (id: Pty.ID) => Effect.Effect<void, NotFoundError | UnavailableError>
+  readonly shutdown: () => Effect.Effect<void, UnavailableError>
+  readonly attach: (
+    id: Pty.ID,
+    input: {
+      readonly cursor: number
+      readonly attachmentID: string
+      readonly role: Role
+      readonly takeover?: boolean
+      readonly onEvent: (event: StreamEvent) => void
+      readonly onEnd: () => void
+    },
+  ) => Effect.Effect<Attachment, NotFoundError | UnavailableError>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/PersistentPty") {}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const groups = yield* Group.Service
+    const database = yield* Database.Service
+    const context = yield* Effect.context()
+    const runFork = Effect.runForkWith(context)
+    const client = new Client(runtimeDirectory(databasePath(database.db)))
+    const removing = new Set<Pty.ID>()
+
+    const list = Effect.fn("PersistentPty.list")(function* (groupID?: Group.ID) {
+      const response = yield* optionalRequest(client, { op: "list" })
+      if (!response) return []
+      if (response.type !== "terminals") return yield* unexpected(response)
+      return response.terminals
+        .map(toInfo)
+        .filter((terminal) => groupID === undefined || terminal.groupID === groupID)
+    })
+
+    const get = Effect.fn("PersistentPty.get")(function* (id: Pty.ID) {
+      const found = (yield* list()).find((terminal) => terminal.id === id)
+      if (!found) return yield* new NotFoundError({ ptyID: id })
+      return found
+    })
+
+    const create = Effect.fn("PersistentPty.create")(function* (
+      groupID: Group.ID,
+      input: {
+        readonly command: string
+        readonly args: readonly string[]
+        readonly cwd: string
+        readonly title: string
+        readonly env: Readonly<Record<string, string>>
+        readonly cols?: number
+        readonly rows?: number
+      },
+    ) {
+      const group = yield* groups.get(groupID)
+      if (!group) return yield* new GroupNotFoundError({ groupID })
+      const response = yield* request(client, {
+        op: "create",
+        program: input.command,
+        args: input.args,
+        cwd: input.cwd,
+        title: input.title,
+        group_id: groupID,
+        env: input.env,
+        cols: input.cols ?? 80,
+        rows: input.rows ?? 24,
+      }, true)
+      if (response.type !== "created") return yield* unexpected(response)
+      const terminal = toInfo(response.terminal)
+      yield* groups.set(
+        Group.Info.make({
+          id: group.id,
+          items: group.items.concat({ type: "terminal", id: terminal.id }),
+        }),
+      )
+      return terminal
+    })
+
+    const write = Effect.fn("PersistentPty.write")(function* (
+      id: Pty.ID,
+      data: string,
+      attachmentID?: string,
+    ) {
+      yield* get(id)
+      const response = yield* request(client, {
+        op: "write",
+        id: fromID(id),
+        attachment_id: attachmentID ?? null,
+        data_base64: Buffer.from(data).toString("base64"),
+      })
+      if (response.type !== "ok") return yield* unexpected(response)
+      return undefined
+    })
+
+    const resize = Effect.fn("PersistentPty.resize")(function* (
+      id: Pty.ID,
+      cols: number,
+      rows: number,
+      attachmentID?: string,
+    ) {
+      yield* get(id)
+      const response = yield* request(client, {
+        op: "resize",
+        id: fromID(id),
+        attachment_id: attachmentID ?? null,
+        cols,
+        rows,
+      })
+      if (response.type !== "ok") return yield* unexpected(response)
+      return undefined
+    })
+
+    const control = Effect.fn("PersistentPty.control")(function* (
+      id: Pty.ID,
+      attachmentID: string,
+      cols: number,
+      rows: number,
+    ) {
+      yield* get(id)
+      const response = yield* request(client, {
+        op: "control",
+        id: fromID(id),
+        attachment_id: attachmentID,
+        cols,
+        rows,
+      })
+      if (response.type !== "ok") return yield* unexpected(response)
+      return undefined
+    })
+
+    const input = Effect.fn("PersistentPty.input")(function* (
+      id: Pty.ID,
+      attachmentID: string,
+      cols: number,
+      rows: number,
+      data: Uint8Array,
+    ) {
+      yield* get(id)
+      const response = yield* request(client, {
+        op: "input",
+        id: fromID(id),
+        attachment_id: attachmentID,
+        cols,
+        rows,
+        data_base64: Buffer.from(data).toString("base64"),
+      })
+      if (response.type !== "ok") return yield* unexpected(response)
+      return undefined
+    })
+
+    const snapshot = Effect.fn("PersistentPty.snapshot")(function* (id: Pty.ID) {
+      yield* get(id)
+      const response = yield* request(client, { op: "snapshot", id: fromID(id) })
+      if (response.type !== "snapshot") return yield* unexpected(response)
+      return {
+        info: toInfo(response.terminal),
+        text: response.text,
+        checkpoint: Buffer.from(response.checkpoint_base64, "base64"),
+        cursor: { x: response.cursor_x, y: response.cursor_y },
+      }
+    })
+
+    const remove = Effect.fn("PersistentPty.remove")(function* (id: Pty.ID) {
+      const terminal = yield* get(id)
+      const response = yield* request(client, { op: "terminate", id: fromID(id) })
+      if (response.type !== "ok") return yield* unexpected(response)
+      const group = yield* groups.get(terminal.groupID)
+      if (!group) return undefined
+      yield* groups.set(
+        Group.Info.make({
+          id: group.id,
+          items: group.items.filter((item) => item.type !== "terminal" || item.id !== id),
+        }),
+      )
+      return undefined
+    })
+
+    const shutdown = Effect.fn("PersistentPty.shutdown")(function* () {
+      const response = yield* Effect.tryPromise({ try: () => client.shutdown(), catch: unavailable })
+      if (!response) return
+      if (response.type !== "ok") return yield* unexpected(response)
+    })
+
+    const removeVisibleExit = (id: Pty.ID) => {
+      if (removing.has(id)) return
+      removing.add(id)
+      runFork(
+        remove(id).pipe(
+          Effect.catchTags({
+            "PersistentPty.NotFoundError": () => Effect.void,
+            "PersistentPty.UnavailableError": (error) =>
+              Effect.logWarning("failed to remove visible exited terminal", { id, error: error.message }),
+          }),
+          Effect.ensuring(Effect.sync(() => removing.delete(id))),
+        ),
+      )
+    }
+
+    const attach = Effect.fn("PersistentPty.attach")(function* (
+      id: Pty.ID,
+      input: {
+        readonly cursor: number
+        readonly attachmentID: string
+        readonly role: Role
+        readonly takeover?: boolean
+        readonly onEvent: (event: StreamEvent) => void
+        readonly onEnd: () => void
+      },
+    ) {
+      yield* get(id)
+      return yield* Effect.tryPromise({
+        try: () =>
+          client.subscribe(fromID(id), {
+            ...input,
+            onEvent: (event) => {
+              if (event.type === "exited") removeVisibleExit(id)
+              input.onEvent(event)
+            },
+          }),
+        catch: (error) => unavailable(error),
+      })
+    })
+
+    return Service.of({ list, get, create, write, resize, control, input, snapshot, remove, shutdown, attach })
+  }),
+)
+
+export const node = makeGlobalNode({ service: Service, layer, deps: [Group.node, Database.node] })
+
+class Client {
+  private registration?: Promise<Registration>
+
+  constructor(private readonly directory: string) {}
+
+  request(value: object, start = false): Promise<WireResponse> {
+    return this.connect(start)
+      .then((registration) => oneShot(registration, value))
+      .catch((error) => {
+        if (!(error instanceof ConnectError)) throw error
+        this.registration = undefined
+        if (!start) throw error
+        return this.connect(true).then((registration) => oneShot(registration, value))
+      })
+  }
+
+  requestIfRunning(value: object) {
+    return this.request(value).catch(() => undefined)
+  }
+
+  async shutdown() {
+    const response = await this.requestIfRunning({ op: "shutdown" })
+    this.registration = undefined
+    if (!response) return
+    const deadline = Date.now() + 5_000
+    while (Date.now() < deadline) {
+      const running = await discover(this.directory).then(
+        () => true,
+        () => false,
+      )
+      if (!running) return response
+      await setTimeout(50)
+    }
+    throw new Error("opencode-pty did not stop")
+  }
+
+  async subscribe(
+    id: number,
+    input: {
+      readonly cursor: number
+      readonly attachmentID: string
+      readonly role: Role
+      readonly takeover?: boolean
+      readonly onEvent: (event: StreamEvent) => void
+      readonly onEnd: () => void
+    },
+  ): Promise<Attachment> {
+    const registration = await this.connect(false)
+    const socket = net.createConnection(registration.socket)
+    const frames = decoder(socket)
+    await connected(socket)
+    socket.write(
+      encode({
+        token: registration.token,
+        request: {
+          op: "subscribe",
+          id,
+          offset: input.cursor,
+          attachment_id: input.attachmentID,
+          role: input.role,
+          takeover: input.takeover ?? false,
+        },
+      }),
+    )
+    const initial = await frames.next()
+    if (initial.done) throw new Error("opencode-pty closed before attachment")
+    const response = decode(initial.value)
+    if (response.type === "error") throw new Error(response.message)
+    if (response.type !== "attached") throw new Error(`unexpected opencode-pty response: ${response.type}`)
+    let detached = false
+    const pump = async () => {
+      try {
+        for await (const frame of frames) {
+          if (frame[0] === 0) {
+            if (frame.length < 17) throw new Error("invalid opencode-pty output frame")
+            input.onEvent({
+              type: "output",
+              start: Number(frame.readBigUInt64BE(1)),
+              end: Number(frame.readBigUInt64BE(9)),
+              data: frame.subarray(17),
+            })
+            continue
+          }
+          const event = decode(frame)
+          if (event.type === "resized")
+            input.onEvent({
+              type: "resized",
+              cols: event.cols,
+              rows: event.rows,
+              generation: event.generation,
+              checkpoint: Buffer.from(event.checkpoint_base64, "base64"),
+            })
+          if (event.type === "controller_changed")
+            input.onEvent({
+              type: "controller_changed",
+              attachmentID: event.attachment_id ?? undefined,
+              generation: event.generation,
+            })
+          if (event.type === "exited") {
+            input.onEvent({
+              type: "exited",
+              exitCode: event.exit_code ?? undefined,
+              finalOffset: event.final_offset,
+            })
+            return
+          }
+        }
+      } finally {
+        if (!detached) input.onEnd()
+      }
+    }
+    let activated = false
+    return {
+      info: toInfo(response.terminal),
+      role: response.role,
+      generation: response.generation,
+      replay: {
+        requestedOffset: response.requested_offset,
+        availableOffset: response.available_offset,
+        endOffset: response.end_offset,
+        truncated: response.truncated,
+        data: Buffer.from(response.replay_base64, "base64"),
+      },
+      activate() {
+        if (activated || detached) return
+        activated = true
+        void pump().catch(() => {})
+      },
+      detach() {
+        if (detached) return
+        detached = true
+        socket.destroy()
+      },
+    }
+  }
+
+  private connect(start: boolean) {
+    this.registration ??= start ? ensure(this.directory) : discover(this.directory)
+    return this.registration.catch((error) => {
+      this.registration = undefined
+      throw error
+    })
+  }
+}
+
+const request = (client: Client, value: object, start = false) =>
+  Effect.tryPromise({ try: () => client.request(value, start), catch: (error) => unavailable(error) })
+
+const optionalRequest = (client: Client, value: object) =>
+  Effect.promise(() => client.requestIfRunning(value))
+
+const unexpected = (response: WireResponse) =>
+  Effect.fail(new UnavailableError({ message: `unexpected opencode-pty response: ${response.type}` }))
+
+const unavailable = (error: unknown) =>
+  new UnavailableError({ message: error instanceof Error ? error.message : String(error) })
+
+function databasePath(db: Database.Interface["db"]) {
+  const client: unknown = db.$client
+  if ((typeof client !== "object" && typeof client !== "function") || client === null || !("config" in client))
+    return undefined
+  const config = client.config
+  if (typeof config !== "object" || config === null || !("filename" in config)) return undefined
+  if (typeof config.filename !== "string" || config.filename === ":memory:") return undefined
+  return path.resolve(config.filename)
+}
+
+const runtimeDirectory = (databasePath?: string) => {
+  const root =
+    process.env.OPENCODE_PTY_RUNTIME_DIR ??
+    (process.env.XDG_RUNTIME_DIR
+      ? path.join(process.env.XDG_RUNTIME_DIR, "opencode-pty")
+      : path.join(
+          os.tmpdir(),
+          `opencode-pty-${typeof process.getuid === "function" ? process.getuid() : process.env.USER || "unknown"}`,
+        ))
+  const identity = databasePath ?? `memory:${crypto.randomUUID()}`
+  return path.join(root, createHash("sha256").update(identity).digest("hex").slice(0, 16))
+}
+
+const registrationPath = (directory: string) => path.join(directory, "service.json")
+
+async function ensure(directory: string) {
+  const found = await discover(directory).catch(() => undefined)
+  if (found) return found
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(process.env.OPENCODE_PTY_BIN || "opencode-pty", ["daemon"], {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, OPENCODE_PTY_RUNTIME_DIR: directory },
+    })
+    child.once("spawn", () => {
+      child.unref()
+      resolve()
+    })
+    child.once("error", reject)
+  })
+  const deadline = Date.now() + 5_000
+  let last: unknown
+  while (Date.now() < deadline) {
+    try {
+      return await discover(directory)
+    } catch (error) {
+      last = error
+      await setTimeout(50)
+    }
+  }
+  throw last instanceof Error ? last : new Error("opencode-pty did not become ready")
+}
+
+async function discover(directory: string) {
+  const registration = Schema.decodeUnknownSync(Registration)(
+    JSON.parse(await readFile(registrationPath(directory), "utf8")),
+  )
+  if (registration.protocol !== ProtocolVersion) throw new Error("opencode-pty protocol mismatch")
+  const response = await oneShot(registration, { op: "ping" })
+  if (
+    response.type !== "pong" ||
+    response.instance_id !== registration.instance_id ||
+    response.pid !== registration.pid ||
+    response.protocol !== ProtocolVersion
+  )
+    throw new Error("opencode-pty registration mismatch")
+  return registration
+}
+
+async function oneShot(registration: Registration, request: object) {
+  const socket = net.createConnection(registration.socket)
+  const frames = decoder(socket)
+  await connected(socket).catch((cause) => {
+    socket.destroy()
+    throw new ConnectError(cause)
+  })
+  socket.write(encode({ token: registration.token, request }))
+  const first = await frames.next()
+  socket.end()
+  if (first.done) throw new Error("opencode-pty closed without response")
+  const response = decode(first.value)
+  if (response.type === "error") throw new Error(response.message)
+  return response
+}
+
+class ConnectError extends Error {
+  constructor(cause: unknown) {
+    super(cause instanceof Error ? cause.message : String(cause))
+  }
+}
+
+function connected(socket: net.Socket) {
+  return new Promise<void>((resolve, reject) => {
+    socket.once("connect", resolve)
+    socket.once("error", reject)
+  })
+}
+
+function encode(value: unknown) {
+  const payload = Buffer.from(JSON.stringify(value))
+  if (payload.length > MaxFrameBytes) throw new Error("opencode-pty frame too large")
+  const output = Buffer.allocUnsafe(payload.length + 4)
+  output.writeUInt32BE(payload.length)
+  payload.copy(output, 4)
+  return output
+}
+
+async function* decoder(socket: net.Socket) {
+  let pending = Buffer.alloc(0)
+  for await (const value of socket) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value)
+    pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk])
+    while (pending.length >= 4) {
+      const length = pending.readUInt32BE(0)
+      if (length > MaxFrameBytes) throw new Error("opencode-pty frame too large")
+      if (pending.length < length + 4) break
+      yield pending.subarray(4, length + 4)
+      pending = pending.subarray(length + 4)
+    }
+  }
+  if (pending.length !== 0) throw new Error("opencode-pty truncated frame")
+}
+
+function decode(payload: Uint8Array) {
+  return Schema.decodeUnknownSync(Response)(JSON.parse(Buffer.from(payload).toString("utf8")))
+}
+
+function toInfo(value: WireTerminal): Info {
+  const status = value.lifecycle.status
+  return {
+    ...Pty.Info.make({
+      id: toID(value.id),
+      title: value.title,
+      command: value.command[0] || "",
+      args: value.command.slice(1),
+      cwd: value.cwd,
+      status: status === "running" ? "running" : "exited",
+      pid: value.pid ?? 0,
+      ...(status === "exited" ? { exitCode: value.lifecycle.exit_code ?? undefined } : {}),
+    }),
+    groupID: Group.ID.make(value.group_id),
+    size: { cols: value.cols, rows: value.rows },
+    output: { head: value.output_head, tail: value.output_tail },
+  }
+}
+
+function toID(value: number) {
+  return Pty.ID.make(`pty_persistent_${value}`)
+}
+
+function fromID(value: Pty.ID) {
+  if (!value.startsWith("pty_persistent_")) throw new Error(`invalid persistent PTY ID: ${value}`)
+  const parsed = Number(value.slice("pty_persistent_".length))
+  if (!Number.isSafeInteger(parsed) || parsed < 1) throw new Error(`invalid persistent PTY ID: ${value}`)
+  return parsed
+}

packages/core/src/plugin/host.ts

@@ -332,10 +332,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: import("../p
               }),
             default: {
               get: draft.default.get,
-              set: (selection) =>
-                draft.default.set(
-                  selection === false || selection === "random" ? selection : WebSearch.ID.make(selection),
-                ),
+              set: (providerID) => draft.default.set(WebSearch.ID.make(providerID)),
             },
           })
         }),

packages/core/src/plugin/promise.ts

@@ -1,3 +1,396 @@
 export * as PluginPromise from "./promise.js"
 
-export { fromPromise } from "@opencode-ai/plugin/promise/adapter"
+import { define } from "@opencode-ai/plugin/effect/plugin"
+import type { Context, Plugin } from "@opencode-ai/plugin/promise/plugin"
+import type { Info } from "@opencode-ai/plugin/promise/tool"
+import { Agent } from "@opencode-ai/schema/agent"
+import { Integration } from "@opencode-ai/schema/integration"
+import { Location } from "@opencode-ai/schema/location"
+import { Model } from "@opencode-ai/schema/model"
+import { Provider } from "@opencode-ai/schema/provider"
+import { AbsolutePath } from "@opencode-ai/schema/schema"
+import { Session } from "@opencode-ai/schema/session"
+import { SessionMessage } from "@opencode-ai/schema/session-message"
+import { Skill } from "@opencode-ai/schema/skill"
+import { Workspace } from "@opencode-ai/schema/workspace"
+import { WebSearch } from "@opencode-ai/schema/websearch"
+import { DateTime, Effect, Scope, Stream } from "effect"
+import { Tool } from "../tool.js"
+
+type HostRegistration = { readonly dispose: Effect.Effect<void> }
+type Registration = { readonly dispose: () => Promise<void> }
+type PromiseEvent = ReturnType<Context["event"]["subscribe"]> extends AsyncIterable<infer Event> ? Event : never
+type JsonValue = null | boolean | number | string | Array<JsonValue> | { [key: string]: JsonValue }
+
+/**
+ * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
+ * loader (`Plugin` / `PluginSupervisor`) can run it unchanged.
+ *
+ * Hook registrations created during the async `setup` attach to the plugin's
+ * scope, so unloading the plugin disposes them. The captured fiber context
+ * preserves boot-time batching, so Promise-plugin transforms still coalesce
+ * into one reload per domain.
+ */
+export function fromPromise(plugin: Plugin) {
+  return define({
+    id: plugin.id,
+    effect: (host) =>
+      Effect.gen(function* () {
+        const scope = yield* Scope.Scope
+        const context = yield* Effect.context<Scope.Scope>()
+
+        // Run a hook registration on the plugin scope and resolve once it is registered.
+        const register = (effect: Effect.Effect<HostRegistration, never, Scope.Scope>): Promise<Registration> =>
+          Effect.runPromiseWith(context)(Scope.provide(scope)(effect)).then((registration) => ({
+            dispose: () => Effect.runPromiseWith(context)(registration.dispose),
+          }))
+
+        const run = <A, E>(effect: Effect.Effect<A, E>) => Effect.runPromiseWith(context)(effect).then(wire)
+
+        const transform =
+          <Draft>(domain: {
+            transform: (callback: (draft: Draft) => void) => Effect.Effect<HostRegistration, never, Scope.Scope>
+          }) =>
+          (callback: (draft: Draft) => void) =>
+            register(
+              domain.transform((draft) => {
+                callback(draft)
+              }),
+            )
+
+        const context2: Context = {
+          app: host.app,
+          options: host.options,
+          agent: {
+            get: (input) => run(host.agent.get({ ...input, agentID: Agent.ID.make(input.agentID) })),
+            list: (input) => run(host.agent.list(input)),
+            transform: transform(host.agent),
+            reload: () => run(host.agent.reload()),
+          },
+          aisdk: {
+            hook: (name, callback) =>
+              register(host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+          },
+          catalog: {
+            provider: {
+              list: (input) => run(host.catalog.provider.list(input)),
+              get: (input) =>
+                run(host.catalog.provider.get({ ...input, providerID: Provider.ID.make(input.providerID) })),
+            },
+            model: {
+              list: (input) => run(host.catalog.model.list(input)),
+              default: (input) =>
+                run(host.catalog.model.default(input)).then((result) => ({ ...result, data: result.data ?? null })),
+            },
+            transform: transform(host.catalog),
+            reload: () => run(host.catalog.reload()),
+          },
+          command: {
+            list: (input) => run(host.command.list(input)),
+            transform: transform(host.command),
+            reload: () => run(host.command.reload()),
+          },
+          event: {
+            subscribe: () => Stream.toAsyncIterable(host.event.subscribe().pipe(Stream.map(wireEvent))),
+          },
+          integration: {
+            list: (input) => run(host.integration.list(input)),
+            get: (input) =>
+              run(host.integration.get({ ...input, integrationID: Integration.ID.make(input.integrationID) })).then(
+                (result) => ({ ...result, data: result.data ?? null }),
+              ),
+            connect: {
+              key: (input) =>
+                run(
+                  host.integration.connect.key({ ...input, integrationID: Integration.ID.make(input.integrationID) }),
+                ),
+            },
+            oauth: {
+              connect: (input) =>
+                run(
+                  host.integration.oauth.connect({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    methodID: Integration.MethodID.make(input.methodID),
+                  }),
+                ),
+              status: (input) =>
+                run(
+                  host.integration.oauth.status({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    attemptID: Integration.AttemptID.make(input.attemptID),
+                  }),
+                ),
+              complete: (input) =>
+                run(
+                  host.integration.oauth.complete({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    attemptID: Integration.AttemptID.make(input.attemptID),
+                  }),
+                ),
+              cancel: (input) =>
+                run(
+                  host.integration.oauth.cancel({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    attemptID: Integration.AttemptID.make(input.attemptID),
+                  }),
+                ),
+            },
+            command: {
+              connect: (input) =>
+                run(
+                  host.integration.command.connect({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    methodID: Integration.MethodID.make(input.methodID),
+                  }),
+                ),
+              status: (input) =>
+                run(
+                  host.integration.command.status({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    attemptID: Integration.AttemptID.make(input.attemptID),
+                  }),
+                ),
+              cancel: (input) =>
+                run(
+                  host.integration.command.cancel({
+                    ...input,
+                    integrationID: Integration.ID.make(input.integrationID),
+                    attemptID: Integration.AttemptID.make(input.attemptID),
+                  }),
+                ),
+            },
+            transform: (callback) =>
+              register(
+                host.integration.transform((draft) =>
+                  callback({
+                    list: draft.list,
+                    get: draft.get,
+                    update: draft.update,
+                    remove: draft.remove,
+                    method: {
+                      list: draft.method.list,
+                      update: (input) => {
+                        if (!("authorize" in input)) return draft.method.update(input)
+                        const refresh = input.refresh
+                        draft.method.update({
+                          ...input,
+                          authorize: (answer) =>
+                            Effect.promise(() => input.authorize(answer)).pipe(
+                              Effect.map((authorization) =>
+                                authorization.mode === "auto"
+                                  ? {
+                                      ...authorization,
+                                      callback: Effect.promise(() => authorization.callback),
+                                    }
+                                  : {
+                                      ...authorization,
+                                      callback: (code) => Effect.promise(() => authorization.callback(code)),
+                                    },
+                              ),
+                            ),
+                          refresh:
+                            refresh === undefined
+                              ? undefined
+                              : (credential) => Effect.promise(() => refresh(credential)),
+                        })
+                      },
+                      remove: draft.method.remove,
+                    },
+                  }),
+                ),
+              ),
+            reload: () => run(host.integration.reload()),
+            connection: {
+              active: (id) => Effect.runPromiseWith(context)(host.integration.connection.active(id)),
+              resolve: (connection) => Effect.runPromiseWith(context)(host.integration.connection.resolve(connection)),
+            },
+          },
+          plugin: {
+            list: (input) => run(host.plugin.list(input)),
+          },
+          reference: {
+            list: (input) => run(host.reference.list(input)),
+            transform: transform(host.reference),
+            reload: () => run(host.reference.reload()),
+          },
+          skill: {
+            list: (input) => run(host.skill.list(input)),
+            transform: transform(host.skill),
+            reload: () => run(host.skill.reload()),
+          },
+          tool: {
+            transform: (callback) =>
+              register(
+                host.tool.transform((draft) =>
+                  callback({
+                    add: (tool: Info) =>
+                      draft.add({
+                        ...tool,
+                        execute: (input, context) => executePromiseTool(tool, input, context),
+                      }),
+                  }),
+                ),
+              ),
+            hook: (name, callback) =>
+              register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+          },
+          websearch: {
+            providers: (input) => run(host.websearch.providers(input)),
+            query: (input) =>
+              run(
+                host.websearch.query({
+                  ...input,
+                  providerID: input.providerID === undefined ? undefined : WebSearch.ID.make(input.providerID),
+                }),
+              ),
+            reload: () => run(host.websearch.reload()),
+            transform: (callback) =>
+              register(
+                host.websearch.transform((draft) => {
+                  callback({
+                    add: (definition) =>
+                      draft.add({
+                        id: definition.id,
+                        name: definition.name,
+                        execute: (input) => attempt((signal) => definition.execute(input, { signal })),
+                      }),
+                    default: draft.default,
+                  })
+                }),
+              ),
+          },
+          session: {
+            hook: (name, callback) =>
+              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+            create: (input) =>
+              run(
+                host.session.create(
+                  input === undefined
+                    ? undefined
+                    : {
+                        id: input.id == null ? undefined : Session.ID.make(input.id),
+                        agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
+                        model: input.model == null ? undefined : model(input.model),
+                        location:
+                          input.location == null
+                            ? undefined
+                            : Location.Ref.make({
+                                directory: AbsolutePath.make(input.location.directory),
+                                workspaceID:
+                                  input.location.workspaceID === undefined
+                                    ? undefined
+                                    : Workspace.ID.make(input.location.workspaceID),
+                              }),
+                      },
+                ),
+              ),
+            get: (input) => run(host.session.get({ sessionID: Session.ID.make(input.sessionID) })),
+            prompt: (input) =>
+              run(
+                host.session.prompt({
+                  ...input,
+                  sessionID: Session.ID.make(input.sessionID),
+                  id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+                  skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
+                  delivery: input.delivery ?? undefined,
+                  resume: input.resume ?? undefined,
+                }),
+              ),
+            generate: (input) =>
+              run(host.session.generate({ sessionID: Session.ID.make(input.sessionID), prompt: input.prompt })),
+            command: (input) =>
+              run(
+                host.session.command({
+                  ...input,
+                  sessionID: Session.ID.make(input.sessionID),
+                  id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+                  agent: input.agent == null ? undefined : Agent.ID.make(input.agent),
+                  model: input.model == null ? undefined : model(input.model),
+                  skills: input.skills?.map((skill) => ({ ...skill, id: Skill.ID.make(skill.id) })),
+                  arguments: input.arguments ?? undefined,
+                  delivery: input.delivery ?? undefined,
+                  resume: input.resume ?? undefined,
+                }),
+              ),
+            synthetic: (input) =>
+              run(
+                host.session.synthetic({
+                  ...input,
+                  sessionID: Session.ID.make(input.sessionID),
+                  id: input.id == null ? undefined : SessionMessage.ID.make(input.id),
+                  description: input.description ?? undefined,
+                  delivery: input.delivery ?? undefined,
+                  resume: input.resume ?? undefined,
+                }),
+              ),
+            interrupt: (input) => run(host.session.interrupt({ sessionID: Session.ID.make(input.sessionID) })),
+          },
+          shell: {
+            hook: (name, callback) =>
+              register(host.shell.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
+          },
+        }
+
+        const cleanup = yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)))
+        if (!cleanup) return
+        yield* Effect.addFinalizer(() => Effect.promise(() => Promise.resolve(cleanup())))
+      }),
+  })
+}
+
+function attempt<A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) {
+  return Effect.tryPromise({ try: evaluate, catch: (cause) => cause })
+}
+
+function model(input: { readonly id: string; readonly providerID: string; readonly variant?: string }) {
+  return Model.Ref.make({
+    id: Model.ID.make(input.id),
+    providerID: Provider.ID.make(input.providerID),
+    variant: input.variant === undefined ? undefined : Model.VariantID.make(input.variant),
+  })
+}
+
+type Wire<Value> = unknown extends Value
+  ? JsonValue
+  : Value extends string | number | boolean | bigint | symbol | null | undefined
+    ? Value
+    : Value extends DateTime.DateTime
+      ? number
+      : Value extends readonly [infer Head, ...infer Tail]
+        ? [Wire<Head>, ...WireTuple<Tail>]
+        : Value extends ReadonlyArray<infer Item>
+          ? Array<Wire<Item>>
+          : Value extends object
+            ? { -readonly [Key in keyof Value]: Wire<Value[Key]> }
+            : Value
+
+type WireTuple<Value extends ReadonlyArray<unknown>> = {
+  -readonly [Key in keyof Value]: Wire<Value[Key]>
+}
+
+function wire<Value>(value: Value): Wire<Value>
+function wire(value: unknown): unknown {
+  if (DateTime.isDateTime(value)) return DateTime.toEpochMillis(value)
+  if (Array.isArray(value)) return value.map(wire)
+  if (typeof value !== "object" || value === null) return value
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, wire(item)]))
+}
+
+function wireEvent(value: unknown): PromiseEvent
+function wireEvent(value: unknown): unknown {
+  return wire(value)
+}
+
+const executePromiseTool = (tool: Info, input: any, context: Tool.Context) =>
+  Effect.promise(() =>
+    tool.execute(input, {
+      ...context,
+      progress: (update) => Effect.runPromise(context.progress(update)),
+    }),
+  )

packages/core/src/session/generate-node.ts

@@ -13,7 +13,7 @@ import { SessionHistory } from "./history.js"
 import { SessionModelHeaders } from "./model-headers.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
 import { SessionRunnerModel } from "./runner/model.js"
-import { SessionSystemPrompt } from "./system-prompt.js"
+import PROMPT_DEFAULT from "./runner/prompt/base.txt"
 import { toLLMMessages } from "./runner/to-llm-message.js"
 
 export const layer = Layer.effect(
@@ -39,12 +39,7 @@ export const layer = Layer.effect(
           sessionID: selection.session.id,
           agent: selection.agent.id,
           model: model.ref,
-          system: [
-            selection.agent.info.system
-              ? selection.agent.info.system
-              : SessionSystemPrompt.make(toolDefinitions.map((tool) => tool.name)),
-            history.initial,
-          ]
+          system: [selection.agent.info.system ? selection.agent.info.system : PROMPT_DEFAULT, history.initial]
             .filter((part) => part.length > 0)
             .map(SystemPart.make),
           messages: [

packages/core/src/session/model-request.ts

@@ -19,7 +19,7 @@ import { SessionModelTransport } from "./model-transport.js"
 import { SessionPromptCacheKey } from "./prompt-cache-key.js"
 import { PromptCacheDiagnostics } from "./prompt-cache-diagnostics.js"
 import { MAX_STEPS_PROMPT } from "./runner/max-steps.js"
-import { SessionSystemPrompt } from "./system-prompt.js"
+import PROMPT_DEFAULT from "./runner/prompt/base.txt"
 import { toLLMMessages } from "./runner/to-llm-message.js"
 
 const IMAGE_BYTES_TRIGGER = 25 * 1024 * 1024 // 25 MiB
@@ -190,10 +190,7 @@ export const layer = Layer.effect(
       // The final Step keeps definitions available to protocols with native "none",
       // preserving their prompt cache prefix. Calls are still rejected at execution.
       const tools = input.context.tools
-      const system = [
-        agent.info.system ? agent.info.system : SessionSystemPrompt.make(tools.definitions.map((tool) => tool.name)),
-        input.context.initial,
-      ]
+      const system = [agent.info.system ? agent.info.system : PROMPT_DEFAULT, input.context.initial]
         .filter((part) => part.length > 0)
         .map(SystemPart.make)
       const history = toLLMMessages(input.context.messages, resolved.ref, providerMetadataKey)

packages/core/src/session/runner/prompt/base.txt

@@ -0,0 +1,95 @@
+You are opencode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+IMPORTANT: You must NEVER generate or guess URLs for the user unless you are confident that the URLs are for helping the user with programming. You may use URLs provided by the user in their messages or local files.
+
+If the user asks for help or wants to give feedback inform them of the following:
+- /help: Get help with using opencode
+- To give feedback, users should report the issue at https://github.com/anomalyco/opencode/issues
+
+When the user directly asks about opencode (eg 'can opencode do...', 'does opencode have...') or asks in second person (eg 'are you able...', 'can you do...'), first use the webfetch tool to gather information to answer the question from opencode docs at https://opencode.ai/v2/docs/
+
+# Tone and style
+You should be concise, direct, and to the point. When you run a non-trivial shell command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
+Remember that your output will be displayed on a command line interface. Your responses can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like the shell tool or code comments as means to communicate with the user during the session.
+If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
+IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
+<example>
+user: what is 2+2?
+assistant: 4
+</example>
+
+<example>
+user: is 11 a prime number?
+assistant: Yes
+</example>
+
+<example>
+user: what command should I run to list files in the current directory?
+assistant: ls
+</example>
+
+<example>
+user: what command should I run to watch files in the current directory?
+assistant: [use the read tool to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
+npm run dev
+</example>
+
+<example>
+user: what files are in the directory src/?
+assistant: [uses read and sees foo.c, bar.c, baz.c]
+user: which file contains the implementation of foo?
+assistant: src/foo.c
+</example>
+
+<example>
+user: write tests for new feature
+assistant: [uses grep and glob search tools to find where similar tests are defined, uses concurrent read file tool use blocks in one tool call to read relevant files at the same time, uses edit file tool to write new tests]
+</example>
+
+# Proactiveness
+You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
+1. Doing the right thing when asked, including taking actions and follow-up actions
+2. Not surprising the user with actions you take without asking
+For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+3. Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
+
+# Following conventions
+When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language).
+- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
+- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
+- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
+
+# Code style
+- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked
+
+# Doing tasks
+The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
+- Use the available search tools to understand the codebase and the user's query. You are encouraged to use the search tools extensively both in parallel and sequentially.
+- Implement the solution using all tools available to you
+- Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
+- VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (e.g. npm run lint, npm run typecheck, ruff, etc.) with the shell tool if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time.
+NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
+
+- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
+
+# Tool usage policy
+- When doing file search, prefer to use the subagent tool in order to reduce context usage.
+- You have the capability to call multiple tools in a single response. When multiple independent pieces of information are requested, batch your tool calls together for optimal performance. When making multiple shell tool calls, you MUST send a single message with multiple tools calls to run the calls in parallel. For example, if you need to run "git status" and "git diff", send a single message with two tool calls to run the calls in parallel.
+
+You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
+
+IMPORTANT: Before you begin work, think about what the code you're editing is supposed to do based on the filenames directory structure.
+
+# Code References
+
+When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
+
+<example>
+user: Where are errors from the client handled?
+assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.
+</example>

packages/core/src/session/runner/prompt/system.txt

@@ -1,14 +0,0 @@
-You are an AI agent powered by OpenCode, a coding agent harness. Help the user accomplish their goals using the tools you have available.
-
-# Harness
-- Responses are rendered as GitHub-flavored Markdown.
-- `<system-reminder>` blocks are harness instructions, not user-authored content. Read and follow them.
-${OPENCODE_TOOL_GUIDANCE}
-
-# Communication
-- Use clear file paths when referring to files.
-- Keep responses clear and concise, and avoid unnecessary technical jargon.
-
-# Working in codebases
-- Keep changes consistent with the structure, naming, style, and patterns of the surrounding code.
-- Treat unfamiliar files or changes as potential user work and investigate before deleting or overwriting them.

packages/core/src/session/system-prompt.ts

@@ -1,24 +0,0 @@
-export * as SessionSystemPrompt from "./system-prompt.js"
-
-import PROMPT from "./runner/prompt/system.txt"
-
-export function make(tools: string[]) {
-  const instructions: string[] = []
-  if (tools.includes("write")) {
-    instructions.push(
-      "- Use the write tool to create files or completely replace their content. Prefer using the edit tool for targeted changes.",
-    )
-  }
-  if (tools.includes("edit")) {
-    instructions.push(
-      "- Use the edit tool for targeted changes to existing text files. It replaces the exact text in `oldString` with `newString`, and the values must differ. By default, `oldString` must occur exactly once. If it occurs multiple times, include more surrounding context to make it unique or set `replaceAll` to true to replace every occurrence.",
-    )
-  }
-  // if (tools.includes("patch")) {
-  //   // instructions.push(...)
-  // }
-  if (tools.includes("read")) {
-    instructions.push("- Prefer using the read tool rather than shell commands like `cat`.")
-  }
-  return PROMPT.replace("${OPENCODE_TOOL_GUIDANCE}", instructions.join("\n"))
-}

packages/core/src/tool/plugin/websearch.ts

@@ -4,8 +4,8 @@ import type { Context as PluginContext } from "@opencode-ai/plugin/effect/plugin
 import { ToolFailure } from "@opencode-ai/ai"
 import { Effect, Schema, Semaphore } from "effect"
 import { HttpClientError } from "effect/unstable/http"
-import { Config } from "../../config.js"
 import { Form } from "../../form.js"
+import { KV } from "../../kv.js"
 import { Permission } from "../../permission.js"
 import { WebSearch } from "../../websearch.js"
 
@@ -30,7 +30,7 @@ export const Plugin = {
   effect: Effect.fn("WebSearchTool.Plugin")(function* (ctx: PluginContext) {
     const permission = yield* Permission.Service
     const forms = yield* Form.Service
-    const config = yield* Config.Service
+    const kv = yield* KV.Service
     const websearch = yield* WebSearch.Service
 
     yield* ctx.tool
@@ -65,7 +65,7 @@ export const Plugin = {
                     return providerSelectionLock
                       .withPermit(
                         Effect.gen(function* () {
-                          if (yield* websearch.default()) return
+                          if (yield* websearch.default()) return yield* Effect.void
                           const providers = (yield* ctx.websearch.providers()).data
                           const defaultProvider = providers[0]
                           if (!defaultProvider) return yield* new WebSearch.ProviderRequiredError()
@@ -83,7 +83,7 @@ export const Plugin = {
                                 options: [
                                   {
                                     value: "allow",
-                                    label: `Allow search via ${providers.map((provider) => provider.name).join(", ")}`,
+                                    label: `Allow web search via ${defaultProvider.name}`,
                                   },
                                   {
                                     value: "choose",
@@ -97,9 +97,7 @@ export const Plugin = {
                           if (response.status === "cancelled")
                             return yield* Effect.fail(new Error("Web search cancelled"))
                           if (response.answer.choice === "disable") {
-                            yield* config.update((draft) => {
-                              draft.websearch = false
-                            })
+                            yield* kv.set("websearch:provider", false)
                             return yield* new WebSearch.DisabledError()
                           }
                           const selection =
@@ -125,19 +123,13 @@ export const Plugin = {
                               : undefined
                           if (selection?.status === "cancelled")
                             return yield* Effect.fail(new Error("Web search cancelled"))
-                          const providerID = selection?.answer.provider ?? "random"
+                          const providerID = selection?.answer.provider ?? defaultProvider.id
                           if (
                             typeof providerID !== "string" ||
-                            (providerID !== "random" && !providers.some((provider) => provider.id === providerID))
+                            !providers.some((provider) => provider.id === providerID)
                           )
                             return yield* new WebSearch.ProviderRequiredError()
-                          yield* config.update((draft) => {
-                            draft.websearch = {
-                              provider: providerID === "random" ? "random" : WebSearch.ID.make(providerID),
-                            }
-                          })
-                          if (providerID !== "random") return WebSearch.ID.make(providerID)
-                          return providers[Math.floor(Math.random() * providers.length)]?.id
+                          return yield* kv.set("websearch:provider", providerID)
                         }),
                       )
                       .pipe(
@@ -145,12 +137,7 @@ export const Plugin = {
                           duration: "1 minute",
                           orElse: () => Effect.fail(new Error("Web search cancelled")),
                         }),
-                        Effect.flatMap((providerID) => {
-                          if (!providerID) return Effect.suspend(search)
-                          return context
-                            .progress({ provider: providerID })
-                            .pipe(Effect.andThen(ctx.websearch.query({ ...input, providerID })))
-                        }),
+                        Effect.andThen(Effect.suspend(search)),
                       )
                   }),
                 )
@@ -206,8 +193,7 @@ export const Plugin = {
 
     yield* ctx.session.hook("context", (event) =>
       Effect.gen(function* () {
-        const disabled = Config.latest(yield* config.entries(), "websearch") === false
-        if (disabled) delete event.tools[name]
+        if ((yield* kv.get("websearch:provider")) === false) delete event.tools[name]
       }),
     )
   }),

packages/core/src/websearch.ts

@@ -4,6 +4,7 @@ import { WebSearch } from "@opencode-ai/schema/websearch"
 import { Context, Effect, Layer, Schema } from "effect"
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node"
 import { Bus } from "./bus.js"
+import { KV } from "./kv.js"
 import { State } from "./state.js"
 
 export const ID = WebSearch.ID
@@ -59,14 +60,14 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/We
 
 type Data = {
   readonly providers: Map<ID, ProviderImplementation>
-  selection?: ID | "random" | false
+  defaultProviderID?: ID
 }
 
 export type Draft = {
   add: (provider: ProviderImplementation) => void
   default: {
-    get: () => ID | "random" | false | undefined
-    set: (selection: ID | "random" | false) => void
+    get: () => ID | undefined
+    set: (providerID: ID) => void
   }
 }
 
@@ -74,14 +75,15 @@ const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const bus = yield* Bus.Service
+    const kv = yield* KV.Service
     const decodeResults = Schema.decodeUnknownEffect(Schema.Array(Result))
     const state = State.create<Data, Draft>({
       initial: () => ({ providers: new Map() }),
       draft: (draft) => ({
         add: (provider) => draft.providers.set(provider.id, provider),
         default: {
-          get: () => draft.selection,
-          set: (selection) => (draft.selection = selection),
+          get: () => draft.defaultProviderID,
+          set: (providerID) => (draft.defaultProviderID = providerID),
         },
       }),
       finalize: () => bus.publish(WebSearch.Event.Updated, {}).pipe(Effect.asVoid),
@@ -94,12 +96,12 @@ const layer = Layer.effect(
 
     const defaultProvider = Effect.fn("WebSearch.default")(function* () {
       const data = state.get()
-      if (data.selection === false) return yield* new DisabledError()
-      if (data.selection === "random") {
-        const providers = Array.from(data.providers.values())
-        return providers[Math.floor(Math.random() * providers.length)]
-      }
-      return data.selection ? data.providers.get(data.selection) : undefined
+      const configured = data.defaultProviderID ? data.providers.get(data.defaultProviderID) : undefined
+      if (configured) return configured
+      const stored = yield* kv.get("websearch:provider")
+      if (stored === false) return yield* new DisabledError()
+      if (typeof stored !== "string") return
+      return data.providers.get(ID.make(stored))
     })
 
     const resolve = Effect.fn("WebSearch.resolve")(function* (input: Input) {
@@ -138,5 +140,5 @@ const layer = Layer.effect(
 export const node = makeLocationNode({
   service: Service,
   layer,
-  deps: [Bus.node],
+  deps: [Bus.node, KV.node],
 })

packages/core/test/config/config.test.ts

@@ -72,53 +72,6 @@ const provider = {
 }
 
 describe("Config", () => {
-  it.live("updates the first file-backed document", () =>
-    Effect.acquireRelease(
-      Effect.promise(() => tmpdir()),
-      (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-    ).pipe(
-      Effect.flatMap((tmp) => {
-        const global = path.join(tmp.path, "global")
-        const project = path.join(tmp.path, "project")
-        const globalFile = path.join(global, "opencode.jsonc")
-        const projectFile = path.join(project, "opencode.json")
-        return Effect.promise(async () => {
-          await Promise.all([fs.mkdir(global, { recursive: true }), fs.mkdir(project, { recursive: true })])
-          await Promise.all([
-            fs.writeFile(globalFile, '{\n  // Keep this comment.\n  "shell": "global"\n}\n'),
-            fs.writeFile(projectFile, JSON.stringify({ shell: "project" })),
-          ])
-        }).pipe(
-          Effect.andThen(
-            Effect.gen(function* () {
-              const config = yield* Config.Service
-              const updated = yield* config.update((draft) => {
-                draft.shell = "updated"
-              })
-
-              expect(updated.shell).toBe("updated")
-              expect(yield* Effect.promise(() => fs.readFile(globalFile, "utf8"))).toContain("// Keep this comment.")
-              expect(yield* Effect.promise(() => fs.readFile(globalFile, "utf8"))).toContain('"shell": "updated"')
-              expect(JSON.parse(yield* Effect.promise(() => fs.readFile(projectFile, "utf8")))).toEqual({
-                shell: "project",
-              })
-            }).pipe(Effect.provide(testLayer(project, global))),
-          ),
-        )
-      }),
-    ),
-  )
-
-  it.effect("fails updates when no file-backed document exists", () =>
-    Effect.gen(function* () {
-      const config = yield* Config.Service
-      const error = yield* config.update((draft) => void draft).pipe(Effect.flip)
-      expect(error.message).toBe("No editable config document found")
-    }).pipe(
-      Effect.provide(Config.testLayer([new Document({ type: "document", info: new Info({ shell: "virtual" }) })])),
-    ),
-  )
-
   it.live("loads explicit file and content overrides in priority order", () =>
     Effect.acquireRelease(
       Effect.promise(() => tmpdir()),
@@ -905,7 +858,7 @@ describe("Config", () => {
             expect(documents.map((document) => document.type)).toEqual(["document", "document"])
             expect(documents.map((document) => document.info.$schema)).toEqual(["base", "last"])
             expect(documents[0]).toBeInstanceOf(Document)
-            expect(documents[0]?.path).toBe(AbsolutePath.make(path.join(tmp.path, "opencode.json")))
+            expect(documents[0]?.path).toBe(path.join(tmp.path, "opencode.json"))
             expect(documents[1]?.info.providers?.last).toBeInstanceOf(ConfigProvider.Info)
 
             yield* Effect.promise(() =>
@@ -1452,14 +1405,9 @@ describe("Config", () => {
           )
           return yield* Effect.gen(function* () {
             const config = yield* Config.Service
-            const watcher = yield* Watcher.Test
             const documents = (yield* config.entries()).filter((entry) => entry.type === "document")
 
             expect(documents.map((document) => document.info.$schema)).toEqual(["base"])
-            expect(yield* watcher.subscriptions()).toContainEqual({
-              path: path.join(tmp.path, "opencode.jsonc"),
-              type: "file",
-            })
           }).pipe(Effect.provide(testLayer(tmp.path)))
         }),
       ),
@@ -1543,9 +1491,13 @@ describe("Config", () => {
               "global",
               AbsolutePath.make(global),
               "outside",
+              AbsolutePath.make(path.join(tmp.path, "opencode.json")),
               "root",
+              AbsolutePath.make(path.join(root, "opencode.json")),
               "parent",
+              AbsolutePath.make(path.join(parent, "opencode.jsonc")),
               "directory",
+              AbsolutePath.make(path.join(directory, "opencode.json")),
               "root-dot",
               AbsolutePath.make(path.join(root, ".opencode")),
               "directory-dot",

packages/core/test/config/reload.test.ts

@@ -18,7 +18,6 @@ import { Provider } from "@opencode-ai/core/provider"
 import { Reference } from "@opencode-ai/core/reference"
 import { Skill } from "@opencode-ai/core/skill"
 import { Effect, Schema } from "effect"
-import { AbsolutePath } from "@opencode-ai/core/schema"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "../plugin/fixture"
 
@@ -80,7 +79,7 @@ describe("config plugin reloads", () => {
 function config(name: string) {
   return new Document({
     type: "document",
-    path: AbsolutePath.make(document),
+    path: document,
     info: decode({
       agents: { [name]: { description: `${title(name)} agent`, mode: "subagent" } },
       commands: { [name]: { template: `${title(name)} command`, description: `${title(name)} command` } },

packages/core/test/formatter.test.ts

@@ -1,7 +1,7 @@
 import fs from "fs/promises"
 import path from "path"
 import { describe, expect } from "bun:test"
-import { Effect, Layer, Schema } from "effect"
+import { Effect, Layer, Schema, Stream } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { AbsolutePath } from "@opencode-ai/core/schema"
 import { Npm } from "@opencode-ai/util/npm"
@@ -27,7 +27,16 @@ function formatterLayer(directory: string, configured?: ConfigInput["formatter"]
           }),
         ]
   return AppNodeBuilder.build(Formatter.node, [
-    [Config.node, Config.testLayer(entries)],
+    [
+      Config.node,
+      Layer.succeed(
+        Config.Service,
+        Config.Service.of({
+          entries: () => Effect.succeed(entries),
+          changes: () => Stream.empty,
+        }),
+      ),
+    ],
     [
       Location.node,
       Layer.succeed(Location.Service, Location.Service.of(location({ directory: AbsolutePath.make(directory) }))),

packages/core/test/group.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect } from "bun:test"
+import { Group } from "@opencode-ai/core/persistent-pty"
+import { Bus } from "@opencode-ai/core/bus"
+import { KV } from "@opencode-ai/core/kv"
+import { Pty } from "@opencode-ai/schema/pty"
+import { Session } from "@opencode-ai/schema/session"
+import { LayerNode } from "@opencode-ai/util/effect/layer-node"
+import { Effect, Fiber, Stream } from "effect"
+import { testEffect } from "./lib/effect"
+
+const it = testEffect(LayerNode.compile(LayerNode.group([Group.node, KV.node, Bus.node])))
+
+describe("Group", () => {
+  it.effect("persists ordered groups in one versioned KV document", () =>
+    Effect.gen(function* () {
+      const groups = yield* Group.Service
+      const kv = yield* KV.Service
+      const created = yield* groups.create([
+        { type: "session", id: Session.ID.make("ses_one") },
+        { type: "terminal", id: Pty.ID.make("pty_one") },
+      ])
+
+      expect(yield* groups.get(created.id)).toEqual(created)
+      expect(yield* groups.list()).toEqual([created])
+      expect(yield* kv.get("group:v1")).toEqual([created])
+
+      const updated = Group.Info.make({
+        id: created.id,
+        items: [{ type: "terminal", id: Pty.ID.make("pty_two") }],
+      })
+      yield* groups.set(updated)
+      expect(yield* groups.list()).toEqual([updated])
+
+      yield* groups.remove(created.id)
+      expect(yield* groups.get(created.id)).toBeUndefined()
+      expect(yield* kv.get("group:v1")).toEqual([])
+    }),
+  )
+
+  it.effect("serializes concurrent document mutations", () =>
+    Effect.gen(function* () {
+      const groups = yield* Group.Service
+      yield* Effect.all(
+        Array.from({ length: 20 }, (_, index) =>
+          groups.create([{ type: "session", id: Session.ID.make(`ses_${index}`) }]),
+        ),
+        { concurrency: "unbounded" },
+      )
+
+      expect(yield* groups.list()).toHaveLength(20)
+    }),
+  )
+
+  it.effect("publishes every removed group item", () =>
+    Effect.gen(function* () {
+      const groups = yield* Group.Service
+      const bus = yield* Bus.Service
+      const session = { type: "session" as const, id: Session.ID.make("ses_one") }
+      const terminal = { type: "terminal" as const, id: Pty.ID.make("pty_one") }
+      const group = yield* groups.create([session, terminal])
+      const events = yield* bus
+        .subscribe(Group.Event.ItemRemoved)
+        .pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped)
+      yield* Effect.yieldNow
+
+      yield* groups.set(Group.Info.make({ id: group.id, items: [session] }))
+      yield* groups.remove(group.id)
+
+      expect(Array.from(yield* Fiber.join(events)).map((event) => event.data)).toEqual([
+        { groupID: group.id, item: terminal },
+        { groupID: group.id, item: session },
+      ])
+    }),
+  )
+
+  it.effect("publishes every added group item", () =>
+    Effect.gen(function* () {
+      const groups = yield* Group.Service
+      const bus = yield* Bus.Service
+      const session = { type: "session" as const, id: Session.ID.make("ses_one") }
+      const terminal = { type: "terminal" as const, id: Pty.ID.make("pty_one") }
+      const group = yield* groups.create([session])
+      const event = yield* bus.subscribe(Group.Event.ItemAdded).pipe(Stream.runHead, Effect.forkScoped)
+      yield* Effect.yieldNow
+
+      yield* groups.set(Group.Info.make({ id: group.id, items: [session, terminal] }))
+
+      expect((yield* Fiber.join(event)).valueOrUndefined?.data).toEqual({ groupID: group.id, item: terminal })
+    }),
+  )
+})

packages/core/test/mcp.test.ts

@@ -185,11 +185,7 @@ function resourceMcpLayer(
         overrides?.entries
           ? Layer.succeed(
               Config.Service,
-              Config.Service.of({
-                entries: overrides.entries,
-                update: () => Effect.die("unused config update"),
-                changes: () => Stream.never,
-              }),
+              Config.Service.of({ entries: overrides.entries, changes: () => Stream.never }),
             )
           : Config.testLayer([
               new Document({

packages/core/test/plugin/host.ts

@@ -388,10 +388,7 @@ export function webSearchHost(websearch: WebSearch.Interface): Plugin.Context["w
             }),
           default: {
             get: draft.default.get,
-            set: (selection) =>
-              draft.default.set(
-                selection === false || selection === "random" ? selection : WebSearch.ID.make(selection),
-              ),
+            set: (providerID) => draft.default.set(WebSearch.ID.make(providerID)),
           },
         })
       }),

packages/core/test/plugin/promise.test.ts

@@ -4,7 +4,6 @@ import { DateTime, Effect, Schema } from "effect"
 import { Agent } from "@opencode-ai/core/agent"
 import { Catalog } from "@opencode-ai/core/catalog"
 import { Model } from "@opencode-ai/core/model"
-import { Location } from "@opencode-ai/core/location"
 import { Plugin } from "@opencode-ai/core/plugin"
 import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
@@ -15,10 +14,7 @@ import { SessionMessage } from "@opencode-ai/core/session/message"
 import { SessionInbox } from "@opencode-ai/core/session/inbox"
 import { Tool } from "@opencode-ai/core/tool"
 import { Provider } from "@opencode-ai/core/provider"
-import { Project } from "@opencode-ai/core/project"
-import { AbsolutePath } from "@opencode-ai/core/schema"
 import { define } from "@opencode-ai/plugin/promise/plugin"
-import { Money } from "@opencode-ai/schema/money"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
@@ -27,53 +23,6 @@ import { host as testHost } from "./host"
 const it = testEffect(PluginTestLayer)
 
 describe("fromPromise", () => {
-  it.effect("adapts session creation through the protocol schema", () =>
-    Effect.gen(function* () {
-      let seen: unknown
-      const host = testHost({
-        session: {
-          create: (input) => {
-            seen = input
-            return Effect.succeed(
-              Session.Info.make({
-                id: Session.ID.make("ses_protocol_adapter"),
-                projectID: Project.ID.make("project"),
-                cost: Money.USD.make(0),
-                tokens: { input: 1, output: 2, reasoning: 3, cache: { read: 4, write: 5 } },
-                time: { created: DateTime.makeUnsafe(10), updated: DateTime.makeUnsafe(20) },
-                title: input?.title,
-                location: Location.Ref.make({ directory: AbsolutePath.make("/workspace") }),
-              }),
-            )
-          },
-        },
-      })
-
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-session-create",
-          setup: async (ctx) => {
-            await expect(Reflect.apply(ctx.session.create, undefined, [{ title: 42 }])).rejects.toBeDefined()
-            const result = await ctx.session.create({
-              id: null,
-              title: "Promise title",
-              agent: null,
-              model: null,
-              location: null,
-            })
-            expect(result).toMatchObject({
-              id: "ses_protocol_adapter",
-              title: "Promise title",
-              time: { created: 10, updated: 20 },
-            })
-          },
-        }),
-      ).effect(host)
-
-      expect(seen).toEqual({ title: "Promise title" })
-    }),
-  )
-
   it.effect("forwards transient session generation", () =>
     Effect.gen(function* () {
       const host = testHost({
@@ -95,42 +44,6 @@ describe("fromPromise", () => {
     }),
   )
 
-  it.effect("preserves no-content and rejected Promise behavior", () =>
-    Effect.gen(function* () {
-      const seen: unknown[] = []
-      const host = testHost({
-        session: {
-          interrupt: (input) => {
-            if (input.sessionID === Session.ID.make("ses_failure")) {
-              return Effect.fail(new Error("interrupt failed"))
-            }
-            expect(input.continue).toBe(true)
-            return Effect.void
-          },
-          rename: (input) => Effect.sync(() => seen.push(input)),
-          wait: (input) => Effect.sync(() => seen.push(input)),
-        },
-      })
-
-      yield* PluginPromise.fromPromise(
-        define({
-          id: "promise-session-interrupt",
-          setup: async (ctx) => {
-            expect(await ctx.session.interrupt({ sessionID: "ses_success", continue: true })).toBeUndefined()
-            await expect(ctx.session.interrupt({ sessionID: "ses_failure" })).rejects.toThrow("interrupt failed")
-            expect(await ctx.session.rename({ sessionID: "ses_success", title: "Renamed" })).toBeUndefined()
-            expect(await ctx.session.wait({ sessionID: "ses_success" })).toBeUndefined()
-          },
-        }),
-      ).effect(host)
-
-      expect(seen).toEqual([
-        { sessionID: Session.ID.make("ses_success"), title: "Renamed" },
-        { sessionID: Session.ID.make("ses_success") },
-      ])
-    }),
-  )
-
   it.effect("forwards synthetic session input", () =>
     Effect.gen(function* () {
       const input = {
@@ -201,7 +114,6 @@ describe("fromPromise", () => {
             ctx.skill.list(),
           ])
           seen.push(...results.map((result) => result.location.directory))
-          expect((await ctx.integration.get({ integrationID: "missing" })).data).toBeNull()
         },
       })
 

packages/core/test/plugin/system-prompt.test.ts

@@ -7,7 +7,6 @@ import { PluginHooks } from "@opencode-ai/core/plugin/hooks"
 import { PluginHost } from "@opencode-ai/core/plugin/host"
 import { SystemPromptPlugin } from "@opencode-ai/core/plugin/system-prompt"
 import { Session } from "@opencode-ai/core/session"
-import { SessionSystemPrompt } from "@opencode-ai/core/session/system-prompt"
 import type { SessionHooks } from "@opencode-ai/plugin/effect/session"
 import { Model } from "@opencode-ai/schema/model"
 import { Provider } from "@opencode-ai/schema/provider"
@@ -15,9 +14,10 @@ import { Effect } from "effect"
 import { testEffect } from "../lib/effect"
 import { PluginTestLayer } from "./fixture"
 import PROMPT_META from "../../src/plugin/system-prompt/meta.txt"
+import PROMPT_DEFAULT from "../../src/session/runner/prompt/base.txt"
 
 const it = testEffect(PluginTestLayer)
-const fallback = SessionSystemPrompt.make([])
+const fallback = PROMPT_DEFAULT
 const makeHost = Effect.gen(function* () {
   const agents = yield* Agent.Service
   const plugins = yield* Plugin.Service
@@ -74,7 +74,7 @@ describe("SystemPromptPlugin", () => {
         ["kimi-k2", "# Prompt and Tool Use"],
         ["trinity", "what command should I run to list files"],
         ["meta/muse-spark-1.1", "powered by Muse Spark"],
-        ["llama-3.3", fallback],
+        ["llama-3.3", "You are opencode, an interactive CLI tool"],
       ] as const
 
       yield* Effect.forEach(

packages/core/test/session-runner.test.ts

@@ -71,7 +71,6 @@ import { InstructionDiscovery } from "@opencode-ai/core/instruction-discovery"
 import { SkillInstructions } from "@opencode-ai/core/skill/instructions"
 import { ReferenceInstructions } from "@opencode-ai/core/reference/instructions"
 import { McpInstructions } from "@opencode-ai/core/mcp/instructions"
-import { SessionSystemPrompt } from "@opencode-ai/core/session/system-prompt"
 import { ID } from "@opencode-ai/core/model"
 import { Location } from "@opencode-ai/core/location"
 import { Provider } from "@opencode-ai/core/provider"
@@ -82,6 +81,7 @@ import { asc, desc, eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 import { permissionLayer } from "./lib/permission"
 import { agentHost, catalogHost, host } from "./plugin/host"
+import PROMPT_DEFAULT from "../src/session/runner/prompt/base.txt"
 import { CodeModeInstructions } from "@opencode-ai/core/codemode/instructions"
 
 let requests: LLMRequest[] = []
@@ -147,7 +147,7 @@ const modelTransport = Layer.succeed(
   }),
 )
 const model = LanguageModel.make({ id: "fake-model", provider: "fake", route: OpenAIChat.route })
-const defaultSystem = SessionSystemPrompt.make([])
+const defaultSystem = PROMPT_DEFAULT
 const replacementModel = LanguageModel.make({ id: "replacement", provider: "fake", route: OpenAIChat.route })
 const compactModel = LanguageModel.make({
   id: "compact",

packages/core/test/session-system-prompt.test.ts

@@ -1,8 +0,0 @@
-import { expect, test } from "bun:test"
-import { SessionSystemPrompt } from "@opencode-ai/core/session/system-prompt"
-
-test("renders the default system prompt instructions", () => {
-  const prompt = SessionSystemPrompt.make(["edit", "read", "shell"])
-  expect(prompt).not.toContain("${OPENCODE_TOOL_GUIDANCE}")
-  expect(prompt).toContain("Use the edit tool for targeted changes to existing text files")
-})

packages/core/test/tool-output.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect } from "bun:test"
 import path from "path"
-import { Effect } from "effect"
+import { Effect, Layer, Stream } from "effect"
 import { Config } from "@opencode-ai/core/config"
 import { Document, Info } from "@opencode-ai/schema/config"
 import { ConfigToolOutput } from "@opencode-ai/schema/config/tool-output"
@@ -20,7 +20,13 @@ const withStore = <A, E, R>(
   Effect.acquireUseRelease(
     Effect.promise(() => tmpdir()),
     (tmp) => {
-      const config = Config.testLayer([new Document({ type: "document", info })])
+      const config = Layer.succeed(
+        Config.Service,
+        Config.Service.of({
+          entries: () => Effect.succeed([new Document({ type: "document", info })]),
+          changes: () => Stream.empty,
+        }),
+      )
       const layer = AppNodeBuilder.build(LayerNode.group([ToolOutput.node, FSUtil.node]), [
         [Config.node, config],
         [Global.node, Global.layerWith({ data: tmp.path })],

packages/core/test/tool-websearch.test.ts

@@ -1,13 +1,12 @@
 import { beforeEach, describe, expect } from "bun:test"
-import { Deferred, Effect, Layer, Stream } from "effect"
+import { Deferred, Effect, Layer } from "effect"
 import { HttpClientError, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Permission } from "@opencode-ai/core/permission"
-import { Config } from "@opencode-ai/core/config"
 import { Form } from "@opencode-ai/core/form"
+import { KV } from "@opencode-ai/core/kv"
 import { WebSearch } from "@opencode-ai/core/websearch"
-import { Document, Info } from "@opencode-ai/schema/config"
 import { Session } from "@opencode-ai/core/session"
 import { toSessionError } from "@opencode-ai/core/session/to-session-error"
 import { Tool } from "@opencode-ai/core/tool"
@@ -19,7 +18,6 @@ import { imagePassthrough } from "./lib/image"
 import { permissionLayer } from "./lib/permission"
 import { toolIdentity, executeTool, registerToolPlugin, toolDefinitions } from "./lib/tool"
 import { webSearchHost } from "./plugin/host"
-import { produce } from "immer"
 
 const webSearchToolNode = makeLocationNode({
   name: "test/websearch-tool-plugin",
@@ -29,14 +27,14 @@ const webSearchToolNode = makeLocationNode({
       yield* registerToolPlugin(WebSearchTool.Plugin, { websearch: webSearchHost(websearch) })
     }),
   ),
-  deps: [Tool.node, Permission.node, WebSearch.node, Form.node, Config.node],
+  deps: [Tool.node, Permission.node, WebSearch.node, Form.node, KV.node],
 })
 
 const sessionID = Session.ID.make("ses_websearch_test")
 const assertions: Permission.AssertInput[] = []
 const queries: WebSearch.Input[] = []
 const formRequests: Form.CreateInput[] = []
-let selection: WebSearch.ID | "random" | false | undefined
+const values = new Map<string, KV.Value>()
 const providers = [
   { id: WebSearch.ID.make("exa"), name: "Exa" },
   { id: WebSearch.ID.make("parallel"), name: "Parallel" },
@@ -56,7 +54,7 @@ beforeEach(() => {
   assertions.length = 0
   queries.length = 0
   formRequests.length = 0
-  selection = undefined
+  values.clear()
   providerRequired = false
   formResponse = { status: "cancelled" }
   formResponses.length = 0
@@ -75,39 +73,28 @@ const permission = permissionLayer({
 const websearch = Layer.succeed(
   WebSearch.Service,
   WebSearch.Service.of({
-    transform: (transform) =>
-      Effect.sync(() => {
-        transform({
-          add: () => undefined,
-          default: {
-            get: () => selection,
-            set: (next) => (selection = next),
-          },
-        })
-        return { dispose: Effect.void }
-      }),
+    transform: () => Effect.die("unused"),
     reload: () => Effect.die("unused"),
     providers: () => Effect.succeed(providers),
     default: () =>
       Effect.gen(function* () {
-        if (selection === false) return yield* new WebSearch.DisabledError()
-        return selection ? providers.find((provider) => provider.id === selection) : undefined
+        const stored = values.get("websearch:provider")
+        if (stored === false) return yield* new WebSearch.DisabledError()
+        return typeof stored === "string" ? providers.find((provider) => provider.id === stored) : undefined
       }),
     query: (input) =>
       Effect.gen(function* () {
         queries.push(input)
+        const stored = values.get("websearch:provider")
         if (queryBarrier && synchronizedQueries < 5) {
           synchronizedQueries++
           if (synchronizedQueries === 5) yield* Deferred.succeed(queryBarrier, undefined)
           yield* Deferred.await(queryBarrier)
         }
         if (queryError) return yield* queryError
-        if (providerRequired && !selection) return yield* new WebSearch.ProviderRequiredError()
-        if (selection)
-          return new WebSearch.Response({
-            providerID: selection === "random" ? result.providerID : WebSearch.ID.make(selection),
-            results: result.results,
-          })
+        if (providerRequired && typeof stored !== "string") return yield* new WebSearch.ProviderRequiredError()
+        if (typeof stored === "string")
+          return new WebSearch.Response({ providerID: WebSearch.ID.make(stored), results: result.results })
         return result
       }),
   }),
@@ -128,30 +115,12 @@ const form = Layer.succeed(
     cancel: () => Effect.die("unused"),
   }),
 )
-const config = Layer.succeed(
-  Config.Service,
-  Config.Service.of({
-    entries: () =>
-      Effect.succeed([
-        new Document({
-          type: "document",
-          info: new Info({
-            websearch: selection === undefined ? undefined : selection === false ? false : { provider: selection },
-          }),
-        }),
-      ]),
-    update: (update) =>
-      Effect.sync(() => {
-        const info = produce(
-          new Info({
-            websearch: selection === undefined ? undefined : selection === false ? false : { provider: selection },
-          }),
-          update,
-        )
-        selection = info.websearch === false ? false : info.websearch?.provider
-        return info
-      }),
-    changes: () => Stream.never,
+const kv = Layer.succeed(
+  KV.Service,
+  KV.Service.of({
+    get: (key) => Effect.succeed(values.get(key)),
+    set: (key, value) => Effect.sync(() => values.set(key, value)).pipe(Effect.asVoid),
+    remove: (key) => Effect.sync(() => values.delete(key)).pipe(Effect.asVoid),
   }),
 )
 const it = testEffect(
@@ -159,7 +128,7 @@ const it = testEffect(
     [Permission.node, permission],
     [WebSearch.node, websearch],
     [Form.node, form],
-    [Config.node, config],
+    [KV.node, kv],
     [Image.node, imagePassthrough],
   ]),
 )
@@ -278,7 +247,7 @@ describe("WebSearchTool registration", () => {
           call: { type: "tool-call", id: "call-enable", name: "websearch", input: { query: "effect" } },
         }),
       ).toMatchObject({ status: "completed", metadata: { provider: "exa" } })
-      expect(selection).toBe("random")
+      expect(values.get("websearch:provider")).toBe("exa")
       expect(queries).toHaveLength(2)
       expect(formRequests).toEqual([
         {
@@ -295,7 +264,7 @@ describe("WebSearchTool registration", () => {
               options: [
                 {
                   value: "allow",
-                  label: "Allow search via Exa, Parallel",
+                  label: "Allow web search via Exa",
                 },
                 {
                   value: "choose",
@@ -336,7 +305,7 @@ describe("WebSearchTool registration", () => {
           call: { type: "tool-call", id: "call-choose", name: "websearch", input: { query: "effect" } },
         }),
       ).toMatchObject({ status: "completed", metadata: { provider: "parallel" } })
-      expect(selection).toBe(WebSearch.ID.make("parallel"))
+      expect(values.get("websearch:provider")).toBe("parallel")
       expect(queries).toHaveLength(2)
       expect(formRequests[1]).toEqual({
         sessionID,
@@ -384,7 +353,7 @@ describe("WebSearchTool registration", () => {
 
       expect(results.every((item) => item.status === "completed")).toBe(true)
       expect(formRequests).toHaveLength(1)
-      expect(selection).toBe("random")
+      expect(values.get("websearch:provider")).toBe("exa")
     }),
   )
 
@@ -401,7 +370,7 @@ describe("WebSearchTool registration", () => {
           call: { type: "tool-call", id: "call-disable", name: "websearch", input: { query: "effect" } },
         }),
       ).toMatchObject({ status: "error" })
-      expect(selection).toBe(false)
+      expect(values.get("websearch:provider")).toBe(false)
       expect(queries).toHaveLength(1)
     }),
   )
@@ -410,7 +379,7 @@ describe("WebSearchTool registration", () => {
     Effect.gen(function* () {
       const registry = yield* Tool.Service
       const tools = yield* registry.snapshot()
-      selection = WebSearch.ID.make("exa")
+      values.set("websearch:provider", "exa")
 
       yield* Effect.forEach(
         [

packages/core/test/websearch.test.ts

@@ -3,10 +3,11 @@ import { Effect, Exit, Scope } from "effect"
 import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
 import { LayerNode } from "@opencode-ai/util/effect/layer-node"
 import { Bus } from "@opencode-ai/core/bus"
+import { KV } from "@opencode-ai/core/kv"
 import { WebSearch } from "@opencode-ai/core/websearch"
 import { testEffect } from "./lib/effect"
 
-const it = testEffect(AppNodeBuilder.build(LayerNode.group([WebSearch.node, Bus.node])))
+const it = testEffect(AppNodeBuilder.build(LayerNode.group([WebSearch.node, Bus.node, KV.node])))
 
 const register = (id: string) =>
   Effect.gen(function* () {
@@ -80,14 +81,16 @@ describe("WebSearch", () => {
     }),
   )
 
-  it.effect("chooses a registered provider for random selection", () =>
+  it.effect("uses the provider stored in KV", () =>
     Effect.gen(function* () {
       yield* register("exa")
-      yield* register("parallel")
+      const parallel = yield* register("parallel")
       const websearch = yield* WebSearch.Service
-      yield* websearch.transform((draft) => draft.default.set("random"))
+      const kv = yield* KV.Service
+      yield* kv.set("websearch:provider", parallel.providerID)
 
-      expect(["exa", "parallel"]).toContain((yield* websearch.query({ query: "random" })).providerID)
+      expect((yield* websearch.query({ query: "stored" })).providerID).toBe(parallel.providerID)
+      yield* kv.remove("websearch:provider")
     }),
   )
 
@@ -95,9 +98,11 @@ describe("WebSearch", () => {
     Effect.gen(function* () {
       yield* register("exa")
       const websearch = yield* WebSearch.Service
-      yield* websearch.transform((draft) => draft.default.set(false))
+      const kv = yield* KV.Service
+      yield* kv.set("websearch:provider", false)
 
       expect((yield* websearch.query({ query: "disabled" }).pipe(Effect.flip))._tag).toBe("WebSearch.Disabled")
+      yield* kv.remove("websearch:provider")
     }),
   )
 

packages/plugin/package.json

@@ -23,7 +23,6 @@
     "@ai-sdk/provider": "3.0.8",
     "@opencode-ai/ai": "workspace:*",
     "@opencode-ai/client": "workspace:*",
-    "@opencode-ai/protocol": "workspace:*",
     "@opencode-ai/schema": "workspace:*",
     "@opencode-ai/sdk": "1.18.5",
     "@standard-schema/spec": "catalog:",

packages/plugin/src/effect/websearch.ts

@@ -17,7 +17,7 @@ export interface WebSearchDomain extends WebsearchApi<unknown> {
 export interface WebSearchDraft {
   add(definition: WebSearchDefinition): void
   readonly default: {
-    get(): string | false | undefined
-    set(selection: string | false): void
+    get(): string | undefined
+    set(providerID: string): void
   }
 }

packages/plugin/src/promise/adapter.ts

@@ -1,324 +0,0 @@
-import { Tool } from "@opencode-ai/schema/tool"
-import { Effect, Schema, SchemaAST, Scope, Stream } from "effect"
-import { HttpApiEndpoint, HttpApiSchema } from "effect/unstable/httpapi"
-import { define } from "../effect/plugin.js"
-import type { Context, Plugin } from "./plugin.js"
-import type { Info } from "./tool.js"
-
-type HostRegistration = { readonly dispose: Effect.Effect<void> }
-type Registration = { readonly dispose: () => Promise<void> }
-type PromiseEvent = ReturnType<Context["event"]["subscribe"]> extends AsyncIterable<infer Event> ? Event : never
-
-interface CompiledEndpoint {
-  readonly decode: ReadonlyArray<(input: unknown) => Effect.Effect<unknown, Schema.SchemaError>>
-  readonly encode: (output: unknown) => Effect.Effect<unknown, Schema.SchemaError>
-  readonly noContent: boolean
-}
-
-const compiledEndpoints = new WeakMap<object, CompiledEndpoint>()
-
-function compileEndpoint(endpoint: HttpApiEndpoint.Top) {
-  const cached = compiledEndpoints.get(endpoint)
-  if (cached) return cached
-  const payloadSchemas = Array.from(endpoint.payload.values()).flatMap(({ schemas }) => schemas)
-  const successSchemas = Array.from(endpoint.success)
-  if (payloadSchemas.length > 1 || successSchemas.length > 1) {
-    throw new Error(`Unsupported API schema cardinality: ${endpoint.identifier}`)
-  }
-  const inputs = [
-    endpoint.params,
-    endpoint.query === undefined ? undefined : Schema.toType(endpoint.query),
-    endpoint.headers,
-    ...payloadSchemas,
-  ].filter((schema): schema is Schema.Top => schema !== undefined) as Array<RuntimeSchema>
-  const success = (successSchemas[0] ?? HttpApiSchema.NoContent) as RuntimeSchema
-  const noContent = HttpApiSchema.isNoContent(success.ast)
-  const type = Schema.toType(success).ast
-  const data = SchemaAST.isObjects(success.ast)
-    ? success.ast.propertySignatures.find((property) => property.name === "data")
-    : undefined
-  const output =
-    !noContent &&
-    SchemaAST.isObjects(type) &&
-    type.indexSignatures.length === 0 &&
-    type.propertySignatures.length === 1 &&
-    type.propertySignatures[0]?.name === "data" &&
-    data !== undefined
-      ? (Schema.make<Schema.Top>(data.type) as RuntimeSchema)
-      : success
-  const compiled = {
-    decode: inputs.map((schema) => Schema.decodeUnknownEffect(schema)),
-    encode: Schema.encodeUnknownEffect(output),
-    noContent,
-  } satisfies CompiledEndpoint
-  compiledEndpoints.set(endpoint, compiled)
-  return compiled
-}
-
-/**
- * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
- * loader (`Plugin` / `PluginSupervisor`) can run it unchanged.
- *
- * Hook registrations created during the async `setup` attach to the plugin's
- * scope, so unloading the plugin disposes them. The captured fiber context
- * preserves boot-time batching, so Promise-plugin transforms still coalesce
- * into one reload per domain.
- */
-export function fromPromise(plugin: Plugin) {
-  return define({
-    id: plugin.id,
-    effect: (host) =>
-      Effect.gen(function* () {
-        const [{ ClientApi }, { OpenCodeEvent }] = yield* Effect.promise(() =>
-          Promise.all([import("@opencode-ai/protocol/client"), import("@opencode-ai/protocol/groups/event")]),
-        )
-        const AgentEndpoints = ClientApi.groups["server.agent"].endpoints
-        const CommandEndpoints = ClientApi.groups["server.command"].endpoints
-        const IntegrationEndpoints = ClientApi.groups["server.integration"].endpoints
-        const ModelEndpoints = ClientApi.groups["server.model"].endpoints
-        const PluginEndpoints = ClientApi.groups["server.plugin"].endpoints
-        const ProviderEndpoints = ClientApi.groups["server.provider"].endpoints
-        const ReferenceEndpoints = ClientApi.groups["server.reference"].endpoints
-        const SessionEndpoints = ClientApi.groups["server.session"].endpoints
-        const SkillEndpoints = ClientApi.groups["server.skill"].endpoints
-        const WebSearchEndpoints = ClientApi.groups["server.websearch"].endpoints
-        const scope = yield* Scope.Scope
-        const context = yield* Effect.context<Scope.Scope>()
-
-        // Run a hook registration on the plugin scope and resolve once it is registered.
-        const register = (effect: Effect.Effect<HostRegistration, never, Scope.Scope>): Promise<Registration> =>
-          Effect.runPromiseWith(context)(Scope.provide(scope)(effect)).then((registration) => ({
-            dispose: () => Effect.runPromiseWith(context)(registration.dispose),
-          }))
-
-        const run = <A, E>(effect: Effect.Effect<A, E>) => Effect.runPromiseWith(context)(effect)
-
-        const adaptApiMethod = <PromiseMethod>(
-          endpoint: HttpApiEndpoint.Top,
-          method: (input: never) => Effect.Effect<unknown, unknown>,
-        ) => {
-          const compiled = compileEndpoint(endpoint)
-          return ((input?: unknown) =>
-            Effect.gen(function* () {
-              const decoded = yield* Effect.forEach(compiled.decode, (decode) => decode(input ?? {}))
-              const result = yield* method(Object.assign({}, ...decoded) as never)
-              if (compiled.noContent) return undefined
-              return yield* compiled.encode(result)
-            }).pipe(Effect.runPromiseWith(context))) as PromiseMethod
-        }
-
-        const transform =
-          <Draft>(domain: {
-            transform: (callback: (draft: Draft) => void) => Effect.Effect<HostRegistration, never, Scope.Scope>
-          }) =>
-          (callback: (draft: Draft) => void) =>
-            register(
-              domain.transform((draft) => {
-                callback(draft)
-              }),
-            )
-
-        const context2: Context = {
-          app: host.app,
-          options: host.options,
-          agent: {
-            get: adaptApiMethod(AgentEndpoints["agent.get"], host.agent.get),
-            list: adaptApiMethod(AgentEndpoints["agent.list"], host.agent.list),
-            transform: transform(host.agent),
-            reload: () => run(host.agent.reload()),
-          },
-          aisdk: {
-            hook: (name, callback) =>
-              register(host.aisdk.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
-          },
-          catalog: {
-            provider: {
-              list: adaptApiMethod(ProviderEndpoints["provider.list"], host.catalog.provider.list),
-              get: adaptApiMethod(ProviderEndpoints["provider.get"], host.catalog.provider.get),
-            },
-            model: {
-              list: adaptApiMethod(ModelEndpoints["model.list"], host.catalog.model.list),
-              default: adaptApiMethod(ModelEndpoints["model.default"], host.catalog.model.default),
-            },
-            transform: transform(host.catalog),
-            reload: () => run(host.catalog.reload()),
-          },
-          command: {
-            list: adaptApiMethod(CommandEndpoints["command.list"], host.command.list),
-            transform: transform(host.command),
-            reload: () => run(host.command.reload()),
-          },
-          event: {
-            subscribe: () =>
-              Stream.toAsyncIterable(
-                host.event.subscribe().pipe(
-                  Stream.mapEffect((event) => Schema.encodeUnknownEffect(OpenCodeEvent)(event)),
-                  Stream.map((event) => event as unknown as PromiseEvent),
-                ),
-              ),
-          },
-          integration: {
-            list: adaptApiMethod(IntegrationEndpoints["integration.list"], host.integration.list),
-            get: adaptApiMethod(IntegrationEndpoints["integration.get"], host.integration.get),
-            connect: {
-              key: adaptApiMethod(IntegrationEndpoints["integration.connect.key"], host.integration.connect.key),
-            },
-            oauth: {
-              connect: adaptApiMethod(
-                IntegrationEndpoints["integration.oauth.connect"],
-                host.integration.oauth.connect,
-              ),
-              status: adaptApiMethod(IntegrationEndpoints["integration.oauth.status"], host.integration.oauth.status),
-              complete: adaptApiMethod(
-                IntegrationEndpoints["integration.oauth.complete"],
-                host.integration.oauth.complete,
-              ),
-              cancel: adaptApiMethod(IntegrationEndpoints["integration.oauth.cancel"], host.integration.oauth.cancel),
-            },
-            command: {
-              connect: adaptApiMethod(
-                IntegrationEndpoints["integration.command.connect"],
-                host.integration.command.connect,
-              ),
-              status: adaptApiMethod(
-                IntegrationEndpoints["integration.command.status"],
-                host.integration.command.status,
-              ),
-              cancel: adaptApiMethod(
-                IntegrationEndpoints["integration.command.cancel"],
-                host.integration.command.cancel,
-              ),
-            },
-            transform: (callback) =>
-              register(
-                host.integration.transform((draft) =>
-                  callback({
-                    list: draft.list,
-                    get: draft.get,
-                    update: draft.update,
-                    remove: draft.remove,
-                    method: {
-                      list: draft.method.list,
-                      update: (input) => {
-                        if (!("authorize" in input)) return draft.method.update(input)
-                        const refresh = input.refresh
-                        draft.method.update({
-                          ...input,
-                          authorize: (answer) =>
-                            Effect.promise(() => input.authorize(answer)).pipe(
-                              Effect.map((authorization) =>
-                                authorization.mode === "auto"
-                                  ? {
-                                      ...authorization,
-                                      callback: Effect.promise(() => authorization.callback),
-                                    }
-                                  : {
-                                      ...authorization,
-                                      callback: (code) => Effect.promise(() => authorization.callback(code)),
-                                    },
-                              ),
-                            ),
-                          refresh:
-                            refresh === undefined
-                              ? undefined
-                              : (credential) => Effect.promise(() => refresh(credential)),
-                        })
-                      },
-                      remove: draft.method.remove,
-                    },
-                  }),
-                ),
-              ),
-            reload: () => run(host.integration.reload()),
-            connection: {
-              active: (id) => Effect.runPromiseWith(context)(host.integration.connection.active(id)),
-              resolve: (connection) => Effect.runPromiseWith(context)(host.integration.connection.resolve(connection)),
-            },
-          },
-          plugin: {
-            list: adaptApiMethod(PluginEndpoints["plugin.list"], host.plugin.list),
-          },
-          reference: {
-            list: adaptApiMethod(ReferenceEndpoints["reference.list"], host.reference.list),
-            transform: transform(host.reference),
-            reload: () => run(host.reference.reload()),
-          },
-          skill: {
-            list: adaptApiMethod(SkillEndpoints["skill.list"], host.skill.list),
-            transform: transform(host.skill),
-            reload: () => run(host.skill.reload()),
-          },
-          tool: {
-            transform: (callback) =>
-              register(
-                host.tool.transform((draft) =>
-                  callback({
-                    add: (tool: Info) =>
-                      draft.add({
-                        ...tool,
-                        execute: (input, context) => executePromiseTool(tool, input, context),
-                      }),
-                  }),
-                ),
-              ),
-            hook: (name, callback) =>
-              register(host.tool.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
-          },
-          websearch: {
-            providers: adaptApiMethod(WebSearchEndpoints["websearch.providers"], host.websearch.providers),
-            query: adaptApiMethod(WebSearchEndpoints["websearch.query"], host.websearch.query),
-            reload: () => run(host.websearch.reload()),
-            transform: (callback) =>
-              register(
-                host.websearch.transform((draft) => {
-                  callback({
-                    add: (definition) =>
-                      draft.add({
-                        id: definition.id,
-                        name: definition.name,
-                        execute: (input) => attempt((signal) => definition.execute(input, { signal })),
-                      }),
-                    default: draft.default,
-                  })
-                }),
-              ),
-          },
-          session: {
-            hook: (name, callback) =>
-              register(host.session.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
-            create: adaptApiMethod(SessionEndpoints["session.create"], host.session.create),
-            get: adaptApiMethod(SessionEndpoints["session.get"], host.session.get),
-            prompt: adaptApiMethod(SessionEndpoints["session.prompt"], host.session.prompt),
-            generate: adaptApiMethod(SessionEndpoints["session.generate"], host.session.generate),
-            command: adaptApiMethod(SessionEndpoints["session.command"], host.session.command),
-            synthetic: adaptApiMethod(SessionEndpoints["session.synthetic"], host.session.synthetic),
-            interrupt: adaptApiMethod(SessionEndpoints["session.interrupt"], host.session.interrupt),
-            rename: adaptApiMethod(SessionEndpoints["session.rename"], host.session.rename),
-            wait: adaptApiMethod(SessionEndpoints["session.wait"], host.session.wait),
-          },
-          shell: {
-            hook: (name, callback) =>
-              register(host.shell.hook(name, (event) => Effect.promise(() => Promise.resolve(callback(event))))),
-          },
-        }
-
-        const cleanup = yield* Effect.promise(() => Promise.resolve(plugin.setup(context2)))
-        if (!cleanup) return
-        yield* Effect.addFinalizer(() => Effect.promise(() => Promise.resolve(cleanup())))
-      }),
-  })
-}
-
-function attempt<A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) {
-  return Effect.tryPromise({ try: evaluate, catch: (cause) => cause })
-}
-
-type RuntimeSchema = Schema.Codec<unknown, unknown>
-
-const executePromiseTool = (tool: Info, input: any, context: Tool.Context) =>
-  Effect.promise(() =>
-    tool.execute(input, {
-      ...context,
-      progress: (update) => Effect.runPromise(context.progress(update)),
-    }),
-  )

packages/plugin/src/promise/session.ts

@@ -38,7 +38,7 @@ export interface SessionHooks {
 
 export type SessionDomain = Pick<
   SessionApi,
-  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "wait"
+  "create" | "get" | "prompt" | "generate" | "command" | "synthetic" | "interrupt"
 > & {
   readonly hook: Hooks<SessionHooks>
 }

packages/plugin/src/promise/websearch.ts

@@ -19,7 +19,7 @@ export interface WebSearchDomain extends WebSearchApi {
 export interface WebSearchDraft {
   add(definition: WebSearchDefinition): void
   readonly default: {
-    get(): string | false | undefined
-    set(selection: string | false): void
+    get(): string | undefined
+    set(providerID: string): void
   }
 }

packages/protocol/openapi.json

@@ -10534,7 +10534,7 @@
         "summary": "List references"
       }
     },
-    "/api/worktree/{projectID}": {
+    "/api/experimental/project/{projectID}/worktree": {
       "get": {
         "tags": ["worktree"],
         "operationId": "v2.worktree.list",
@@ -10736,7 +10736,7 @@
         }
       }
     },
-    "/api/worktree/{projectID}/refresh": {
+    "/api/experimental/project/{projectID}/worktree/refresh": {
       "post": {
         "tags": ["worktree"],
         "operationId": "v2.worktree.refresh",
@@ -23517,24 +23517,6 @@
         "required": ["path"],
         "additionalProperties": false
       },
-      "ConfigWebSearch.Info": {
-        "type": "object",
-        "properties": {
-          "provider": {
-            "anyOf": [
-              {
-                "type": "string",
-                "enum": ["random"]
-              },
-              {
-                "type": "string"
-              }
-            ]
-          }
-        },
-        "required": ["provider"],
-        "additionalProperties": false
-      },
       "Config.Plugin.Entry": {
         "type": "object",
         "properties": {
@@ -24053,15 +24035,14 @@
             }
           },
           "websearch": {
-            "anyOf": [
-              {
-                "type": "boolean",
-                "enum": [false]
-              },
-              {
-                "$ref": "#/components/schemas/ConfigWebSearch.Info"
+            "type": "object",
+            "properties": {
+              "provider": {
+                "type": "string"
               }
-            ]
+            },
+            "required": ["provider"],
+            "additionalProperties": false
           },
           "plugins": {
             "type": "array",
@@ -24164,6 +24145,20 @@
         "required": ["type", "path"],
         "additionalProperties": false
       },
+      "Config.File": {
+        "type": "object",
+        "properties": {
+          "type": {
+            "type": "string",
+            "enum": ["file"]
+          },
+          "path": {
+            "type": "string"
+          }
+        },
+        "required": ["type", "path"],
+        "additionalProperties": false
+      },
       "Config.AgentsDirectory": {
         "type": "object",
         "properties": {
@@ -24200,6 +24195,9 @@
           {
             "$ref": "#/components/schemas/Config.Directory"
           },
+          {
+            "$ref": "#/components/schemas/Config.File"
+          },
           {
             "$ref": "#/components/schemas/Config.AgentsDirectory"
           },

packages/protocol/src/api.ts

@@ -19,6 +19,7 @@ import { HealthGroup } from "./groups/health.js"
 import { ServerGroup } from "./groups/server.js"
 import { DebugGroup } from "./groups/debug.js"
 import { PtyGroup } from "./groups/pty.js"
+import { PersistentPtyGroup } from "./groups/persistent-pty.js"
 import { ShellGroup } from "./groups/shell.js"
 import { ReferenceGroup } from "./groups/reference.js"
 import { Authorization } from "./middleware/authorization.js"
@@ -86,6 +87,7 @@ type ApiGroups<
   | typeof DebugGroup
   | typeof MigrationGroup
   | typeof WorktreeGroup
+  | typeof PersistentPtyGroup
   | LocationGroups<LocationId>
   | FormGroups<LocationId, LocationService, FormLocationId, FormLocationService>
   | SessionGroups<SessionLocationId, SessionLocationService>
@@ -166,6 +168,7 @@ const makeApiFromGroup = <
     .add(SkillGroup.middleware(locationMiddleware))
     .add(eventGroup)
     .add(PtyGroup.middleware(locationMiddleware))
+    .add(PersistentPtyGroup)
     .add(ShellGroup.middleware(locationMiddleware))
     .add(ReferenceGroup.middleware(locationMiddleware))
     .add(WorktreeGroup)

packages/protocol/src/groups/persistent-pty.ts

@@ -0,0 +1,137 @@
+import { Group } from "@opencode-ai/schema/group"
+import { PersistentPty } from "@opencode-ai/schema/persistent-pty"
+import { Pty } from "@opencode-ai/schema/pty"
+import { PtyTicket } from "@opencode-ai/schema/pty-ticket"
+import { Schema } from "effect"
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
+import {
+  ForbiddenError,
+  InvalidRequestError,
+  PtyNotFoundError,
+  ServiceUnavailableError,
+} from "../errors.js"
+import {
+  PTY_CONNECT_TICKET_QUERY,
+  PTY_CONNECT_TOKEN_HEADER,
+  PTY_CONNECT_TOKEN_HEADER_VALUE,
+} from "./pty.js"
+
+export { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE }
+
+const CONNECT_PATH = /^\/api\/persistent-pty\/[^/]+\/connect$/
+
+export function hasPersistentPtyConnectTicketURL(url: URL) {
+  return CONNECT_PATH.test(url.pathname) && !!url.searchParams.get(PTY_CONNECT_TICKET_QUERY)
+}
+
+const errors = [InvalidRequestError, ServiceUnavailableError] as const
+const terminalErrors = [PtyNotFoundError, ServiceUnavailableError] as const
+
+export const PersistentPtyGroup = HttpApiGroup.make("server.persistentPty")
+  .add(
+    HttpApiEndpoint.get("persistentPty.group.list", "/api/pty-group", {
+      success: Schema.Struct({ data: Schema.Array(Group.Info) }),
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.post("persistentPty.group.create", "/api/pty-group", {
+      payload: Schema.Struct({ items: Schema.optional(Schema.Array(Group.Item)) }),
+      success: Schema.Struct({ data: Group.Info }),
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.get("persistentPty.group.get", "/api/pty-group/:groupID", {
+      params: { groupID: Group.ID },
+      success: Schema.Struct({ data: Group.Info }),
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.put("persistentPty.group.set", "/api/pty-group/:groupID", {
+      params: { groupID: Group.ID },
+      payload: Schema.Struct({ items: Schema.Array(Group.Item) }),
+      success: Schema.Struct({ data: Group.Info }),
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.delete("persistentPty.group.remove", "/api/pty-group/:groupID", {
+      params: { groupID: Group.ID },
+      success: HttpApiSchema.NoContent,
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.get("persistentPty.list", "/api/pty-group/:groupID/terminal", {
+      params: { groupID: Group.ID },
+      success: Schema.Struct({ data: Schema.Array(PersistentPty.Info) }),
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.post("persistentPty.create", "/api/pty-group/:groupID/terminal", {
+      params: { groupID: Group.ID },
+      payload: PersistentPty.CreateInput,
+      success: Schema.Struct({ data: PersistentPty.Info }),
+      error: errors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.post("persistentPty.shutdown", "/api/persistent-pty/shutdown", {
+      success: HttpApiSchema.NoContent,
+      error: [ServiceUnavailableError],
+    }),
+  )
+  .add(
+    HttpApiEndpoint.get("persistentPty.get", "/api/persistent-pty/:ptyID", {
+      params: { ptyID: Pty.ID },
+      success: Schema.Struct({ data: PersistentPty.Info }),
+      error: terminalErrors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.put("persistentPty.update", "/api/persistent-pty/:ptyID", {
+      params: { ptyID: Pty.ID },
+      payload: PersistentPty.UpdateInput,
+      success: Schema.Struct({ data: PersistentPty.Info }),
+      error: terminalErrors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.get("persistentPty.snapshot", "/api/persistent-pty/:ptyID/snapshot", {
+      params: { ptyID: Pty.ID },
+      success: Schema.Struct({ data: PersistentPty.Snapshot }),
+      error: terminalErrors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.delete("persistentPty.remove", "/api/persistent-pty/:ptyID", {
+      params: { ptyID: Pty.ID },
+      success: HttpApiSchema.NoContent,
+      error: terminalErrors,
+    }),
+  )
+  .add(
+    HttpApiEndpoint.post("persistentPty.connectToken", "/api/persistent-pty/:ptyID/connect-token", {
+      params: { ptyID: Pty.ID },
+      success: Schema.Struct({ data: PtyTicket.ConnectToken }),
+      error: [ForbiddenError, PtyNotFoundError, ServiceUnavailableError],
+    }),
+  )
+  .add(
+    HttpApiEndpoint.get("persistentPty.connect", "/api/persistent-pty/:ptyID/connect", {
+      params: { ptyID: Pty.ID },
+      success: Schema.Boolean,
+      error: [ForbiddenError, PtyNotFoundError, ServiceUnavailableError],
+    }).annotateMerge(
+      OpenApi.annotations({
+        identifier: "v2.persistentPty.connect",
+        summary: "Connect to a persistent PTY",
+        description: "Stream persistent PTY output through the OpenCode server.",
+        transform: (operation) => ({ ...operation, "x-websocket": true }),
+      }),
+    ),
+  )
+  .annotateMerge(OpenApi.annotations({ title: "persistentPty", description: "Prototype persistent PTY routes." }))

packages/protocol/src/groups/worktree.ts

@@ -3,7 +3,7 @@ import { Worktree } from "@opencode-ai/schema/worktree"
 import { Schema, Struct } from "effect"
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
 
-const root = "/api/worktree/:projectID"
+const root = "/api/experimental/project/:projectID/worktree"
 
 export class WorktreeError extends Schema.ErrorClass<WorktreeError>("WorktreeError")(
   {

packages/protocol/src/simulation.ts

@@ -22,24 +22,13 @@ export namespace JsonRpc {
     data: Schema.optional(Schema.Json),
   })
 
-  export const Response = Schema.Union(
-    [
-      Schema.Struct({
-        jsonrpc: Schema.Literal("2.0"),
-        id: JsonRpcID,
-        result: Schema.Json,
-        error: Schema.optionalKey(Schema.Never),
-      }),
-      Schema.Struct({
-        jsonrpc: Schema.Literal("2.0"),
-        id: JsonRpcID,
-        result: Schema.optionalKey(Schema.Never),
-        error: ErrorObject,
-      }),
-    ],
-    { mode: "oneOf" },
-  )
-  export type Response = Schema.Schema.Type<typeof Response>
+  export const Response = Schema.Struct({
+    jsonrpc: Schema.Literal("2.0"),
+    id: JsonRpcID,
+    result: Schema.optional(Schema.Json),
+    error: Schema.optional(ErrorObject),
+  })
+  export interface Response extends Schema.Schema.Type<typeof Response> {}
 
   export const decodeRequest = Schema.decodeUnknownSync(Request)
 
@@ -60,28 +49,6 @@ export namespace JsonRpc {
   }
 }
 
-export class SimulationRequestError extends Schema.TaggedErrorClass<SimulationRequestError>()(
-  "SimulationRequestError",
-  {
-    method: Schema.String,
-    code: Schema.Number,
-    message: Schema.String,
-    data: Schema.optionalKey(Schema.Json),
-  },
-) {}
-
-const request = <
-  const Tag extends string,
-  Payload extends Schema.Top | Schema.Struct.Fields = typeof Schema.Void,
-  Success extends Schema.Top = typeof Schema.Void,
->(
-  tag: Tag,
-  options?: {
-    readonly payload?: Payload
-    readonly success?: Success
-  },
-) => Rpc.make(tag, { ...options, error: SimulationRequestError })
-
 export namespace Handshake {
   export const ProtocolVersion = Schema.Literal(1)
   export type ProtocolVersion = Schema.Schema.Type<typeof ProtocolVersion>
@@ -114,7 +81,7 @@ export namespace Handshake {
     protocolVersion: ProtocolVersion,
     role: EndpointRole,
     server: Identity,
-    capabilities: Schema.Array(Capability).check(Schema.isUnique()),
+    capabilities: Schema.Array(Capability),
   })
   export interface Response extends Schema.Schema.Type<typeof Response> {}
 
@@ -597,29 +564,30 @@ export namespace Backend {
     matched: Schema.Boolean,
   })
   export interface NetworkLogEntry extends Schema.Schema.Type<typeof NetworkLogEntry> {}
-
-  export const Notification = Schema.Union([
-    Schema.Struct({
-      jsonrpc: Schema.Literal("2.0"),
-      method: Schema.Literal("llm.request"),
-      params: ProviderInvocation,
-    }),
-    Schema.Struct({
-      jsonrpc: Schema.Literal("2.0"),
-      method: Schema.Literal("tool.invocation"),
-      params: ToolInvocation,
-    }),
-    Schema.Struct({
-      jsonrpc: Schema.Literal("2.0"),
-      method: Schema.Literal("tool.cancel"),
-      params: ToolCancellation,
-    }),
-  ])
-  export type Notification = Schema.Schema.Type<typeof Notification>
-  export const decodeNotification = Schema.decodeUnknownSync(Notification)
-  export const decodeNotificationEffect = Schema.decodeUnknownEffect(Schema.fromJsonString(Notification))
 }
 
+export class SimulationRequestError extends Schema.TaggedErrorClass<SimulationRequestError>()(
+  "SimulationRequestError",
+  {
+    method: Schema.String,
+    code: Schema.Number,
+    message: Schema.String,
+    data: Schema.optionalKey(Schema.Json),
+  },
+) {}
+
+const request = <
+  const Tag extends string,
+  Payload extends Schema.Top | Schema.Struct.Fields = typeof Schema.Void,
+  Success extends Schema.Top = typeof Schema.Void,
+>(
+  tag: Tag,
+  options?: {
+    readonly payload?: Payload
+    readonly success?: Success
+  },
+) => Rpc.make(tag, { ...options, error: SimulationRequestError })
+
 export const UiRpcs = RpcGroup.make(
   request("simulation.handshake", { payload: Handshake.Params, success: Handshake.Response }),
   request("ui.state", { success: Frontend.State }),

packages/schema/AGENTS.md

@@ -14,7 +14,7 @@
 - Current contracts are unversioned: use names like `Session`, `Permission`, `Question`, and identifiers like `Permission.Request`.
 - Legacy contracts retained for active compatibility, persistence, or migration are explicitly `V1`: use names like `SessionV1`, `PermissionV1`, and identifiers like `PermissionV1.Request`.
 - Do not preserve `V2` as the permanent name for the replacement architecture. Remove `V2` from current namespaces, brands, and identifiers as the contracts are normalized.
-- Retained V1 contracts live under `src/v1/`. New/current code must not depend on that subtree.
+- Retained V1 contracts should live under a dedicated `src/v1/` subtree once the V1 isolation PR runs. New/current code must not depend on that subtree.
 - V1 coexistence is temporary. Keep compatibility entrypoints only where migration requires them, and delete the V1 subtree when the legacy runtime is retired.
 - `@opencode-ai/protocol` and `@opencode-ai/sdk-next` are current `/api/...` surfaces.
 

packages/schema/src/config.ts

@@ -94,7 +94,7 @@ export class Info extends Schema.Class<Info>("Config.Info")({
   references: ConfigReference.Info.pipe(optional).annotate({
     description: "Named local directories or Git repositories available as external context",
   }),
-  websearch: ConfigWebSearch.Selection.pipe(optional).annotate({
+  websearch: ConfigWebSearch.Info.pipe(optional).annotate({
     description: "Web search provider selection",
   }),
   plugins: ConfigPlugin.Plugins.pipe(optional).annotate({
@@ -109,7 +109,7 @@ export class Info extends Schema.Class<Info>("Config.Info")({
 
 export class Document extends Schema.Class<Document>("Config.Document")({
   type: Schema.Literal("document"),
-  path: AbsolutePath.pipe(optional),
+  path: Schema.String.pipe(optional),
   info: Info,
 }) {}
 
@@ -118,6 +118,11 @@ export class Directory extends Schema.Class<Directory>("Config.Directory")({
   path: AbsolutePath,
 }) {}
 
+export class File extends Schema.Class<File>("Config.File")({
+  type: Schema.Literal("file"),
+  path: AbsolutePath,
+}) {}
+
 export class AgentsDirectory extends Schema.Class<AgentsDirectory>("Config.AgentsDirectory")({
   type: Schema.Literal("agents"),
   path: AbsolutePath,
@@ -128,7 +133,7 @@ export class ClaudeDirectory extends Schema.Class<ClaudeDirectory>("Config.Claud
   path: AbsolutePath,
 }) {}
 
-export const Entry = Schema.Union([Document, Directory, AgentsDirectory, ClaudeDirectory]).annotate({
+export const Entry = Schema.Union([Document, Directory, File, AgentsDirectory, ClaudeDirectory]).annotate({
   identifier: "Config.Entry",
 })
 export type Entry = typeof Entry.Type

packages/schema/src/config/websearch.ts

@@ -4,8 +4,5 @@ import { Schema } from "effect"
 import { WebSearch } from "../websearch.js"
 
 export class Info extends Schema.Class<Info>("ConfigWebSearch.Info")({
-  provider: Schema.Union([Schema.Literal("random"), WebSearch.ID]),
+  provider: WebSearch.ID,
 }) {}
-
-export const Selection = Schema.Union([Schema.Literal(false), Info])
-export type Selection = typeof Selection.Type

packages/schema/src/event-manifest.ts

@@ -10,6 +10,7 @@ import { Event } from "./event.js"
 import { FileSystem } from "./filesystem.js"
 import { FileSystemV1 } from "./filesystem-v1.js"
 import { Form } from "./form.js"
+import { Group } from "./group.js"
 import { InstallationEvent } from "./installation-event.js"
 import { Integration } from "./integration.js"
 import { LegacyEventV1 } from "./legacy-event.js"
@@ -56,6 +57,7 @@ const featureDefinitions = Event.inventory(
   ...Pty.Event.Definitions,
   ...Shell.Event.Definitions,
   ...Form.Event.Definitions,
+  ...Group.Event.Definitions,
   ...WebSearch.Event.Definitions,
 )
 

packages/schema/src/group.ts

@@ -0,0 +1,43 @@
+export * as Group from "./group.js"
+
+import { Schema } from "effect"
+import { ephemeral, inventory } from "./event.js"
+import { ascending } from "./identifier.js"
+import { Pty } from "./pty.js"
+import { statics } from "./schema.js"
+import { Session } from "./session.js"
+
+const IDSchema = Schema.String.check(Schema.isStartsWith("grp_")).pipe(Schema.brand("GroupID"))
+
+export const ID = IDSchema.pipe(
+  statics((schema: typeof IDSchema) => ({ create: () => schema.make("grp_" + ascending()) })),
+)
+export type ID = typeof ID.Type
+
+export const SessionItem = Schema.Struct({
+  type: Schema.tag("session"),
+  id: Session.ID,
+})
+export interface SessionItem extends Schema.Schema.Type<typeof SessionItem> {}
+
+export const TerminalItem = Schema.Struct({
+  type: Schema.tag("terminal"),
+  id: Pty.ID,
+})
+export interface TerminalItem extends Schema.Schema.Type<typeof TerminalItem> {}
+
+export const Item = Schema.Union([SessionItem, TerminalItem]).pipe(
+  Schema.toTaggedUnion("type"),
+  Schema.annotate({ identifier: "Group.Item" }),
+)
+export type Item = typeof Item.Type
+
+export const Info = Schema.Struct({
+  id: ID,
+  items: Schema.Array(Item),
+}).annotate({ identifier: "Group.Info" })
+export interface Info extends Schema.Schema.Type<typeof Info> {}
+
+const ItemAdded = ephemeral({ type: "group.item.added", schema: { groupID: ID, item: Item } })
+const ItemRemoved = ephemeral({ type: "group.item.removed", schema: { groupID: ID, item: Item } })
+export const Event = { ItemAdded, ItemRemoved, Definitions: inventory(ItemAdded, ItemRemoved) }

packages/schema/src/index.ts

@@ -6,6 +6,7 @@ export { Credential } from "./credential.js"
 export { Event } from "./event.js"
 export { FileSystem } from "./filesystem.js"
 export { Form } from "./form.js"
+export { Group } from "./group.js"
 export { Integration } from "./integration.js"
 export { LLM } from "./llm.js"
 export { AI } from "./ai.js"
@@ -31,6 +32,7 @@ export { Shell } from "./shell.js"
 export { Skill } from "./skill.js"
 export { TokenUsage } from "./token-usage.js"
 export { Pty } from "./pty.js"
+export { PersistentPty } from "./persistent-pty.js"
 export { PtyTicket } from "./pty-ticket.js"
 export { Question } from "./question.js"
 export { Workspace } from "./workspace.js"

packages/schema/src/persistent-pty.ts

@@ -0,0 +1,38 @@
+export * as PersistentPty from "./persistent-pty.js"
+
+import { Schema } from "effect"
+import { Group } from "./group.js"
+import { Pty } from "./pty.js"
+import { NonNegativeInt, PositiveInt, optional } from "./schema.js"
+
+export const Info = Schema.Struct({
+  ...Pty.Info.fields,
+  groupID: Group.ID,
+  size: Schema.Struct({ cols: PositiveInt, rows: PositiveInt }),
+  output: Schema.Struct({ head: NonNegativeInt, tail: NonNegativeInt }),
+}).annotate({ identifier: "PersistentPty.Info" })
+export interface Info extends Schema.Schema.Type<typeof Info> {}
+
+export const CreateInput = Schema.Struct({
+  command: Schema.String,
+  args: Schema.Array(Schema.String),
+  cwd: Schema.String,
+  title: Schema.String,
+  env: Schema.Record(Schema.String, Schema.String),
+  size: optional(Schema.Struct({ cols: PositiveInt, rows: PositiveInt })),
+}).annotate({ identifier: "PersistentPty.CreateInput" })
+export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {}
+
+export const UpdateInput = Schema.Struct({
+  attachmentID: optional(Schema.String),
+  size: Schema.Struct({ cols: PositiveInt, rows: PositiveInt }),
+}).annotate({ identifier: "PersistentPty.UpdateInput" })
+export interface UpdateInput extends Schema.Schema.Type<typeof UpdateInput> {}
+
+export const Snapshot = Schema.Struct({
+  info: Info,
+  text: Schema.String,
+  checkpoint: Schema.Uint8Array,
+  cursor: Schema.Struct({ x: NonNegativeInt, y: NonNegativeInt }),
+}).annotate({ identifier: "PersistentPty.Snapshot" })
+export interface Snapshot extends Schema.Schema.Type<typeof Snapshot> {}

packages/schema/test/config.test.ts

@@ -6,22 +6,13 @@ import { ConfigMCP } from "../src/config/mcp.js"
 import { ConfigProvider } from "../src/config/provider.js"
 import { Mcp } from "../src/mcp.js"
 import { AbsolutePath } from "../src/schema.js"
-import { WebSearch } from "../src/websearch.js"
 
 describe("Config.Entry", () => {
-  test("accepts disabled, fixed, and random web search selection", () => {
-    const decode = Schema.decodeUnknownSync(Config.Info)
-
-    expect(decode({ websearch: false }).websearch).toBe(false)
-    expect(decode({ websearch: { provider: "exa" } }).websearch).toEqual({ provider: WebSearch.ID.make("exa") })
-    expect(decode({ websearch: { provider: "random" } }).websearch).toEqual({ provider: "random" })
-  })
-
   test("round-trips every configuration entry type", () => {
     const entries = [
       new Config.Document({
         type: "document",
-        path: AbsolutePath.make("/project/opencode.json"),
+        path: "/project/opencode.json",
         info: new Config.Info({
           permissions: [
             { action: "shell", resource: "*", effect: "ask" },
@@ -31,6 +22,7 @@ describe("Config.Entry", () => {
       }),
       new Config.Document({ type: "document", info: new Config.Info({ shell: "/bin/zsh" }) }),
       new Config.Directory({ type: "directory", path: AbsolutePath.make("/project/.opencode") }),
+      new Config.File({ type: "file", path: AbsolutePath.make("/project/opencode.json") }),
       new Config.AgentsDirectory({ type: "agents", path: AbsolutePath.make("/project/.agents") }),
       new Config.ClaudeDirectory({ type: "claude", path: AbsolutePath.make("/project/.claude") }),
     ]
@@ -41,7 +33,14 @@ describe("Config.Entry", () => {
     expect(decoded).toEqual(entries)
     expect(decoded[0]).toBeInstanceOf(Config.Document)
     expect(decoded[1]).not.toHaveProperty("path")
-    expect(decoded.map((entry) => entry.type)).toEqual(["document", "document", "directory", "agents", "claude"])
+    expect(decoded.map((entry) => entry.type)).toEqual([
+      "document",
+      "document",
+      "directory",
+      "file",
+      "agents",
+      "claude",
+    ])
     expect(decoded[0]?.type === "document" ? decoded[0].info.permissions : undefined).toEqual([
       { action: "shell", resource: "*", effect: "ask" },
       { action: "shell", resource: "git status", effect: "allow" },

packages/schema/test/event-manifest.test.ts

@@ -4,6 +4,7 @@ import {
   Config,
   FileSystem,
   Form,
+  Group,
   Integration,
   Permission,
   Project,
@@ -64,6 +65,7 @@ describe("public event manifest", () => {
     expect(Integration.Event.Definitions).toEqual([Integration.Event.Updated, Integration.Event.ConnectionUpdated])
     expect(Permission.Event.Definitions).toEqual([Permission.Event.Asked, Permission.Event.Replied])
     expect(Form.Event.Definitions).toEqual([Form.Event.Created, Form.Event.Replied, Form.Event.Cancelled])
+    expect(Group.Event.Definitions).toEqual([Group.Event.ItemAdded, Group.Event.ItemRemoved])
     expect(Reference.Event.Definitions).toEqual([Reference.Event.Updated])
     expect(Plugin.Event.Definitions).toEqual([Plugin.Event.Added, Plugin.Event.Updated])
     expect(McpEvent.Definitions).toEqual([McpEvent.ToolsChanged, McpEvent.ResourcesChanged, McpEvent.StatusChanged])

packages/schema/test/group.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test"
+import { Schema } from "effect"
+import { Group } from "../src/group.js"
+import { Pty } from "../src/pty.js"
+import { Session } from "../src/session.js"
+
+describe("Group", () => {
+  test("creates branded group IDs", () => {
+    expect(Group.ID.create()).toStartWith("grp_")
+    expect(() => Schema.decodeUnknownSync(Group.ID)("ses_invalid")).toThrow()
+  })
+
+  test("preserves one ordered session and terminal item list", () => {
+    const group = Schema.decodeUnknownSync(Group.Info)({
+      id: Group.ID.create(),
+      items: [
+        { type: "session", id: Session.ID.make("ses_one") },
+        { type: "terminal", id: Pty.ID.make("pty_one") },
+        { type: "session", id: Session.ID.make("ses_two") },
+      ],
+    })
+
+    expect(group.items.map((item) => item.type)).toEqual(["session", "terminal", "session"])
+    expect(() =>
+      Schema.decodeUnknownSync(Group.Info)({
+        id: group.id,
+        items: [{ type: "other", id: "other_one" }],
+      }),
+    ).toThrow()
+  })
+})

packages/server/src/handlers.ts

@@ -16,6 +16,7 @@ import { HealthHandler } from "./handlers/health"
 import { ServerHandler } from "./handlers/server"
 import { DebugHandler } from "./handlers/debug"
 import { PtyHandler } from "./handlers/pty"
+import { PersistentPtyHandler } from "./handlers/persistent-pty"
 import { ShellHandler } from "./handlers/shell"
 import { ReferenceHandler } from "./handlers/reference"
 import { LocationHandler } from "./handlers/location"
@@ -55,6 +56,7 @@ export const handlers = Layer.mergeAll(
   SkillHandler,
   EventHandler.pipe(Layer.provide(EventFeed.layer)),
   PtyHandler,
+  PersistentPtyHandler,
   ShellHandler,
   ReferenceHandler,
   WorktreeHandler,

packages/server/src/handlers/persistent-pty.ts

@@ -0,0 +1,290 @@
+import { Group, PersistentPty } from "@opencode-ai/core/persistent-pty"
+import { PtyTicket } from "@opencode-ai/core/pty/ticket"
+import {
+  ForbiddenError,
+  InvalidRequestError,
+  PtyNotFoundError,
+  ServiceUnavailableError,
+} from "@opencode-ai/protocol/errors"
+import {
+  PTY_CONNECT_TICKET_QUERY,
+  PTY_CONNECT_TOKEN_HEADER,
+  PTY_CONNECT_TOKEN_HEADER_VALUE,
+} from "@opencode-ai/protocol/groups/persistent-pty"
+import { Effect, Queue } from "effect"
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi"
+import { Socket } from "effect/unstable/socket"
+import { Api } from "../api"
+import { CorsConfig, isAllowedRequestOrigin } from "../cors"
+
+export const PersistentPtyHandler = HttpApiBuilder.group(Api, "server.persistentPty", (handlers) =>
+  Effect.gen(function* () {
+    const tickets = yield* PtyTicket.Service
+    const cors = yield* CorsConfig
+    const groups = yield* Group.Service
+    const pty = yield* PersistentPty.Service
+
+    return handlers
+      .handle(
+        "persistentPty.group.list",
+        Effect.fn(function* () {
+          return { data: yield* groups.list() }
+        }),
+      )
+      .handle(
+        "persistentPty.group.create",
+        Effect.fn(function* (ctx) {
+          return { data: yield* groups.create(ctx.payload.items) }
+        }),
+      )
+      .handle(
+        "persistentPty.group.get",
+        Effect.fn(function* (ctx) {
+          const group = yield* groups.get(ctx.params.groupID)
+          if (!group)
+            return yield* new InvalidRequestError({
+              message: `Group not found: ${ctx.params.groupID}`,
+              field: "groupID",
+            })
+          return { data: group }
+        }),
+      )
+      .handle(
+        "persistentPty.group.set",
+        Effect.fn(function* (ctx) {
+          const group = Group.Info.make({ id: ctx.params.groupID, items: ctx.payload.items })
+          yield* groups.set(group)
+          return { data: group }
+        }),
+      )
+      .handle(
+        "persistentPty.group.remove",
+        Effect.fn(function* (ctx) {
+          yield* groups.remove(ctx.params.groupID)
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+      .handle(
+        "persistentPty.list",
+        Effect.fn(function* (ctx) {
+          return { data: yield* pty.list(ctx.params.groupID).pipe(mapUnavailable) }
+        }),
+      )
+      .handle(
+        "persistentPty.create",
+        Effect.fn(function* (ctx) {
+          return {
+            data: yield* pty
+              .create(ctx.params.groupID, {
+                command: ctx.payload.command,
+                args: ctx.payload.args,
+                cwd: ctx.payload.cwd,
+                title: ctx.payload.title,
+                env: ctx.payload.env,
+                cols: ctx.payload.size?.cols,
+                rows: ctx.payload.size?.rows,
+              })
+              .pipe(
+                Effect.catchTags({
+                  "PersistentPty.GroupNotFoundError": () =>
+                    new InvalidRequestError({
+                      message: `Group not found: ${ctx.params.groupID}`,
+                      field: "groupID",
+                    }),
+                  "PersistentPty.UnavailableError": unavailable,
+                }),
+              ),
+          }
+        }),
+      )
+      .handle(
+        "persistentPty.shutdown",
+        Effect.fn(function* () {
+          yield* pty.shutdown().pipe(mapUnavailable)
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+      .handle(
+        "persistentPty.get",
+        Effect.fn(function* (ctx) {
+          return { data: yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError) }
+        }),
+      )
+      .handle(
+        "persistentPty.update",
+        Effect.fn(function* (ctx) {
+          yield* pty
+            .resize(
+              ctx.params.ptyID,
+              ctx.payload.size.cols,
+              ctx.payload.size.rows,
+              ctx.payload.attachmentID,
+            )
+            .pipe(mapTerminalError)
+          return { data: yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError) }
+        }),
+      )
+      .handle(
+        "persistentPty.snapshot",
+        Effect.fn(function* (ctx) {
+          return { data: yield* pty.snapshot(ctx.params.ptyID).pipe(mapTerminalError) }
+        }),
+      )
+      .handle(
+        "persistentPty.remove",
+        Effect.fn(function* (ctx) {
+          yield* pty.remove(ctx.params.ptyID).pipe(mapTerminalError)
+          return HttpApiSchema.NoContent.make()
+        }),
+      )
+      .handle(
+        "persistentPty.connectToken",
+        Effect.fn(function* (ctx) {
+          const request = yield* HttpServerRequest.HttpServerRequest
+          if (
+            request.headers[PTY_CONNECT_TOKEN_HEADER] !== PTY_CONNECT_TOKEN_HEADER_VALUE ||
+            !isAllowedRequestOrigin(request.headers.origin, request.headers.host, cors)
+          )
+            return yield* new ForbiddenError({ message: "Invalid persistent PTY connect token request" })
+          yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError)
+          return { data: yield* tickets.issue({ ptyID: ctx.params.ptyID }) }
+        }),
+      )
+      .handleRaw(
+        "persistentPty.connect",
+        Effect.fn("PersistentPtyHandler.connect")(function* (ctx) {
+          const exists = yield* pty.get(ctx.params.ptyID).pipe(
+            Effect.as(true),
+            Effect.catchTag("PersistentPty.NotFoundError", () => Effect.succeed(false)),
+            Effect.catchTag("PersistentPty.UnavailableError", () => Effect.succeed(false)),
+          )
+          if (!exists) return HttpServerResponse.empty({ status: 404 })
+
+          const url = new URL(ctx.request.url, "http://localhost")
+          const ticket = url.searchParams.get(PTY_CONNECT_TICKET_QUERY)
+          if (ticket) {
+            const valid = isAllowedRequestOrigin(ctx.request.headers.origin, ctx.request.headers.host, cors)
+              ? yield* tickets.consume({ ticket, ptyID: ctx.params.ptyID })
+              : false
+            if (!valid) return HttpServerResponse.empty({ status: 403 })
+          }
+
+          const cursor = Number(url.searchParams.get("cursor") ?? "0")
+          const role = url.searchParams.get("role") === "observer" ? "observer" : "controller"
+          const framedInput = url.searchParams.get("input_protocol") === "1"
+          const attachmentID = url.searchParams.get("attachment_id") ?? crypto.randomUUID()
+          if (!Number.isSafeInteger(cursor) || cursor < 0) return HttpServerResponse.empty({ status: 400 })
+
+          const socket = yield* Effect.orDie(ctx.request.upgrade)
+          const write = yield* socket.writer
+          const outbox = yield* Queue.unbounded<string | Uint8Array | Socket.CloseEvent>()
+          const attachment = yield* pty
+            .attach(ctx.params.ptyID, {
+              cursor,
+              attachmentID,
+              role,
+              takeover: url.searchParams.get("takeover") === "true",
+              onEvent: (event) => {
+                if (event.type === "output") Queue.offerUnsafe(outbox, event.data)
+                if (event.type === "resized")
+                  Queue.offerUnsafe(
+                    outbox,
+                    JSON.stringify({ ...event, checkpoint: Buffer.from(event.checkpoint).toString("base64") }),
+                  )
+                if (event.type !== "output" && event.type !== "resized")
+                  Queue.offerUnsafe(outbox, JSON.stringify(event))
+              },
+              onEnd: () => Queue.offerUnsafe(outbox, new Socket.CloseEvent(1000)),
+            })
+            .pipe(
+              Effect.catchTags({
+                "PersistentPty.NotFoundError": () => Effect.succeed(undefined),
+                "PersistentPty.UnavailableError": () => Effect.succeed(undefined),
+              }),
+            )
+          if (!attachment) return HttpServerResponse.empty({ status: 404 })
+
+          Queue.offerUnsafe(
+            outbox,
+            JSON.stringify({
+              type: "attached",
+              attachmentID,
+              inputProtocol: framedInput ? 1 : 0,
+              info: attachment.info,
+              role: attachment.role,
+              generation: attachment.generation,
+              replay: {
+                requestedOffset: attachment.replay.requestedOffset,
+                availableOffset: attachment.replay.availableOffset,
+                endOffset: attachment.replay.endOffset,
+                truncated: attachment.replay.truncated,
+              },
+            }),
+          )
+          if (attachment.replay.data.length > 0) Queue.offerUnsafe(outbox, attachment.replay.data)
+          Queue.offerUnsafe(
+            outbox,
+            JSON.stringify({ type: "replay_complete", endOffset: attachment.replay.endOffset }),
+          )
+          attachment.activate()
+
+          const drain = Effect.gen(function* () {
+            while (true) {
+              const item = yield* Queue.take(outbox)
+              yield* write(item)
+              if (item instanceof Socket.CloseEvent) return
+            }
+          })
+
+          yield* Effect.race(
+            drain,
+            socket.runRaw((message) => {
+              if (role !== "controller") return Effect.void
+              const data = typeof message === "string" ? Buffer.from(message) : message
+              if (!framedInput)
+                return pty
+                  .input(
+                    ctx.params.ptyID,
+                    attachmentID,
+                    attachment.info.size.cols,
+                    attachment.info.size.rows,
+                    data,
+                  )
+                  .pipe(Effect.ignore)
+              if (data.byteLength < 5) return Effect.void
+              const view = new DataView(data.buffer, data.byteOffset, data.byteLength)
+              const type = data[0]
+              const cols = view.getUint16(1)
+              const rows = view.getUint16(3)
+              if ((type !== 0 && type !== 1) || cols === 0 || rows === 0) return Effect.void
+              if (type === 0) return pty.control(ctx.params.ptyID, attachmentID, cols, rows).pipe(Effect.ignore)
+              return pty.input(ctx.params.ptyID, attachmentID, cols, rows, data.subarray(5)).pipe(Effect.ignore)
+            }),
+          ).pipe(
+            Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void),
+            Effect.ensuring(Effect.sync(() => attachment.detach())),
+            Effect.orDie,
+          )
+          return HttpServerResponse.empty()
+        }),
+      )
+  }),
+)
+
+const mapUnavailable = <A>(effect: Effect.Effect<A, PersistentPty.UnavailableError>) =>
+  effect.pipe(Effect.catchTag("PersistentPty.UnavailableError", unavailable))
+
+const mapTerminalError = <A>(
+  effect: Effect.Effect<A, PersistentPty.NotFoundError | PersistentPty.UnavailableError>,
+) =>
+  effect.pipe(
+    Effect.catchTags({
+      "PersistentPty.NotFoundError": (error) =>
+        new PtyNotFoundError({ ptyID: error.ptyID, message: `PTY session not found: ${error.ptyID}` }),
+      "PersistentPty.UnavailableError": unavailable,
+    }),
+  )
+
+const unavailable = (error: PersistentPty.UnavailableError) =>
+  new ServiceUnavailableError({ message: error.message, service: "opencode-pty" })

packages/server/src/middleware/authorization.ts

@@ -3,6 +3,7 @@ import { UnauthorizedError } from "@opencode-ai/protocol/errors"
 import { Authorization } from "@opencode-ai/protocol/middleware/authorization"
 export { Authorization } from "@opencode-ai/protocol/middleware/authorization"
 import { hasPtyConnectTicketURL } from "@opencode-ai/protocol/groups/pty"
+import { hasPersistentPtyConnectTicketURL } from "@opencode-ai/protocol/groups/persistent-pty"
 import { Effect, Encoding, Layer, Redacted } from "effect"
 import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 
@@ -49,7 +50,8 @@ export const authorizationLayer = Layer.effect(
         const request = yield* HttpServerRequest.HttpServerRequest
         // Browsers cannot set headers on WebSocket upgrades, so a ticketed PTY connect skips
         // credential checks here; the connect handler consumes and validates the ticket.
-        if (hasPtyConnectTicketURL(new URL(request.url, "http://localhost"))) return yield* effect
+        const url = new URL(request.url, "http://localhost")
+        if (hasPtyConnectTicketURL(url) || hasPersistentPtyConnectTicketURL(url)) return yield* effect
         if (yield* authorizedRequest(request, config)) return yield* effect
         yield* HttpEffect.appendPreResponseHandler((_request, response) =>
           Effect.succeed(HttpServerResponse.setHeader(response, "www-authenticate", WWW_AUTHENTICATE)),

packages/server/src/process.ts

@@ -4,6 +4,7 @@ import { NodeHttpServer, NodeHttpServerRequest } from "@effect/platform-node"
 import { SessionRestart } from "@opencode-ai/core/session/execution/restart"
 import { ServiceStatus } from "@opencode-ai/protocol/groups/health"
 import { hasPtyConnectTicketURL } from "@opencode-ai/protocol/groups/pty"
+import { hasPersistentPtyConnectTicketURL } from "@opencode-ai/protocol/groups/persistent-pty"
 import { Cause, Context, Deferred, Effect, Exit, Layer, Option, Ref, Schema, Scope } from "effect"
 import { HttpMiddleware, HttpRouter, HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http"
 import { randomUUID } from "node:crypto"
@@ -183,7 +184,11 @@ function dispatch(
     const state = yield* status.current
     const app = yield* Ref.get(application)
     const ready = state.type === "ready" && Option.isSome(app)
-    if ((!ready || !hasPtyConnectTicketURL(url)) && !(yield* authorizedRequest(request, auth))) return unauthorized()
+    if (
+      (!ready || (!hasPtyConnectTicketURL(url) && !hasPersistentPtyConnectTicketURL(url))) &&
+      !(yield* authorizedRequest(request, auth))
+    )
+      return unauthorized()
     if (ready) return yield* app.value
     return unavailable(state)
   })

packages/server/src/routes.ts

@@ -13,6 +13,7 @@ import { Command } from "@opencode-ai/core/command"
 import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { PtyTicket } from "@opencode-ai/core/pty/ticket"
 import { Pty } from "@opencode-ai/core/pty"
+import { Group, PersistentPty } from "@opencode-ai/core/persistent-pty"
 import { Project } from "@opencode-ai/core/project"
 import { Session } from "@opencode-ai/core/session"
 import { SessionTransfer } from "@opencode-ai/core/session/transfer"
@@ -60,6 +61,8 @@ const applicationServiceNodes = [
   SdkPlugins.node,
   PermissionSaved.node,
   PtyTicket.node,
+  Group.node,
+  PersistentPty.node,
   Credential.node,
   WellKnown.node,
   PtyEnvironment.node,

packages/server/test/config.test.ts

@@ -7,7 +7,6 @@ import { HttpServer } from "effect/unstable/http"
 import { tmpdir } from "../../core/test/fixture/tmpdir"
 import { it } from "../../core/test/lib/effect"
 import { ServerProcess } from "../src/process"
-import { AbsolutePath } from "@opencode-ai/schema/schema"
 
 it.live("returns ordered config entries for the requested directory", () =>
   Effect.acquireUseRelease(
@@ -58,7 +57,7 @@ it.live("returns ordered config entries for the requested directory", () =>
           { action: "shell", resource: "*", effect: "ask" },
           { action: "shell", resource: "git status", effect: "allow" },
         ])
-        expect(document?.path).toBe(AbsolutePath.make(config))
+        expect(entries.some((entry) => entry.type === "file" && entry.path === config)).toBe(true)
         if (!Array.isArray(body)) throw new Error("Expected a config entry array")
         const raw = body.find((entry) => isRecord(entry) && entry["type"] === "document" && entry["path"] === config)
         if (!isRecord(raw) || !isRecord(raw["info"])) throw new Error("Expected a config document")

packages/server/test/persistent-pty.test.ts

@@ -0,0 +1,397 @@
+import { existsSync } from "node:fs"
+import fs from "node:fs/promises"
+import { createHash } from "node:crypto"
+import os from "node:os"
+import path from "node:path"
+import { expect } from "bun:test"
+import { Group } from "@opencode-ai/schema/group"
+import { PersistentPty } from "@opencode-ai/schema/persistent-pty"
+import { Effect, Schema } from "effect"
+import { HttpServer } from "effect/unstable/http"
+import { it } from "../../core/test/lib/effect"
+import { ServerProcess } from "../src/process"
+
+const binary = process.env.OPENCODE_PTY_BIN ?? "/root/projects/opencode-pty/target/debug/opencode-pty"
+const smoke = existsSync(binary) ? it.live : it.live.skip
+
+smoke(
+  "creates a group with two persistent terminals through the client API",
+  () =>
+    Effect.acquireUseRelease(
+      Effect.promise(async () => {
+        const environment = {
+          binary: process.env.OPENCODE_PTY_BIN,
+          runtime: process.env.OPENCODE_PTY_RUNTIME_DIR,
+          xdg: process.env.XDG_RUNTIME_DIR,
+        }
+        const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-pty-server-test-"))
+        const database = path.join(root, "opencode.db")
+        const runtime = path.join(root, "runtime")
+        process.env.OPENCODE_PTY_BIN = binary
+        delete process.env.OPENCODE_PTY_RUNTIME_DIR
+        process.env.XDG_RUNTIME_DIR = runtime
+        return {
+          database,
+          directory: path.join(
+            runtime,
+            "opencode-pty",
+            createHash("sha256").update(database).digest("hex").slice(0, 16),
+          ),
+          environment,
+          root,
+        }
+      }),
+      (fixture) =>
+        Effect.gen(function* () {
+          const server = yield* ServerProcess.start<never, never>({
+            hostname: "127.0.0.1",
+            port: 0,
+            password: "secret",
+            app: { version: "test-version" },
+            database: { path: fixture.database },
+            fs: { filewatcher: false },
+          })
+          const base = HttpServer.formatAddress(server.address)
+          expect(existsSync(path.join(fixture.directory, "service.json"))).toBeFalse()
+          const group = Schema.decodeUnknownSync(Group.Info)(
+            (yield* request(base, "POST", "/api/pty-group", { items: [] })).data,
+          )
+          expect((yield* request(base, "GET", `/api/pty-group/${group.id}/terminal`)).data).toEqual([])
+          expect(existsSync(path.join(fixture.directory, "service.json"))).toBeFalse()
+          const first = Schema.decodeUnknownSync(PersistentPty.Info)(
+            (
+              yield* request(base, "POST", `/api/pty-group/${group.id}/terminal`, {
+                command: "/bin/sh",
+                args: ["-c", "stty -echo; printf terminal-one; cat"],
+                cwd: process.cwd(),
+                title: "first",
+                env: {},
+              })
+            ).data,
+          )
+          expect(first.size).toEqual({ cols: 80, rows: 24 })
+          expect(existsSync(path.join(fixture.directory, "service.json"))).toBeTrue()
+          const second = Schema.decodeUnknownSync(PersistentPty.Info)(
+            (
+              yield* request(base, "POST", `/api/pty-group/${group.id}/terminal`, {
+                command: "/bin/sh",
+                args: ["-c", "printf terminal-two; sleep 30"],
+                cwd: process.cwd(),
+                title: "second",
+                env: {},
+              })
+            ).data,
+          )
+
+          const updated = Schema.decodeUnknownSync(Group.Info)(
+            (yield* request(base, "GET", `/api/pty-group/${group.id}`)).data,
+          )
+          expect(updated.items).toEqual([
+            { type: "terminal", id: first.id },
+            { type: "terminal", id: second.id },
+          ])
+
+          const terminals = Schema.decodeUnknownSync(Schema.Array(PersistentPty.Info))(
+            (yield* request(base, "GET", `/api/pty-group/${group.id}/terminal`)).data,
+          )
+          expect(terminals.map((terminal) => terminal.id).sort()).toEqual([first.id, second.id].sort())
+          expect(yield* waitForText(base, first.id, "terminal-one")).toContain("terminal-one")
+          expect(yield* waitForText(base, second.id, "terminal-two")).toContain("terminal-two")
+          yield* Effect.promise(() => verifySharedControl(base, first.id))
+          const snapshot = yield* request(base, "GET", `/api/persistent-pty/${first.id}/snapshot`)
+          if (
+            !isRecord(snapshot.data) ||
+            typeof snapshot.data.checkpoint !== "string" ||
+            !isRecord(snapshot.data.info) ||
+            !isRecord(snapshot.data.info.output) ||
+            typeof snapshot.data.info.output.tail !== "number"
+          )
+            throw new Error("Persistent PTY snapshot response was invalid")
+          expect(Buffer.from(snapshot.data.checkpoint, "base64").byteLength).toBeGreaterThan(0)
+          expect(snapshot.data.info.output.tail).toBeGreaterThan(0)
+
+          yield* request(base, "DELETE", `/api/persistent-pty/${first.id}`)
+          yield* request(base, "DELETE", `/api/persistent-pty/${second.id}`)
+          expect((yield* request(base, "GET", `/api/pty-group/${group.id}`)).data).toMatchObject({ items: [] })
+
+          yield* request(base, "POST", "/api/persistent-pty/shutdown")
+
+          const unattended = Schema.decodeUnknownSync(PersistentPty.Info)(
+            (
+              yield* request(base, "POST", `/api/pty-group/${group.id}/terminal`, {
+                command: "/bin/sh",
+                args: ["-c", "exit 7"],
+                cwd: process.cwd(),
+                title: "unattended",
+                env: {},
+              })
+            ).data,
+          )
+          yield* waitForStatus(base, unattended.id, "exited")
+          expect((yield* request(base, "GET", `/api/pty-group/${group.id}`)).data).toMatchObject({
+            items: [{ type: "terminal", id: unattended.id }],
+          })
+          yield* request(base, "DELETE", `/api/persistent-pty/${unattended.id}`)
+
+          const visible = Schema.decodeUnknownSync(PersistentPty.Info)(
+            (
+              yield* request(base, "POST", `/api/pty-group/${group.id}/terminal`, {
+                command: "/bin/sh",
+                args: ["-c", "read value"],
+                cwd: process.cwd(),
+                title: "visible",
+                env: {},
+              })
+            ).data,
+          )
+          yield* attachAndExit(base, visible.id)
+          yield* waitForGroupItems(base, group.id, [])
+          yield* request(base, "DELETE", `/api/pty-group/${group.id}`)
+        }),
+      (fixture) =>
+        Effect.promise(async () => {
+          await Bun.spawn([binary, "stop"], {
+            env: { ...process.env, OPENCODE_PTY_RUNTIME_DIR: fixture.directory },
+            stdout: "ignore",
+            stderr: "ignore",
+          }).exited
+          await fs.rm(fixture.root, { recursive: true, force: true })
+          restore("OPENCODE_PTY_BIN", fixture.environment.binary)
+          restore("OPENCODE_PTY_RUNTIME_DIR", fixture.environment.runtime)
+          restore("XDG_RUNTIME_DIR", fixture.environment.xdg)
+        }),
+    ),
+  20_000,
+)
+
+function request(base: string, method: string, pathname: string, body?: unknown, headers?: Record<string, string>) {
+  return Effect.tryPromise({
+    try: async () => {
+      const response = await fetch(new URL(pathname, base), {
+        method,
+        headers: {
+          authorization: `Basic ${btoa("opencode:secret")}`,
+          ...headers,
+          ...(body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+      })
+      if (!response.ok) throw new Error(`${method} ${pathname} failed (${response.status}): ${await response.text()}`)
+      if (response.status === 204) return {}
+      const value: unknown = await response.json()
+      if (!isRecord(value)) throw new Error(`${method} ${pathname} returned a non-object response`)
+      return value
+    },
+    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+  })
+}
+
+function waitForText(base: string, ptyID: string, expected: string) {
+  return Effect.tryPromise({
+    try: async () => {
+      for (let attempt = 0; attempt < 40; attempt++) {
+        const response = await Effect.runPromise(request(base, "GET", `/api/persistent-pty/${ptyID}/snapshot`))
+        if (isRecord(response.data) && typeof response.data.text === "string" && response.data.text.includes(expected))
+          return response.data.text
+        await Bun.sleep(50)
+      }
+      throw new Error(`Persistent PTY snapshot did not contain ${expected}`)
+    },
+    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+  })
+}
+
+function waitForStatus(base: string, ptyID: string, status: string) {
+  return Effect.tryPromise({
+    try: async () => {
+      for (let attempt = 0; attempt < 40; attempt++) {
+        const response = await Effect.runPromise(request(base, "GET", `/api/persistent-pty/${ptyID}`))
+        if (isRecord(response.data) && response.data.status === status) return
+        await Bun.sleep(50)
+      }
+      throw new Error(`Persistent PTY ${ptyID} did not reach status ${status}`)
+    },
+    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+  })
+}
+
+function attachAndExit(base: string, ptyID: string) {
+  return Effect.tryPromise({
+    try: async () => {
+      const response = await Effect.runPromise(
+        request(base, "POST", `/api/persistent-pty/${ptyID}/connect-token`, undefined, {
+          "x-opencode-ticket": "1",
+        }),
+      )
+      if (!isRecord(response.data) || typeof response.data.ticket !== "string")
+        throw new Error("Persistent PTY connect token response was invalid")
+      const url = new URL(`/api/persistent-pty/${ptyID}/connect`, base)
+      url.protocol = "ws:"
+      url.searchParams.set("ticket", response.data.ticket)
+      await new Promise<void>((resolve, reject) => {
+        const socket = new WebSocket(url)
+        const timeout = setTimeout(() => {
+          socket.close()
+          reject(new Error("Persistent PTY did not exit while attached"))
+        }, 5_000)
+        socket.addEventListener("message", (event) => {
+          if (typeof event.data !== "string") return
+          const message: unknown = JSON.parse(event.data)
+          if (!isRecord(message)) return
+          if (message.type === "attached") socket.send(new Uint8Array([4]))
+          if (message.type !== "exited") return
+          clearTimeout(timeout)
+          socket.close()
+          resolve()
+        })
+        socket.addEventListener("error", () => {
+          clearTimeout(timeout)
+          reject(new Error("Persistent PTY WebSocket failed"))
+        })
+      })
+    },
+    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+  })
+}
+
+async function verifySharedControl(base: string, ptyID: string) {
+  const first = await openTerminalSocket(base, ptyID, "first")
+  const second = await openTerminalSocket(base, ptyID, "second")
+  try {
+    first.socket.send(controlFrame(90, 25))
+    first.socket.send(inputFrame(90, 25, "from-first\n"))
+    await waitForSocketOutput([first, second], "from-first")
+
+    second.socket.send(inputFrame(70, 20, "from-second\n"))
+    await waitForSocketOutput([first, second], "from-second")
+
+    second.socket.send(inputFrame(70, 20, "x".repeat(1024 * 1024)))
+    second.socket.send(inputFrame(70, 20, "after-burst\n"))
+    await waitForSocketOutput([first, second], "after-burst")
+    expect(first.closed).toBeFalse()
+    expect(second.closed).toBeFalse()
+    expect(first.resizes).toBeGreaterThan(0)
+    expect(second.resizes).toBeGreaterThan(0)
+    expect(first.output).not.toContain("\0")
+    expect(second.output).not.toContain("\0")
+  } finally {
+    first.socket.close()
+    second.socket.close()
+  }
+}
+
+async function openTerminalSocket(base: string, ptyID: string, attachmentID: string) {
+  const response = await Effect.runPromise(
+    request(base, "POST", `/api/persistent-pty/${ptyID}/connect-token`, undefined, {
+      "x-opencode-ticket": "1",
+    }),
+  )
+  if (!isRecord(response.data) || typeof response.data.ticket !== "string")
+    throw new Error("Persistent PTY connect token response was invalid")
+  const url = new URL(`/api/persistent-pty/${ptyID}/connect`, base)
+  url.protocol = "ws:"
+  url.searchParams.set("ticket", response.data.ticket)
+  url.searchParams.set("attachment_id", attachmentID)
+  url.searchParams.set("takeover", "true")
+  url.searchParams.set("input_protocol", "1")
+  const state = { socket: new WebSocket(url), output: "", closed: false, resizes: 0 }
+  state.socket.binaryType = "arraybuffer"
+  await new Promise<void>((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error("Persistent PTY WebSocket did not attach")), 5_000)
+    let attached = false
+    state.socket.addEventListener("message", (event) => {
+      if (event.data instanceof ArrayBuffer) {
+        state.output += new TextDecoder().decode(event.data)
+        return
+      }
+      if (typeof event.data !== "string") return
+      const message: unknown = JSON.parse(event.data)
+      if (!isRecord(message)) return
+      if (message.type === "resized") {
+        if (typeof message.checkpoint !== "string") {
+          clearTimeout(timeout)
+          reject(new Error("Persistent PTY resize omitted its checkpoint"))
+          return
+        }
+        state.resizes++
+        return
+      }
+      if (message.type === "attached") {
+        if (message.inputProtocol === 1) {
+          attached = true
+          return
+        }
+        clearTimeout(timeout)
+        reject(new Error("Persistent PTY WebSocket did not negotiate framed input"))
+        return
+      }
+      if (message.type !== "replay_complete" || !attached) return
+      clearTimeout(timeout)
+      resolve()
+    })
+    state.socket.addEventListener("close", () => {
+      state.closed = true
+    })
+    state.socket.addEventListener("error", () => {
+      clearTimeout(timeout)
+      reject(new Error("Persistent PTY WebSocket failed"))
+    })
+  })
+  return state
+}
+
+function inputFrame(cols: number, rows: number, input: string) {
+  const data = new TextEncoder().encode(input)
+  const frame = new Uint8Array(5 + data.byteLength)
+  const view = new DataView(frame.buffer)
+  frame[0] = 1
+  view.setUint16(1, cols)
+  view.setUint16(3, rows)
+  frame.set(data, 5)
+  return frame
+}
+
+function controlFrame(cols: number, rows: number) {
+  const frame = new Uint8Array(5)
+  const view = new DataView(frame.buffer)
+  view.setUint16(1, cols)
+  view.setUint16(3, rows)
+  return frame
+}
+
+async function waitForSocketOutput(
+  sockets: Array<{ output: string; closed: boolean }>,
+  expected: string,
+) {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    if (sockets.every((socket) => socket.output.includes(expected))) return
+    if (sockets.some((socket) => socket.closed)) throw new Error("Persistent PTY observer disconnected")
+    await Bun.sleep(20)
+  }
+  throw new Error(
+    `Persistent PTY sockets did not both receive ${expected}: ${JSON.stringify(sockets.map((socket) => socket.output))}`,
+  )
+}
+
+function waitForGroupItems(base: string, groupID: string, expected: unknown[]) {
+  return Effect.tryPromise({
+    try: async () => {
+      for (let attempt = 0; attempt < 40; attempt++) {
+        const response = await Effect.runPromise(request(base, "GET", `/api/pty-group/${groupID}`))
+        if (isRecord(response.data) && JSON.stringify(response.data.items) === JSON.stringify(expected)) return
+        await Bun.sleep(50)
+      }
+      throw new Error(`Persistent PTY group ${groupID} did not reconcile`)
+    },
+    catch: (cause) => (cause instanceof Error ? cause : new Error(String(cause))),
+  })
+}
+
+function restore(key: string, value: string | undefined) {
+  if (value === undefined) delete process.env[key]
+  if (value !== undefined) process.env[key] = value
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}

packages/server/test/worktree.test.ts

@@ -36,7 +36,7 @@ it.live("lists, creates, and removes worktrees by project ID", () =>
         const resolved = yield* Effect.promise(() => fetch(location, { headers }).then((response) => response.json()))
         if (!isRecord(resolved) || !isRecord(resolved.project) || typeof resolved.project.id !== "string")
           throw new Error("Expected resolved project")
-        const url = new URL(`/api/worktree/${resolved.project.id}`, base)
+        const url = new URL(`/api/experimental/project/${resolved.project.id}/worktree`, base)
 
         const initial = yield* Effect.promise(() => fetch(url, { headers }).then((response) => response.json()))
         expect(initial).toEqual([{ directory: project }])

packages/simulation/test/protocol.test.ts

@@ -1,64 +1,6 @@
 import { describe, expect, test } from "bun:test"
 import { Effect, Schema } from "effect"
-import { Backend, Frontend, Handshake, JsonRpc } from "../src/protocol"
-
-const successResponse: Schema.Schema.Type<typeof JsonRpc.Response> = { jsonrpc: "2.0", id: 1, result: null }
-// @ts-expect-error responses require one outcome
-const missingResponse: Schema.Schema.Type<typeof JsonRpc.Response> = { jsonrpc: "2.0", id: 1 }
-// @ts-expect-error responses cannot contain both outcomes
-const invalidResponse: Schema.Schema.Type<typeof JsonRpc.Response> = {
-  jsonrpc: "2.0",
-  id: 1,
-  result: null,
-  error: { code: -32600, message: "Invalid request" },
-}
-void [successResponse, missingResponse, invalidResponse]
-
-test("normalizes an omitted finish reason", () => {
-  expect(Backend.decodeRequest({ jsonrpc: "2.0", id: 1, method: "llm.finish", params: { id: "inv_1" } })).toMatchObject(
-    { params: { id: "inv_1", reason: "stop" } },
-  )
-})
-
-test("decodes typed backend notifications", () => {
-  expect(
-    Backend.decodeNotification({
-      jsonrpc: "2.0",
-      method: "tool.cancel",
-      params: { id: "tool_1", reason: "interrupted" },
-    }),
-  ).toEqual({
-    jsonrpc: "2.0",
-    method: "tool.cancel",
-    params: { id: "tool_1", reason: "interrupted" },
-  })
-  expect(() =>
-    Backend.decodeNotification({
-      jsonrpc: "2.0",
-      method: "tool.cancel",
-      params: { id: "tool_1", reason: "unknown" },
-    }),
-  ).toThrow()
-})
-
-test("requires exactly one JSON-RPC response outcome", () => {
-  const decode = Schema.decodeUnknownSync(JsonRpc.Response)
-  expect(decode({ jsonrpc: "2.0", id: 1, result: null })).toEqual({ jsonrpc: "2.0", id: 1, result: null })
-  expect(decode({ jsonrpc: "2.0", id: 1, error: { code: -32600, message: "Invalid request" } })).toEqual({
-    jsonrpc: "2.0",
-    id: 1,
-    error: { code: -32600, message: "Invalid request" },
-  })
-  expect(() => decode({ jsonrpc: "2.0", id: 1 })).toThrow()
-  expect(() =>
-    decode({
-      jsonrpc: "2.0",
-      id: 1,
-      result: null,
-      error: { code: -32600, message: "Invalid request" },
-    }),
-  ).toThrow()
-})
+import { Backend, Frontend, Handshake } from "../src/protocol"
 
 test("decodes ui.matches text params", () => {
   expect(

packages/simulation/test/simulated-provider.test.ts

@@ -83,7 +83,7 @@ test("streams a Drive-controlled provider response and removes the finished invo
           jsonrpc: "2.0",
           id: 3,
           method: "llm.finish",
-          params: { id: params.id },
+          params: { id: params.id, reason: "stop" },
         }),
       )
       expect(yield* Queue.take(messages)).toMatchObject({ id: 3, result: { ok: true } })

packages/tui/src/app.tsx

@@ -31,7 +31,6 @@ import {
   batch,
   Show,
 } from "solid-js"
-import { createStore } from "solid-js/store"
 import {
   TuiLifecycleProvider,
   TuiAppProvider,
@@ -76,7 +75,6 @@ import { clampSessionTabsWidth, sessionTabsFitVertically, SESSION_SIDEBAR_WIDTH
 import { ThemeErrorToast } from "./component/theme-error-toast"
 import { createThemeSource, ThemeProvider, useTheme, useThemes } from "./context/theme"
 import { Home } from "./routes/home"
-import { Session } from "./routes/session"
 import { PromptHistoryProvider } from "./prompt/history"
 import { FrecencyProvider } from "./prompt/frecency"
 import { PromptStashProvider } from "./prompt/stash"
@@ -100,6 +98,8 @@ import { destroyRenderer } from "./util/renderer"
 import { cliErrorMessage, errorFormat } from "./util/error"
 import { AttentionProvider } from "./context/attention"
 import { StorageProvider, useStorage } from "./context/storage"
+import { PaneLayoutProvider } from "./context/pane-layout"
+import { PaneWorkspace } from "./component/pane-workspace"
 import { createTuiClipboard } from "./clipboard"
 
 registerOpencodeSpinner()
@@ -217,7 +217,7 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
         reconnect: async (signal: AbortSignal) => {
           const endpoint = await managed.reconnect(signal)
           const next = { baseUrl: endpoint.url, headers: Service.headers(endpoint) }
-          return { api: OpenCode.make(next) }
+          return { api: OpenCode.make(next), endpoint }
         },
         restart: managed.restart,
       }
@@ -372,48 +372,50 @@ export const run = Effect.fn("Tui.run")(function* (input: TuiInput) {
                                                 : undefined
                                             }
                                           >
-                                            <ClientProvider api={api} service={service}>
+                                            <ClientProvider api={api} endpoint={input.server.endpoint} service={service}>
                                               <PermissionProvider>
                                                 <DataProvider>
                                                   <LocationProvider>
                                                     <SessionTabsProvider>
-                                                      <ThemeProvider
-                                                        mode={mode}
-                                                        source={createThemeSource(global.config)}
-                                                      >
-                                                        <ThemeErrorToast />
-                                                        <LocalProvider>
-                                                          <PromptStashProvider>
-                                                            <DialogProvider>
-                                                              <FrecencyProvider>
-                                                                <PromptHistoryProvider>
-                                                                  <PromptRefProvider>
-                                                                    <EditorContextProvider>
-                                                                      <AttentionProvider>
-                                                                        <PluginProvider
-                                                                          packages={input.packages}
-                                                                          directories={pluginDirectories}
-                                                                        >
-                                                                          <App
-                                                                            pair={
-                                                                              input.server.endpoint.auth
-                                                                                ? input.server.endpoint.auth
-                                                                                : {
-                                                                                    username: "opencode",
-                                                                                    password: "",
-                                                                                  }
-                                                                            }
-                                                                          />
-                                                                        </PluginProvider>
-                                                                      </AttentionProvider>
-                                                                    </EditorContextProvider>
-                                                                  </PromptRefProvider>
-                                                                </PromptHistoryProvider>
-                                                              </FrecencyProvider>
-                                                            </DialogProvider>
-                                                          </PromptStashProvider>
-                                                        </LocalProvider>
-                                                      </ThemeProvider>
+                                                      <PaneLayoutProvider>
+                                                        <ThemeProvider
+                                                          mode={mode}
+                                                          source={createThemeSource(global.config)}
+                                                        >
+                                                          <ThemeErrorToast />
+                                                          <LocalProvider>
+                                                            <PromptStashProvider>
+                                                              <DialogProvider>
+                                                                <FrecencyProvider>
+                                                                  <PromptHistoryProvider>
+                                                                    <PromptRefProvider>
+                                                                      <EditorContextProvider>
+                                                                        <AttentionProvider>
+                                                                          <PluginProvider
+                                                                            packages={input.packages}
+                                                                            directories={pluginDirectories}
+                                                                          >
+                                                                            <App
+                                                                              pair={
+                                                                                input.server.endpoint.auth
+                                                                                  ? input.server.endpoint.auth
+                                                                                  : {
+                                                                                      username: "opencode",
+                                                                                      password: "",
+                                                                                    }
+                                                                              }
+                                                                            />
+                                                                          </PluginProvider>
+                                                                        </AttentionProvider>
+                                                                      </EditorContextProvider>
+                                                                    </PromptRefProvider>
+                                                                  </PromptHistoryProvider>
+                                                                </FrecencyProvider>
+                                                              </DialogProvider>
+                                                            </PromptStashProvider>
+                                                          </LocalProvider>
+                                                        </ThemeProvider>
+                                                      </PaneLayoutProvider>
                                                     </SessionTabsProvider>
                                                   </LocationProvider>
                                                 </DataProvider>
@@ -606,6 +608,11 @@ function App(props: { pair?: DialogPairCredentials }) {
       return
     }
 
+    if (route.data.type === "workspace") {
+      renderer.setTerminalTitle("OC | Terminal")
+      return
+    }
+
     if (route.data.type === "plugin") {
       renderer.setTerminalTitle(`OC | ${route.data.name}`)
     }
@@ -1302,7 +1309,22 @@ function App(props: { pair?: DialogPairCredentials }) {
                 </Match>
                 <Match when={route.data.type === "session"}>
                   <Show when={route.data.type === "session" ? route.data.sessionID : undefined} keyed>
-                    {(_) => <Session verticalTabsWidth={verticalTabsVisible() ? verticalTabsWidth() : 0} />}
+                    {(sessionID) => (
+                      <PaneWorkspace
+                        sessionID={sessionID}
+                        verticalTabsWidth={verticalTabsVisible() ? verticalTabsWidth() : 0}
+                      />
+                    )}
+                  </Show>
+                </Match>
+                <Match when={route.data.type === "workspace"}>
+                  <Show when={route.data.type === "workspace" ? route.data.groupID : undefined} keyed>
+                    {(groupID) => (
+                      <PaneWorkspace
+                        groupID={groupID}
+                        verticalTabsWidth={verticalTabsVisible() ? verticalTabsWidth() : 0}
+                      />
+                    )}
                   </Show>
                 </Match>
                 <Match when={route.data.type === "plugin"}>

packages/tui/src/component/devtools-bar.tsx

@@ -17,12 +17,13 @@ import { useDialog } from "../ui/dialog"
 import { DialogExperiments } from "./dialog-experiments"
 import { usePlugin } from "../plugin/context"
 import { errorMessage } from "../util/error"
+import { usePaneLayout } from "../context/pane-layout"
 
 const graphWidth = 23
 const sampleIntervalMilliseconds = 2_000
 const sampleRetentionMilliseconds = 30_000
 const statusWindowMilliseconds = 6_000
-type Panel = "server" | "theme" | "tools" | "ui"
+type Panel = "server" | "theme" | "tools" | "ui" | "layout"
 type ProcessSample = Readonly<{ cpu: number; memory: number; delay: number; time: number }>
 export type RuntimeStatus = "normal" | "medium" | "high"
 
@@ -38,6 +39,7 @@ export function DevToolsBar() {
   const keymap = Keymap.use()
   const renderer = useRenderer()
   const dimensions = useTerminalDimensions()
+  const panes = usePaneLayout()
   const { current: theme, mode, supports, setMode } = themes
   const elevatedTheme = useTheme("elevated")
   const [panel, setPanel] = createSignal<Panel>()
@@ -46,6 +48,8 @@ export function DevToolsBar() {
   const [dumpError, setDumpError] = createSignal<string>()
   const [frontendSamples, setFrontendSamples] = createSignal<readonly ProcessSample[]>([])
   const [debugOverlay, setDebugOverlay] = createSignal(renderer.debugOverlay.enabled)
+  const [creatingTerminal, setCreatingTerminal] = createSignal(false)
+  const [terminalError, setTerminalError] = createSignal<string>()
   let focus: Renderable | null
   const connected = createMemo(() => client.connection.status() === "connected")
   const serverIndicator = createMemo(() => connectionIndicator(client.connection.status(), client.connection.attempt()))
@@ -220,6 +224,18 @@ export function DevToolsBar() {
     setDumping(false)
   }
 
+  async function newTerminal() {
+    const routeData = route.data
+    if (routeData.type !== "session") return
+    setCreatingTerminal(true)
+    setTerminalError()
+    await panes.newTerminal(routeData.sessionID).then(
+      () => close(),
+      (error) => setTerminalError(errorMessage(error)),
+    )
+    setCreatingTerminal(false)
+  }
+
   return (
     <box height={1} flexShrink={0} flexDirection="row" backgroundColor={theme.raise(theme.background.default)}>
       <Show when={panel()}>
@@ -418,6 +434,31 @@ export function DevToolsBar() {
           </PanelBox>
         </Show>
       </BarItem>
+      <BarItem active={panel() === "layout"} onClick={() => toggle("layout")}>
+        <text fg={panel() === "layout" ? theme.text.action.primary.focused : theme.text.subdued}>Layout</text>
+        <Show when={panel() === "layout"}>
+          <PanelBox>
+            <PanelTitle>Layout</PanelTitle>
+            <Action
+              onClick={() => void newTerminal()}
+              disabled={route.data.type !== "session" || creatingTerminal()}
+              hoverBackground
+            >
+              {creatingTerminal() ? "Creating terminal..." : "New terminal"}
+            </Action>
+            <Show when={route.data.type !== "session"}>
+              <text fg={elevatedTheme.text.subdued}>Open a session first.</text>
+            </Show>
+            <Show when={terminalError()}>
+              {(error) => (
+                <text fg={elevatedTheme.text.feedback.error.default} wrapMode="word">
+                  {error()}
+                </text>
+              )}
+            </Show>
+          </PanelBox>
+        </Show>
+      </BarItem>
       <BarItem
         active={false}
         onClick={() => {

packages/tui/src/component/pane-workspace.tsx

@@ -0,0 +1,98 @@
+import { createResource, Match, Show, Switch } from "solid-js"
+import { usePaneLayout } from "../context/pane-layout"
+import type { PaneLayoutNode } from "../context/pane-layout-model"
+import { useTheme } from "../context/theme"
+import { Session } from "../routes/session"
+import { PersistentTerminalPane } from "./persistent-terminal-pane"
+
+export function PaneWorkspace(props: { sessionID?: string; groupID?: string; verticalTabsWidth: number }) {
+  const panes = usePaneLayout()
+  createResource(
+    () => props.groupID ?? props.sessionID,
+    (key) => (props.groupID ? panes.loadGroup(key) : panes.load(key)).catch(() => undefined),
+  )
+  const workspace = () => (props.groupID ? panes.getGroup(props.groupID) : props.sessionID ? panes.get(props.sessionID) : undefined)
+  return (
+    <Show
+      when={workspace()}
+      fallback={props.sessionID ? <Session verticalTabsWidth={props.verticalTabsWidth} /> : null}
+    >
+      {(value) => (
+        <PaneNode
+          node={value().layout}
+          rootSessionID={props.sessionID}
+          verticalTabsWidth={props.verticalTabsWidth}
+        />
+      )}
+    </Show>
+  )
+}
+
+function PaneNode(props: { node: PaneLayoutNode; rootSessionID?: string; verticalTabsWidth: number }) {
+  const panes = usePaneLayout()
+  const theme = useTheme()
+  return (
+    <Switch>
+      <Match when={props.node.type === "item" ? props.node.item : undefined}>
+        {(item) => (
+          <Switch>
+            <Match when={item().type === "session" && item().id === props.rootSessionID}>
+              <Session verticalTabsWidth={props.verticalTabsWidth} />
+            </Match>
+            <Match when={item().type === "session"}>
+              <UnavailablePane label={`Session ${item().id}`} />
+            </Match>
+            <Match when={item().type === "terminal"}>
+              <PersistentTerminalPane
+                ptyID={item().id}
+                autoFocus={!props.rootSessionID || panes.shouldFocus(item().id)}
+                onAutoFocus={() => panes.clearFocus(item().id)}
+              />
+            </Match>
+          </Switch>
+        )}
+      </Match>
+      <Match when={props.node.type === "split" ? props.node : undefined}>
+        {(node) => (
+          <box
+            flexGrow={1}
+            minWidth={0}
+            minHeight={0}
+            flexDirection={node().direction === "horizontal" ? "row" : "column"}
+          >
+            <box flexGrow={node().ratio} flexBasis={0} minWidth={0} minHeight={0}>
+              <PaneNode
+                node={node().first}
+                rootSessionID={props.rootSessionID}
+                verticalTabsWidth={props.verticalTabsWidth}
+              />
+            </box>
+            <box
+              flexGrow={1 - node().ratio}
+              flexBasis={0}
+              minWidth={0}
+              minHeight={0}
+              border={node().direction === "horizontal" ? ["left"] : ["top"]}
+              borderColor={theme.border.default}
+            >
+              <PaneNode
+                node={node().second}
+                rootSessionID={props.rootSessionID}
+                verticalTabsWidth={props.verticalTabsWidth}
+              />
+            </box>
+          </box>
+        )}
+      </Match>
+    </Switch>
+  )
+}
+
+function UnavailablePane(props: { label: string }) {
+  const theme = useTheme()
+  return (
+    <box flexGrow={1} alignItems="center" justifyContent="center">
+      <text fg={theme.text.subdued}>{props.label} is unavailable in this prototype.</text>
+    </box>
+  )
+}

packages/tui/src/component/persistent-terminal-pane.tsx

@@ -0,0 +1,302 @@
+import { EmbeddedTerminalRenderable } from "@opentui/core"
+import { extend, useRenderer } from "@opentui/solid"
+import { createEffect, createSignal, onCleanup, onMount, Show } from "solid-js"
+import { useClient } from "../context/client"
+import { Keymap } from "../context/keymap"
+import { useTheme } from "../context/theme"
+import { errorMessage } from "../util/error"
+
+declare module "@opentui/solid" {
+  interface OpenTUIComponents {
+    embeddedTerminal: typeof EmbeddedTerminalRenderable
+  }
+}
+
+extend({ embeddedTerminal: EmbeddedTerminalRenderable })
+
+type TerminalSize = { cols: number; rows: number }
+type StreamItem =
+  | { type: "output"; data: Uint8Array }
+  | { type: "resize"; size: TerminalSize; checkpoint?: Uint8Array }
+  | { type: "ready" }
+
+export function PersistentTerminalPane(props: { ptyID: string; autoFocus?: boolean; onAutoFocus?: () => void }) {
+  const client = useClient()
+  const keymap = Keymap.use()
+  const theme = useTheme()
+  const renderer = useRenderer()
+  const [failure, setFailure] = createSignal<string>()
+  const attachmentID = crypto.randomUUID()
+  const stream: StreamItem[] = []
+  const pendingInput: Uint8Array[] = []
+  let terminal: EmbeddedTerminalRenderable | undefined
+  let socket: WebSocket | undefined
+  let attached = false
+  let controller = false
+  let restored = false
+  let wantsControl = false
+  let disposed = false
+  let size: TerminalSize | undefined
+  let canonicalSize: TerminalSize | undefined
+  let terminalSize: TerminalSize | undefined
+  let lastIntermediateRender = 0
+  let waitingSize: { size: TerminalSize; resolve: () => void } | undefined
+
+  const setCanonicalSize = (value: TerminalSize) => {
+    canonicalSize = value
+    if (!terminal) return
+    terminal.width = value.cols
+    terminal.height = value.rows
+  }
+
+  const send = (data: Uint8Array) => {
+    if (attached && socket?.readyState === WebSocket.OPEN) socket.send(data)
+  }
+
+  const interact = () => {
+    if (!restored) {
+      wantsControl = true
+      return
+    }
+    if (!size) return
+    send(interactionFrame(size))
+  }
+
+  const sendInput = (data: Uint8Array) => {
+    if (!restored) {
+      pendingInput.push(data)
+      return
+    }
+    if (size) send(interactionFrame(size, data))
+  }
+
+  const processStream = () => {
+    if (disposed || !terminal || !sameSize(canonicalSize, terminalSize)) return
+    while (stream.length > 0) {
+      const item = stream[0]!
+      if (item.type === "output") {
+        stream.shift()
+        const output = [item.data]
+        while (true) {
+          const next = stream[0]
+          if (!next || next.type !== "output") break
+          output.push(next.data)
+          stream.shift()
+        }
+        terminal.write(output.length === 1 ? output[0] : Buffer.concat(output))
+        continue
+      }
+      if (item.type === "resize") {
+        setCanonicalSize(item.size)
+        if (!sameSize(canonicalSize, terminalSize)) return
+        stream.shift()
+        if (item.checkpoint)
+          terminal.write(Buffer.concat([Buffer.from("\x1bc"), Buffer.from(item.checkpoint)]))
+        continue
+      }
+      stream.shift()
+      restored = true
+      const input = pendingInput.splice(0)
+      if (input.length > 0) input.forEach(sendInput)
+      if (input.length === 0 && (controller || wantsControl)) interact()
+      wantsControl = false
+    }
+  }
+
+  const enqueue = (item: StreamItem) => {
+    stream.push(item)
+    processStream()
+  }
+
+  const waitForTerminalSize = (value: TerminalSize) => {
+    if (sameSize(value, terminalSize)) return Promise.resolve()
+    return new Promise<void>((resolve) => {
+      waitingSize = { size: value, resolve }
+    })
+  }
+
+  const offKeys = keymap.intercept(
+    "key",
+    ({ event }) => {
+      if (!terminal?.focused) return
+      event.preventDefault()
+      event.stopPropagation()
+      terminal.handleKeyPress(event)
+    },
+    { priority: 100 },
+  )
+
+  createEffect(() => {
+    if (!props.autoFocus || !terminal) return
+    terminal.focus()
+    props.onAutoFocus?.()
+  })
+
+  onMount(() => {
+    void connect().catch((error) => setFailure(errorMessage(error)))
+  })
+
+  onCleanup(() => {
+    disposed = true
+    waitingSize?.resolve()
+    socket?.close()
+    offKeys()
+  })
+
+  async function connect() {
+    const endpoint = client.endpoint
+    if (!endpoint) throw new Error("Persistent terminal server endpoint is unavailable")
+    const snapshot = await client.api["server.persistentPty"].snapshot({ ptyID: props.ptyID })
+    if (disposed) return
+    setCanonicalSize(snapshot.info.size)
+    await waitForTerminalSize(snapshot.info.size)
+    if (disposed) return
+    terminal?.write(Buffer.from(snapshot.checkpoint, "base64"))
+    const token = await client.api["server.persistentPty"].connectToken(
+      { ptyID: props.ptyID },
+      { headers: { "x-opencode-ticket": "1" } },
+    )
+    if (disposed) return
+    const url = new URL(`/api/persistent-pty/${encodeURIComponent(props.ptyID)}/connect`, endpoint.url)
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:"
+    url.searchParams.set("ticket", token.ticket)
+    url.searchParams.set("cursor", String(snapshot.info.output.tail))
+    url.searchParams.set("attachment_id", attachmentID)
+    url.searchParams.set("takeover", "true")
+    url.searchParams.set("input_protocol", "1")
+
+    const next = new WebSocket(url)
+    next.binaryType = "arraybuffer"
+    next.addEventListener("message", (event) => {
+      if (disposed) return
+      if (event.data instanceof ArrayBuffer) {
+        enqueue({ type: "output", data: new Uint8Array(event.data) })
+        const now = performance.now()
+        if (now - lastIntermediateRender >= 16) {
+          lastIntermediateRender = now
+          renderer.intermediateRender()
+        }
+        return
+      }
+      if (typeof event.data !== "string") return
+      const message: unknown = JSON.parse(event.data)
+      if (!message || typeof message !== "object" || !("type" in message)) return
+      if (
+        message.type === "resized" &&
+        "cols" in message &&
+        typeof message.cols === "number" &&
+        "rows" in message &&
+        typeof message.rows === "number" &&
+        "checkpoint" in message &&
+        typeof message.checkpoint === "string"
+      ) {
+        enqueue({
+          type: "resize",
+          size: { cols: message.cols, rows: message.rows },
+          checkpoint: Buffer.from(message.checkpoint, "base64"),
+        })
+        return
+      }
+      if (message.type === "replay_complete") {
+        enqueue({ type: "ready" })
+        return
+      }
+      if (
+        message.type === "controller_changed" &&
+        "attachmentID" in message &&
+        (typeof message.attachmentID === "string" || message.attachmentID === undefined)
+      ) {
+        const previous = controller
+        controller = message.attachmentID === attachmentID
+        if (controller && !previous && restored) interact()
+        return
+      }
+      if (message.type !== "attached") return
+      if (!("inputProtocol" in message) || message.inputProtocol !== 1) {
+        setFailure("Persistent terminal server is out of date; restart OpenCode")
+        next.close()
+        return
+      }
+      if (
+        "info" in message &&
+        message.info &&
+        typeof message.info === "object" &&
+        "size" in message.info &&
+        message.info.size &&
+        typeof message.info.size === "object" &&
+        "cols" in message.info.size &&
+        typeof message.info.size.cols === "number" &&
+        "rows" in message.info.size &&
+        typeof message.info.size.rows === "number"
+      )
+        enqueue({ type: "resize", size: { cols: message.info.size.cols, rows: message.info.size.rows } })
+      controller = "role" in message && message.role === "controller"
+      attached = true
+    })
+    next.addEventListener("error", () => {
+      if (!disposed) setFailure("Terminal connection failed")
+    })
+    next.addEventListener("close", () => {
+      if (!disposed) setFailure("Terminal disconnected")
+    })
+    socket = next
+  }
+
+  return (
+    <box
+      flexGrow={1}
+      minWidth={0}
+      minHeight={0}
+      overflow="hidden"
+      onSizeChange={function () {
+        size = { cols: this.width, rows: this.height }
+        if (controller && restored) interact()
+      }}
+      // TODO: Revisit when embedded terminal mouse handlers can compose without replacing its internal focus handler.
+      onMouseDown={() => interact()}
+    >
+      <Show when={!failure()} fallback={<text fg={theme.text.feedback.error.default}>{failure()}</text>}>
+        <embeddedTerminal
+          ref={(value) => {
+            terminal = value
+            terminalSize = { cols: 80, rows: 24 }
+            if (canonicalSize) {
+              value.width = canonicalSize.cols
+              value.height = canonicalSize.rows
+            }
+          }}
+          position="absolute"
+          left={0}
+          top={0}
+          width={80}
+          height={24}
+          onData={(data, source) => {
+            if (source === "input") sendInput(data)
+          }}
+          onTerminalResize={(cols, rows) => {
+            terminalSize = { cols, rows }
+            if (waitingSize && sameSize(waitingSize.size, terminalSize)) {
+              waitingSize.resolve()
+              waitingSize = undefined
+            }
+            processStream()
+          }}
+        />
+      </Show>
+    </box>
+  )
+}
+
+function sameSize(first: TerminalSize | undefined, second: TerminalSize | undefined) {
+  return !!first && !!second && first.cols === second.cols && first.rows === second.rows
+}
+
+function interactionFrame(size: { cols: number; rows: number }, data?: Uint8Array) {
+  const frame = new Uint8Array(5 + (data?.byteLength ?? 0))
+  const view = new DataView(frame.buffer)
+  frame[0] = data ? 1 : 0
+  view.setUint16(1, size.cols)
+  view.setUint16(3, size.rows)
+  if (data) frame.set(data, 5)
+  return frame
+}

packages/tui/src/component/session-tabs.tsx

@@ -51,8 +51,7 @@ const RIGHT_MOUSE_BUTTON = 2
 type TabContextMenuState = {
   x: number
   y: number
-  sessionID?: string
-  title?: string
+  tab?: SessionTab
 }
 
 type ContextController = ReturnType<typeof useSessionTabs>
@@ -189,16 +188,20 @@ function TabContextMenu(props: { state: TabContextMenuState; tabs: SessionTabsCo
   const theme = useTheme("elevated")
   const dialog = useDialog()
   const actions = createMemo(() => {
-    const sessionID = props.state.sessionID
+    const tab = props.state.tab
     return [
       ...(props.tabs.add ? [{ title: "New tab", run: () => props.tabs.add?.() }] : []),
-      ...(sessionID
+      ...(tab
         ? [
-            {
-              title: "Rename",
-              run: () => DialogSessionRename.show(dialog, sessionID, props.state.title),
-            },
-            { title: "Close", run: () => props.tabs.close(sessionID) },
+            ...(!tab.groupID
+              ? [
+                  {
+                    title: "Rename",
+                    run: () => DialogSessionRename.show(dialog, tab.sessionID, tab.title),
+                  },
+                ]
+              : []),
+            { title: "Close", run: () => props.tabs.close(tab.sessionID) },
           ]
         : []),
     ]
@@ -345,7 +348,6 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
   let rail: { screenX: number; screenY: number } | undefined
   let scroll: ScrollBoxRenderable | undefined
   let didDrag = false
-  let addPressed = false
   // A captured drag ends with a synthetic up on its drop target; do not turn that into a click.
   let suppressClick = false
 
@@ -421,7 +423,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const status = createMemo(() => itemStatus(tab))
               const [sweepLevel, setSweepLevel] = createSignal(0)
               const [closeHovered, setCloseHovered] = createSignal(false)
-              const session = createMemo(() => data.session.get(tab.sessionID))
+              const session = createMemo(() => (tab.groupID ? undefined : data.session.get(tab.sessionID)))
               const project = createMemo(() => {
                 const value = session()
                 return value ? data.project.get(value.projectID) : undefined
@@ -430,7 +432,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const restingTitleWidth = () => Math.max(1, width() - numberWidth() - 2)
               const hoveredTitleWidth = () => Math.max(1, restingTitleWidth() - 1)
               const titleWidth = () => (hovered() === tab.sessionID ? hoveredTitleWidth() : restingTitleWidth())
-              const title = () => tab.title ?? "Untitled session"
+              const title = () => tab.title ?? (tab.groupID ? "Terminal" : "Untitled session")
               const scrolling = () => marquee.active() === tab.sessionID
               const visibleTitleParts = createMemo(() =>
                 scrolling()
@@ -449,6 +451,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               const detail = createMemo(() => {
                 const fixture = tabs.detail?.(tab.sessionID)
                 if (fixture !== undefined) return fixture
+                if (tab.groupID) return tab.directory ?? ""
                 const value = session()
                 const currentProject = project()
                 const projectLabel = projectName(currentProject, value?.location.directory) ?? ""
@@ -574,10 +577,9 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
                       setDragging(undefined)
                       if (!rail) return
                       setContextMenu({
-                        x: event.x,
-                        y: event.y,
-                        sessionID: tab.sessionID,
-                        title: tab.title,
+                        x: event.x - rail.screenX,
+                        y: event.y - rail.screenY,
+                        tab,
                       })
                       event.preventDefault()
                       event.stopPropagation()
@@ -761,8 +763,7 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               onMouseDown={(event: MouseEvent) => {
                 didDrag = false
                 setDragging(undefined)
-                addPressed = event.button !== RIGHT_MOUSE_BUTTON
-                if (addPressed) return
+                if (event.button !== RIGHT_MOUSE_BUTTON) return
                 if (!rail) return
                 setContextMenu({ x: event.x, y: event.y })
                 event.preventDefault()
@@ -771,11 +772,8 @@ function VerticalSessionTabs(props: { controller?: SessionTabsController; animat
               onMouseUp={(event: MouseEvent) => {
                 if (event.button === RIGHT_MOUSE_BUTTON) return
                 if (suppressClick) return
-                if (!addPressed) return
-                addPressed = false
                 if (!newTab()) tabs.add?.()
               }}
-              onMouseDragEnd={() => (addPressed = false)}
             >
               <text
                 width={2}
@@ -842,7 +840,6 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
   const [contextMenu, setContextMenu] = createSignal<TabContextMenuState>()
   let strip: { screenX: number; screenY: number } | undefined
   let didDrag = false
-  let addPressed = false
   // A captured drag ends with a synthetic up on its drop target; do not turn that into a click.
   let suppressClick = false
   const hueStep = () => (mode() === "light" ? 800 : 200)
@@ -1038,7 +1035,7 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
           }
           const glowColor = () => feedbackColor() ?? accent()
           const glows = () => !selected() && (status().attention || (!status().busy && status().unread !== undefined))
-          const title = () => tab.title ?? "Untitled session"
+          const title = () => tab.title ?? (tab.groupID ? "Terminal" : "Untitled session")
           const tabNumber = createMemo(() => items().findIndex((item) => item.sessionID === tab.sessionID) + 1)
           // Shortcut labels stay one cell wide: 1-9, 0 for ten, then a neutral dot.
           const numberWidth = () => 2
@@ -1113,10 +1110,9 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
                   didDrag = false
                   setDragging(undefined)
                   setContextMenu({
-                    x: event.x,
-                    y: event.y,
-                    sessionID: tab === NEW_SESSION_TAB ? undefined : tab.sessionID,
-                    title: tab === NEW_SESSION_TAB ? undefined : tab.title,
+                    x: event.x - (strip?.screenX ?? 0),
+                    y: event.y - (strip?.screenY ?? 0),
+                    tab: tab === NEW_SESSION_TAB ? undefined : tab,
                   })
                   event.preventDefault()
                   event.stopPropagation()
@@ -1209,8 +1205,7 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
           onMouseDown={(event) => {
             didDrag = false
             setDragging(undefined)
-            addPressed = event.button !== RIGHT_MOUSE_BUTTON
-            if (addPressed) return
+            if (event.button !== RIGHT_MOUSE_BUTTON) return
             setContextMenu({ x: event.x, y: event.y })
             event.preventDefault()
             event.stopPropagation()
@@ -1218,11 +1213,8 @@ function HorizontalSessionTabs(props: { controller?: SessionTabsController; anim
           onMouseUp={(event) => {
             if (event.button === RIGHT_MOUSE_BUTTON) return
             if (suppressClick) return
-            if (!addPressed) return
-            addPressed = false
             tabs.add?.()
           }}
-          onMouseDragEnd={() => (addPressed = false)}
         >
           {" + "}
         </text>

packages/tui/src/context/client.tsx

@@ -1,4 +1,5 @@
 import type { OpenCodeClient, OpenCodeEvent } from "@opencode-ai/client"
+import type { Endpoint } from "@opencode-ai/client/service"
 import { createGlobalEmitter } from "@solid-primitives/event-bus"
 import { batch, onCleanup, onMount } from "solid-js"
 import { createStore } from "solid-js/store"
@@ -18,7 +19,7 @@ export type ClientConnectionEvent = {
 }
 
 type ManagedService = {
-  reconnect: (signal: AbortSignal) => Promise<{ api: OpenCodeClient }>
+  reconnect: (signal: AbortSignal) => Promise<{ api: OpenCodeClient; endpoint?: Endpoint }>
   restart: () => Promise<void>
 }
 
@@ -29,11 +30,12 @@ const eventFlushInterval = 10
 
 export const { use: useClient, provider: ClientProvider } = createSimpleContext({
   name: "Client",
-  init: (props: { api: OpenCodeClient; service?: ManagedService }) => {
+  init: (props: { api: OpenCodeClient; endpoint?: Endpoint; service?: ManagedService }) => {
     const log = useLog({ component: "client" })
     const abort = new AbortController()
     const history: ClientConnectionEvent[] = []
     let api = props.api
+    let endpoint = props.endpoint
     const events = createGlobalEmitter<ClientEventMap>()
     let pending: OpenCodeEvent[] = []
     let flushTimer: ReturnType<typeof setTimeout> | undefined
@@ -158,6 +160,7 @@ export const { use: useClient, provider: ClientProvider } = createSimpleContext(
             if (abort.signal.aborted || controller.signal.aborted) return
             if (next) {
               api = next.api
+              if (next.endpoint) endpoint = next.endpoint
               if (attempt === 1) continue
             }
           }
@@ -179,6 +182,9 @@ export const { use: useClient, provider: ClientProvider } = createSimpleContext(
       get api() {
         return api
       },
+      get endpoint() {
+        return endpoint
+      },
       event: {
         on: events.on,
         listen: events.listen,

packages/tui/src/context/pane-layout-model.ts

@@ -0,0 +1,70 @@
+import type { GroupItem } from "@opencode-ai/client"
+
+export type PaneLayoutNode =
+  | { type: "item"; item: GroupItem }
+  | {
+      type: "split"
+      direction: "horizontal" | "vertical"
+      ratio: number
+      first: PaneLayoutNode
+      second: PaneLayoutNode
+    }
+
+export function defaultPaneLayout(items: readonly GroupItem[]): PaneLayoutNode | undefined {
+  const master = items[0]
+  if (!master) return undefined
+  const stack = items.slice(1)
+  if (stack.length === 0) return { type: "item", item: master }
+  return {
+    type: "split",
+    direction: "horizontal",
+    ratio: 0.5,
+    first: { type: "item", item: master },
+    second: stackLayout(stack),
+  }
+}
+
+function stackLayout(items: readonly GroupItem[]): PaneLayoutNode {
+  const first = items[0]
+  if (items.length === 1) return { type: "item", item: first }
+  return {
+    type: "split",
+    direction: "vertical",
+    ratio: 1 / items.length,
+    first: { type: "item", item: first },
+    second: stackLayout(items.slice(1)),
+  }
+}
+
+export function paneLayoutItems(node: PaneLayoutNode): GroupItem[] {
+  if (node.type === "item") return [node.item]
+  return paneLayoutItems(node.first).concat(paneLayoutItems(node.second))
+}
+
+export function removePaneLayoutItem(node: PaneLayoutNode, item: GroupItem): PaneLayoutNode | undefined {
+  if (node.type === "item") return itemKey(node.item) === itemKey(item) ? undefined : node
+  const first = removePaneLayoutItem(node.first, item)
+  const second = removePaneLayoutItem(node.second, item)
+  if (!first) return second
+  if (!second) return first
+  if (first === node.first && second === node.second) return node
+  return { ...node, first, second }
+}
+
+export function reconcilePaneLayout(node: PaneLayoutNode | undefined, items: readonly GroupItem[]) {
+  if (!node) return defaultPaneLayout(items)
+  const wanted = new Map(items.map((item) => [itemKey(item), item]))
+  const kept = paneLayoutItems(node).filter((item) => wanted.has(itemKey(item)))
+  if (kept.length !== items.length || kept.some((item, index) => itemKey(item) !== itemKey(items[index])))
+    return defaultPaneLayout(items)
+  return replaceItems(node, wanted)
+}
+
+function replaceItems(node: PaneLayoutNode, items: ReadonlyMap<string, GroupItem>): PaneLayoutNode {
+  if (node.type === "item") return { type: "item", item: items.get(itemKey(node.item)) ?? node.item }
+  return { ...node, first: replaceItems(node.first, items), second: replaceItems(node.second, items) }
+}
+
+function itemKey(item: GroupItem) {
+  return `${item.type}:${item.id}`
+}

packages/tui/src/context/pane-layout.tsx

@@ -0,0 +1,158 @@
+import type { GroupInfo, GroupItem, LocationRef, PersistentPtyInfo } from "@opencode-ai/client"
+import { createSimpleContext } from "./helper"
+import { useClient } from "./client"
+import { useData } from "./data"
+import { useStorage } from "./storage"
+import { reconcilePaneLayout, removePaneLayoutItem, type PaneLayoutNode } from "./pane-layout-model"
+import { useEvent } from "./event"
+import { createSignal, onCleanup } from "solid-js"
+
+type PaneWorkspace = {
+  sessionID?: string
+  groupID: string
+  items: GroupItem[]
+  layout: PaneLayoutNode
+}
+
+type PaneLayoutState = {
+  workspaces: Record<string, PaneWorkspace>
+}
+
+export const { use: usePaneLayout, provider: PaneLayoutProvider } = createSimpleContext({
+  name: "PaneLayout",
+  init: () => {
+    const client = useClient()
+    const data = useData()
+    const event = useEvent()
+    const [focus, setFocus] = createSignal<string>()
+    const [store, update] = useStorage().store<PaneLayoutState>("pane-layout-v1", {
+      initial: { workspaces: {} },
+    })
+
+    const save = (key: string, group: GroupInfo, sessionID?: string) =>
+      update((draft) => {
+        const layout = reconcilePaneLayout(draft.workspaces[key]?.layout, group.items)
+        if (!layout) {
+          delete draft.workspaces[key]
+          return
+        }
+        draft.workspaces[key] = {
+          sessionID,
+          groupID: group.id,
+          items: group.items,
+          layout,
+        }
+      })
+
+    onCleanup(
+      event.on("group.item.added", (evt) => {
+        void update((draft) => {
+          Object.values(draft.workspaces).forEach((workspace) => {
+            if (workspace.groupID !== evt.data.groupID) return
+            if (workspace.items.some((item) => item.type === evt.data.item.type && item.id === evt.data.item.id)) return
+            workspace.items.push(evt.data.item)
+            workspace.layout = reconcilePaneLayout(workspace.layout, workspace.items) ?? workspace.layout
+          })
+        }).catch((error) => console.error("Failed to add pane layout item", error))
+      }),
+    )
+
+    onCleanup(
+      event.on("group.item.removed", (evt) => {
+        void update((draft) => {
+          Object.entries(draft.workspaces).forEach(([sessionID, workspace]) => {
+            if (workspace.groupID !== evt.data.groupID) return
+            const layout = removePaneLayoutItem(workspace.layout, evt.data.item)
+            if (!layout) {
+              delete draft.workspaces[sessionID]
+              return
+            }
+            workspace.items = workspace.items.filter(
+              (item) => item.type !== evt.data.item.type || item.id !== evt.data.item.id,
+            )
+            workspace.layout = layout
+          })
+        }).catch((error) => console.error("Failed to remove pane layout item", error))
+      }),
+    )
+
+    return {
+      get(sessionID: string) {
+        return store.workspaces[sessionID]
+      },
+      async load(sessionID: string) {
+        const current = store.workspaces[sessionID]
+        if (current) {
+          const group = await client.api["server.persistentPty"].group.get({ groupID: current.groupID })
+          await save(sessionID, group, sessionID)
+          return
+        }
+        const groups = await client.api["server.persistentPty"].group.list()
+        const group = groups.find((item) =>
+          item.items.some((entry) => entry.type === "session" && entry.id === sessionID),
+        )
+        if (group) await save(sessionID, group, sessionID)
+      },
+      getGroup(groupID: string) {
+        return store.workspaces[groupID]
+      },
+      async loadGroup(groupID: string) {
+        await save(groupID, await client.api["server.persistentPty"].group.get({ groupID }))
+      },
+      async refresh(sessionID: string) {
+        const current = store.workspaces[sessionID]
+        if (!current) return
+        const group = await client.api["server.persistentPty"].group.get({ groupID: current.groupID })
+        await save(sessionID, group, sessionID)
+      },
+      async newTerminal(sessionID: string): Promise<PersistentPtyInfo> {
+        const api = client.api["server.persistentPty"]
+        const current = store.workspaces[sessionID]
+        const existing = current
+          ? await api.group.get({ groupID: current.groupID })
+          : (await api.group.list()).find((group) =>
+              group.items.some((item) => item.type === "session" && item.id === sessionID),
+            )
+        const group = existing ?? (await api.group.create({ items: [{ type: "session", id: sessionID }] }))
+        const session = data.session.get(sessionID)
+        const terminal = await api.create({
+          groupID: group.id,
+          command: process.env.SHELL || "/bin/sh",
+          args: [],
+          cwd: session?.location.directory ?? process.cwd(),
+          title: "Terminal",
+          env: {},
+        })
+        const next = await api.group.get({ groupID: group.id })
+        setFocus(terminal.id)
+        await save(sessionID, next, sessionID)
+        return terminal
+      },
+      async newTerminalWorkspace(location: LocationRef) {
+        const api = client.api["server.persistentPty"]
+        const group = await api.group.create({ items: [] })
+        const terminal = await api
+          .create({
+            groupID: group.id,
+            command: process.env.SHELL || "/bin/sh",
+            args: [],
+            cwd: location.directory,
+            title: "Terminal",
+            env: {},
+          })
+          .catch(async (error) => {
+            await api.group.remove({ groupID: group.id }).catch(() => undefined)
+            throw error
+          })
+        await save(group.id, await api.group.get({ groupID: group.id }))
+        return { group, terminal }
+      },
+      shouldFocus(ptyID: string) {
+        return focus() === ptyID
+      },
+      clearFocus(ptyID: string) {
+        setFocus((current) => (current === ptyID ? undefined : current))
+      },
+    }
+  },
+})

packages/tui/src/context/route.tsx

@@ -17,6 +17,11 @@ export type SessionRoute = {
   prompt?: PromptInfo
 }
 
+export type WorkspaceRoute = {
+  type: "workspace"
+  groupID: string
+}
+
 export type PluginRoute = {
   type: "plugin"
   id: string
@@ -24,7 +29,7 @@ export type PluginRoute = {
   data?: Record<string, unknown>
 }
 
-export type Route = HomeRoute | SessionRoute | PluginRoute
+export type Route = HomeRoute | SessionRoute | WorkspaceRoute | PluginRoute
 
 export const { use: useRoute, provider: RouteProvider } = createSimpleContext({
   name: "Route",
@@ -51,6 +56,9 @@ function initialRoute(value: unknown): Route | undefined {
   if (value.type === "session" && "sessionID" in value && typeof value.sessionID === "string") {
     return { type: "session", sessionID: value.sessionID }
   }
+  if (value.type === "workspace" && "groupID" in value && typeof value.groupID === "string") {
+    return { type: "workspace", groupID: value.groupID }
+  }
   if (
     value.type === "plugin" &&
     "id" in value &&

packages/tui/src/context/session-tabs-model.ts

@@ -1,6 +1,8 @@
 export type SessionTab = {
   sessionID: string
   title?: string
+  groupID?: string
+  directory?: string
 }
 
 export type SessionTabUnread = "activity" | "error"

packages/tui/src/context/session-tabs.tsx

@@ -74,6 +74,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     const fallback = empty()
     const [promptPulses, setPromptPulses] = createSignal<Record<string, number>>({})
     let history: SessionTabHistory = { entries: [], index: -1 }
+    const closing = new Set<string>()
     // User-closed tabs eligible for reopening; in-memory like history, deleted sessions pruned.
     let closedTabs: ClosedSessionTab[] = []
     const scrollAnchors = new Map<string, ScrollAnchor>()
@@ -112,6 +113,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     }
     const normalize = (value: TabsState) => ({
       tabs: value.tabs.reduce<SessionTab[]>((tabs, tab) => {
+        if (tab.groupID) return openSessionTab(tabs, { ...tab, sessionID: tab.groupID })
         const sessionID = root(tab.sessionID)
         return openSessionTab(tabs, { sessionID, title: title(sessionID, tab.title) })
       }, []),
@@ -121,7 +123,11 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         return result
       }, {}),
     })
-    const current = () => (route.data.type === "session" ? root(route.data.sessionID) : undefined)
+    const current = () => {
+      if (route.data.type === "session") return root(route.data.sessionID)
+      if (route.data.type === "workspace") return route.data.groupID
+      return undefined
+    }
     const newTab = createMemo((open = false) => {
       if (route.data.type === "home") return true
       if (!open) return false
@@ -129,6 +135,9 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       return sessionID !== undefined && !state().tabs.some((tab) => tab.sessionID === sessionID)
     }, false)
     const status = (sessionID: string) => {
+      if (state().tabs.some((tab) => tab.sessionID === sessionID && tab.groupID)) {
+        return { unread: undefined, promptPulse: 0, attention: false, busy: false }
+      }
       const session = root(sessionID)
       const members = data.session.family(session)
       const family = members.length > 0 ? members : [session]
@@ -155,6 +164,10 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
 
     createEffect(() => {
       if (!enabled()) return
+      if (route.data.type === "workspace") {
+        history = recordSessionTabHistory(history, route.data.groupID)
+        return
+      }
       if (route.data.type !== "session" || route.data.sessionID === "dummy") return
       const sessionID = root(route.data.sessionID)
       history = recordSessionTabHistory(history, sessionID)
@@ -198,7 +211,8 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     // the first connection slots and switches still render from a warm cache.
     const openTabSessions = createMemo(() =>
       state()
-        .tabs.map((tab) => tab.sessionID)
+        .tabs.filter((tab) => !tab.groupID)
+        .map((tab) => tab.sessionID)
         .sort()
         .join("\n"),
     )
@@ -226,7 +240,8 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       })()
       const timer = setTimeout(async () => {
         const sessions = state()
-          .tabs.map((tab) => tab.sessionID)
+          .tabs.filter((tab) => !tab.groupID)
+          .map((tab) => tab.sessionID)
           .filter((sessionID) => sessionID !== current())
         for (const sessionID of sessions) {
           if (stale) return
@@ -247,12 +262,6 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     onCleanup(event.on("session.execution.succeeded", (evt) => markUnread(evt.data.sessionID, "activity")))
     onCleanup(event.on("session.execution.interrupted", (evt) => markUnread(evt.data.sessionID, "activity")))
     onCleanup(event.on("session.execution.failed", (evt) => markUnread(evt.data.sessionID, "error")))
-    onCleanup(
-      event.on("session.moved", (evt) => {
-        if (!enabled() || !state().tabs.some((tab) => tab.sessionID === root(evt.data.sessionID))) return
-        void Promise.allSettled([data.location.syncInfo(evt.data.location), data.location.vcs.sync(evt.data.location)])
-      }),
-    )
     onCleanup(
       event.on("session.inbox.enqueued", (evt) => {
         if (!enabled() || evt.data.item.type !== "user") return
@@ -264,16 +273,48 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
     onCleanup(
       event.on("session.deleted", (evt) => {
         const target = root(evt.data.sessionID)
-        closedTabs = closedTabs.filter((entry) => entry.tab.sessionID !== target)
+        closedTabs = closedTabs.filter((entry) => entry.tab.groupID || entry.tab.sessionID !== target)
         remove(evt.data.sessionID, enabled())
       }),
     )
 
-    function remove(sessionID: string, navigate: boolean) {
-      const target = root(sessionID)
+    onCleanup(
+      event.on("group.item.removed", (evt) => {
+        if (closing.has(evt.data.groupID)) return
+        if (!state().tabs.some((tab) => tab.groupID === evt.data.groupID)) return
+        void client.api["server.persistentPty"].group
+          .get({ groupID: evt.data.groupID })
+          .then(async (group) => {
+            if (group.items.length > 0) return
+            await client.api["server.persistentPty"].group.remove({ groupID: group.id })
+            remove(group.id, enabled())
+          })
+          .catch(() => undefined)
+      }),
+    )
+
+    function tab(id: string) {
+      return state().tabs.find((item) => item.sessionID === id)
+    }
+
+    function navigate(id: string | undefined) {
+      if (!id) {
+        route.navigate({ type: "home" })
+        return
+      }
+      const target = tab(id)
+      if (target?.groupID) {
+        route.navigate({ type: "workspace", groupID: target.groupID })
+        return
+      }
+      route.navigate({ type: "session", sessionID: id })
+    }
+
+    function remove(sessionID: string, shouldNavigate: boolean) {
+      const target = tab(sessionID)?.groupID ? sessionID : root(sessionID)
       scrollAnchors.delete(target)
       const closed = closeSessionTab(state().tabs, target)
-      const selected = navigate && current() === target
+      const selected = shouldNavigate && current() === target
       if (closed.tabs === state().tabs && !selected) return
       const previous = selected
         ? moveSessionTabHistory(recordSessionTabHistory(history, target), closed.tabs, target, -1)
@@ -290,7 +331,25 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
         delete next[target]
         return next
       })
-      if (selected) route.navigate(next ? { type: "session", sessionID: next } : { type: "home" })
+      if (selected) navigate(next)
+    }
+
+    async function closeWorkspace(tab: SessionTab) {
+      if (!tab.groupID || closing.has(tab.groupID)) return
+      closing.add(tab.groupID)
+      try {
+        const api = client.api["server.persistentPty"]
+        const group = await api.group.get({ groupID: tab.groupID })
+        if (!group.items.some((item) => item.type === "session")) {
+          for (const terminal of await api.list({ groupID: group.id })) await api.remove({ ptyID: terminal.id })
+          await api.group.remove({ groupID: group.id })
+        }
+        remove(tab.sessionID, true)
+      } catch (error) {
+        console.error("Failed to close terminal workspace", error)
+      } finally {
+        closing.delete(tab.groupID)
+      }
     }
 
     return {
@@ -320,8 +379,25 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       },
       select(sessionID: string) {
         if (!enabled()) return
+        const target = tab(sessionID)
+        if (target?.groupID) {
+          route.navigate({ type: "workspace", groupID: target.groupID })
+          return
+        }
         route.navigate({ type: "session", sessionID: root(sessionID) })
       },
+      openWorkspace(groupID: string, directory: string) {
+        if (!enabled()) return
+        update((draft) => {
+          draft.tabs = openSessionTab(draft.tabs, {
+            sessionID: groupID,
+            groupID,
+            directory,
+            title: "Terminal",
+          })
+        })
+        route.navigate({ type: "workspace", groupID })
+      },
       add() {
         if (!enabled()) return
         const sessionID = current()
@@ -338,17 +414,21 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       },
       close(sessionID?: string) {
         if (!enabled()) return
-        const target = sessionID ? root(sessionID) : current()
+        const target = sessionID ? (tab(sessionID)?.groupID ? sessionID : root(sessionID)) : current()
         if (!target) {
           const previous = moveSessionTabHistory(history, state().tabs, undefined, -1)
           history = previous.history
           const session = previous.sessionID ?? state().tabs.at(-1)?.sessionID
-          if (route.data.type === "home" && session) route.navigate({ type: "session", sessionID: session })
+          if (route.data.type === "home" && session) navigate(session)
           return
         }
         const index = state().tabs.findIndex((tab) => tab.sessionID === target)
-        const tab = state().tabs[index]
-        if (tab) closedTabs = recordClosedSessionTab(closedTabs, tab, index)
+        const selected = state().tabs[index]
+        if (selected?.groupID) {
+          void closeWorkspace(selected)
+          return
+        }
+        if (selected) closedTabs = recordClosedSessionTab(closedTabs, selected, index)
         remove(target, true)
       },
       reopen() {
@@ -364,7 +444,7 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       },
       move(sessionID: string, index: number) {
         if (!enabled()) return
-        const session = root(sessionID)
+        const session = tab(sessionID)?.groupID ? sessionID : root(sessionID)
         if (moveSessionTab(state().tabs, session, index) === state().tabs) return
         update((draft) => {
           draft.tabs = moveSessionTab(draft.tabs, session, index)
@@ -373,19 +453,19 @@ export const { use: useSessionTabs, provider: SessionTabsProvider } = createSimp
       cycle(direction: 1 | -1) {
         if (!enabled()) return
         const tab = cycleSessionTab(state().tabs, current(), direction)
-        if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
+        if (tab) navigate(tab.sessionID)
       },
       cycleUnread(direction: 1 | -1) {
         if (!enabled()) return
         const tab = cycleSessionTab(state().tabs, current(), direction, (tab) =>
           Boolean(state().unread[tab.sessionID] || status(tab.sessionID).attention),
         )
-        if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
+        if (tab) navigate(tab.sessionID)
       },
       selectIndex(index: number) {
         if (!enabled()) return
         const tab = state().tabs[index]
-        if (tab) route.navigate({ type: "session", sessionID: tab.sessionID })
+        if (tab) navigate(tab.sessionID)
       },
     }
   },

packages/tui/src/feature-plugins/prompt/footer.tsx

@@ -1,15 +1,24 @@
 import { Plugin } from "@opencode-ai/plugin/tui"
-import { createMemo, Match, Show, Switch } from "solid-js"
+import { createMemo, createSignal, Match, Show, Switch } from "solid-js"
 import { contextUsage, formatContextUsage } from "../../util/session"
 import { useTerminalDimensions } from "@opentui/solid"
+import { usePaneLayout } from "../../context/pane-layout"
+import { useSessionTabs } from "../../context/session-tabs"
 
 const money = new Intl.NumberFormat("en-US", {
   style: "currency",
   currency: "USD",
 })
 
-export function PromptFooter(props: { context: Plugin.Context; sessionID?: string; mode: "normal" | "shell" }) {
+export function PromptFooter(props: {
+  context: Plugin.Context
+  sessionID?: string
+  mode: "normal" | "shell"
+  onNewTerminal?: () => Promise<void>
+}) {
   const dimensions = useTerminalDimensions()
+  const [terminalHovered, setTerminalHovered] = createSignal(false)
+  const [terminalPending, setTerminalPending] = createSignal(false)
   const subagents = createMemo(() => {
     if (!props.sessionID) return 0
     const count = props.context.data.session
@@ -41,33 +50,53 @@ export function PromptFooter(props: { context: Plugin.Context; sessionID?: strin
   })
   const live = createMemo(() => Boolean(subagents() || shells()))
   const shortcut = (id: string) => props.context.keymap.shortcuts(id)[0]
+  const newTerminal = async () => {
+    if (terminalPending() || !props.onNewTerminal) return
+    setTerminalPending(true)
+    await props.onNewTerminal().finally(() => setTerminalPending(false))
+  }
 
   return (
     <Switch>
       <Match when={props.mode === "normal"}>
-        <Switch>
-          <Match when={live() || status().length > 0}>
-            <text fg={props.context.theme.text.subdued} wrapMode="none" truncate flexShrink={1}>
-              <Show when={live() && shortcut("session.child.first")}>
-                {(value) => <span style={{ fg: props.context.theme.text.default }}>{value()} </span>}
-              </Show>
-              <Show when={subagents()}>{(value) => <span>{value()}</span>}</Show>
-              <Show when={subagents() && shells()}> · </Show>
-              <Show when={shells()}>{(value) => <span>{value()}</span>}</Show>
-              <Show when={live() && status().length > 0}> · </Show>
-              <Show when={status().length > 0}>{status().join(" · ")}</Show>
+        <Show
+          when={props.sessionID}
+          fallback={
+            <text
+              fg={terminalHovered() ? props.context.theme.text.default : props.context.theme.text.subdued}
+              selectable={false}
+              onMouseOver={() => setTerminalHovered(true)}
+              onMouseOut={() => setTerminalHovered(false)}
+              onMouseUp={() => void newTerminal()}
+            >
+              {terminalPending() ? "starting terminal" : "new terminal"}
             </text>
-          </Match>
-          <Match when={dimensions().width >= 44}>
+          }
+        >
+          <Switch>
+            <Match when={live() || status().length > 0}>
+              <text fg={props.context.theme.text.subdued} wrapMode="none" truncate flexShrink={1}>
+                <Show when={live() && shortcut("session.child.first")}>
+                  {(value) => <span style={{ fg: props.context.theme.text.default }}>{value()} </span>}
+                </Show>
+                <Show when={subagents()}>{(value) => <span>{value()}</span>}</Show>
+                <Show when={subagents() && shells()}> · </Show>
+                <Show when={shells()}>{(value) => <span>{value()}</span>}</Show>
+                <Show when={live() && status().length > 0}> · </Show>
+                <Show when={status().length > 0}>{status().join(" · ")}</Show>
+              </text>
+            </Match>
+            <Match when={dimensions().width >= 44}>
+              <text fg={props.context.theme.text.default} flexShrink={0}>
+                {shortcut("agent.cycle")} <span style={{ fg: props.context.theme.text.subdued }}>agents</span>
+              </text>
+            </Match>
+          </Switch>
+          <Show when={dimensions().width >= 44}>
             <text fg={props.context.theme.text.default} flexShrink={0}>
-              {shortcut("agent.cycle")} <span style={{ fg: props.context.theme.text.subdued }}>agents</span>
+              {shortcut("command.palette.show")} <span style={{ fg: props.context.theme.text.subdued }}>commands</span>
             </text>
-          </Match>
-        </Switch>
-        <Show when={dimensions().width >= 44}>
-          <text fg={props.context.theme.text.default} flexShrink={0}>
-            {shortcut("command.palette.show")} <span style={{ fg: props.context.theme.text.subdued }}>commands</span>
-          </text>
+          </Show>
         </Show>
       </Match>
       <Match when={props.mode === "shell"}>
@@ -82,12 +111,31 @@ export function PromptFooter(props: { context: Plugin.Context; sessionID?: strin
   )
 }
 
+function PromptFooterSlot(props: { context: Plugin.Context; sessionID?: string; mode: "normal" | "shell" }) {
+  const panes = usePaneLayout()
+  const tabs = useSessionTabs()
+  const newTerminal = async () => {
+    const location = props.context.location
+    if (!location || !tabs.enabled()) return
+    await panes
+      .newTerminalWorkspace(location)
+      .then(({ group }) => tabs.openWorkspace(group.id, location.directory))
+      .catch((error) => {
+        props.context.ui.toast.show({
+          variant: "error",
+          message: error instanceof Error ? error.message : "Failed to create terminal",
+        })
+      })
+  }
+  return <PromptFooter {...props} onNewTerminal={newTerminal} />
+}
+
 export default Plugin.define({
   id: "opencode.prompt-footer",
   setup(context) {
     context.ui.slot({
       append: "prompt.footer",
-      render: (props) => <PromptFooter context={context} sessionID={props.sessionID} mode={props.mode} />,
+      render: (props) => <PromptFooterSlot context={context} sessionID={props.sessionID} mode={props.mode} />,
     })
   },
 })

packages/tui/src/plugin/api.tsx

@@ -168,17 +168,22 @@ export function createPluginContext(input: {
           host.route.navigate(destination)
         },
         current() {
+          if (host.route.data.type === "workspace") return { type: "home" }
           return host.route.data
         },
       },
       tabs: {
         enabled: host.sessionTabs.enabled,
         list: () =>
-          host.sessionTabs.tabs().map((tab) => ({
-            ...tab,
-            active: host.sessionTabs.current() === tab.sessionID,
-            ...host.sessionTabs.status(tab.sessionID),
-          })),
+          host.sessionTabs
+            .tabs()
+            .filter((tab) => !tab.groupID)
+            .map((tab) => ({
+              sessionID: tab.sessionID,
+              title: tab.title,
+              active: host.sessionTabs.current() === tab.sessionID,
+              ...host.sessionTabs.status(tab.sessionID),
+            })),
         open(sessionID) {
           if (!host.sessionTabs.enabled()) return false
           host.sessionTabs.select(sessionID)
@@ -186,14 +191,14 @@ export function createPluginContext(input: {
         },
         focus(sessionID) {
           if (!host.sessionTabs.enabled()) return false
-          if (!host.sessionTabs.tabs().some((tab) => tab.sessionID === sessionID)) return false
+          if (!host.sessionTabs.tabs().some((tab) => !tab.groupID && tab.sessionID === sessionID)) return false
           host.sessionTabs.select(sessionID)
           return true
         },
         close(sessionID) {
           if (!host.sessionTabs.enabled()) return false
           const target = sessionID ?? host.sessionTabs.current()
-          if (!target || !host.sessionTabs.tabs().some((tab) => tab.sessionID === target)) return false
+          if (!target || !host.sessionTabs.tabs().some((tab) => !tab.groupID && tab.sessionID === target)) return false
           host.sessionTabs.close(target)
           return true
         },

packages/tui/test/component/session-tabs-mouse.test.tsx

@@ -1,62 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { testRender } from "@opentui/solid"
-import { expect, test } from "bun:test"
-import { createSignal } from "solid-js"
-import { ConfigProvider } from "../../src/config"
-import { EMPTY_SESSION_TAB_STATUS, SessionTabs, type SessionTabsController } from "../../src/component/session-tabs"
-import { ThemeProvider } from "../../src/context/theme"
-import { emptyThemeSource } from "../fixture/fixture"
-import { TestTuiContexts } from "../fixture/tui-environment"
-import { createTuiResolvedConfig } from "../fixture/tui-runtime"
-
-test("releasing a transcript selection over tab controls does not activate them", async () => {
-  const [active, setActive] = createSignal("first")
-  const [added, setAdded] = createSignal(0)
-  const controller = {
-    tabs: () => [
-      { sessionID: "first", title: "First" },
-      { sessionID: "second", title: "Second" },
-    ],
-    current: active,
-    select: setActive,
-    close() {},
-    move() {},
-    add: () => setAdded((value) => value + 1),
-    status: () => EMPTY_SESSION_TAB_STATUS,
-  } satisfies SessionTabsController
-  const app = await testRender(
-    () => (
-      <TestTuiContexts>
-        <ConfigProvider config={createTuiResolvedConfig({ tabs: { enabled: true } })}>
-          <ThemeProvider mode="dark" source={emptyThemeSource}>
-            <box flexDirection="column">
-              <SessionTabs controller={controller} animations={false} />
-              <text>selectable transcript text</text>
-            </box>
-          </ThemeProvider>
-        </ConfigProvider>
-      </TestTuiContexts>
-    ),
-    { width: 60, height: 3 },
-  )
-
-  try {
-    app.renderer.start()
-    await app.waitForFrame((frame) => frame.includes("Second"))
-    await app.mockMouse.pressDown(5, 1)
-    await app.mockMouse.release(40, 0)
-    expect(active()).toBe("first")
-
-    await app.mockMouse.click(40, 0)
-    expect(active()).toBe("second")
-
-    await app.mockMouse.pressDown(5, 1)
-    await app.mockMouse.release(58, 0)
-    expect(added()).toBe(0)
-
-    await app.mockMouse.click(58, 0)
-    expect(added()).toBe(1)
-  } finally {
-    app.renderer.destroy()
-  }
-})

packages/tui/test/context/pane-layout-model.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test"
+import type { GroupItem } from "@opencode-ai/client"
+import {
+  defaultPaneLayout,
+  paneLayoutItems,
+  reconcilePaneLayout,
+  removePaneLayoutItem,
+} from "../../src/context/pane-layout-model"
+
+const session = (id: string): GroupItem => ({ type: "session", id })
+const terminal = (id: string): GroupItem => ({ type: "terminal", id })
+
+describe("pane layout model", () => {
+  test("builds a master pane with an evenly divided right stack", () => {
+    const items = [session("ses_1"), terminal("pty_1"), terminal("pty_2"), terminal("pty_3")]
+    const layout = defaultPaneLayout(items)
+
+    expect(layout).toEqual({
+      type: "split",
+      direction: "horizontal",
+      ratio: 0.5,
+      first: { type: "item", item: items[0] },
+      second: {
+        type: "split",
+        direction: "vertical",
+        ratio: 1 / 3,
+        first: { type: "item", item: items[1] },
+        second: {
+          type: "split",
+          direction: "vertical",
+          ratio: 0.5,
+          first: { type: "item", item: items[2] },
+          second: { type: "item", item: items[3] },
+        },
+      },
+    })
+    expect(paneLayoutItems(layout!)).toEqual(items)
+  })
+
+  test("preserves stored split ratios when backend items still match", () => {
+    const items = [session("ses_1"), terminal("pty_1")]
+    const layout = defaultPaneLayout(items)!
+    if (layout.type !== "split") throw new Error("Expected a split")
+    layout.ratio = 0.65
+
+    expect(reconcilePaneLayout(layout, items)).toMatchObject({ ratio: 0.65 })
+  })
+
+  test("rebuilds the default layout when backend order changes", () => {
+    const items = [session("ses_1"), terminal("pty_1")]
+    const layout = defaultPaneLayout(items)!
+    if (layout.type !== "split") throw new Error("Expected a split")
+    layout.ratio = 0.65
+
+    expect(reconcilePaneLayout(layout, items.toReversed())).toMatchObject({ ratio: 0.5 })
+  })
+
+  test("removes a pane and preserves the remaining BSP layout", () => {
+    const items = [session("ses_1"), terminal("pty_1"), terminal("pty_2")]
+    const layout = defaultPaneLayout(items)!
+    if (layout.type !== "split" || layout.second.type !== "split") throw new Error("Expected nested splits")
+    layout.ratio = 0.65
+    layout.second.ratio = 0.3
+
+    expect(removePaneLayoutItem(layout, items[1])).toEqual({
+      type: "split",
+      direction: "horizontal",
+      ratio: 0.65,
+      first: { type: "item", item: items[0] },
+      second: { type: "item", item: items[2] },
+    })
+  })
+})

packages/tui/test/context/session-tabs.test.tsx

@@ -1,6 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { expect, test } from "bun:test"
-import type { OpenCodeEvent } from "@opencode-ai/client"
+import type { GroupItem, OpenCodeEvent, PersistentPtyInfo } from "@opencode-ai/client"
 import { testRender } from "@opentui/solid"
 import { mkdirSync, watch } from "fs"
 import path from "path"
@@ -36,6 +36,8 @@ async function renderSessionTabs(
     sessionGate?: Promise<void>
     sessionDirectories?: Record<string, string>
     newLocation?: "launch" | "inherit"
+    groups?: Record<string, GroupItem[]>
+    terminals?: Record<string, PersistentPtyInfo[]>
   },
 ) {
   const temporary = options?.state ? undefined : await tmpdir()
@@ -55,7 +57,9 @@ async function renderSessionTabs(
   const sessions: string[] = []
   const locations: string[] = []
   const vcsLocations: string[] = []
-  const calls = createFetch(async (url) => {
+  const removedGroups: string[] = []
+  const removedTerminals: string[] = []
+  const calls = createFetch(async (url, request) => {
     if (url.pathname === "/api/location") {
       const requested = url.searchParams.get("location[directory]") ?? directory
       locations.push(requested)
@@ -72,6 +76,19 @@ async function renderSessionTabs(
         data: { branch: { current: "main", default: "main" } },
       })
     }
+    const terminalGroupID = url.pathname.match(/^\/api\/pty-group\/([^/]+)\/terminal$/)?.[1]
+    if (terminalGroupID && request.method === "GET") return json({ data: options?.terminals?.[terminalGroupID] ?? [] })
+    const groupID = url.pathname.match(/^\/api\/pty-group\/([^/]+)$/)?.[1]
+    if (groupID && request.method === "GET") return json({ data: { id: groupID, items: options?.groups?.[groupID] ?? [] } })
+    if (groupID && request.method === "DELETE") {
+      removedGroups.push(groupID)
+      return new Response(null, { status: 204 })
+    }
+    const ptyID = url.pathname.match(/^\/api\/persistent-pty\/([^/]+)$/)?.[1]
+    if (ptyID && request.method === "DELETE") {
+      removedTerminals.push(ptyID)
+      return new Response(null, { status: 204 })
+    }
     const sessionID = url.pathname.match(/^\/api\/session\/([^/]+)$/)?.[1]
     if (!sessionID) return undefined
     sessions.push(sessionID)
@@ -140,6 +157,8 @@ async function renderSessionTabs(
     sessions,
     locations,
     vcsLocations,
+    removedGroups,
+    removedTerminals,
     state,
     emit: (event: OpenCodeEvent) => events.emit({ ...event, location: { directory } }),
     focus: () => app.renderer.emit("focus"),
@@ -197,32 +216,6 @@ test("loads VCS metadata for each persisted tab location", async () => {
   }
 })
 
-test("loads location metadata when an open session moves", async () => {
-  const destination = `${directory}/moved-worktree`
-  const setup = await renderSessionTabs("first")
-
-  try {
-    await wait(() => setup.locations.includes(directory) && setup.vcsLocations.includes(directory))
-    setup.emit({
-      id: "evt_moved",
-      created: 1,
-      type: "session.moved",
-      durable: { aggregateID: "first", seq: 1, version: 1 },
-      data: {
-        sessionID: "first",
-        location: { directory: destination },
-        projectID: "project",
-      },
-    })
-
-    await wait(() => setup.data.session.get("first")?.location.directory === destination)
-    await wait(() => setup.locations.includes(destination))
-    await wait(() => setup.vcsLocations.includes(destination))
-  } finally {
-    await setup.destroy()
-  }
-})
-
 test("stores session tabs for the current working directory by default", async () => {
   const setup = await renderSessionTabs("first")
 
@@ -435,3 +428,57 @@ test("add inherits the current session location when configured", async () => {
     await setup.destroy()
   }
 })
+
+test("closing a terminal-only workspace tab terminates its terminals and removes its group", async () => {
+  const groupID = "grp_terminal"
+  const terminal = {
+    id: "pty_terminal",
+    title: "Terminal",
+    command: "/bin/sh",
+    args: [],
+    cwd: directory,
+    status: "running" as const,
+    pid: 123,
+    groupID,
+    size: { cols: 80, rows: 24 },
+    output: { head: 0, tail: 0 },
+  }
+  const setup = await renderSessionTabs("first", {
+    home: true,
+    groups: { [groupID]: [{ type: "terminal", id: terminal.id }] },
+    terminals: { [groupID]: [terminal] },
+  })
+
+  try {
+    setup.tabs.openWorkspace(groupID, directory)
+    await wait(() => setup.tabs.current() === groupID && setup.tabs.tabs().some((tab) => tab.groupID === groupID))
+    setup.tabs.close(groupID)
+    await wait(() => setup.removedGroups.includes(groupID) && !setup.tabs.tabs().some((tab) => tab.groupID === groupID))
+
+    expect(setup.removedTerminals).toEqual([terminal.id])
+    expect(setup.route.data).toEqual({ type: "home" })
+  } finally {
+    await setup.destroy()
+  }
+})
+
+test("closing a workspace tab with a session only detaches it", async () => {
+  const groupID = "grp_session"
+  const setup = await renderSessionTabs("first", {
+    home: true,
+    groups: { [groupID]: [{ type: "session", id: "ses_one" }] },
+  })
+
+  try {
+    setup.tabs.openWorkspace(groupID, directory)
+    await wait(() => setup.tabs.current() === groupID && setup.tabs.tabs().some((tab) => tab.groupID === groupID))
+    setup.tabs.close(groupID)
+    await wait(() => !setup.tabs.tabs().some((tab) => tab.groupID === groupID))
+
+    expect(setup.removedGroups).toEqual([])
+    expect(setup.removedTerminals).toEqual([])
+    expect(setup.route.data).toEqual({ type: "home" })
+  } finally {
+    await setup.destroy()
+  }
+})

packages/tui/test/feature-plugins/prompt-footer.test.tsx

@@ -43,3 +43,28 @@ test("prompt footer separates simultaneous subagent, shell, and usage status", a
     app.renderer.destroy()
   }
 })
+
+test("home prompt footer offers a new terminal instead of agent and command hints", async () => {
+  const color = RGBA.fromInts(200, 200, 200)
+  const context = {
+    theme: { text: { default: color, subdued: color } },
+    keymap: { shortcuts: () => [] },
+    data: {
+      session: { family: () => [], status: () => "idle" },
+      shell: { list: () => [] },
+    },
+  } as unknown as Context
+  const app = await testRender(() => <PromptFooter context={context} mode="normal" onNewTerminal={async () => {}} />, {
+    width: 80,
+    height: 2,
+  })
+
+  try {
+    await app.renderOnce()
+    expect(app.captureCharFrame()).toContain("new terminal")
+    expect(app.captureCharFrame()).not.toContain("agents")
+    expect(app.captureCharFrame()).not.toContain("commands")
+  } finally {
+    app.renderer.destroy()
+  }
+})