eve 0.64.0 → 0.65.0

package/docs/tools/workflows.mdx

@@ -44,7 +44,7 @@ export default defineWorkflowTool({
       ],
     });
 
-    if (answer.optionId !== "approve") {
+    if (answer.status !== "answered" || answer.optionId !== "approve") {
       return { deployed: false, reason: "rejected" };
     }
     return { deployed: true, url: await applyDeploy(plan) };
@@ -277,12 +277,30 @@ const answer = await ctx.ask({
   display?: "confirmation" | "select" | "text",
   options?: { id: string; label: string; description?: string; style?: "primary" | "danger" | "default" }[],
   allowFreeform?: boolean,
-}); // { optionId?: string; text?: string }
+  dismissible?: boolean,
+});
+// | { status: "answered"; optionId?: string; text?: string }
+// | { status: "dismissed" }
+// | { status: "unavailable" }
 ```
 
 `ctx.ask` publishes an `input.requested` event on the session — rendered the way channels render
-`ask_question` and tool approvals — and returns an awaitable answer. Awaiting it suspends the run until a response arrives.
-It composes with the SDK's own constructs; race it against a deadline:
+tool approvals — and returns an awaitable answer. Awaiting it suspends the run until a response arrives.
+The `ask_question` tool is a workflow tool built on `ctx.ask`.
+
+The answer's `status` tells the body what happened:
+
+- `answered`: the person picked an option (`optionId`) or typed a reply (`text`).
+- `dismissed`: the request set `dismissible: true` and the person sent a message that did not answer
+  it. The message reaches the agent as a normal turn. Only blocking tools can be dismissed this way.
+- `unavailable`: the session cannot request input, such as a scheduled run. `ctx.ask` returns this
+  immediately instead of waiting for an answer no one can give.
+
+A plain follow-up message answers the request when it is the only pending question and the message
+matches an option or the request allows free text. This applies to blocking tools only: answer a
+question from a background tool or a subagent with a structured response.
+
+`ctx.ask` composes with the SDK's own constructs; race it against a deadline:
 
 ```ts
 const pending = ctx.ask({ prompt: `Deploy ${service}?`, options: APPROVE_OR_CANCEL });
@@ -290,13 +308,16 @@ const answer = await Promise.race([pending, sleep("4h")]);
 if (answer === undefined) return { deployed: false, reason: "timed out" };
 ```
 
-- The request belongs to the run, not the turn. It stays answerable until it is answered or the run
-  ends. In a background tool that means long after the turn that started it.
+- The request belongs to the run, not the turn. It stays answerable until it is answered, dismissed,
+  or the run ends. In a background tool that means long after the turn that started it.
 - A request is answered once. Ask again for the next answer.
+- Choose option `id`s that read well on their own, such as `approve` or the option's label. A
+  response carries only the `id`. If a person answers after the request has already resolved, for
+  example from an old Slack menu, the agent receives the `id` as a new message, not the label.
 - Ending the run, by returning, throwing, or cancellation, withdraws its pending requests.
 - Several requests may be outstanding at once.
-- A response never steers. A new human message while a request is pending follows the session's
-  normal `turnPolicy`.
+- A response never steers. A new human message that does not answer a pending request follows the
+  session's normal `turnPolicy`.
 
 Compare the [`approval`](/docs/human-in-the-loop) policy, which gates the call before `execute` runs
 and can only show the model's input. Both compose: `approval` before the run, `ctx.ask` inside it.
@@ -322,9 +343,9 @@ The first argument is an available agent target. On the root agent, `"agent"` st
 continue an existing child. An inline `outputSchema` requires structured output and determines the
 return type, so `result` in the example is typed as `{ findings: string[] }`.
 
-### Route to a hidden subagent with JEV
+### Route to a hidden subagent with Jev
 
-Use an authored workflow tool when the parent model should decide to delegate, but JEV should choose the specialist. Set `tool: false` on each specialist so the parent model sees only the routing tool. The specialists remain available through `ctx.agents` and callable through `ctx.agent()`.
+Use an authored workflow tool when the parent model should decide to delegate, but [Jev](https://vercel.com/i/what-is-jev) should choose the specialist. Set `tool: false` on each specialist so the parent model sees only the routing tool. The specialists remain available through `ctx.agents` and callable through `ctx.agent()`.
 
 If the router may select the root-copy `agent`, author a root `description` that explains which work should stay with a copy of the root. `ctx.agents.agent` always exists in a top-level root workflow, but its `description` is an empty string when omitted from `agent.ts`. `agentRouter()` considers only entries with a non-empty description, so it does not route to an undescribed root copy.
 
@@ -333,7 +354,7 @@ import { defineAgent } from "eve";
 
 export default defineAgent({
   description: "Coordinate cross-specialist tasks that need the root agent's complete toolset.",
-  model: "anthropic/claude-opus-4.8",
+  model: "anthropic/claude-opus-5.5",
 });
 ```
 
