eve 0.64.1 → 0.65.0

package/docs/tools/human-in-the-loop.md

@@ -39,7 +39,7 @@ export default defineTool({
 
 By default, omitted `approval` behaves like `never()`, so tool calls may execute without human approval. Require human approval or other safeguards for sensitive, irreversible, regulated, financial, healthcare, employment, housing, legal, safety-impacting, user-impacting, or external side-effecting actions.
 
-`auto()` uses an [AI SDK evaluation model](/docs/guides/evaluate) to classify each call as `clear` or `caution`. It defaults to `typesafe-ai/jev`. Like `evaluate`, a model string uses Vercel AI Gateway unless the application configures a global AI SDK default provider:
+`auto()` uses an [AI SDK evaluation model](/docs/guides/evaluate) to classify each call as `clear` or `caution`. It defaults to `typesafe-ai/jev`, TypeSafe AI's [Jev evaluation model](https://vercel.com/i/what-is-jev). Like `evaluate`, a model string uses Vercel AI Gateway unless the application configures a global AI SDK default provider:
 
 ```ts
 approval: auto({ model: "typesafe-ai/jev" });
@@ -150,27 +150,38 @@ export default defineTool({
 
 ## Questions
 
-The built-in `ask_question` tool lets the model pause and ask the user, rather than guessing. It has no `execute` — the model calls it with `{ prompt, options?, allowFreeform? }`:
+The `ask_question` tool lets the model pause and ask the user one question, rather than guessing. The model calls it with `{ question, options? }`:
 
-- `prompt`: the question to put to the user.
-- `options`: an optional list of choices to offer. Channels render these as buttons or a select menu.
-- `allowFreeform`: whether the user may answer with free text instead of picking an option.
+- `question`: the question to put to the user, with the context needed to answer it.
+- `options`: two or three mutually exclusive choices, each with a `label` and a one-sentence `description`. Channels render these as buttons or a select menu. Omit `options` for an open-ended question.
 
-`ask_question` is part of the [default tool set](/docs/concepts/built-in-tools), so it is available without you defining anything. It produces the same `input.requested` pause as an approval, and resumes the same way.
+The user can always type their own answer instead of picking an option, so the model never needs an "Other" option. The tool returns `{ status: "answered", answer }` with the chosen option's label or the user's words, `{ status: "dismissed" }` when the user moved on without answering, or `{ status: "unavailable" }` when the session cannot request input.
+
+`ask_question` is an [opt-in framework tool](/docs/concepts/built-in-tools#ask_question). Add it with `eve add tool/ask_question`, which creates this file:
+
+```ts title="agent/tools/ask_question.ts"
+import { askQuestion } from "eve/tools/ask_question";
+
+export default askQuestion();
+```
+
+`ask_question` is an ordinary [workflow tool](/docs/tools/workflows) built on `ctx.ask()`. Write your own workflow tool with `ctx.ask()` when you need a different schema or want to act on the answer in the same call. Without any asking tool, the model asks in its reply text and the user's next message carries the answer.
 
 ## How pause and resume works
 
 Approvals and questions share one protocol:
 
-1. The model requests input (an approval, or an `ask_question`).
+1. A tool call needs approval, or a workflow tool such as `ask_question` calls `ctx.ask()`.
 2. eve emits an `input.requested` stream event carrying the pending requests.
 3. The turn parks at `session.waiting`, durably, for as long as it takes.
 4. The client answers with `inputResponses` (structured, keyed by `requestId`) or a normal follow-up `message`. A follow-up whose text matches an option ID, option label, or numeric option index resolves automatically, including approval options such as `approve` and `cancel`.
 
+For `ctx.ask()` questions from blocking tools, a follow-up message answers the question only when exactly one question is pending. The message must match an option, or the question must allow free text. Otherwise the message reaches the model as a normal turn, and each pending question created with `dismissible: true` resolves as `dismissed`. Questions from background tools and subagents need a structured response.
+
 Each request includes a `kind` discriminator: `tool-approval`, `question`, or
-`session-limit`. Clients should use `kind` to choose behavior and presentation;
-`toolName` and `requestId` identify the action and request but do not encode its
-semantics.
+`session-limit`. Clients should use `kind` to choose behavior and presentation.
+`requestId` identifies the request to answer, and `action.callId` identifies the
+tool call that raised it; neither encodes the request's semantics.
 
 The run picks back up exactly where it parked. Because the pause is durable, nothing is held in memory while it waits — the process can restart and the parked turn survives.
 
@@ -189,7 +200,7 @@ From your own frontend, scan all messages for pending requests and answer throug
 ## What to read next
 
 - [Tools](/docs/tools): define the typed actions an approval gates
-- [Built-in tools](/docs/concepts/built-in-tools): the default tools, including `ask_question`
+- [Built-in tools](/docs/concepts/built-in-tools): the default tools and opt-in tools such as `ask_question`
 - [Sessions, runs & streaming](/docs/concepts/sessions-runs-and-streaming): the event and resume contract behind the pause
 - [Building a frontend](/docs/guides/frontend/overview): render and answer requests from your own UI
 - [Multi-tenant approvals](/docs/patterns/multi-tenant-approvals): resolve per-tenant approval policy for authored and connection tools

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.1",
+  "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/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};