codex-toys 0.140.13 → 0.140.15

package/docs/pages/guides/dashboard-over-runtime.md

@@ -0,0 +1,87 @@
+---
+title: Dashboard Over Runtime
+description: Build a browser dashboard backed by the codex-toys runtime HTTP edge and workspace functions.
+---
+
+# Dashboard Over Runtime
+
+A dashboard over runtime is a browser UI that talks to `codex-toys runtime http`.
+The HTTP edge forwards generic app, workbench, and function calls to the same
+runtime used by CLI and SSH operation. It does not create a separate durable
+dashboard surface or custom thread registry.
+
+## Serve Static Files
+
+```bash
+codex-toys runtime http --cwd . --static ./dashboard
+```
+
+The dashboard can call same-origin `/api/*` routes:
+
+```text
+GET  /api/status
+GET  /api/schema
+POST /api/rpc
+POST /api/app/:method
+POST /api/workbench/:method
+POST /api/workbench/overview
+```
+
+## Browser Client
+
+```ts
+import { createCodexToysBrowserClient } from "codex-toys/runtime";
+
+const codexToys = createCodexToysBrowserClient();
+const overview = await codexToys.workbench.call("workbench.overview", {});
+const threads = await codexToys.app.call("thread/list", {
+  limit: 20,
+  sourceKinds: [],
+});
+const functions = await codexToys.functions.list();
+```
+
+Prefer workspace functions for product-specific data. They keep dashboard
+semantics in the workspace instead of baking product routes into codex-toys.
+
+## Vite Middleware
+
+```ts
+import { codexToysRuntime } from "codex-toys/runtime";
+
+export default {
+  plugins: [
+    codexToysRuntime({
+      cwd: ".",
+    }),
+  ],
+};
+```
+
+The Vite plugin serves the runtime API under `/__codex_toys/api`. Point the
+browser client at that base path:
+
+```ts
+const codexToys = createCodexToysBrowserClient({
+  basePath: "/__codex_toys/api",
+});
+```
+
+## Remote Runtime Without Remote HTTP
+
+Run the HTTP edge locally and connect it to a remote runtime over SSH:
+
+```bash
+codex-toys runtime http \
+  --ssh workbox \
+  --cwd /srv/codex/workspaces/ops \
+  --static ./dashboard
+```
+
+The browser talks to localhost. The remote host exposes no HTTP port.
+
+## Boundary
+
+The runtime HTTP edge owns transport, schema discovery, browser helpers, and
+forwarding. The workspace owns dashboard data through functions. Native Codex
+owns thread creation, thread opening, archive/delete, and app UI updates.

package/docs/pages/guides/remote-runtime.md