@@ -342,7 +363,7 @@ import { defineAgent } from "eve";
 
 export default defineAgent({
   description: "Investigation, analysis, and explanation",
-  model: "anthropic/claude-opus-4.8",
+  model: "anthropic/claude-opus-5.5",
   tool: false,
 });
 ```
@@ -352,12 +373,12 @@ import { defineAgent } from "eve";
 
 export default defineAgent({
   description: "Execution and operational changes",
-  model: "openai/gpt-5.6-sol",
+  model: "openai/gpt-6-sol",
   tool: false,
 });
 ```
 
-Define the model-visible router under `agent/tools/`. Build the JEV criteria from the subagents' effective descriptions, then pass its typed choice directly to `ctx.agent()`:
+Define the model-visible router under `agent/tools/`. Build the Jev criteria from the subagents' effective descriptions, then pass its typed choice directly to `ctx.agent()`:
 
 ```ts title="agent/tools/agent-router.ts"
 import { evaluate } from "eve/ai";
@@ -406,7 +427,7 @@ export default defineWorkflowTool({
 });
 ```
 
-The evaluation runs in a step so workflow replay records its result instead of making the routing request again. The parent model receives `agent-router`, but not `researcher` or `operator`. JEV returns the typed `"researcher" | "operator"` choice, and the selected subagent's result becomes the `agent-router` tool result.
+The evaluation runs in a step so workflow replay records its result instead of making the routing request again. The parent model receives `agent-router`, but not `researcher` or `operator`. Jev returns the typed `"researcher" | "operator"` choice, and the selected subagent's result becomes the `agent-router` tool result.
 
 `ctx.agents` is a replay-stable metadata snapshot taken when the workflow starts. In a top-level root workflow, `ctx.agents.agent` always represents the root-copy target and carries the root's authored `description` when provided. The snapshot also includes declared agents hidden from the parent model with `tool: false` or `disableTool()`, but exposes no model definitions, credentials, or callbacks. A delegated root copy omits `agent`, so `agentRouter()` cannot select another root copy recursively. Invocation still checks each target's availability through `ctx.agent()`.
 
@@ -420,11 +441,11 @@ import { agentRouter } from "eve/tools/agent-router";
 export default agentRouter();
 ```
 
-Its input is `{ message: string, outputSchema?: object }`. `agentRouter()` ignores entries without a non-empty description. With two or more described targets, it sends the message and effective descriptions to JEV, then invokes the selected name through `ctx.agent()`. It invokes a sole target without evaluation and forwards an optional `outputSchema` unchanged. In a top-level root session, the candidates include the root-copy `agent`; delegated root copies and declared subagent contexts include only their declared targets.
+Its input is `{ message: string, outputSchema?: object }`. `agentRouter()` ignores entries without a non-empty description. With two or more described targets, it sends the message and effective descriptions to Jev, then invokes the selected name through `ctx.agent()`. It invokes a sole target without evaluation and forwards an optional `outputSchema` unchanged. In a top-level root session, the candidates include the root-copy `agent`; delegated root copies and declared subagent contexts include only their declared targets.
 
 When an authored tool accepts a JSON Schema supplied by the model, represent that input with a permissive object such as `z.looseObject({})`. Avoid `z.record(z.string(), z.json())`: its generated JSON Schema uses `propertyNames`, which OpenAI does not support. Validate the supplied value at the point where your tool consumes it.
 
-This pattern controls specialist selection, not whether the parent model delegates at all. Route before the parent model runs if every incoming request must go through JEV.
+This pattern controls specialist selection, not whether the parent model delegates at all. Route before the parent model runs if every incoming request must go through Jev.
 
 ## Report progress: `yield`
 
@@ -515,7 +536,9 @@ async execute({ service }, ctx) {
   }
 
   if (answer === undefined) return { deployed: false, reason: "timed out" };
-  if (answer.optionId !== "approve") return { deployed: false, reason: "rejected" };
+  if (answer.status !== "answered" || answer.optionId !== "approve") {
+    return { deployed: false, reason: "rejected" };
+  }
   return { deployed: true, url: await applyDeploy(plan) };
 }
 ```
