eve 0.55.0 → 0.57.0

package/docs/reference/cli.md

@@ -57,7 +57,7 @@ Creates a new agent app or adds an agent to an existing app. Always installs dep
 
 Existing packages do not need a target-selection prompt: run `eve init` from the project directory or `eve init path/to/app`. New projects in non-interactive environments need a new directory name, such as `eve init my-agent`.
 
-After scaffolding, a human terminal usually continues into `eve dev`. Enable the self-modification subagent to edit your agent from the dev session. Otherwise, if a coding-agent REPL is on `PATH`, you can launch it to make changes instead of opening the TUI. Fresh projects use the parent workspace's package manager when there is one; otherwise they use the manager that launched `eve init`.
+After scaffolding in an interactive human terminal, eve opens the TUI directly. Noninteractive and coding-agent invocations return without starting an interactive session. Fresh projects use the parent workspace's package manager when there is one; otherwise they use the manager that launched `eve init`.
 
 | Flag                   | Type   | Default                    | Description                                                                                                              |
 | ---------------------- | ------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
@@ -123,7 +123,7 @@ Commands for installing and discovering [shadcn registry](https://ui.shadcn.com/
 
 ```bash
 eve add extension/agent-browser
-eve add linear
+eve add channel/linear
 eve add channel/slack --skip-install
 eve add https://example.com/r/my-extension.json --overwrite
 eve registry add @acme=https://example.com/r/{name}.json
@@ -134,11 +134,11 @@ eve registry view @acme/my-extension
 eve add @acme/my-extension
 ```
 
-`eve add` asks before running setup declared by an official item and runs multiple declared flows in declaration order. Product-level packages can offer independently installable components: `eve add linear` lets you select the Linear Channel, Linear MCP, or both, with both selected by default. Interactive Vercel-backed setup signs in and creates or links a project when needed instead of stopping with a prerequisite. `--yes` installs a package's default components and accepts detected or recommended setup answers.
+`eve add` asks before running setup declared by an official item and runs multiple declared flows in declaration order. Interactive Vercel-backed setup signs in and creates or links a project when needed instead of stopping with a prerequisite. `--yes` accepts detected or recommended setup answers.
 
-Coding agents should use `eve add <item> --non-interactive`, adding `--yes` to accept recommended setup values and reduce setup round trips. Explicit `--answer` values take precedence. This mode never opens an eve prompt. When a component or setup decision is missing, the NDJSON terminal event includes a stable question key and a safe continuation command; add the requested answer to that command. Supply answers with repeatable `--answer 'key=<JSON value>'` options. Follow a reported `eve link` prerequisite before retrying Vercel Connect setup. Do not put secrets in command-line answers; use the integration's documented environment variable or secret store.
+Coding agents should use `eve add <item> --non-interactive`, adding `--yes` to accept recommended setup values and reduce setup round trips. Explicit `--answer` values take precedence. This mode never opens an eve prompt. When a setup decision is missing, the NDJSON terminal event includes a stable question key and a safe continuation command; add the requested answer to that command. Supply answers with repeatable `--answer 'key=<JSON value>'` options. Follow a reported `eve link` prerequisite before retrying Vercel Connect setup. Do not put secrets in command-line answers; use the integration's documented environment variable or secret store.
 
-When setup is skipped, cancelled, or needs more input after installation, eve prints or returns the matching `eve add <item> --skip-install` continuation. It reruns the selected components' declared flows without reinstalling registry files.
+When setup is skipped, cancelled, or needs more input after installation, eve prints or returns the matching `eve add <item> --skip-install` continuation. It reruns the item's declared flows without reinstalling registry files.
 
 `eve registry add` records configured sources in `package.json#registries`. `eve registry list` aggregates the official catalog and all configured sources by default. `eve registry search` also includes [skills.sh](https://skills.sh), available without configuration at `@skills`, and groups results by source with each source's available result count. Search returns up to 10 matches per source by default; pass `--limit <count>` to request between 1 and 100. Either command can browse one supplied URL or namespace. Official and other universal items with explicit file targets do not require shadcn project configuration.
 
@@ -234,7 +234,7 @@ Pass a bare URL and the UI connects to that server instead of booting a local on
 
 `eve acp` reserves stdin and stdout for newline-delimited JSON-RPC and sends diagnostics to stderr. Without a URL, it supervises an isolated local development server. With a URL, it bridges ACP to that server's existing eve HTTP API and accepts the same URL credentials and request headers as `eve dev <url>`. Pass `--scope <team>` when the active Vercel scope does not own the deployment; `EVE_VERCEL_SCOPE` provides the same value for managed harnesses. See [Agent Client Protocol (ACP)](../protocols/acp) for client configuration and capability limits.
 
-A fresh `eve init` starts onboarding before the first prompt: the TUI installs the Vercel CLI if needed, asks you to log in if needed, guides you through model configuration, then lets you choose channels and integrations. Other `--input` text stays editable in the prompt.
+A fresh `eve init` opens the TUI and reuses an available model connection or opens `/login`. No Vercel project, channels, integrations, or review step is required before chat. Use `/model` to change models and settings, and `/add` to install an addition. Other `--input` text stays editable in the prompt. See [Terminal UI](../guides/dev-tui) for credential precedence and login options.
 
 For a URL target protected by HTTP Basic auth, put the credentials in the URL. eve sends them as a Basic `Authorization` header and strips them from the server URL before connecting:
 
@@ -317,7 +317,7 @@ A durable conversation produces one bounded trace per turn. Worker replacements
 
 Every span carries a real duration. A turn's root `invoke_agent` span is written when the turn settles, so a running turn shows only its steps.
 
-Model, `execute_tool`, and memory spans omit their content by default. Set `EVE_TRACES_CONTENT=on` to capture system prompts, prompt messages, and response text for models; call arguments and results for tools; and recalled memory records. Each captured value is capped at 32 KB.
+Model, `execute_tool`, and memory spans retain their content by default. Set `EVE_TRACES_CONTENT=off` to omit system prompts, prompt messages, and response text for models; call arguments and results for tools; and recalled memory records. Each captured value is capped at 32 KB.
 
 Step spans carry token counts under `agent.usage.*`, and cost when Vercel AI Gateway served the call. Model spans also expose `gen_ai.usage.*` token counters. The CLI sums step-level counters only, so model and delegated-call totals are not counted twice.
 
@@ -325,13 +325,13 @@ Step spans carry token counts under `agent.usage.*`, and cost when Vercel AI Gat
 
 eve sweeps the store when an activation's writes finish, when a session finishes, and when the dev server starts. An open conversation does not pin every completed turn's trace. Sweeps evict oldest-first past the bounds below, except that active traces, the newest traces, and anything written in the last five minutes are kept. A sweep can therefore exceed the size budget. Set the bounds in `.env.local`, which `eve dev` loads automatically; each accepts `off` to disable it individually.
 
-| Variable                     | Default              | Effect                                                                                              |
-| ---------------------------- | -------------------- | --------------------------------------------------------------------------------------------------- |
-| `EVE_TRACES`                 | on                   | `off` stops writing traces and stops sweeping                                                       |
-| `EVE_TRACES_CONTENT`         | off                  | `on` captures model prompt/response, tool input/output, and memory-record attributes on local spans |
-| `EVE_TRACES_MAX_AGE_MS`      | `604800000` (7d)     | Age after which a trace may be evicted                                                              |
-| `EVE_TRACES_MAX_TOTAL_BYTES` | `536870912` (512 MB) | Size budget for the whole store                                                                     |
-| `EVE_TRACES_RETAIN_COUNT`    | `20`                 | Newest traces kept regardless of age or size                                                        |
+| Variable                     | Default              | Effect                                                                                            |
+| ---------------------------- | -------------------- | ------------------------------------------------------------------------------------------------- |
+| `EVE_TRACES`                 | on                   | `off` stops writing traces and stops sweeping                                                     |
+| `EVE_TRACES_CONTENT`         | on                   | `off` omits model prompt/response, tool input/output, and memory-record attributes on local spans |
+| `EVE_TRACES_MAX_AGE_MS`      | `604800000` (7d)     | Age after which a trace may be evicted                                                            |
+| `EVE_TRACES_MAX_TOTAL_BYTES` | `536870912` (512 MB) | Size budget for the whole store                                                                   |
+| `EVE_TRACES_RETAIN_COUNT`    | `20`                 | Newest traces kept regardless of age or size                                                      |
 
 ## `eve link`
 
@@ -399,10 +399,10 @@ Lists the user-authored channels in the current project.
 4. `eve build` before shipping.
 5. `eve start` to smoke-test the built output locally.
 
-Related: [Project layout](../getting-started#project-layout) · [instrumentation.ts](../guides/instrumentation).
+Related: [Project layout](../getting-started#project-layout) · [Instrumentation](../observability/instrumentation).
 
 ## What to read next
 
 - [Project layout](../getting-started#project-layout): what `eve info` discovers
-- [instrumentation.ts](../guides/instrumentation): tracing and the error catalog
+- [Instrumentation](../observability/instrumentation): tracing and the error catalog
 - [Deployment](../guides/deployment/overview): `eve build` and `eve start` in production

package/docs/reference/telemetry.md

@@ -12,7 +12,7 @@ eve collects usage data from its CLI to help improve its commands and developmen
 eve sends the following information to Vercel:
 
 - The eve version, operating system, CPU architecture, and whether stdin is a terminal.
-- The command you ran, its outcome, and setup or onboarding steps when applicable. When setup or onboarding fails, eve sends a bounded category describing the failed step. It does not send the underlying error.
+- The command you ran, its outcome, and setup or onboarding steps when applicable, including connection-ready and first-response timing. When setup or onboarding fails, eve sends a bounded category describing the failed step. It does not send the underlying error.
 - For `eve dev`, whether you connected to a local or remote agent and whether the UI was interactive or headless.
 - Random identifiers for the CLI session, installation, and project, plus whether the installation and project identifiers are ephemeral or persistent.
 

package/docs/reference/typescript-api.md

@@ -48,16 +48,16 @@ export default defineTool({
 | `defineSchedule`                                      | `eve/schedules`                                                         | `agent/schedules/<name>.ts`                                                            | [Schedules](../schedules)                              |
 | `defineState`                                         | `eve/context`                                                           | tools, hooks, lifecycle                                                                | [Session context](../guides/session-context)           |
 | `defineSandbox`                                       | `eve/sandbox`                                                           | `agent/sandbox.ts`                                                                     | [Sandbox](../sandbox)                                  |
-| `defineInstrumentation`                               | `eve/instrumentation`                                                   | `agent/instrumentation.ts`                                                             | [instrumentation.ts](../guides/instrumentation)        |
+| `defineInstrumentation`                               | `eve/instrumentation`                                                   | `agent/instrumentation.ts`                                                             | [Instrumentation](../observability/instrumentation)    |
 | `defineRemoteAgent`                                   | `eve`                                                                   | `agent/subagents/<id>/agent.ts`                                                        | [Remote agents](../guides/remote-agents)               |
 | `defineEval`                                          | `eve/evals`                                                             | `evals/*.eval.ts`                                                                      | [Evals](../evals/overview)                             |
 | `defineEvalConfig`                                    | `eve/evals`                                                             | `evals/evals.config.ts`                                                                | [Evals](../evals/overview)                             |
 | `mockModel`                                           | `eve/evals`                                                             | Deterministic fixture agent models                                                     | [Evals](../evals/overview)                             |
 | `useEveAgent`                                         | `eve/react`, `eve/vue`, `eve/svelte`                                    | frontend                                                                               | [Frontend](../guides/frontend/overview)                |
 
-Tool-wide authoring helpers and types such as `defineTool`, `defineWorkflowTool`, `defineDurableCallback`, `defineDynamic`, `disableTool`, and `ToolLabelDefinition` come from `eve/tools`. Capability-specific definitions and helpers use their own subpaths (see [Built-in tools](../concepts/built-in-tools)): reusable definitions such as `bash` and `glob` come from `eve/tools/<name>`, `webSearch` comes from `eve/tools/web_search`, `experimental_workflow` comes from `eve/tools/workflow`, `sleep` comes from `eve/tools/sleep`, and approval policies and types come from `eve/tools/approval`. The route verbs `GET`/`HEAD`/`POST`/`PUT`/`PATCH`/`DELETE`/`OPTIONS`/`WS` plus `disableRoute` come from `eve/channels`, and the channel auth helpers `localDev`/`vercelOidc`/`placeholderAuth` come from `eve/channels/auth`.
+Tool-wide authoring helpers and types such as `defineTool`, `defineWorkflowTool`, `defineDurableCallback`, `defineDynamic`, `disableTool`, and `ToolLabelDefinition` come from `eve/tools`. Capability-specific definitions and helpers use their own subpaths (see [Built-in tools](../concepts/built-in-tools)): reusable definitions such as `bash` and `glob` come from `eve/tools/<name>`, `webSearch` comes from `eve/tools/web_search`, `sleep` comes from `eve/tools/sleep`, and approval policies and types come from `eve/tools/approval`. The route verbs `GET`/`HEAD`/`POST`/`PUT`/`PATCH`/`DELETE`/`OPTIONS`/`WS` plus `disableRoute` come from `eve/channels`, and the channel auth helpers `localDev`/`vercelOidc`/`placeholderAuth` come from `eve/channels/auth`.
 
-`AgentReasoningDefinition` is exported from `eve` for the top-level `defineAgent({ reasoning })` setting. `AgentLimitsDefinition` is exported for `defineAgent({ limits })`. `AgentWorkflowDefinition`, `AgentWorkflowRetentionDefinition`, and `AgentWorkflowWorldDefinition` are exported from `eve` for the `defineAgent({ experimental: { workflow } })` config shape. `ExperimentalWorkflowToolInput` is exported from `eve/tools/workflow`; `WebSearchToolInput` and `WebSearchProvider` are exported from `eve/tools/web_search`.
+`AgentReasoningDefinition` is exported from `eve` for the top-level `defineAgent({ reasoning })` setting. `AgentLimitsDefinition` is exported for `defineAgent({ limits })`. `AgentWorkflowDefinition`, `AgentWorkflowRetentionDefinition`, and `AgentWorkflowWorldDefinition` are exported from `eve` for the `defineAgent({ experimental: { workflow } })` config shape. `WebSearchToolInput` and `WebSearchProvider` are exported from `eve/tools/web_search`.
 
 `defineInstructions` accepts `{ content: string, role?: "system" | "user" }`; omitted `role` means `"system"`. Its `eve/instructions` version of `defineDynamic` accepts only `session.started` and `turn.started` handlers returning `defineInstructions(...)` or `null`. The legacy `{ markdown: string }` definition remains available as a deprecated system-role form.
 
@@ -74,11 +74,11 @@ cross resolved instances.
 
 eve evaluates TypeScript definition modules during compilation so it can validate and normalize the agent. Within one agent node, each module namespace loads at most once during that compile. The resolved definition then determines whether the module is also an entry in the runtime bundle:
 
-| Lifecycle           | Authored definitions                                                                                                                                                                                                                            |
-| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Compile only        | Static instructions and skills, prompt-form TypeScript schedules, static Gateway or default agent config, provider-managed web search, `Workflow` configuration, fully shadowed channels, and a child sandbox that selects its parent's sandbox |
-| Compile and runtime | Dynamic instructions, skills, tools, models, and subagents; executable tools; effective channels; connections; hooks; memory; handler schedules; direct-provider models; independent sandboxes; and remote subagents                            |
-| Runtime only        | Instrumentation modules and extension mount initialization                                                                                                                                                                                      |
+| Lifecycle           | Authored definitions                                                                                                                                                                                                                              |
+| ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Compile only        | Static instructions and skills, prompt-form TypeScript schedules, static Gateway or default agent config, provider-managed web search, Workflow SDK configuration, fully shadowed channels, and a child sandbox that selects its parent's sandbox |
+| Compile and runtime | Dynamic instructions, skills, tools, models, and subagents; executable tools; effective channels; connections; hooks; memory; handler schedules; direct-provider models; independent sandboxes; and remote subagents                              |
+| Runtime only        | Instrumentation modules and extension mount initialization                                                                                                                                                                                        |
 
 A compile-only module is not imported when the deployed runtime starts. For example, eve stores the resolved content from a static `instructions.ts` in the compiled manifest. A compile-and-runtime module is evaluated during compilation and imported again when a runtime process loads the module map. Keep module-top-level work deterministic, and put request- or session-specific work in the definition's runtime callbacks.
 
@@ -116,7 +116,7 @@ import template from "../../prompts/template.txt?raw";
 | `eve/tools/{bash,read_file,write_file,todo,web_fetch,load_skill,glob,grep}` | Individual reusable tool definitions                                                                    |
 | `eve/tools/approval`                                                        | Approval types and `always`, `once`, `never`                                                            |
 | `eve/tools/web_search`                                                      | Provider-managed `webSearch` configuration                                                              |
-| `eve/tools/workflow`                                                        | Experimental `Workflow` tool definition                                                                 |
+| `eve/tools/workflow`                                                        | Runtime-generated `workflow` tool factory                                                               |
 | `eve/tools/sleep`                                                           | Opt-in durable `sleep` tool                                                                             |
 | `eve/connections`                                                           | `defineMcpClientConnection`, `defineOpenAPIConnection`, `defineDynamic`                                 |
 | `eve/channels`                                                              | `defineChannel`, `disableRoute`, route verbs                                                            |
@@ -135,7 +135,8 @@ import template from "../../prompts/template.txt?raw";
 | `eve/sandbox`                                                               | `defineSandbox`, backends                                                                               |
 | `eve/instrumentation`                                                       | `defineInstrumentation`, `isChannel`                                                                    |
 | `eve/local-dev`                                                             | `getLocalDevCapability`, `LocalDevCapability`                                                           |
-| `eve/models/openai`                                                         | `chatgpt`, deprecated `experimental_chatgpt`                                                            |
+| `eve/models/openai`                                                         | `openai`, `chatgpt`, deprecated `experimental_chatgpt`                                                  |
+| `eve/models/anthropic`                                                      | `anthropic`                                                                                             |
 | `eve/evals`                                                                 | `defineEval`, `defineEvalConfig`, `mockModel`, eval types                                               |
 | `eve/evals/expect`                                                          | `includes`, `equals`, `matches`, `similarity`                                                           |
 | `eve/evals/reporters`                                                       | `Braintrust`, `JUnit`, `EvalReporter`                                                                   |
@@ -169,9 +170,15 @@ The function returns `LocalDevCapability | undefined`. It returns a capability o
 
 Run source mutations inside `withSuspendedSource()`. It acquires a unique watcher lease, waits for your asynchronous callback to settle, and then releases the lease. Concurrent or nested calls cannot resume each other early, and releasing the final lease rebuilds the runtime artifacts. The callback's return value is returned, and its error is rethrown after release. If suspension cannot be acquired, the callback does not run. If the host cannot confirm release after a retry, the method throws an actionable error; restart `eve dev` before making more source changes.
 
+## Direct provider models
+
+`openai(model?)` from `eve/models/openai` and `anthropic(model?)` from `eve/models/anthropic` return eve-owned model instances using the vendored providers. They accept only an optional model ID. Defaults are `gpt-5.6-luna-fast` and `claude-sonnet-5`, respectively.
+
+Use `/login` for local credentials, or set `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`. Local secret-store discovery is disabled in deployments; provision server credentials explicitly. See [Set the model](../agent-config#set-the-model) for an example.
+
 ## ChatGPT subscription models
 
-`chatgpt()` from `eve/models/openai` serves an OpenAI model through your local ChatGPT login and bills the ChatGPT subscription. With no argument, it selects `gpt-5.6-sol`:
+`chatgpt()` from `eve/models/openai` serves an OpenAI model through your local ChatGPT login and bills the ChatGPT subscription. With no argument, it selects `gpt-5.6-luna-fast`:
 
 ```ts title="agent/agent.ts"
 import { defineAgent } from "eve";
@@ -188,7 +195,7 @@ Pass another bare OpenAI model slug to override the default. `experimental_chatg
 
 eve uses one local authentication path with two credential owners:
 
-1. Run `eve dev`, open `/model`, and select **Provider** → **ChatGPT subscription**.
+1. Run `eve dev`, open `/login`, and select **ChatGPT subscription**.
 2. If `codex` is on `PATH`, eve uses `codex app-server` and launches `codex login` when sign-in is needed. Codex owns credential storage and refresh.
 3. If the Codex binary is not found, eve falls back to direct browser sign-in and owns the saved session and refresh. If the browser does not open, use the URL printed in the terminal.
 
@@ -206,9 +213,9 @@ ChatGPT subscription credentials are local user credentials. `eve deploy` blocks
 
 Troubleshooting:
 
-- **`chatgpt-sub login`**: open `/model` and select **Provider** → **ChatGPT subscription** to sign in again. eve launches `codex login` when Codex is available, or its direct sign-in flow when it is not.
+- **`chatgpt-sub login`**: open `/login` and select **ChatGPT subscription** to sign in again. eve launches `codex login` when Codex is available, or its direct sign-in flow when it is not.
 - **`chatgpt-sub unavailable` with Codex installed**: update or restart Codex and retry. eve does not mask app-server failures by switching to a different saved session.
-- **`chatgpt-sub unavailable` without Codex**: follow the reported OS credential-store recovery steps, or check your network connection if token refresh failed. Retry from `/model`. If eve reports an invalid stored session, sign in again to replace it.
+- **`chatgpt-sub unavailable` without Codex**: follow the reported OS credential-store recovery steps, or check your network connection if token refresh failed. Retry from `/login`. If eve reports an invalid stored session, sign in again to replace it.
 - **Model rejected by the backend**: model availability depends on the signed-in ChatGPT account. Pick another supported OpenAI model.
 - **Device sign-in unavailable**: enable device code authorization in ChatGPT security settings, or sign in from a local terminal with port 1455 available.
 

package/docs/sandbox.mdx

@@ -168,7 +168,7 @@ With `backend` omitted, eve uses `defaultBackend()`, which resolves on first use
 3. **microsandbox** when the host supports it: macOS on Apple Silicon, or glibc Linux with KVM enabled.
 4. **just-bash** as the dependency-free fallback.
 
-By default, Docker and microsandbox pull `ghcr.io/vercel/eve` while Vercel Sandbox pulls `vcr.vercel.com/vercel/eve/base`. Each image tag matches the installed eve version. Set `EVE_SANDBOX_IMAGE_TAG` to replace the version-derived tag for these default images. An explicit `image` passed to `docker()`, `microsandbox()`, or `vercel()` takes precedence. A snapshot `source` on `vercel()` takes precedence over its `image` because Vercel Sandbox treats them as mutually exclusive.
+By default, Docker and microsandbox pull `ghcr.io/vercel/eve` while Vercel Sandbox pulls `vcr.vercel.com/vercel/eve/base`. Each image tag matches the installed eve version without build metadata: a commit tarball version such as `0.56.0+git.4c27b3e37fa36d84` uses image tag `0.56.0`. Set `EVE_SANDBOX_IMAGE_TAG` to replace the version-derived tag for these default images. An explicit `image` passed to `docker()`, `microsandbox()`, or `vercel()` takes precedence. A snapshot `source` on `vercel()` takes precedence over its `image` because Vercel Sandbox treats them as mutually exclusive.
 
 On every backend, authored commands run as the non-root `vercel-sandbox` user through a non-interactive `bash -lc` login shell. `/workspace` and `$HOME` are writable, `$HOME/.local/bin` is on `PATH` for user-scoped executables, and system paths such as `/usr/local` stay root-owned. Use passwordless `sudo` when setup genuinely needs system-wide changes; `sudo` resets the environment, so pass through variables like `NPM_CONFIG_PREFIX` explicitly if a privileged step depends on them.
 
@@ -188,11 +188,11 @@ export default defineSandbox({
 
 ### Docker
 
-`docker()` drives the Docker CLI directly. By default, it uses the `ghcr.io/vercel/eve` image tag matching the installed eve version. eve creates `/workspace` and verifies Bash during framework setup, before authored bootstrap code runs. Configure it through `docker({ image, env, pullPolicy, networkPolicy })`, and install authored runtime tools in sandbox bootstrap or provide them through a custom image. Templates are committed as local Docker images and reused across sessions when the sandbox source, seed files, `revalidationKey`, and Docker backend options still match. Sessions run as long-lived containers whose filesystems persist `/workspace` changes across turns for the same durable session. `eve dev` prunes stale template images in the background.
+`docker()` drives the Docker CLI directly. By default, it uses the `ghcr.io/vercel/eve` image tag matching the installed eve version without build metadata. eve creates `/workspace` and verifies Bash during framework setup, before authored bootstrap code runs. Configure it through `docker({ image, env, pullPolicy, networkPolicy })`, and install authored runtime tools in sandbox bootstrap or provide them through a custom image. Templates are committed as local Docker images and reused across sessions when the sandbox source, seed files, `revalidationKey`, and Docker backend options still match. Sessions run as long-lived containers whose filesystems persist `/workspace` changes across turns for the same durable session. `eve dev` prunes stale template images in the background.
 
 ### microsandbox
 
-`microsandbox()` runs each sandbox in a lightweight local VM with snapshot-backed templates, a `vercel-sandbox` user, and a firewall capable of domain-level network policies and credential brokering. It is the closest local match to hosted Vercel Sandbox. By default, it uses the `ghcr.io/vercel/eve` image tag matching the installed eve version. During framework setup, before authored bootstrap code runs, eve verifies Bash and creates `/workspace` and the sandbox user. Install authored runtime tools in sandbox bootstrap or provide them through a custom image. Supported hosts are macOS on Apple Silicon, or Linux (glibc) with KVM. The `microsandbox` npm package and its VM runtime are not bundled with eve, so `eve dev` installs both automatically when missing (disable with `setup: { autoInstall: false }`); production processes fail with actionable install errors instead.
+`microsandbox()` runs each sandbox in a lightweight local VM with snapshot-backed templates, a `vercel-sandbox` user, and a firewall capable of domain-level network policies and credential brokering. It is the closest local match to hosted Vercel Sandbox. By default, it uses the `ghcr.io/vercel/eve` image tag matching the installed eve version without build metadata. During framework setup, before authored bootstrap code runs, eve verifies Bash and creates `/workspace` and the sandbox user. Install authored runtime tools in sandbox bootstrap or provide them through a custom image. Supported hosts are macOS on Apple Silicon, or Linux (glibc) with KVM. The `microsandbox` npm package and its VM runtime are not bundled with eve, so `eve dev` installs both automatically when missing (disable with `setup: { autoInstall: false }`); production processes fail with actionable install errors instead.
 
 ### just-bash
 

package/docs/subagents/index.mdx

@@ -32,7 +32,7 @@ The root session receives `agent` by default. The model calls it to delegate a t
 }
 ```
 
-The copy uses the root's instructions, connections, auth, and sandbox. It receives the same tools except for the root-only `agent` and `Workflow`, and starts with fresh conversation history and fresh state. Its file writes are immediately visible to the root. The built-in `agent` always runs in the background and needs no configuration: each call returns `{ status: "working", taskId, agentId }`, then task notifications wake the parent with completion, failure, or cancellation. Give parallel children non-overlapping write scopes.
+The copy uses the root's instructions, connections, auth, and sandbox. It receives the same tools except for the root-only `agent`, and starts with fresh conversation history and fresh state. Its file writes are immediately visible to the root. The built-in `agent` always runs in the background and needs no configuration: each call returns `{ status: "working", taskId, agentId }`, then task notifications wake the parent with completion, failure, or cancellation. Give parallel children non-overlapping write scopes.
 
 `agent` is intentionally root-only. Copies created by it cannot call `agent`, and declared subagents never receive the built-in tool. If a stale or forced recursive call reaches execution, eve rejects it instead of starting another child session.
 
@@ -199,7 +199,7 @@ eve lowers every subagent visible to the current agent (the root built-in copy,
 
 Declared subagents can call nested subagents defined under their own directories. eve does not apply a separate depth limit; nesting ends where the authored directory tree ends. The built-in `agent` follows the stricter root-only rule above, so `limits.maxSubagentDepth` no longer exists.
 
-Child sessions can still call their own declared or remote subagents, but they receive neither `Workflow` nor the built-in `agent`. Background subagents run through the model tool loop and are not available inside a model-authored `Workflow` program.
+Child sessions can still call their own declared or remote subagents, but they do not receive the built-in `agent`. Authored workflow tools use the same subagent availability and authorization checks as direct delegation.
 
 A directly declared subagent's tool name is the bare path-derived name, with no prefix. `agent/subagents/researcher/` registers as the tool `researcher`. A subagent supplied by a mounted extension includes the mount namespace, such as `crm__reviewer`. The model, approvals, logs, and evals reference the resulting name. Its input schema is:
 
@@ -227,9 +227,9 @@ Subagent model calls automatically retry classified transient provider failures,
 
 A child parks after answering instead of terminating, keeping its session and conversation history alive. A failed child turn can also leave the child parked — its latest status shows the error and the parent may message it again. Pass a parked child's `agentId` to the same subagent tool with a new `message` to continue that session. Omitting `agentId` (or passing an empty string or `null`) always starts a new child, and an `agentId` that matches no known agent falls back to starting a new child rather than failing. Passing a known `agentId` through a different subagent tool fails with `AGENT_MISMATCH`.
 
-To steer a running background child, call the same subagent tool with its `agentId` and the updated `message`. eve cancels the previous task before starting a new task in the same child session. The child retains its conversation history, and the receipt contains the same `agentId` with a new `taskId`. The cancelled task cannot publish a later successful result. Steering does not undo tool side effects that have already occurred.
+To steer a running background child, call the same subagent tool with its `agentId` and the updated `message`. Before answer output or local tool execution begins, steering interrupts the child's pending model generation and applies the update in the same turn. Executing tools finish and checkpoint their results first; after answer output starts, steering waits for the next committed Workflow boundary. The receipt retains the same `agentId` and `taskId`; steering does not cancel the task, replace its completion callback, or undo tool side effects that have already occurred.
 
-A child that is still starting, or is owned by a blocking workflow invocation rather than an admitted background task, continues to return `AGENT_BUSY`. Cancellation or delivery failures are reported to the caller; eve does not start a replacement child session to hide them.
+A child that is still starting, or is owned by a blocking workflow invocation rather than an admitted background task, continues to return `AGENT_BUSY`. Delivery failures are reported to the caller; eve does not start a replacement child session to hide them.
 
 Whenever the set of parked (resumable) children changes, eve appends a framework-injected note to the conversation — labeled `[Agents]` and carrying an `<agents>` block — listing each child's `agentId`, name, and latest status. The static system prompt tells the model the note is injected by eve, not written by the user. The note is appended only when the listing changes (an append-only design that preserves the provider prompt cache), the most recent note is authoritative, and children that are starting or running do not appear until they park again.
 

package/docs/tools/workflows.mdx

@@ -99,7 +99,62 @@ workflow and step modules reachable from the agent's runtime modules. Unrelated
 in the host application stay outside the agent bundle. An unresolved workflow import fails
 the build with the missing import in the error.
 
-### Migrate an existing workflow tool
+### Add a runtime-generated workflow tool
+
+Create `agent/tools/workflow.ts` and export the provided `workflow` factory when the model should
+supply the JavaScript program at runtime:
+
+```ts title="agent/tools/workflow.ts"
+import { workflow } from "eve/tools/workflow";
+
+export default workflow({ maxSubagents: 20 });
+```
+
+The model supplies an async function body through the tool's `js` input. Its only host capability is
+`ctx.agent(name, { message, agentId?, outputSchema? })`. For example:
+
+```js
+const [triage, review] = await Promise.all([
+  ctx.agent("ticket-triage", { message: JSON.stringify(tickets) }),
+  ctx.agent("ticket-review", { message: JSON.stringify(tickets) }),
+]);
+return { triage, review };
+```
+
+`maxSubagents` defaults to `100` and must be an integer from `1` through `128`. The generated
+program cannot access the workflow context, session state,
+credentials, imports, or ordinary tools. Agent authorization, questions, approvals, cancellation,
+and `agentId` continuation use the same owner-managed behavior as direct `ctx.agent` calls.
+
+The sandbox resumes after every pending call in the current batch settles. `Promise.all` supports
+fan-out followed by fan-in, but `Promise.race` does not resume after only the first child settles.
+A child failure is thrown at the corresponding `ctx.agent` call, so generated code can catch it.
+The program must return a JSON-serializable value.
+
+### Migrate from `experimental_workflow`
+
+The experimental uppercase `Workflow` framework tool and its exports have been removed. Replace the
+old sentinel:
+
+```diff
+-import { experimental_workflow } from "eve/tools/workflow";
+-
+-export default experimental_workflow({ maxSubagents: 20 });
+```
+
+with the lowercase factory:
+
+```ts
+import { workflow } from "eve/tools/workflow";
+
+export default workflow({ maxSubagents: 20 });
+```
+
+The path gives the authored tool the model-facing name `workflow`. eve does not discover or inject
+an agent catalog. Calls use the same target resolution, availability, and authorization checks as
+`ctx.agent` in any other authored workflow tool.
+
+### Migrate an authored workflow tool
 
 Replace `defineTool` with `defineWorkflowTool`, keep the executor's `"use workflow"` directive,
 and replace `agent(ctx, input)` and `ask(ctx, request)` with `ctx.agent(target, input)` and
@@ -315,7 +370,7 @@ final-output rules of ordinary `defineTool` generators.
 
 ## Cancel and clean up: `ctx.abortSignal`
 
-`ctx.abortSignal` aborts when the run is cancelled: a steered turn for a waiting tool, `task_cancel`
+`ctx.abortSignal` aborts when the run is cancelled: explicit turn cancellation for a waiting tool, `task_cancel`
 or the session ending for a background one. It is durable — it survives replay, and a step that
 receives it observes the abort. Pass it into the steps that should stop, and clean up in
 `try/finally`:

package/docs/tutorial/how-it-runs.mdx

@@ -11,7 +11,7 @@ The analytics assistant sent one message and got one answer. Three terms describ
 | **turn**    | One message you send and the work it triggers.    |
 | **step**    | A durable checkpoint within the turn.             |
 
-Each turn runs as a durable workflow, and eve saves progress at every step. Completed steps never re-run; eve replays the recorded result. A step interrupted mid-execution re-runs, so make non-idempotent side effects like charges or emails idempotent, or gate them with approval. A turn that's waiting on you (an approval, a question) resumes whenever you answer, even if that's much later.
+The session runs as one durable workflow, and eve saves each turn's progress at every step. Completed steps never re-run; eve replays the recorded result. A step interrupted mid-execution re-runs, so make non-idempotent side effects like charges or emails idempotent, or gate them with approval. A turn that's waiting on you (an approval, a question) resumes whenever you answer, even if that's much later.
 
 That's why the features in the rest of this tutorial work the way they do:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.55.0",
+  "version": "0.57.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -211,6 +211,11 @@
       "eve-source": "./dist/src/public/workflow-modules.d.ts",
       "types": "./dist/src/public/workflow-modules.d.ts"
     },
+    "./models/anthropic": {
+      "types": "./dist/src/public/models/anthropic/index.d.ts",
+      "import": "./dist/src/public/models/anthropic/index.js",
+      "default": "./dist/src/public/models/anthropic/index.js"
+    },
     "./models/openai": {
       "types": "./dist/src/public/models/openai/index.d.ts",
       "import": "./dist/src/public/models/openai/index.js",

package/dist/src/cli/commands/init-repl.d.ts

@@ -1,80 +0,0 @@
-import { type Prompter } from "#setup/prompter.js";
-declare const positional: (prompt: string) => string[];
-declare const CODING_AGENT_REPLS: readonly [{
-    readonly command: "claude";
-    readonly label: "Claude Code";
-    readonly promptArgs: typeof positional;
-}, {
-    readonly command: "codex";
-    readonly label: "Codex";
-    readonly promptArgs: typeof positional;
-}, {
-    readonly command: "cursor-agent";
-    readonly label: "Cursor";
-    readonly promptArgs: typeof positional;
-}, {
-    readonly command: "droid";
-    readonly label: "Droid";
-    readonly promptArgs: typeof positional;
-}, {
-    readonly command: "gemini";
-    readonly label: "Gemini CLI";
-    readonly promptArgs: (prompt: string) => string[];
-}, {
-    readonly command: "opencode";
-    readonly label: "opencode";
-    readonly promptArgs: (prompt: string) => string[];
-}, {
-    readonly command: "pi";
-    readonly label: "Pi";
-    readonly promptArgs: typeof positional;
-}];
-type CodingAgentReplDefinition = (typeof CODING_AGENT_REPLS)[number];
-/** A coding-agent REPL that can take over the terminal after `eve init`. */
-export type CodingAgentRepl = CodingAgentReplDefinition["command"];
-/** The one post-init continuation point for a human terminal session. */
-export type InitHandoff = "exit" | "eve-dev" | CodingAgentRepl;
-export interface InitReplDependencies {
-    createPrompter(): Prompter;
-    hasInteractiveTerminal(): boolean;
-    isCodingAgentReplAvailable(command: CodingAgentRepl): Promise<boolean>;
-}
-/** The full path of the named REPL's executable on `PATH`, or null if absent. */
-export declare function resolveCodingAgentRepl(command: CodingAgentRepl): Promise<string | null>;
-/** True when the named REPL resolves to an executable on the current `PATH`. */
-export declare function isCodingAgentReplAvailable(command: CodingAgentRepl): Promise<boolean>;
-/**
- * Offers any locally installed coding-agent REPLs immediately before the
- * existing `eve dev` handoff. Non-interactive sessions, and systems with none
- * of them on `PATH`, keep the prior direct-to-dev behavior.
- */
-export declare function selectInitHandoff(input: {
-    agentName: string;
-    deps?: Partial<InitReplDependencies>;
-}): Promise<InitHandoff>;
-interface ReplSpawnPlan {
-    file: string;
-    args: readonly string[];
-    shell: boolean;
-    /** False means the prompt is not in argv and the caller must surface it. */
-    seeded: boolean;
-}
-/**
- * Decides how to launch a REPL from its resolved executable path. A directly
- * spawnable executable runs without a shell, so the multi-line prompt passes
- * through argv verbatim. A `.cmd`/`.bat` shim (or an unresolved command) can
- * only run via cmd.exe, which cannot carry the prompt's newlines or
- * metacharacters in an argument, so it launches the bare REPL and reports the
- * prompt as unseeded.
- */
-export declare function replSpawnPlan(command: CodingAgentRepl, resolvedPath: string | null, prompt: string, platform?: NodeJS.Platform): ReplSpawnPlan;
-/** Starts the selected coding-agent REPL in the newly initialized project. */
-export declare function spawnCodingAgentRepl(input: {
-    command: CodingAgentRepl;
-    cwd: string;
-    prompt: string;
-    /** Surfaces the prompt when it could not be seeded into the REPL's argv. */
-    onPromptUnseeded?: (prompt: string) => void;
-    resolvePath?: (command: CodingAgentRepl) => Promise<string | null>;
-}): Promise<boolean>;
-export {};

package/dist/src/cli/commands/init-repl.js

@@ -1 +0,0 @@
-import{hasInteractiveTerminal}from"./preconditions.js";import{access,stat}from"node:fs/promises";import{delimiter,extname,join}from"node:path";import{constants}from"node:fs";import{createPrompter}from"#setup/prompter.js";import{spawn}from"node:child_process";const positional=e=>[e],CODING_AGENT_REPLS=[{command:`claude`,label:`Claude Code`,promptArgs:positional},{command:`codex`,label:`Codex`,promptArgs:positional},{command:`cursor-agent`,label:`Cursor`,promptArgs:positional},{command:`droid`,label:`Droid`,promptArgs:positional},{command:`gemini`,label:`Gemini CLI`,promptArgs:e=>[`-i`,e]},{command:`opencode`,label:`opencode`,promptArgs:e=>[`--prompt`,e]},{command:`pi`,label:`Pi`,promptArgs:positional}],WINDOWS_EXECUTABLE_EXTENSIONS=[`.COM`,`.EXE`,`.BAT`,`.CMD`],defaultDependencies={createPrompter,hasInteractiveTerminal,isCodingAgentReplAvailable};function executableNames(e){if(process.platform!==`win32`)return[e];let t=process.env.PATHEXT?.split(`;`).filter(Boolean);return(t&&t.length>0?t:WINDOWS_EXECUTABLE_EXTENSIONS).map(t=>`${e}${t}`)}async function isExecutable(e){try{return(await stat(e)).isFile()?(await access(e,constants.X_OK),!0):!1}catch{return!1}}async function resolveCodingAgentRepl(e){let t=process.env.PATH;if(t===void 0||t.length===0)return null;for(let n of t.split(delimiter))if(n.length!==0)for(let t of executableNames(e)){let e=join(n,t);if(await isExecutable(e))return e}return null}async function isCodingAgentReplAvailable(e){return await resolveCodingAgentRepl(e)!==null}function handoffOptions(e,t){return[{value:`eve-dev`,label:`Start eve dev`,focusHint:`talk to '${t}' in your terminal`},...e.map(e=>({value:e.command,label:`Open ${e.label}`,focusHint:`build '${t}' using ${e.label}`})),{value:`exit`,label:`Exit`,focusHint:`return to your terminal`}]}async function selectInitHandoff(e){let t={...defaultDependencies,...e.deps};if(!t.hasInteractiveTerminal())return`eve-dev`;let n=await Promise.all(CODING_AGENT_REPLS.map(({command:e})=>t.isCodingAgentReplAvailable(e))),r=CODING_AGENT_REPLS.filter((e,t)=>n[t]);return r.length===0?`eve-dev`:t.createPrompter().select({message:`How would you like to continue?`,options:handoffOptions(r,e.agentName),initialValue:`eve-dev`})}function codingAgentRepl(e){let t=CODING_AGENT_REPLS.find(t=>t.command===e);if(t===void 0)throw Error(`Unsupported coding-agent REPL "${e}".`);return t}function isDirectlySpawnable(e,t){if(t!==`win32`)return!0;let n=extname(e).toLowerCase();return n===`.exe`||n===`.com`}function replSpawnPlan(e,t,n,r=process.platform){return t!==null&&isDirectlySpawnable(t,r)?{file:t,args:codingAgentRepl(e).promptArgs(n),shell:!1,seeded:!0}:{file:e,args:[],shell:r===`win32`,seeded:!1}}async function spawnCodingAgentRepl(e){let t=e.resolvePath??resolveCodingAgentRepl,n=replSpawnPlan(e.command,await t(e.command),e.prompt);return n.seeded||e.onPromptUnseeded?.(e.prompt),new Promise(t=>{let r=spawn(n.file,n.args,{cwd:e.cwd,shell:n.shell,stdio:`inherit`}),i=!1,settle=e=>{i||(i=!0,t(e))};r.once(`error`,()=>settle(!1)),r.once(`close`,e=>settle(e===0))})}export{isCodingAgentReplAvailable,replSpawnPlan,resolveCodingAgentRepl,selectInitHandoff,spawnCodingAgentRepl};

package/dist/src/cli/commands/init-self-modification.d.ts

@@ -1,7 +0,0 @@
-import { type Prompter } from "#setup/prompter.js";
-export interface InitSelfModificationDependencies {
-    createPrompter(): Prompter;
-    hasInteractiveTerminal(): boolean;
-}
-/** Offers eve's self-modification subagent before the external coding-agent handoff. */
-export declare function selectInitSelfModification(dependencies?: InitSelfModificationDependencies): Promise<boolean>;

package/dist/src/cli/commands/init-self-modification.js

@@ -1 +0,0 @@
-import{hasInteractiveTerminal}from"./preconditions.js";import{createPrompter}from"#setup/prompter.js";const defaultDependencies={createPrompter,hasInteractiveTerminal};async function selectInitSelfModification(e=defaultDependencies){return e.hasInteractiveTerminal()?e.createPrompter().select({message:`Enable local self-modification?`,description:`Self-modification adds a subagent that can edit your agent's source during local development.`,options:[{value:!0,label:`Enable self-modification`,focusHint:`let your eve agent make source changes in dev`},{value:!1,label:`Not now`,focusHint:`continue with eve dev or an external coding agent`}],initialValue:!1}):!1}export{selectInitSelfModification};

package/dist/src/cli/commands/registry-package.d.ts

@@ -1,52 +0,0 @@
-import { type RegistryConfig } from "#compiled/shadcn-registry/index.js";
-import { z } from "#compiled/zod/index.js";
-import { type Prompter } from "#setup/prompter.js";
-import type { RegistrySetupCompletion } from "#setup/registry-setup-protocol.js";
-import type { AddCommandOptions, RegistryCommandLogger } from "./registry.js";
-import { type DeclaredPnpmBuildPolicy } from "./registry-pnpm-build-policy-flow.js";
-import type { RegistrySetupCommand } from "./registry-setup-command.js";
-export declare const RegistryPackageComponentSchema: z.ZodObject<{
-    item: z.ZodString;
-    label: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    default: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-export type RegistryPackageComponent = z.infer<typeof RegistryPackageComponentSchema>;
-interface PackageMetadata {
-    requires?: string;
-    install?: {
-        pnpm?: {
-            buildScripts: readonly DeclaredPnpmBuildPolicy[];
-        };
-    };
-    setup?: RegistrySetupCommand[];
-}
-export interface RegistryPackageDependencies {
-    createPrompter?: () => Prompter;
-    hasInteractiveTerminal?: () => boolean;
-}
-export interface RegistryPackageOperations {
-    itemAddress(item: string): string;
-    metadata(item: unknown): PackageMetadata | undefined;
-    assertCompatibleVersion(requiredVersion: string | undefined): void;
-    runSetups(input: {
-        item: string;
-        setups: RegistrySetupCommand[];
-        prompter: Prompter;
-    }): Promise<RegistrySetupCompletion | false>;
-    setupReminder(item: string): string;
-}
-export declare function runRegistryPackage(input: {
-    logger: RegistryCommandLogger;
-    appRoot: string;
-    item: string;
-    components: readonly RegistryPackageComponent[];
-    config: RegistryConfig;
-    options: AddCommandOptions & {
-        prompter?: Prompter;
-        signal?: AbortSignal;
-    };
-    dependencies: RegistryPackageDependencies;
-    operations: RegistryPackageOperations;
-}): Promise<RegistrySetupCompletion | false>;
-export {};

package/dist/src/cli/commands/registry-package.js

@@ -1 +0,0 @@
-import{hasInteractiveTerminal}from"./preconditions.js";import{headlessSetupContinuation,serializeHeadlessSetupEvent}from"./setup-headless.js";import{prepareDeclaredPnpmBuildPolicy}from"./registry-pnpm-build-policy-flow.js";import{z}from"#compiled/zod/index.js";import{createPrompter}from"#setup/prompter.js";import{headlessAsker,interactiveAsker,withAnswers,withPolicy}from"#setup/ask.js";import{mergeRegistrySetupCompletions}from"#setup/registry-setup-completion.js";import{addRegistryItems,getRegistryItems}from"#compiled/shadcn-registry/index.js";const RegistryPackageComponentSchema=z.object({item:z.string().min(1),label:z.string().min(1),description:z.string().optional(),default:z.boolean().default(!1)});async function selectComponents(e,t,n,r,i,a){if(r.prompter===void 0&&!r.nonInteractive&&(r.yes===!0||!i))return n.filter(e=>e.default);let o={key:`components`,message:`Add ${t}`,required:!0,recommended:n.filter(e=>e.default),options:n.map(e=>({id:e.item,value:e,label:e.label,hint:e.description}))},s=r.nonInteractive?withAnswers(r.answers??{})(r.yes?withPolicy(`assume`)(headlessAsker()):headlessAsker()):interactiveAsker(a());try{return await s.askMany(o)}catch(n){if(!r.nonInteractive||!(n instanceof Error)||n.name!==`InteractionRequired`)throw n;let i=n.question,{setupQuestionToWire:a}=await import(`#setup/setup-question-wire.js`),o=a(i);e.error(serializeHeadlessSetupEvent({version:1,type:`blocked`,status:`input_required`,item:t,installed:!1,completedItems:[],question:o,next:headlessSetupContinuation({item:t,installed:!1,answers:r.answers,question:o})})),process.exitCode=2;return}}async function runRegistryPackage(e){let{logger:t,appRoot:n,item:r,components:i,config:a,options:o,dependencies:s,operations:c}=e,l=s.hasInteractiveTerminal?.()??hasInteractiveTerminal(),u=o.prompter,getPrompter=()=>u??=s.createPrompter?.()??createPrompter(),d=await selectComponents(t,r,i,o,l,getPrompter);if(d===void 0)return!1;let f=d.map(e=>c.itemAddress(e.item)),p=await getRegistryItems(f,{config:a});if(p.length!==d.length)throw Error(`Registry package "${r}" could not resolve all selected components.`);let m=p.map(e=>{let t=c.metadata(e);return c.assertCompatibleVersion(t?.requires),t});if(o.skipInstall!==!0&&!await prepareDeclaredPnpmBuildPolicy({logger:t,appRoot:n,item:r,policies:m.flatMap(e=>e?.install?.pnpm?.buildScripts??[]),options:o}))return!1;o.skipInstall!==!0&&await addRegistryItems(f,{config:a,cwd:n,overwrite:o.overwrite,silent:o.silent});let h={facts:[]};if(o.skipSetup===!0)return h;if(!o.nonInteractive&&o.yes!==!0&&o.prompter===void 0&&!l)return t.log(c.setupReminder(r)),h;for(let e of m){if(e?.setup===void 0)continue;let t=await c.runSetups({item:r,setups:e.setup,prompter:getPrompter()});if(t===!1)return!1;h=mergeRegistrySetupCompletions(h,t)}return h}export{RegistryPackageComponentSchema,runRegistryPackage};

package/dist/src/cli/dev/tui/prompt-placeholder.d.ts

@@ -1,12 +0,0 @@
-/**
- * The empty prompt's rotating invitation, written in the agent's own voice
- * ("my capabilities") since the prompt is a message to it. Messages point at
- * things an eve agent can actually do out of the box, so an idle prompt
- * doubles as a hint surface. The caret-blink repaint keeps the rotation
- * moving without its own timer.
- */
-export declare const PROMPT_PLACEHOLDER_MESSAGES: readonly string[];
-/** How long each message holds before the rotation advances. */
-export declare const promptPlaceholderCycleMs = 6000;
-/** Picks the message for the given time since the renderer started. */
-export declare function promptPlaceholder(elapsedMs: number): string;

package/dist/src/cli/dev/tui/prompt-placeholder.js

@@ -1 +0,0 @@
-const PROMPT_PLACEHOLDER_MESSAGES=[`Ask about my capabilities`,`Have me explore the workspace`,`Refine my instructions`],promptPlaceholderCycleMs=6e3;function promptPlaceholder(e){let t=Math.floor(Math.max(0,e)/promptPlaceholderCycleMs);return PROMPT_PLACEHOLDER_MESSAGES[t%PROMPT_PLACEHOLDER_MESSAGES.length]}export{PROMPT_PLACEHOLDER_MESSAGES,promptPlaceholder,promptPlaceholderCycleMs};

package/dist/src/cli/dev/tui/remote-auth-command.d.ts

@@ -1,11 +0,0 @@
-import { type RemoteAuthFlow } from "./remote-auth.js";
-import type { RemoteConnectionController } from "./remote-connection.js";
-import type { SetupFlowRenderer } from "./setup-flow.js";
-interface RemoteAuthCommandInput {
-    readonly connection: RemoteConnectionController;
-    readonly flow?: RemoteAuthFlow;
-    readonly renderer: SetupFlowRenderer;
-}
-/** Runs remote `/vc:login` through one TUI panel, connection operation, and auth flow. */
-export declare function runRemoteAuthCommand(input: RemoteAuthCommandInput): Promise<string>;
-export {};

package/dist/src/cli/dev/tui/remote-auth-command.js

@@ -1,3 +0,0 @@
-import{remoteHost}from"./target.js";import{createTuiPrompter}from"./tui-prompter.js";import{describeRemoteAuthCompletedMutations}from"./remote-auth-result.js";import{runRemoteAuthFlow}from"./remote-auth.js";import{WizardCancelledError}from"#setup/step.js";function shouldConfigureTrustedSources(e){switch(e.state){case`auth-required`:case`auth-failed`:return e.challenge.kind===`vercel-deployment-protection`;case`unavailable`:return e.failure.code===`TRUSTED_SOURCES_ENVIRONMENT_MISMATCH`;case`checking`:case`authenticating`:case`ready`:return!1}}function unavailableAfterAuthentication(e,t){let[n=t,...r]=t.split(/\n\s*\n/u);return[`Authentication was refreshed, but ${e} is unavailable: ${/[.!?]$/u.test(n.trim())?n.trim():`${n.trim()}.`}`,...r.map(e=>e.trim()).filter(e=>e.length>0)].join(`
-
-`)}function mutedRenderer(e,t){return{readSelect:n=>t()?Promise.resolve(void 0):e.readSelect(n),readEditableSelect:n=>t()?Promise.resolve(void 0):e.readEditableSelect(n),readText:n=>t()?Promise.resolve(void 0):e.readText(n),readAcknowledge:n=>t()?Promise.resolve():e.readAcknowledge(n),readChoice:n=>t()?{choice:Promise.resolve(void 0),close:()=>{}}:e.readChoice(n),setStatus:n=>{t()||e.setStatus(n)},renderLine:(n,r)=>{(!t()||r===`warning`||r===`error`)&&e.renderLine(n,r)},renderOutput:n=>{t()||e.renderOutput(n)},withInheritedStdio:t=>e.withInheritedStdio(t),withExclusiveTerminal:t=>e.withExclusiveTerminal?.(t)??e.withInheritedStdio(t)}}async function runRemoteAuthCommand(e){e.renderer.begin(`Authenticate via Vercel OIDC`,`pulse`);let t=!0,n=!1,r=new AbortController,i=e.renderer.waitForInterrupt(),a=e.connection.current().target;try{let o=e.flow??runRemoteAuthFlow,s=shouldConfigureTrustedSources(e.connection.current().connection),c=createTuiPrompter(mutedRenderer(e.renderer,()=>n)),l=e.connection.authenticate(async e=>{let n=await o({workspaceRoot:a.workspaceRoot,serverUrl:a.serverUrl,configureTrustedSources:s,prompter:c,signal:e});return t=n.kind===`failed`,n},r.signal),u=await Promise.race([l.then(e=>({kind:`completed`,outcome:e})),i.promise.then(()=>({kind:`interrupted`}))]);u.kind===`interrupted`&&(n=!0,t=!0,r.abort(new WizardCancelledError));let d=u.kind===`completed`?u.outcome:await l;switch(d.kind){case`authenticated`:return`Authenticated ${remoteHost(a)} via Vercel OIDC.`;case`cancelled`:if(n){let e=describeRemoteAuthCompletedMutations(d.completedMutations);return e.length===0?`/vc:login interrupted.`:`/vc:login interrupted. Completed before interruption: ${e.join(`, `)}.`}return d.completedMutations.some(e=>e.kind===`vercel-login`)?`/vc:login dismissed after logging in to Vercel.`:`/vc:login dismissed.`;case`failed`:return d.message;case`unavailable`:return unavailableAfterAuthentication(remoteHost(a),d.failure.message)}}finally{i.dispose(),e.renderer.setStatus(void 0),e.renderer.end({preserveDiagnostics:t})}}export{runRemoteAuthCommand};