@@ -0,0 +1,109 @@
+---
+title: Remote Runtime
+description: Operate a Codex workspace on an SSH host through codex-toys runtime stdio.
+---
+
+# Remote Runtime
+
+A remote runtime is a Codex environment on a VPS or SSH host that is controlled
+from local commands. The remote machine owns Codex auth, config, sessions,
+memories, and workspace state. The local machine starts a short-lived
+`codex-toys runtime serve` process over SSH stdio for each command.
+
+## Prepare The Host
+
+Install these on the remote host:
+
+- Node 24
+- Codex CLI
+- `codex-toys`
+- a working shell for non-interactive SSH
+
+Authenticate Codex on the remote host. Commands sent through `--ssh` use the
+remote Codex home and remote config; they do not use local Codex auth.
+
+## Check Connectivity
+
+```bash
+codex-toys --ssh <host-or-alias> --cwd /srv/codex/workspaces/ops runtime preflight --json
+```
+
+Preflight checks SSH, cwd, Node, Codex, codex-toys, runtime startup, and native
+app-server initialization.
+
+## Configure PATH
+
+Non-interactive SSH shells often have a smaller PATH than login shells. Use
+explicit command paths or prepend entries:
+
+```bash
+codex-toys --ssh workbox \
+  --cwd /srv/codex/workspaces/ops \
+  --remote-path-prepend /opt/node/bin:/usr/local/bin \
+  --runtime-command /usr/local/bin/codex-toys \
+  --codex-command /usr/local/bin/codex \
+  runtime preflight --json
+```
+
+Environment equivalents:
+
+```text
+CODEX_TOYS_REMOTE_SSH_TARGET=workbox
+CODEX_TOYS_REMOTE_CWD=/srv/codex/workspaces/ops
+CODEX_TOYS_REMOTE_PATH_PREPEND=/opt/node/bin:/usr/local/bin
+CODEX_TOYS_RUNTIME_COMMAND=/usr/local/bin/codex-toys
+CODEX_TOYS_REMOTE_CODEX_COMMAND=/usr/local/bin/codex
+CODEX_TOYS_REMOTE_CODEX_ARGS=["-s","danger-full-access"]
+```
+
+## Run Remote Work
+
+Use direct remote calls for quick checks:
+
+```bash
+codex-toys --ssh workbox --cwd /srv/codex/workspaces/ops fetch
+codex-toys --ssh workbox --cwd /srv/codex/workspaces/ops functions list --json
+codex-toys --ssh workbox --cwd /srv/codex/workspaces/ops workflow run release-check --event event.json
+codex-toys --ssh workbox --cwd /srv/codex/workspaces/ops turn run "Scan current folder" --wait
+```
+
+SSH-backed `turn run` must wait because the remote runtime exits when the
+command exits. Use prompt queues, dispatch queues, workflows, or native Codex
+threads for work that should continue independently.
+
+## Inspect Remote State
+
+Remote state stays remote:
+
+```text
+<remote-workspace>/.codex/workbench/local/
+<remote-workspace>/.codex/feed/local/
+<remote-codex-home>/sessions/
+<remote-codex-home>/memories/
+```
+
+`codex-toys` does not copy remote Codex sessions, memories, or workbench state.
+Use the Codex App and native thread links for app-native thread discovery.
+
+## Browser Access
+
+For a browser UI, run the HTTP edge locally and let it speak SSH to the remote
+runtime:
+
+```bash
+codex-toys runtime http \
+  --ssh workbox \
+  --cwd /srv/codex/workspaces/ops \
+  --static ./dashboard
+```
+
+The browser talks to localhost. The remote host still exposes no HTTP port.
+
+## Troubleshooting
+
+- `runtime preflight` fails before runtime startup: SSH target, remote cwd,
+  remote PATH, Node, Codex, or codex-toys is missing.
+- Runtime starts but app calls fail: inspect remote Codex auth and remote Codex
+  config.
+- SSH prompt turns need `--wait`: use native Codex threads, queues, or workflows
+  for supervised background work.

package/docs/pages/index.md

@@ -1,26 +1,26 @@
 ---
 title: codex-toys
-description: Primitive-first documentation for codex-toys workflow, workbench, feed, components, guides, and Codex state helpers.
+description: Primitive-first documentation for codex-toys workflow, runtime, feed, templates, and Codex state helpers.
 ---
 
 # codex-toys
 
-`codex-toys` is a workbench layer for Codex. It gives a repository or operator
-process a small set of primitives for running code before Codex turns, operating
-local or SSH-backed workbenches, ingesting external or manual feed signals,
-dispatching durable work, and moving durable Codex state between homes.
+`codex-toys` is a small workspace layer around native Codex. Native Codex owns
+threads, turns, app UI, plugins, skills, hooks, auth, model settings, and app
+automations. `codex-toys` owns workspace templates, workspace functions,
+workflow execution, feed intake, explicit queues, Actions/runtime scaffolding,
+runtime transports, and Codex state utilities.
 
 The public npm package is `codex-toys`. Internal `@codex-toys/*` packages are
-feature boundaries that are embedded into the public tarball and exposed through
-`codex-toys/*` subpaths.
+implementation boundaries that are embedded into the public tarball and exposed
+through focused `codex-toys/*` subpaths.
 
 ## Primitive Map
 
 | Primitive | Owns | Start here |
 |-----------|------|------------|