@@ -574,7 +597,9 @@ export default defineWorkflowTool({
       ],
     });
 
-    if (decision.optionId !== "approve") return { refunded: false };
+    if (decision.status !== "answered" || decision.optionId !== "approve") {
+      return { refunded: false };
+    }
     return { refunded: true, receipt: await issueRefund(orderId, amount) };
   },
 });

package/docs/tutorial/guard-the-spend.mdx

@@ -55,7 +55,7 @@ The model proposes the query, `approval` returns `"user-approval"`, and the turn
 
 Each session has exactly one active continuation. Answer an approval against a stale handle and it's rejected, so there's no way to double-resume the same parked turn.
 
-The same machinery backs the built-in `ask_question` tool, where the model asks you mid-turn, and per-connection approval via `approval: once()`. See [Tools and human-in-the-loop](../tools).
+The same machinery backs the opt-in `ask_question` tool, where the model asks you mid-turn, and per-connection approval via `approval: once()`. See [Tools and human-in-the-loop](../tools).
 
 → Next: [Ship it](./ship-it)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "private": false,
   "description": "Filesystem-first framework for durable backend AI agents that run anywhere.",
   "keywords": [
@@ -167,11 +167,6 @@
       "import": "./dist/src/public/tools/write-file.js",
       "default": "./dist/src/public/tools/write-file.js"
     },