-| Workflow | A script that inspects state and can start, read, wait on, or delegate Codex turns. | [Workflow](primitives/workflow) |
+| Workflow | A script that inspects state and can start, read, or wait on native Codex turns. | [Workflow](primitives/workflow) |
 | Workbench | Repo-local config, modes, explicit tasks, functions, health, and overview. | [Workbench](primitives/workbench) |
-| Delegation | Starting and tracking Codex work in another workbench-relative cwd. | [Delegation](primitives/delegation) |
 | Dispatch And Queues | Durable future intents, prompt queues, handoff queues, attempts, and collection. | [Dispatch and queues](primitives/dispatch-queues) |
 | Feed | RSS/Atom and manual intake, item storage, cursors, and ack-aware dispatch. | [Feed](primitives/feed) |
 
@@ -28,9 +28,8 @@ feature boundaries that are embedded into the public tarball and exposed through
 
 | Component | Owns | Start here |
 |-----------|------|------------|
-| Toybox | The stdio JSON-RPC workbench control surface used locally and over SSH. | [Toybox](components/toybox) |
-| Proxy | Optional HTTP edge for browser dashboards. | [Proxy](components/proxy) |
-| Kits | Repo-local copies of skills, plugins, and workflow templates. | [Kits](components/kits) |
+| Runtime | Local stdio, SSH stdio, and optional HTTP/browser transport over the same app/workbench/function methods. | [Runtime](components/runtime) |
+| Kits | Workspace templates installed from local or Git sources. | [Kits](components/kits) |
 | CLI | Command porcelain over primitives and components. | [CLI](components/cli) |
 
 ## Guides
@@ -38,12 +37,11 @@ feature boundaries that are embedded into the public tarball and exposed through
 | Guide | Use it when |
 |-------|-------------|
 | [Repository autonomy](guides/repository-autonomy) | A repo should run its workbench on a GitHub Actions schedule and commit durable Codex state back to itself. |
-| [Remote Codex workbench](guides/remote-codex-workbench) | A VPS or SSH host should run a separate Codex workbench controlled from local commands. |
+| [Remote runtime](guides/remote-runtime) | A VPS or SSH host should run Codex work while local commands control it over SSH stdio. |
 | [Local scheduled workbench](guides/local-scheduled-workbench) | A trusted local machine should run explicit workbench or feed commands on systemd user timers. |
-| [Dashboard over toybox](guides/dashboard-over-toybox) | A browser UI should inspect or operate a local or SSH-backed workbench through the proxy. |
+| [Dashboard over runtime](guides/dashboard-over-runtime) | A browser UI should inspect or operate a local or SSH-backed workspace through the runtime HTTP edge. |
 | [Feed to workflow](guides/feed-to-workflow) | RSS or Atom items should dispatch into workflow-backed workbench tasks. |
-| [Capability kit setup](guides/capability-kit-setup) | A workbench should install checked-in local skills, plugins, or workflows from a kit. |
-| [Delegated repo work](guides/delegated-repo-work) | A controlling workbench should start and track Codex work in another checkout. |
+| [Capability kit setup](guides/capability-kit-setup) | A workspace should install checked-in local templates from a kit. |
 
 ## Operations
 
@@ -56,45 +54,46 @@ feature boundaries that are embedded into the public tarball and exposed through
 
 ```bash
 codex-toys fetch
-codex-toys toybox serve --cwd <workbench>
+codex-toys runtime serve --cwd <workspace>
+codex-toys runtime http --cwd <workspace> --static ./dashboard
 codex-toys workflow list
 codex-toys workflow run <name> --event event.json
 codex-toys workbench doctor
+codex-toys functions list --json
 codex-toys feed poll --json
 codex-toys workbench prompt enqueue "Review this later."
 codex-toys workbench dispatch list --json
 ```
 
-Run the same workbench over SSH without opening a remote port:
+Run the same workspace over SSH without opening a remote port:
 
 ```bash
-codex-toys --ssh <target> --cwd <remote-workbench> fetch
-codex-toys --ssh <target> --cwd <remote-workbench> workflow run <name> --event event.json
-codex-toys --ssh <target> --cwd <remote-workbench> workbench dispatch collect --cursor operator --json
+codex-toys --ssh <target> --cwd <remote-workspace> fetch
+codex-toys --ssh <target> --cwd <remote-workspace> runtime preflight --json
+codex-toys --ssh <target> --cwd <remote-workspace> workflow run <name> --event event.json
+codex-toys --ssh <target> --cwd <remote-workspace> functions list --json
+codex-toys --ssh <target> --cwd <remote-workspace> turn run "Scan current folder" --wait
 ```
 
 ## Runtime Shape
 
-Local CLI commands spawn `codex-toys toybox serve` over stdio when they need
-workbench methods. SSH commands start that same toybox on the remote host and
-speak JSON-RPC over SSH stdio. Core commands do not expose HTTP or WebSocket
-servers.
-
-Browser dashboards opt into HTTP explicitly with `codex-toys-proxy`. The proxy
-forwards generic app and workbench calls to the toybox instead of creating a
-second product model.
+Local CLI commands spawn `codex-toys runtime serve` over stdio when they need
+workspace methods. SSH commands start that same stdio runtime on the remote
+host and speak JSON-RPC over SSH stdio. Browser dashboards opt into HTTP with
+`codex-toys runtime http`, which forwards generic app, workbench, and function
+calls to the runtime instead of creating a second product API.
 
 ## Boundary
 
 `codex-toys` owns reusable mechanics:
 
 - Codex app-server bridge helpers
-- toybox transport and method metadata
+- runtime transport and method metadata
 - workflow script execution and host helpers
 - feed intake and cursor state
-- workbench tasks, functions, queues, delegation, and overview
+- workbench tasks, functions, queues, and overview
 - memory and thread rollout file moves
-- kit inspection and repo-local installation
+- kit inspection and workspace-template installation
 
 Installing products own domain completion: credentials, source catalogs, scoring,
 prompt policy, deployment decisions, branch or release policy, external writes,
@@ -113,9 +112,8 @@ Install Codex-facing guidance from the shared plugin marketplace:
 ```bash
 codex plugin marketplace add peezy-tech/skills --ref main
 codex plugin add codex-toys-author@peezy-tech
-codex plugin add codex-toys-local-workbench@peezy-tech
+codex plugin add codex-toys-local-workspace@peezy-tech
 codex plugin add codex-toys-remote-control@peezy-tech
 ```
 
-Use kits only when a workbench intentionally wants repo-local copies of skills,
-plugins, or workflow templates.
+Use kits only when a workspace intentionally wants repo-local templates.

package/docs/pages/operations/plugins.md

@@ -6,15 +6,15 @@ description: Install codex-toys Codex-facing guidance from a Git-backed marketpl
 # Plugins
 
 The npm package installs the CLI and runtime APIs. Codex plugins install
-Codex-facing guidance such as workflow authoring, local toybox operation, and
-remote workbench operation.
+Codex-facing guidance such as workflow authoring, local runtime operation, and
+remote workspace operation.
 
 ## Shared Marketplace
 
 ```bash
 codex plugin marketplace add peezy-tech/skills --ref main
 codex plugin add codex-toys-author@peezy-tech
-codex plugin add codex-toys-local-workbench@peezy-tech
+codex plugin add codex-toys-local-workspace@peezy-tech
 codex plugin add codex-toys-remote-control@peezy-tech
 ```
 
@@ -26,8 +26,8 @@ is reloaded.
 | Plugin | Use it for |
 |--------|------------|
 | `codex-toys-author` | Writing or reviewing workflow scripts. |