-    "./tools/todo": {
-      "types": "./dist/src/public/tools/todo.d.ts",
-      "import": "./dist/src/public/tools/todo.js",
-      "default": "./dist/src/public/tools/todo.js"
-    },
     "./tools/web_fetch": {
       "types": "./dist/src/public/tools/web-fetch.d.ts",
       "import": "./dist/src/public/tools/web-fetch.js",
@@ -501,11 +496,9 @@
     "@vercel/otel": "2.1.3",
     "@vercel/sandbox": "3.3.0",
     "@vercel/sdk": "1.28.8",
-    "@workflow/builders": "5.0.0-beta.55",
     "@workflow/core": "5.0.0-beta.55",
     "@workflow/errors": "5.0.0-beta.22",
     "@workflow/serde": "5.0.0-beta.2",
-    "@workflow/utils": "5.0.0-beta.10",
     "@workflow/world": "5.0.0-beta.37",
     "@workflow/world-local": "5.0.0-beta.46",
     "@workflow/world-vercel": "5.0.0-beta.50",
@@ -518,7 +511,6 @@
     "env-runner": "0.1.16",
     "eventsource-parser": "3.1.0",
     "gray-matter": "4.0.3",
-    "historical-eve-0-30-8": "npm:eve@0.30.8",
     "jose": "6.2.3",
     "jsonc-parser": "3.3.1",
     "just-bash": "3.1.0",

package/dist/src/cli/commands/registry-pnpm-build-policy.js

@@ -1,6 +0,0 @@
-import{access,readFile,writeFile}from"node:fs/promises";import{join}from"node:path";import{PNPM_WORKSPACE_PATH,findClaimingAncestorPnpmWorkspaceRoot}from"#setup/primitives/pm/pnpm.js";function blockRange(e,t){let n=e.findIndex(e=>RegExp(`^${t}:`).test(e));if(n<0)return;if(!RegExp(`^${t}:\\s*(?:#.*)?$`).test(e[n]??``))throw Error(`Cannot safely update ${t} because it does not use block-style YAML in ${PNPM_WORKSPACE_PATH}.`);let r=n+1;for(;r<e.length&&!/^\S/u.test(e[r]??``);)r+=1;return{start:n,end:r}}function unquoteYamlScalar(e){let t=e.trim();if(t.startsWith(`"`)&&t.endsWith(`"`))try{let e=JSON.parse(t);if(typeof e==`string`)return e}catch{return t}return t.startsWith(`'`)&&t.endsWith(`'`)?t.slice(1,-1).replaceAll(`''`,`'`):t}function mappingEntry(e){let t=/^\s+("(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^:#][^:]*?):\s*(true|false)\s*(?:#.*)?$/u.exec(e);if(t!==null)return{key:unquoteYamlScalar(t[1]),value:t[2]===`true`}}function sequenceEntry(e){let t=/^\s+-\s+(.*?)(?:\s+#.*)?$/u.exec(e);return t===null?void 0:unquoteYamlScalar(t[1])}function policyEntries(e,t,n){let r=blockRange(e,t),i=new Map;if(r===void 0)return i;for(let t of e.slice(r.start+1,r.end))if(n===`mapping`){let e=mappingEntry(t);e!==void 0&&i.set(e.key,e.value)}else{let e=sequenceEntry(t);e!==void 0&&i.set(e,!0)}return i}function removePolicyEntries(e,t,n,r){let i=blockRange(e,t);if(i===void 0)return;for(let t=i.end-1;t>i.start;--t){let i=n===`mapping`?mappingEntry(e[t]??``)?.key:sequenceEntry(e[t]??``);i!==void 0&&r.has(i)&&e.splice(t,1)}let a=blockRange(e,t);if(a!==void 0&&!e.slice(a.start+1,a.end).some(e=>(n===`mapping`?mappingEntry(e):sequenceEntry(e))!==void 0)){let t=e.slice(a.start+1,a.end).filter(e=>e.trimStart().startsWith(`#`));e.splice(a.start,a.end-a.start,...t)}}function appendPolicyEntries(e,t,n,r){let i=blockRange(e,t);if(i===void 0){for(;e.at(-1)===``;)e.pop();e.length>0&&e.push(``),e.push(`${t}:`),i={start:e.length-1,end:e.length}}let a=policyEntries(e,t,n),o=r.filter(e=>!a.has(e));if(o.length===0)return;let s=o.map(e=>n===`mapping`?`  ${JSON.stringify(e)}: true`:`  - ${JSON.stringify(e)}`);e.splice(i.end,0,...s)}function withPnpmBuildPolicy(e,t,n){let r=[...new Set(t)].sort(),i=new Set(r),a=e.replace(/\r\n/gu,`
-`).split(`
-`);for(removePolicyEntries(a,`allowBuilds`,`mapping`,i),removePolicyEntries(a,`ignoredOptionalDependencies`,`sequence`,i),n===`allow-builds`?appendPolicyEntries(a,`allowBuilds`,`mapping`,r):appendPolicyEntries(a,`ignoredOptionalDependencies`,`sequence`,r);a.at(-1)===``;)a.pop();return`${a.join(`
-`)}\n`}async function readWorkspacePolicy(e){try{return await readFile(e,`utf8`)}catch(e){if(e.code===`ENOENT`)return``;throw e}}async function owningPnpmWorkspaceRoot(e){try{return await access(join(e,PNPM_WORKSPACE_PATH)),e}catch(e){if(e.code!==`ENOENT`)throw e}return findClaimingAncestorPnpmWorkspaceRoot(e)??e}async function inspectPnpmBuildPolicy(e,t){let n=await owningPnpmWorkspaceRoot(e),r=join(n,PNPM_WORKSPACE_PATH),i=(await readWorkspacePolicy(r)).replace(/\r\n/gu,`
-`).split(`
-`),a=policyEntries(i,`allowBuilds`,`mapping`),o=policyEntries(i,`ignoredOptionalDependencies`,`sequence`);return{filePath:r,packages:t,satisfied:t.every(e=>a.get(e)===!0||o.has(e))}}async function applyPnpmBuildPolicy(e,t){let n=await readWorkspacePolicy(e.filePath);await writeFile(e.filePath,withPnpmBuildPolicy(n,e.packages,t),`utf8`)}export{applyPnpmBuildPolicy,inspectPnpmBuildPolicy,withPnpmBuildPolicy};

package/dist/src/cli/dev/tui/todo-panel.d.ts

@@ -1,44 +0,0 @@
-/**
- * The pinned todo panel: pure parsing and rendering for the task list the
- * model maintains through the framework `todo` tool. The tool writes the
- * whole list on every call, so the panel is driven entirely from tool-call
- * inputs — no protocol addition and no durable client state. The renderer
- * owns lifecycle (when a call updates the panel, when the finished list
- * commits to the transcript); this module only reads inputs and paints rows.
- */
-import type { Theme } from "./theme.js";
-/** One panel row parsed from the `todo` tool's replacement-write input. */
-export interface TodoPanelItem {
-    readonly content: string;
-    readonly status: "pending" | "in_progress" | "completed" | "cancelled";
-}
-/**
- * Extracts the panel items from a tool call when — and only when — it is a
- * `todo` replacement write. Read-only calls (no `todos`) and malformed items
- * return `undefined` so they fall through to the ordinary tool block.
- */
-export declare function readTodoToolItems(toolName: string, input: unknown): TodoPanelItem[] | undefined;
-/** True when every item reached a terminal status (completed or cancelled). */
-export declare function allTodoItemsSettled(items: readonly TodoPanelItem[]): boolean;
-export interface TodoPanelRowsInput {
-    readonly items: readonly TodoPanelItem[];
-    readonly width: number;
-    readonly theme: Theme;
-    /** True while the turn is running: pulses the header and the active item. */
-    readonly working: boolean;
-    /** Current shared pulse frame (the glyph, or a space on the off beat). */
-    readonly pulse: string;
-}
-/**
- * Paints the pinned panel, indented so its marks share the tool column.
- * Settled items ride a `│` rail under the header; the
- * first unsettled item closes the rail with `└` and everything after hangs
- * indented — the list reads as progress flowing through the corner.
- */
-export declare function renderTodoPanelRows(input: TodoPanelRowsInput): string[];
-/**
- * The transcript form of a finished list: every item checked on the rail,
- * closed by `└ Done`. Committed verbatim (pre-styled rows) once every item
- * settles.
- */
-export declare function renderFinishedTodoRows(items: readonly TodoPanelItem[], width: number, theme: Theme): string[];

package/dist/src/cli/dev/tui/todo-panel.js

@@ -1 +0,0 @@
-import"./rail.js";import{toolBaseName}from"./tool-presentation.js";import{clipVisible,stripTerminalControls}from"#cli/ui/terminal-text.js";const TODO_STATUSES=new Set([`pending`,`in_progress`,`completed`,`cancelled`]);function readTodoToolItems(e,t){if(toolBaseName(e)!==`todo`||typeof t!=`object`||!t||Array.isArray(t))return;let n=t.todos;if(!Array.isArray(n))return;let r=[];for(let e of n){if(typeof e!=`object`||!e||Array.isArray(e))return;let t=e,n=t.content,i=t.status;if(typeof n!=`string`||typeof i!=`string`||!TODO_STATUSES.has(i))return;r.push({content:firstLine(stripTerminalControls(n)),status:i})}return r}function allTodoItemsSettled(e){return e.every(e=>e.status===`completed`||e.status===`cancelled`)}function renderTodoPanelRows(e){let{items:t,width:n,theme:r}=e,i=r.colors,a=r.glyph,o=t.filter(e=>e.status===`completed`||e.status===`cancelled`).length,s=[e.working?`  ${i.gray(a.square)} ${i.dim(`Todo`)}`:`  ${i.gray(a.square)} ${i.dim(`${o}/${t.length} tasks`)}`],c=!1;for(let n of t){let t=n.status===`completed`||n.status===`cancelled`,o;c?o=` `:t?o=i.dim(a.rule):(o=i.dim(a.corner),c=!0),s.push(`  ${o} ${todoItemBody(n,e,r)}`)}return s.map(e=>clipVisible(e,n))}function renderFinishedTodoRows(e,t,n){let r=n.colors,i=n.glyph,a=[`  ${r.green(i.success)} ${r.dim(`Todo`)}`];for(let t of e)a.push(`  ${r.dim(i.rule)} ${settledMark(t,n)} ${r.dim(t.content)}`);return a.push(`  ${r.dim(i.corner)} ${r.green(`Done`)}`),a.map(e=>clipVisible(e,t))}function settledMark(e,t){return e.status===`cancelled`?t.colors.red(t.glyph.error):t.colors.green(t.glyph.success)}function todoItemBody(e,t,n){let r=n.colors,i=n.glyph;switch(e.status){case`completed`:return`${r.green(i.success)} ${r.dim(e.content)}`;case`cancelled`:return`${r.red(i.error)} ${r.dim(e.content)}`;case`in_progress`:{let n=t.working?t.pulse.trim().length>0?i.dotActive:` `:i.dotActive;return`${r.yellow(n)} ${e.content}`}case`pending`:return`${r.dim(i.reasoning)} ${r.dim(e.content)}`}}function firstLine(e){return e.split(/\r?\n/u,1)[0]??``}export{allTodoItemsSettled,readTodoToolItems,renderFinishedTodoRows,renderTodoPanelRows};

package/dist/src/compiled/@workflow/builders/LICENSE.md

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        <http://www.apache.org/licenses/>
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2025 Vercel Inc.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/dist/src/compiled/@workflow/builders/index.d.ts

@@ -1,62 +0,0 @@
-/**
- * Shared utilities for detecting files that need workflow transformation.
- * Used by builders, rollup plugin, Next.js loader, and vite plugin.
- */
-export declare const useWorkflowPattern: RegExp;
-export declare const useStepPattern: RegExp;
-export declare const workflowSerdeImportPattern: RegExp;
-export declare const workflowSerdeSymbolPattern: RegExp;
-export declare const workflowSerdeComputedPropertyPattern: RegExp;
-export declare const generatedWorkflowPathPattern: RegExp;
-/**
- * Detects workflow-related patterns in source code.
- */
-export interface WorkflowPatternMatch {
-    /** File contains 'use workflow' directive */
-    hasUseWorkflow: boolean;
-    /** File contains 'use step' directive */
-    hasUseStep: boolean;
-    /** File contains @workflow/serde import */
-    hasSerdeImport: boolean;
-    /** File contains Symbol.for('workflow-serialize') or Symbol.for('workflow-deserialize') */
-    hasSerdeSymbol: boolean;
-    /** File contains any directive ('use workflow' or 'use step') */
-    hasDirective: boolean;
-    /** File contains any serde pattern (import or Symbol.for) */
-    hasSerde: boolean;
-}
-/**
- * Detects workflow-related patterns in source code.
- * @param source - The source code to analyze
- * @returns Object with flags for each detected pattern
- */
-export declare function detectWorkflowPatterns(source: string): WorkflowPatternMatch;
-/**
- * Determines if a file path is a generated workflow route file.
- * @param filePath - The file path to check
- * @returns true if the file is a generated workflow route
- */
-export declare function isGeneratedWorkflowFile(filePath: string): boolean;
-/**
- * Determines if a file should be transformed based on its path and content patterns.
- *
- * Logic:
- * - Generated workflow route files are never transformed
- * - Files with directives ('use workflow' or 'use step') are always transformed
- * - Files with serde patterns are always transformed; the SWC plugin performs
- *   AST-level extraction/filtering to determine whether they actually define
- *   serde classes
- *
- * @param filePath - The file path to check
- * @param patterns - The detected patterns from detectWorkflowPatterns()
- * @returns true if the file should be transformed
- */
-export declare function shouldTransformFile(filePath: string, patterns: WorkflowPatternMatch): boolean;
-/**
- * Combined regex pattern for turbopack content matching.
- * Uses backreferences to ensure matching quote types.
- * Matches: 'use workflow', 'use step', @workflow/serde imports, Symbol.for serialization symbols,
- * and WORKFLOW_SERIALIZE/WORKFLOW_DESERIALIZE computed property usage
- */
-export declare const turbopackContentPattern: RegExp;
-//# sourceMappingURL=transform-utils.d.ts.map

package/dist/src/compiled/@workflow/builders/index.js

@@ -1 +0,0 @@
-const e=/^\s*(['"])use workflow\1;?\s*$/m,t=/^\s*(['"])use step\1;?\s*$/m,n=/from\s+(['"])@workflow\/serde\1/,r=/Symbol\.for\s*\(\s*(['"])workflow-(?:serialize|deserialize)\1\s*\)/,i=/\[\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\s*\]/,a=/`(?:\\[\s\S]|[^`\\])*`/g,o=/\/\*[\s\S]*?\*\/|\/\/[^\r\n]*/g,s=/^\s*(['"])(use workflow|use step)\1;?\s*$/,c=/^\s*(['"])[^'"]+\1;?\s*$/,l=/[/\\]\.well-known[/\\]workflow[/\\]/;function u(e,t){let n;for(let r of e.split(/\r?\n/)){let e=r.trim();if(e===``)continue;let i=s.exec(e);if(i){if(i[2]===t&&(n===void 0||n.endsWith(`{`)||c.test(n)))return!0;n=e;continue}n=e}return!1}function d(e){let t=(e.includes(`use workflow`)||e.includes(`use step`))&&(e.includes("`")||e.includes(`/`))?e.replace(a,e=>e.replace(/[^\r\n]/g,` `)).replace(o,e=>e.replace(/[^\r\n]/g,` `)):e,s=e.includes(`use workflow`)&&u(t,`use workflow`),c=e.includes(`use step`)&&u(t,`use step`),l=e.includes(`@workflow/serde`)&&n.test(e),d=(e.includes(`workflow-serialize`)||e.includes(`workflow-deserialize`))&&r.test(e),f=(e.includes(`WORKFLOW_SERIALIZE`)||e.includes(`WORKFLOW_DESERIALIZE`))&&i.test(e);return{hasUseWorkflow:s,hasUseStep:c,hasSerdeImport:l,hasSerdeSymbol:d,hasDirective:s||c,hasSerde:l||d||f}}function f(e){return l.test(e)}function p(e,t){return f(e)?!1:t.hasDirective||t.hasSerde}const m=/(use workflow|use step|from\s+(['"])@workflow\/serde\2|Symbol\.for\s*\(\s*(['"])workflow-(?:serialize|deserialize)\3\s*\)|\[\s*WORKFLOW_(?:SERIALIZE|DESERIALIZE)\s*\])/;export{d as detectWorkflowPatterns,l as generatedWorkflowPathPattern,f as isGeneratedWorkflowFile,p as shouldTransformFile,m as turbopackContentPattern,t as useStepPattern,e as useWorkflowPattern,i as workflowSerdeComputedPropertyPattern,n as workflowSerdeImportPattern,r as workflowSerdeSymbolPattern};

package/dist/src/execution/compaction.d.ts

@@ -1,14 +0,0 @@
-import type { HarnessModelMessage } from "#harness/messages.js";
-/**
- * Re-applies framework-owned state preservation after the harness compacts
- * message history, returning any messages to append to the compacted history.
- *
- * Runs the framework's built-in preservation steps:
- * - resets read-before-write tracking, so a write after compaction re-reads
- *   the file whose read evidence was summarized away;
- * - re-injects the todo list (when present), so the model keeps its task list.
- *
- * Must be called inside the harness step's `AlsContext`; both steps read
- * durable context state.
- */
-export declare function preserveFrameworkStateOnCompaction(): readonly HarnessModelMessage[];

package/dist/src/execution/compaction.js

@@ -1 +0,0 @@
-import{clearReadFileState}from"#execution/tools/file-state.js";import{getTodoCompactionMessage}from"#execution/tools/todo.js";function preserveFrameworkStateOnCompaction(){clearReadFileState();let e=getTodoCompactionMessage();return e===void 0?[]:[e]}export{preserveFrameworkStateOnCompaction};

package/dist/src/execution/sandbox/development-prewarm.d.ts

@@ -1,20 +0,0 @@
-import { type RuntimeCompiledArtifactsSource } from "#runtime/compiled-artifacts-source.js";
-export declare function prewarmDevelopmentSandboxes(input: {
-    readonly appRoot: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly log?: (message: string) => void;
-}): Promise<void>;
-export declare function startDevelopmentSandboxPrewarmInBackground(input: {
-    readonly appRoot: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly log?: (message: string) => void;
-}): void;
-export declare function subscribeDevelopmentSandboxPrewarmLogs(input: {
-    readonly appRoot: string;
-    readonly log: (message: string) => void;
-}): () => void;
-export declare function waitForDevelopmentSandboxPrewarm(input: {
-    readonly appRoot: string;
-    readonly compiledArtifactsSource: RuntimeCompiledArtifactsSource;
-    readonly log?: (message: string) => void;
-}): Promise<void>;

package/dist/src/execution/sandbox/development-prewarm.js

@@ -1 +0,0 @@
-import{prewarmAppSandboxes}from"./prewarm.js";import{toErrorMessage}from"#shared/errors.js";import{getRuntimeCompiledArtifactsAppRoot,getRuntimeCompiledArtifactsSandboxAppRoot}from"#runtime/compiled-artifacts-source.js";const pendingDevelopmentPrewarms=new Map,retainedDevelopmentPrewarmLogs=new Map;async function prewarmDevelopmentSandboxes(e){startDevelopmentSandboxPrewarmInBackground(e),await waitForDevelopmentSandboxPrewarm(e)}function startDevelopmentSandboxPrewarmInBackground(e){let t=resolvePrewarmKeys(e),n=findPendingPrewarm(t);if(n!==void 0){registerPrewarmAliases(t,n);return}let r={logs:[],promise:Promise.resolve(),subscribers:new Set};for(let e of t)retainedDevelopmentPrewarmLogs.delete(e);let i=prewarmAppSandboxes({appRoot:e.appRoot,compiledArtifactsSource:e.compiledArtifactsSource,log:t=>recordPrewarmLog(r,t,e.log)});r.promise=i,registerPrewarmAliases(t,r),i.catch(t=>{recordPrewarmLog(r,`eve: failed to initialize sandbox templates in the background: ${toErrorMessage(t)}`,e.log)}).finally(()=>{for(let e of t)pendingDevelopmentPrewarms.get(e)===r&&pendingDevelopmentPrewarms.delete(e),r.subscribers.size===0&&r.logs.length>0&&retainedDevelopmentPrewarmLogs.set(e,[...r.logs])})}function subscribeDevelopmentSandboxPrewarmLogs(e){let t=findPendingPrewarm([e.appRoot]);if(t!==void 0){for(let n of t.logs)e.log(n);return t.subscribers.add(e.log),()=>t.subscribers.delete(e.log)}let n=retainedDevelopmentPrewarmLogs.get(e.appRoot);if(n===void 0)return()=>{};retainedDevelopmentPrewarmLogs.delete(e.appRoot);for(let t of n)e.log(t);return()=>{}}async function waitForDevelopmentSandboxPrewarm(e){let t=findPendingPrewarm(resolvePrewarmKeys(e));if(t===void 0)return;let unsubscribe;if(e.log!==void 0){for(let n of t.logs)e.log(n);let subscriber=t=>e.log?.(t);t.subscribers.add(subscriber),unsubscribe=()=>t.subscribers.delete(subscriber)}try{await withProgressHeartbeat(`waiting for background sandbox template prewarm`,e.log,()=>t.promise)}finally{unsubscribe?.()}}function resolvePrewarmKeys(e){let t=new Set([e.appRoot]),n=getRuntimeCompiledArtifactsAppRoot(e.compiledArtifactsSource);n!==void 0&&t.add(n);let r=getRuntimeCompiledArtifactsSandboxAppRoot(e.compiledArtifactsSource);return r!==void 0&&t.add(r),[...t]}function findPendingPrewarm(e){for(let t of e){let e=pendingDevelopmentPrewarms.get(t);if(e!==void 0)return e}}function registerPrewarmAliases(e,t){for(let n of e)pendingDevelopmentPrewarms.set(n,t)}function recordPrewarmLog(e,t,n){e.logs.push(t),e.logs.length>50&&e.logs.splice(0,e.logs.length-50),n?.(t);for(let n of e.subscribers)n(t)}async function withProgressHeartbeat(e,t,n){if(t===void 0)return await n();let r=Date.now(),i=setInterval(()=>{t(`${e} (${Math.round((Date.now()-r)/1e3)}s elapsed)`)},1e4);i.unref?.();try{return await n()}finally{clearInterval(i)}}export{prewarmDevelopmentSandboxes,startDevelopmentSandboxPrewarmInBackground,subscribeDevelopmentSandboxPrewarmLogs,waitForDevelopmentSandboxPrewarm};