-| `codex-toys-local-workbench` | Operating local toyboxes and proxy dashboards. |
-| `codex-toys-remote-control` | Operating SSH-backed workbenches from a local Codex App. |
+| `codex-toys-local-workspace` | Operating local runtimes and HTTP dashboards. |
+| `codex-toys-remote-control` | Operating SSH-backed workspaces from a local Codex App. |
 
 The root `codex-toys` plugin is for product-local development against this repo.
 Prefer the granular plugins for normal use.
@@ -39,7 +39,7 @@ When iterating on this checkout, add the checkout root as a local marketplace:
 ```bash
 codex plugin marketplace add <codex-toys-checkout>
 codex plugin add codex-toys-author@codex-toys
-codex plugin add codex-toys-local-workbench@codex-toys
+codex plugin add codex-toys-local-workspace@codex-toys
 codex plugin add codex-toys-remote-control@codex-toys
 ```
 
@@ -49,4 +49,4 @@ upgrade the affected plugin and start a new thread.
 ## Runtime Boundary
 
 Plugin install does not start a service. The CLI, MCP server, workflow runs,
-functions, delegation, and proxy all use the normal toybox/proxy runtime paths.
+functions, and optional HTTP edge all use the normal runtime paths.

package/docs/pages/primitives/dispatch-queues.md

@@ -110,10 +110,10 @@ codex-toys workbench handoff drain \
 ## SSH
 
 SSH is transport, not a third queue. With `--ssh`, queue commands operate on the
-remote workbench's local queue through the remote toybox.
+remote workspace's local queue through the remote runtime.
 
 ```bash
-codex-toys --ssh <target> --cwd <remote-workbench> workbench dispatch list --json
-codex-toys --ssh <target> --cwd <remote-workbench> workbench prompt run-due --limit 1
-codex-toys --ssh <target> --cwd <remote-workbench> workbench handoff collect --cursor operator --json
+codex-toys --ssh <target> --cwd <remote-workspace> workbench dispatch list --json
+codex-toys --ssh <target> --cwd <remote-workspace> workbench prompt run-due --limit 1
+codex-toys --ssh <target> --cwd <remote-workspace> workbench handoff collect --cursor operator --json
 ```

package/docs/pages/primitives/feed.md

@@ -51,12 +51,12 @@ codex-toys feed dispatch --source project-releases --cursor radar --target workb
 codex-toys feed prune --older-than-days 90 --dry-run
 ```
 
-With `--ssh`, the local CLI starts the remote toybox and calls the same feed
+With `--ssh`, the local CLI starts the remote runtime and calls the same feed
 methods in the remote root selected by `--cwd`.
 
 ```bash
-codex-toys --ssh <target> --cwd <remote-workbench> feed poll --json
-codex-toys --ssh <target> --cwd <remote-workbench> feed collect --cursor radar --json
+codex-toys --ssh <target> --cwd <remote-workspace> feed poll --json
+codex-toys --ssh <target> --cwd <remote-workspace> feed collect --cursor radar --json
 ```
 
 ## State

package/docs/pages/primitives/workbench.md

@@ -131,6 +131,7 @@ where that history belongs in git.
 - functions
 - recent cwd threads
 - git state
-- health checks for Node, codex-toys, Codex, toybox, app-server, and config
+- health checks for Node, codex-toys, Codex, runtime transport, app-server, and config
 
-The proxy exposes the same data through `POST /api/workbench/overview`.
+The runtime HTTP edge exposes the same data through
+`POST /api/workbench/overview`.

package/docs/pages/primitives/workflow.md

@@ -8,14 +8,13 @@ description: The codex-toys primitive for running script code before composing n
 Workflow is the pre-turn orchestration primitive. A workflow runs a JavaScript or
 TypeScript module, gives it a JSON context, and records the JSON object returned
 by the module. The script can decide to skip, return data, start a Codex turn,
-wait on several turns, or delegate work through the toybox.
+or wait on several native Codex turns.
 
 ```text
 event, schedule, or operator command
   -> workflow script
      -> return JSON
      -> optionally call context.turn.*
-     -> optionally call context.delegate.*
 ```
 
 The CLI does not interpret returned `action` fields. The script owns its own
@@ -63,7 +62,7 @@ codex-toys workflow run --script ./check.ts --event event.json
 printf '%s\n' 'export default () => ({ status: "ok" })' | codex-toys workflow run --script-stdin
 ```
 
-By default, workflow turns use the workbench toybox surface. Use `--via app`
+By default, workflow turns use the workbench runtime surface. Use `--via app`
 only when deliberately targeting direct app-server calls without workbench
 helpers.
 
@@ -75,8 +74,8 @@ codex-toys workflow run release-check --event event.json --via app
 Run the workflow on a remote host through SSH stdio:
 
 ```bash
-codex-toys --ssh <target> --cwd <remote-workbench> workflow list --json
-codex-toys --ssh <target> --cwd <remote-workbench> workflow run release-check --event event.json
+codex-toys --ssh <target> --cwd <remote-workspace> workflow list --json
+codex-toys --ssh <target> --cwd <remote-workspace> workflow run release-check --event event.json
 ```
 
 With `--ssh`, discovery, named resolution, event loading, and script execution
@@ -114,14 +113,11 @@ The context includes:
 Host helpers include:
 
 - `context.app.call(method, params)`
-- `context.workbench.call(method, params)`, only through the toybox surface
+- `context.workbench.call(method, params)`, only through the runtime surface
 - `context.turn.start(params)`
 - `context.turn.read(turn)`
 - `context.turn.wait(turn, options)`
 - `context.turn.waitAll(turns, options)`
-- `context.delegate.start(params)`, only through the toybox surface
-- `context.delegate.read(delegation)`
-- `context.delegate.wait(delegation, options)`
 
 ## Turn Fields
 
@@ -143,25 +139,30 @@ Host helpers include:
 Do not combine a sandbox mode with a permissions profile unless the target Codex
 host explicitly supports that combination.
 
-## Delegated Work
+## Background Work
 
-Use delegation when the work belongs in another checkout under the same
-workbench root.
+Workflow does not create a second thread registry. When background work belongs
+in another checkout, start or resume native Codex turns directly through
+`context.turn.*`, dispatch queues, or explicit app-server calls, then return the
+thread id and `codex://thread/<id>` link from the script result.
 
 ```ts
 export default async function run(context) {
-  const delegation = await context.delegate.start({
+  const turn = await context.turn.start({
     cwd: "@/repos/example",
-    prompt: "Inspect this repository and summarize risks.",
-    returnMode: "wake_on_done"
+    prompt: "Inspect this repository and summarize risks."
   });
 
-  return { status: "delegated", delegation };
+  return {
+    status: "started",
+    threadId: turn.threadId,
+    threadUrl: turn.threadId ? `codex://thread/${turn.threadId}` : undefined
+  };
 }
 ```
 
-`context.delegate.*` requires `--via workbench`, because delegation is a toybox
-method, not a direct app-server method.
+Native Codex owns thread discovery, open links, archive/delete, fork, resume,
+and app UI control.
 
 ## Workbench Tasks
 

package/docs/pages/reference/packages.md

@@ -26,11 +26,6 @@ import { v2 } from "codex-toys/bridge/generated";
 import { parseJsonText } from "codex-toys/bridge/json";
 ```
 
-## `codex-toys/toybox`
-
-Stdio JSON-RPC protocol, client, and server primitives for local and SSH-backed
-toyboxes. Use it when another process needs to host or call a toybox directly.
-
 ## `codex-toys/feed`
 
 Feed intake helpers:
@@ -42,7 +37,7 @@ Feed intake helpers:
 - durable feed item storage
 - collection cursors
 - dispatch and pruning
-- toybox method factories and metadata
+- runtime method factories and metadata
 
 ```ts
 import {
@@ -59,10 +54,9 @@ import {
 Workbench runtime and policy helpers:
 
 - workflow script execution and workflow host helpers
-- remote workflow toybox methods
+- remote workflow runtime methods
 - workbench doctor, task execution, dispatch drains, and Actions scaffolding
 - dispatch runs, prompt queue, and local handoff queue
-- delegation methods and state
 - workbench functions
 - workbench and host overview
 - thread presentation helpers and request descriptors
@@ -100,22 +94,21 @@ system packages. The generated Actions-mode workflow uses
 release feed publishes `codex-<codex-version>` tags that bake native Codex into
 the image before the bindings workflow runs.
 
-## `codex-toys/remote`
-
-SSH-backed transport and preflight helpers. This package creates toybox
-transports over SSH stdio, resolves remote options, performs remote preflight,
-and supports remote-control status helpers without exposing remote HTTP ports.
-
-## `codex-toys/proxy`
+## `codex-toys/runtime`
 
-Optional HTTP edge for dashboards. Public entry points include:
+Runtime/connect helpers for local stdio, SSH stdio, browser clients, and the
+optional HTTP edge. This is the public surface for all codex-toys transport
+paths.
 
-- `codex-toys/proxy`
-- `codex-toys/proxy/browser`
-- `codex-toys/proxy/vite`
-- `codex-toys-proxy`
-
-The proxy forwards generic app and workbench methods to a toybox.
+```ts
+import {
+  CodexRuntimeClient,
+  createSshRuntimeTransport,
+  createCodexToysRuntimeHttpHandler,
+  createCodexToysBrowserClient,
+  codexToysRuntime
+} from "codex-toys/runtime";
+```
 
 ## `codex-toys/kits`
 
@@ -126,6 +119,6 @@ workflow templates. Kits read optional `codex-kit.toml` manifests, write
 
 ## `codex-toys`
 
-The CLI package and umbrella runtime export. It publishes the `codex-toys` and
-`codex-toys-proxy` binaries, re-exports the focused runtime surfaces, and
-ships a version-matched Markdown docs snapshot under `docs/pages`.
+The CLI package and umbrella runtime export. It publishes the `codex-toys`
+binary, re-exports the focused runtime surfaces, and ships a version-matched
+Markdown docs snapshot under `docs/pages`.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "codex-toys",
-	"version": "0.140.13",
-	"description": "Codex CLI and umbrella runtime export for bridge, toybox, feed, remote, workbench, actions, proxy, and kits.",
+	"version": "0.140.15",
+	"description": "Codex CLI and umbrella runtime export for bridge, runtime, feed, workbench, actions, and kits.",
 	"type": "module",
 	"license": "Apache-2.0",
 	"repository": {
@@ -18,8 +18,7 @@
 	"sideEffects": false,
 	"types": "./dist/index.d.ts",
 	"bin": {
-		"codex-toys": "dist/cli/index.js",
-		"codex-toys-proxy": "dist/internal/proxy/bin/codex-toys-proxy.js"
+		"codex-toys": "dist/cli/index.js"
 	},
 	"files": [
 		"dist",
@@ -74,25 +73,9 @@
 			"types": "./dist/kits.d.ts",
 			"import": "./dist/kits.js"
 		},
-		"./proxy": {
-			"types": "./dist/proxy/index.d.ts",
-			"import": "./dist/proxy/index.js"
-		},
-		"./proxy/browser": {
-			"types": "./dist/proxy/browser.d.ts",
-			"import": "./dist/proxy/browser.js"
-		},
-		"./proxy/vite": {
-			"types": "./dist/proxy/vite.d.ts",
-			"import": "./dist/proxy/vite.js"
-		},
-		"./remote": {
-			"types": "./dist/remote.d.ts",
-			"import": "./dist/remote.js"
-		},
-		"./toybox": {
-			"types": "./dist/toybox.d.ts",
-			"import": "./dist/toybox.js"
+		"./runtime": {
+			"types": "./dist/runtime.d.ts",
+			"import": "./dist/runtime.js"
 		},
 		"./workbench": {
 			"types": "./dist/workbench.d.ts",