@esso0428/pi-subagents 0.17.6 → 0.17.8

package/dist/workflow/task.js

@@ -0,0 +1,208 @@
+/**
+ * task.ts — the background record one workflow run lives in.
+ *
+ * A `SubagentWorkflow` tool call returns a task id immediately and the run continues
+ * without it, so the run's state cannot live in the tool call's closure: the
+ * inline card, the completion notification and (later) the `/agents → Workflows` dialog
+ * all read it after `execute` has returned. This is that record, shaped after
+ * Claude Code's `local_workflow` task so the fields line up with what the
+ * renderers already expect.
+ *
+ * The progress log is append-only and collapses by index (see `progress.ts`),
+ * so every derived counter here is recomputed from the log rather than
+ * incremented as entries arrive — a re-emitted agent entry replaces its
+ * predecessor, and adding its tokens on top would double-count them.
+ */
+import { randomUUID } from "node:crypto";
+import { escapeXml } from "../xml.js";
+import { collapse, elapsedMs, stats } from "./progress.js";
+/** `wf_` + hex, matching Claude Code's `^wf_[a-z0-9-]{6,}$` run ids. */
+export function workflowRunId() {
+    return `wf_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+}
+export function createWorkflowTask(init) {
+    return {
+        type: "local_workflow",
+        id: init.id,
+        status: "running",
+        script: init.script,
+        scriptPath: init.scriptPath,
+        args: init.args,
+        meta: init.meta,
+        workflowName: init.meta?.name,
+        toolCallId: init.toolCallId,
+        journalPath: init.journalPath,
+        replay: init.replay,
+        resumedFrom: init.resumedFrom,
+        replayedCount: 0,
+        workflowProgress: [],
+        progressVersion: 0,
+        agentCount: 0,
+        doneCount: 0,
+        totalTokens: 0,
+        totalToolCalls: 0,
+        logs: [],
+        abortController: new AbortController(),
+        startTime: init.startTime ?? Date.now(),
+        totalPausedMs: 0,
+    };
+}
+/**
+ * Apply one batch of progress entries.
+ *
+ * Batched rather than per-entry because that is how the worker emits them, and
+ * because every counter below is an O(log) recompute — doing it once per fan-out
+ * frame instead of once per agent is the difference that keeps a 200-agent run
+ * cheap to render.
+ */
+export function updateWorkflowProgressBatch(task, entries) {
+    if (entries.length === 0)
+        return;
+    task.workflowProgress.push(...entries);
+    task.progressVersion++;
+    const { agents, logs } = collapse(task.workflowProgress);
+    task.logs = logs;
+    // `agentCount` is what the runtime has scheduled, which can lead what the log
+    // has seen — never let a recompute walk it backwards.
+    task.agentCount = Math.max(task.agentCount, agents.length);
+    let totalTokens = 0;
+    let totalToolCalls = 0;
+    let done = 0;
+    for (const agent of agents) {
+        totalTokens += agent.tokens ?? 0;
+        totalToolCalls += agent.toolCalls ?? 0;
+        // Counted off the collapsed agents, so a re-emitted row counts once.
+        if (agent.state === "done")
+            done++;
+    }
+    task.totalTokens = totalTokens;
+    task.totalToolCalls = totalToolCalls;
+    task.doneCount = done;
+}
+/**
+ * Hold the run, and stop its clock.
+ *
+ * The elapsed figure every surface shows subtracts `totalPausedMs`, so a run
+ * left paused overnight does not come back reading as a twelve-hour run.
+ */
+export function pauseWorkflowTask(task, now = Date.now()) {
+    if (task.status !== "running" || task.control === undefined)
+        return false;
+    task.control.pause();
+    task.status = "paused";
+    task.pausedAt = now;
+    return true;
+}
+/** Let it go again, banking however long it was held. */
+export function resumeWorkflowTask(task, now = Date.now()) {
+    if (task.status !== "paused" || task.control === undefined)
+        return false;
+    task.control.resume();
+    task.status = "running";
+    task.totalPausedMs = (task.totalPausedMs ?? 0) + Math.max(0, now - (task.pausedAt ?? now));
+    task.pausedAt = undefined;
+    return true;
+}
+/** Settle a task from the run's own result. */
+export function completeWorkflowTask(task, result) {
+    // Banked before the status moves off "paused": a run that finished while held
+    // still spent that time held, and the elapsed figure has to say so.
+    if (task.pausedAt !== undefined) {
+        task.totalPausedMs = (task.totalPausedMs ?? 0) + Math.max(0, Date.now() - task.pausedAt);
+        task.pausedAt = undefined;
+    }
+    // Nothing left to control, and holding the handle would let the dialog offer
+    // pause on a run that has already stopped.
+    task.control = undefined;
+    task.status = result.status;
+    task.meta ??= result.meta;
+    task.workflowName ??= result.meta.name;
+    task.agentCount = Math.max(task.agentCount, result.agentCount);
+    task.replayedCount = result.replayedCount;
+    task.value = result.value;
+    task.error = result.error;
+    task.endTime = Date.now();
+}
+/**
+ * Settle a task that never produced a result — a script rejected before the
+ * worker started (bad `meta`, oversized source, non-JSON `args`).
+ */
+export function failWorkflowTask(task, error) {
+    task.control = undefined;
+    task.pausedAt = undefined;
+    task.status = "failed";
+    task.error = error;
+    task.endTime = Date.now();
+}
+/** The run's outcome as text, for the notification and the LLM-facing result. */
+export function workflowResultText(task) {
+    if (task.error !== undefined)
+        return task.error;
+    if (task.value === undefined)
+        return "No output.";
+    if (typeof task.value === "string")
+        return task.value;
+    return JSON.stringify(task.value, null, 2);
+}
+/**
+ * Resolve a `resumeFromRunId` against the runs this session has seen.
+ *
+ * Same-session only, and deliberately so: the journal lives beside the
+ * session's task files, and a run id from another session would silently find
+ * nothing to replay — reporting that as "resumed" would be a lie the caller
+ * could not see through. An unknown id is an error rather than a cold start,
+ * because a caller that asked to resume is expecting not to pay.
+ */
+export function resolveResumeTarget(runId, tasks) {
+    const id = runId?.trim();
+    if (id === undefined || id === "")
+        return undefined;
+    const prior = tasks.get(id);
+    if (prior === undefined) {
+        const known = [...tasks.keys()];
+        return {
+            ok: false,
+            message: `No workflow run "${id}" in this session. ` +
+                (known.length > 0
+                    ? `Runs this session: ${known.join(", ")}.`
+                    : "Nothing has run yet — call this without `resumeFromRunId`."),
+        };
+    }
+    if (prior.status === "running") {
+        return {
+            ok: false,
+            message: `Workflow "${id}" is still running. Stop it from /agents → Workflows before resuming it.`,
+        };
+    }
+    if (prior.journalPath === undefined) {
+        return { ok: false, message: `Workflow "${id}" has no journal to resume from.` };
+    }
+    return {
+        ok: true,
+        runId: id,
+        journalPath: prior.journalPath,
+        // The persisted copy, which is what `scriptPath` holds when the call had
+        // no file of its own.
+        scriptPath: prior.scriptPath ?? "",
+    };
+}
+/** `<task-notification>`, in the same shape a finished background agent sends. */
+export function formatWorkflowNotification(task, now = Date.now()) {
+    const totals = stats(task.workflowProgress, task.agentCount);
+    const status = task.status === "completed" ? "Done"
+        : task.status === "killed" ? "Stopped"
+            : `Error: ${task.error ?? "unknown"}`;
+    const result = workflowResultText(task);
+    return [
+        `<task-notification>`,
+        `<task-id>${task.id}</task-id>`,
+        task.toolCallId ? `<tool-use-id>${escapeXml(task.toolCallId)}</tool-use-id>` : null,
+        task.scriptPath ? `<script>${escapeXml(task.scriptPath)}</script>` : null,
+        `<status>${escapeXml(status)}</status>`,
+        `<summary>Workflow "${escapeXml(task.workflowName ?? task.id)}" ${task.status} — ${totals.done}/${totals.total} agents${task.replayedCount > 0 ? `, ${task.replayedCount} replayed from ${escapeXml(task.resumedFrom ?? "an earlier run")}` : ""}</summary>`,
+        `<result>${escapeXml(result.length > 4000 ? `${result.slice(0, 4000)}\n...(truncated)` : result)}</result>`,
+        `<usage><total_tokens>${task.totalTokens}</total_tokens><tool_uses>${task.totalToolCalls}</tool_uses><duration_ms>${elapsedMs(task, now)}</duration_ms></usage>`,
+        `</task-notification>`,
+    ].filter(Boolean).join("\n");
+}
+//# sourceMappingURL=task.js.map

package/dist/workflow/task.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.js","sourceRoot":"","sources":["../../src/workflow/task.ts"],"names":[],"mappings":"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"}

package/dist/workflow/tool-description.d.ts

@@ -0,0 +1,39 @@
+/**
+ * tool-description.ts — the model-facing description of the `SubagentWorkflow` tool.
+ *
+ * This is a deliberate port of Claude Code's `Workflow` tool description, not a
+ * paraphrase of it. The rule the text is held to: **match Claude Code's wording
+ * everywhere; deviate only in the specific clause where its sentence would be
+ * false about pi, and keep that deviation minimal and in its voice.** Wording
+ * parity is the point — a user who knows one tool should not have to relearn
+ * the other, and the orchestration patterns below are load-bearing guidance
+ * that gets used badly when compressed.
+ *
+ * Parts omitted because pi has no such feature: the `ultracode` opt-in, MCP
+ * tools reached through `ToolSearch`, the `agent-<id>.jsonl` resume fallback,
+ * and the `/config` workflow-size guideline.
+ *
+ * Clauses that had to deviate, each because Claude Code's is untrue here:
+ *   - `schema` is pressure, not force — `toolChoice` is not plumbed through
+ *     pi's `AgentSession`, so a child can decline and the call returns null.
+ *   - `budget.total` is always null; pi has no token-target directive.
+ *   - `parallel` propagates a fatal run error instead of folding it to null.
+ *   - `effort` inherits the agent definition's level, then the parent's.
+ *   - `isolation` removes the worktree on settle, changes kept on a branch.
+ * Additions with no upstream counterpart: `gate`, `resume`, `effort: "minimal"`,
+ * the saved-workflow directories, and the reject-unknown-options guarantee.
+ *
+ * Kept out of index.ts purely for size. `{{placeholder}}` tokens are rendered by
+ * the same substitution pass the Agent tool's description uses, so a
+ * user-authored override can interpolate the live agent roster.
+ */
+/**
+ * Rendered with `{{typeList}}` substituted. Keep the prose accurate to what the
+ * runtime actually implements — documenting a global we do not ship is worse
+ * than documenting nothing, because the script only fails once it is running.
+ * `workflow-tool-description.test.ts` pins the parts that can drift: the
+ * `agent()` option set, the `resume` exclusions, the effort levels, the caps,
+ * and that every example here uses options the runtime actually accepts.
+ */
+export declare const fullWorkflowToolDescription = "Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background \u2014 this tool returns immediately with a task ID, and you are notified when the workflow completes. Use /agents \u2192 Workflows to watch live progress.\n\nA workflow structures work across many agents \u2014 to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps). The script is where you encode that structure: what fans out, what verifies, what synthesizes.\n\nONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of agents and consume a large amount of tokens; the user must request that scale, not have it inferred. Explicit opt-in means one of:\n- The user directly asked you to run a workflow or use multi-agent orchestration in their own words (\"use a workflow\", \"run a workflow\", \"fan out agents\", \"orchestrate this with subagents\"). The ask must be in the user's words \u2014 a task that would merely benefit from a workflow does not count.\n- The user invoked a skill or slash command whose instructions tell you to call SubagentWorkflow.\n- The user asked you to run a specific named or saved workflow.\n\nFor any other task \u2014 even one that would clearly benefit from parallelism \u2014 do NOT call this tool. Use the Agent tool for individual subagents, or briefly describe what a multi-agent workflow could do and how much it would roughly cost, and ask the user whether to run it. Mention they can ask for one with \"use a workflow\" in a future message to skip the ask.\n\nWhen you do call it, the right move is often **hybrid**: scout inline first (list the files, find the channels, scope the diff) to discover the work-list, then call SubagentWorkflow to pipeline over it. You don't need to know the shape before the *task* \u2014 only before the *orchestration step*.\n\nCommon single-phase workflows you can chain across turns:\n- **Understand** \u2014 parallel readers over relevant subsystems \u2192 structured map\n- **Design** \u2014 judge panel of N independent approaches \u2192 scored synthesis\n- **Review** \u2014 dimensions \u2192 find \u2192 adversarially verify (example below)\n- **Research** \u2014 multi-modal sweep \u2192 deep-read \u2192 synthesize\n- **Migrate** \u2014 discover sites \u2192 transform each (worktree isolation) \u2192 verify\n\nFor larger work, run several in sequence \u2014 read each result before deciding the next phase. You stay in the loop; each workflow is one well-scoped fan-out.\n\nPass the script inline via `script` \u2014 do not Write it to a file first. Every invocation automatically persists its script to a file under the session directory and returns the path in the tool result. To iterate on a workflow, edit that file with Write/Edit and re-invoke SubagentWorkflow with `{scriptPath: \"<path>\"}` instead of resending the full script. A script you will run more than once belongs in `.pi/workflows/<name>.js` (or `.agents/workflows/`, or `<agent dir>/workflows/` for one that follows the user everywhere); call it with `name: \"<name>\"` instead of re-sending the source.\n\nEvery script must begin with `export const meta = {...}`:\n  export const meta = {\n    name: 'find-flaky-tests',\n    description: 'Find flaky tests and propose fixes',   // one-line, shown in permission dialog\n    phases: [                                            // one entry per phase() call\n      { title: 'Scan', detail: 'grep test logs for retries' },\n      { title: 'Fix', detail: 'one agent per flaky test' },\n    ],\n  }\n  // script body starts here \u2014 use agent()/parallel()/pipeline()/phase()/log()\n  phase('Scan')\n  const flaky = await agent('grep CI logs for retry markers', {schema: FLAKY_SCHEMA})\n  ...\n\nThe `meta` object must be a PURE LITERAL \u2014 no variables, function calls, spreads, or template interpolation. Required fields: `name`, `description`. Optional: `whenToUse` (shown in the workflow list), `phases`. Use the SAME phase titles in meta.phases as in phase() calls \u2014 titles are matched exactly; a phase() call with no matching meta entry just gets its own progress group. Add `model` to a phase entry when that phase uses a specific model override.\n\nScript body hooks:\n- agent(prompt: string, opts?: {label?: string, phase?: string, schema?: object, model?: string, effort?: string, isolation?: 'worktree', agentType?: string, gate?: string, resume?: string}): Promise<any> \u2014 spawn a subagent. Without schema, returns its final text as a string. With schema (a JSON Schema), the subagent is given a StructuredOutput tool built from it and agent() returns the validated object \u2014 no parsing needed. A payload that does not match is rejected back to the child, which corrects it; a child that never answers through the tool gets one more prompt and then fails, so the call returns null \u2014 filter after every schema stage. Returns null if the user skips the agent mid-run or the subagent dies on a terminal API error after retries (filter with .filter(Boolean)). opts.label overrides the display label. opts.phase explicitly assigns this agent to a progress group (use this inside pipeline()/parallel() stages to avoid races on the global phase() state \u2014 same phase string \u2192 same group box). opts.model overrides the model for this agent call. Default to omitting it \u2014 the agent inherits the main-loop model (the resolved session model), which is almost always correct. Only set it when you're highly confident a different tier fits the task; when unsure, omit. opts.effort overrides the reasoning effort for this agent call ('minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max') \u2014 omit to inherit the agent definition's own level, then the parent's; use 'low' for cheap mechanical stages and higher tiers only for the hardest verify/judge stages. opts.isolation: 'worktree' runs the agent in a fresh git worktree \u2014 EXPENSIVE (setup time + disk per agent), use ONLY when agents mutate files in parallel and would otherwise conflict; the worktree is removed when the agent settles, its changes preserved on a branch. opts.gate: '<command>' runs a shell command after the agent finishes and requires it to pass \u2014 a non-zero exit marks the agent failed and the command's output becomes the error; prefer gate: 'npm test' over asking another agent whether the code looks right. opts.resume: '<label>' continues the child that ran under that label instead of starting fresh, so an iterative loop keeps its context \u2014 it cannot be combined with agentType, model, effort, isolation, gate or schema. opts.agentType uses a custom subagent type instead of the default workflow subagent \u2014 resolved from the same registry as the Agent tool; composes with schema. Available types:\n{{typeList}}\n- pipeline(items, stage1, stage2, ...): Promise<any[]> \u2014 run each item through all stages independently, NO barrier between stages. Item A can be in stage 3 while item B is still in stage 1. This is the DEFAULT for multi-stage work. Wall-clock = slowest single-item chain, not sum-of-slowest-per-stage. Every stage callback receives (prevResult, originalItem, index) \u2014 use originalItem/index in later stages to label work without threading context through stage 1's return value. A stage that throws drops that item to `null` and skips its remaining stages.\n- parallel(thunks: Array<() => Promise<any>>): Promise<any[]> \u2014 run tasks concurrently. This is a BARRIER: awaits all thunks before returning. A thunk that throws (or whose agent errors) resolves to `null` in the result array, so `.filter(Boolean)` before using the results; only a fatal run error \u2014 a cap breach, or a nested workflow that could not load \u2014 propagates instead of being folded into a null. Use ONLY when you genuinely need all results together.\n- log(message: string): void \u2014 emit a progress message to the user (shown as a narrator line above the progress tree)\n- phase(title: string): void \u2014 start a new phase; subsequent agent() calls are grouped under this title in the progress display\n- args: any \u2014 the value passed as SubagentWorkflow's `args` input, verbatim (undefined if not provided). Pass arrays/objects as actual JSON values in the tool call, NOT as a JSON-encoded string \u2014 `args: [\"a.ts\", \"b.ts\"]`, not `args: \"[\\\"a.ts\\\", ...]\"` (a stringified list reaches the script as one string, so `args.filter`/`args.map` throw). Use this to parameterize named workflows \u2014 e.g. pass a research question, target path, or config object directly instead of via a side-channel file.\n- budget: {total: number|null, spent(): number, remaining(): number} \u2014 `budget.total` is always null here: it comes from a token-target directive pi does not have, so guards like `while (budget.total && budget.remaining() > 50_000) { ... }` correctly do not fire rather than throwing on a missing global. `budget.spent()` returns output tokens spent by this run's agents. `budget.remaining()` returns `Infinity` with no target.\n- workflow(nameOrRef: string | {scriptPath: string}, args?: any): Promise<any> \u2014 run another workflow inline as a sub-step and return whatever it returns. Pass a name to invoke a saved workflow (same registry as {name: \"...\"}), or {scriptPath} to run a script file you Wrote earlier. The child shares this run's concurrency cap, agent counter, abort signal, and token budget \u2014 its agents appear under a \"\u25B8 name\" group in /agents \u2192 Workflows and its tokens count toward budget.spent(). The args param becomes the child's `args` global. Nesting is one level only: workflow() inside a child throws. Throws on unknown name / unreadable scriptPath / child syntax error; catch to handle gracefully.\n\nAny agent() option not listed above is rejected by name at the call.\n\nSubagents are told their final text IS the return value (not a human-facing message), so they return raw data. For structured output, use the schema option \u2014 validation happens at the tool-call layer so the model retries on mismatch.\n\nScripts are plain JavaScript, NOT TypeScript \u2014 type annotations (`: string[]`), interfaces, and generics fail to parse. The script body runs in an async context \u2014 use await directly. Standard JS built-ins (JSON, Math, Array, etc.) are available \u2014 EXCEPT `Date.now()`/`Math.random()`/argless `new Date()`, which throw (they would break resume); pass timestamps in via `args`, stamp results after the workflow returns, and for randomness vary the agent prompt/label by index. `eval` and `Function(...)` throw. No filesystem or Node.js API access.\n\nDEFAULT TO pipeline(). Only reach for a barrier (parallel between stages) when you genuinely need ALL prior-stage results together.\n\nA barrier is correct ONLY when stage N needs cross-item context from all of stage N-1:\n- Dedup/merge across the full result set before expensive downstream work\n- Early-exit if the total count is zero (\"0 bugs found \u2192 skip verification entirely\")\n- Stage N's prompt references \"the other findings\" for comparison\n\nA barrier is NOT justified by:\n- \"I need to flatten/map/filter first\" \u2014 do it inside a pipeline stage: pipeline(items, stageA, r => transform([r]).flat(), stageB)\n- \"The stages are conceptually separate\" \u2014 that's what pipeline() models. Separate stages \u2260 synchronized stages.\n- \"It's cleaner code\" \u2014 barrier latency is real. If 5 finders run and the slowest takes 3\u00D7 the fastest, a barrier wastes 2/3 of the fast finders' idle time.\n\nSmell test: if you wrote\n  const a = await parallel(...)\n  const b = transform(a)        // flatten, map, filter \u2014 no cross-item dependency\n  const c = await parallel(b.map(...))\nthat middle transform doesn't need the barrier. Rewrite as a pipeline with the transform inside a stage. When in doubt: pipeline.\n\nConcurrent agent() calls are capped at min(16, available CPUs - 2) per workflow \u2014 excess calls queue and run as slots free up. You can still pass 100 items to parallel()/pipeline() and they all complete; only ~10 run at any moment. Total agent count across a workflow's lifetime is capped at 1000 \u2014 a runaway-loop backstop set far above any real workflow. A single parallel()/pipeline() call accepts at most 4096 items; passing more is an explicit error, not a silent truncation.\n\nThe canonical multi-stage pattern \u2014 pipeline by default, each dimension verifies as soon as its review completes:\n  export const meta = {\n    name: 'review-changes',\n    description: 'Review changed files across dimensions, verify each finding',\n    phases: [{ title: 'Review' }, { title: 'Verify' }],\n  }\n  const DIMENSIONS = [{key: 'bugs', prompt: '...'}, {key: 'perf', prompt: '...'}]\n  const results = await pipeline(\n    DIMENSIONS,\n    d => agent(d.prompt, {label: `review:${d.key}`, phase: 'Review', schema: FINDINGS_SCHEMA}),\n    review => parallel(review.findings.map(f => () =>\n      agent(`Adversarially verify: ${f.title}`, {label: `verify:${f.file}`, phase: 'Verify', schema: VERDICT_SCHEMA})\n        .then(v => ({...f, verdict: v}))\n    ))\n  )\n  const confirmed = results.flat().filter(Boolean).filter(f => f.verdict?.isReal)\n  return { confirmed }\n  // Dimension 'bugs' findings verify while dimension 'perf' is still reviewing. No wasted wall-clock.\n\nWhen a barrier IS correct \u2014 dedup across all findings before expensive verification:\n  const all = await parallel(DIMENSIONS.map(d => () => agent(d.prompt, {schema: FINDINGS_SCHEMA})))\n  const deduped = dedupeByFileAndLine(all.filter(Boolean).flatMap(r => r.findings))  // <-- genuinely needs ALL at once\n  const verified = await parallel(deduped.map(f => () => agent(verifyPrompt(f), {schema: VERDICT_SCHEMA})))\n\nLoop-until-count pattern \u2014 accumulate to a target:\n  const bugs = []\n  while (bugs.length < 10) {\n    const result = await agent(\"Find bugs in this codebase.\", {schema: BUGS_SCHEMA})\n    bugs.push(...result.bugs)\n    log(`${bugs.length}/10 found`)\n  }\n\nGate-and-retry pattern \u2014 verify by running, and keep the agent's context across attempts:\n  let fixed = await agent('Find and fix the failing test.', {label: 'fix', gate: 'npm test'})\n  if (fixed === null) {                        // a non-zero exit failed the agent\n    // Resume keeps everything the child already learned. It cannot carry the\n    // gate, so re-verification needs its own gated call, in the same tree.\n    fixed = await agent('`npm test` is still failing. Fix the cause.', {label: 'fix', resume: 'fix'})\n    const verified = await agent('Run `npm test` and report the result. Change nothing.',\n      {label: 'verify', phase: 'Verify', gate: 'npm test', effort: 'low'})\n    return { passed: verified !== null, summary: fixed }\n  }\n  return { passed: true, summary: fixed }\n  // An LLM judging whether a fix works is a weaker signal than the test suite.\n\nComposing patterns \u2014 exhaustive review (find \u2192 dedup vs seen \u2192 diverse-lens panel \u2192 loop-until-dry):\n  const seen = new Set(), confirmed = []\n  let dry = 0\n  while (dry < 2) {                                              // loop-until-dry\n    const found = (await parallel(FINDERS.map(f => () =>          // barrier: collect all finders this round\n      agent(f.prompt, {phase: 'Find', schema: BUGS})))).filter(Boolean).flatMap(r => r.bugs)\n    const fresh = found.filter(b => !seen.has(key(b)))           // dedup vs ALL seen \u2014 plain code, not an agent\n    if (!fresh.length) { dry++; continue }\n    dry = 0; fresh.forEach(b => seen.add(key(b)))\n    const judged = await parallel(fresh.map(b => () =>           // every fresh bug judged concurrently...\n      parallel(['correctness','security','repro'].map(lens => () =>   // ...each by 3 distinct lenses\n        agent(`Judge \"${b.desc}\" via the ${lens} lens \u2014 real?`, {phase: 'Verify', schema: VERDICT})))\n        .then(vs => ({ b, real: vs.filter(Boolean).filter(v => v.real).length >= 2 }))))\n    confirmed.push(...judged.filter(v => v.real).map(v => v.b))\n  }\n  return confirmed\n  // dedup vs `seen`, NOT `confirmed` \u2014 else judge-rejected findings reappear every round and it never converges.\n\nQuality patterns \u2014 common shapes; pick by task and compose freely:\n- Adversarial verify: spawn N independent skeptics per finding, each prompted to REFUTE. Kill if \u2265majority refute. Prevents plausible-but-wrong findings from surviving.\n    const votes = await parallel(Array.from({length: 3}, () => () =>\n      agent(`Try to refute: ${claim}. Default to refuted=true if uncertain.`, {schema: VERDICT})))\n    const survives = votes.filter(Boolean).filter(v => !v.refuted).length >= 2\n- Verify by running, not by asking: when a claim is testable, `gate` it rather than asking another model whether it holds.\n- Perspective-diverse verify: when a finding can fail in more than one way, give each verifier a distinct lens (correctness, security, perf, does-it-reproduce) instead of N identical refuters \u2014 diversity catches failure modes redundancy can't.\n- Judge panel: generate N independent attempts from different angles (e.g. MVP-first, risk-first, user-first), score with parallel judges, synthesize from the winner while grafting the best ideas from runners-up. Beats one-attempt-iterated when the solution space is wide.\n- Loop-until-dry: for unknown-size discovery (bugs, issues, edge cases), keep spawning finders until K consecutive rounds return nothing new. Simple counters (while count < N) miss the tail.\n- Multi-modal sweep: parallel agents each searching a different way (by-container, by-content, by-entity, by-time). Each is blind to what the others surface; useful when one search angle won't find everything.\n- Completeness critic: a final agent that asks \"what's missing \u2014 modality not run, claim unverified, source unread?\" What it finds becomes the next round of work.\n- No silent caps: if a workflow bounds coverage (top-N, no-retry, sampling), `log()` what was dropped \u2014 silent truncation reads as \"covered everything\" when it didn't.\n\nScale to what the user asked for. \"find any bugs\" \u2192 a few finders, single-vote verify. \"thoroughly audit this\" or \"be comprehensive\" \u2192 larger finder pool, 3\u20135 vote adversarial pass, synthesis stage. When unsure, lean toward thoroughness for research/review/audit requests and toward brevity for quick checks.\n\nThese patterns aren't exhaustive \u2014 compose novel harnesses when the task calls for it (tournament brackets, self-repair loops, staged escalation, whatever fits).\n\nUse this tool for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.\n\n## Resume\n\nThe tool result includes a runId. To resume after a pause, kill, or script edit, relaunch with SubagentWorkflow({scriptPath, resumeFromRunId}) \u2014 the longest unchanged prefix of agent() calls returns cached results instantly; the first edited/new call and everything after it runs live. Same script + same args \u2192 100% cache hit. It is a prefix and not a lookup: a later call that still matches is not reused once an earlier one has changed. A journaled failure ends the prefix, so resuming a run that died at agent 5 retries exactly agent 5. Same session only, and the run must have finished \u2014 stop it from /agents \u2192 Workflows first. Before diagnosing why a completed workflow returned an empty or unexpected result, Read the run's `<run id>.workflow.jsonl` beside its script \u2014 it records each agent's actual return value; do not assume cached results are non-empty. Date.now()/Math.random()/new Date() are unavailable in scripts (they would break this) \u2014 stamp results after the workflow returns, or pass timestamps via args.";
+//# sourceMappingURL=tool-description.d.ts.map

package/dist/workflow/tool-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-description.d.ts","sourceRoot":"","sources":["../../src/workflow/tool-description.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,4nnBAiK49B,CAAC"}

package/dist/workflow/tool-description.js

@@ -0,0 +1,200 @@
+/**
+ * tool-description.ts — the model-facing description of the `SubagentWorkflow` tool.
+ *
+ * This is a deliberate port of Claude Code's `Workflow` tool description, not a
+ * paraphrase of it. The rule the text is held to: **match Claude Code's wording
+ * everywhere; deviate only in the specific clause where its sentence would be
+ * false about pi, and keep that deviation minimal and in its voice.** Wording
+ * parity is the point — a user who knows one tool should not have to relearn
+ * the other, and the orchestration patterns below are load-bearing guidance
+ * that gets used badly when compressed.
+ *
+ * Parts omitted because pi has no such feature: the `ultracode` opt-in, MCP
+ * tools reached through `ToolSearch`, the `agent-<id>.jsonl` resume fallback,
+ * and the `/config` workflow-size guideline.
+ *
+ * Clauses that had to deviate, each because Claude Code's is untrue here:
+ *   - `schema` is pressure, not force — `toolChoice` is not plumbed through
+ *     pi's `AgentSession`, so a child can decline and the call returns null.
+ *   - `budget.total` is always null; pi has no token-target directive.
+ *   - `parallel` propagates a fatal run error instead of folding it to null.
+ *   - `effort` inherits the agent definition's level, then the parent's.
+ *   - `isolation` removes the worktree on settle, changes kept on a branch.
+ * Additions with no upstream counterpart: `gate`, `resume`, `effort: "minimal"`,
+ * the saved-workflow directories, and the reject-unknown-options guarantee.
+ *
+ * Kept out of index.ts purely for size. `{{placeholder}}` tokens are rendered by
+ * the same substitution pass the Agent tool's description uses, so a
+ * user-authored override can interpolate the live agent roster.
+ */
+/**
+ * Rendered with `{{typeList}}` substituted. Keep the prose accurate to what the
+ * runtime actually implements — documenting a global we do not ship is worse
+ * than documenting nothing, because the script only fails once it is running.
+ * `workflow-tool-description.test.ts` pins the parts that can drift: the
+ * `agent()` option set, the `resume` exclusions, the effort levels, the caps,
+ * and that every example here uses options the runtime actually accepts.
+ */
+export const fullWorkflowToolDescription = `Execute a workflow script that orchestrates multiple subagents deterministically. Workflows run in the background — this tool returns immediately with a task ID, and you are notified when the workflow completes. Use /agents → Workflows to watch live progress.
+
+A workflow structures work across many agents — to be comprehensive (decompose and cover in parallel), to be confident (independent perspectives and adversarial checks before committing), or to take on scale one context can't hold (migrations, audits, broad sweeps). The script is where you encode that structure: what fans out, what verifies, what synthesizes.
+
+ONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of agents and consume a large amount of tokens; the user must request that scale, not have it inferred. Explicit opt-in means one of:
+- The user directly asked you to run a workflow or use multi-agent orchestration in their own words ("use a workflow", "run a workflow", "fan out agents", "orchestrate this with subagents"). The ask must be in the user's words — a task that would merely benefit from a workflow does not count.
+- The user invoked a skill or slash command whose instructions tell you to call SubagentWorkflow.
+- The user asked you to run a specific named or saved workflow.
+
+For any other task — even one that would clearly benefit from parallelism — do NOT call this tool. Use the Agent tool for individual subagents, or briefly describe what a multi-agent workflow could do and how much it would roughly cost, and ask the user whether to run it. Mention they can ask for one with "use a workflow" in a future message to skip the ask.
+
+When you do call it, the right move is often **hybrid**: scout inline first (list the files, find the channels, scope the diff) to discover the work-list, then call SubagentWorkflow to pipeline over it. You don't need to know the shape before the *task* — only before the *orchestration step*.
+
+Common single-phase workflows you can chain across turns:
+- **Understand** — parallel readers over relevant subsystems → structured map
+- **Design** — judge panel of N independent approaches → scored synthesis
+- **Review** — dimensions → find → adversarially verify (example below)
+- **Research** — multi-modal sweep → deep-read → synthesize
+- **Migrate** — discover sites → transform each (worktree isolation) → verify
+
+For larger work, run several in sequence — read each result before deciding the next phase. You stay in the loop; each workflow is one well-scoped fan-out.
+
+Pass the script inline via \`script\` — do not Write it to a file first. Every invocation automatically persists its script to a file under the session directory and returns the path in the tool result. To iterate on a workflow, edit that file with Write/Edit and re-invoke SubagentWorkflow with \`{scriptPath: "<path>"}\` instead of resending the full script. A script you will run more than once belongs in \`.pi/workflows/<name>.js\` (or \`.agents/workflows/\`, or \`<agent dir>/workflows/\` for one that follows the user everywhere); call it with \`name: "<name>"\` instead of re-sending the source.
+
+Every script must begin with \`export const meta = {...}\`:
+  export const meta = {
+    name: 'find-flaky-tests',
+    description: 'Find flaky tests and propose fixes',   // one-line, shown in permission dialog
+    phases: [                                            // one entry per phase() call
+      { title: 'Scan', detail: 'grep test logs for retries' },
+      { title: 'Fix', detail: 'one agent per flaky test' },
+    ],
+  }
+  // script body starts here — use agent()/parallel()/pipeline()/phase()/log()
+  phase('Scan')
+  const flaky = await agent('grep CI logs for retry markers', {schema: FLAKY_SCHEMA})
+  ...
+
+The \`meta\` object must be a PURE LITERAL — no variables, function calls, spreads, or template interpolation. Required fields: \`name\`, \`description\`. Optional: \`whenToUse\` (shown in the workflow list), \`phases\`. Use the SAME phase titles in meta.phases as in phase() calls — titles are matched exactly; a phase() call with no matching meta entry just gets its own progress group. Add \`model\` to a phase entry when that phase uses a specific model override.
+
+Script body hooks:
+- agent(prompt: string, opts?: {label?: string, phase?: string, schema?: object, model?: string, effort?: string, isolation?: 'worktree', agentType?: string, gate?: string, resume?: string}): Promise<any> — spawn a subagent. Without schema, returns its final text as a string. With schema (a JSON Schema), the subagent is given a StructuredOutput tool built from it and agent() returns the validated object — no parsing needed. A payload that does not match is rejected back to the child, which corrects it; a child that never answers through the tool gets one more prompt and then fails, so the call returns null — filter after every schema stage. Returns null if the user skips the agent mid-run or the subagent dies on a terminal API error after retries (filter with .filter(Boolean)). opts.label overrides the display label. opts.phase explicitly assigns this agent to a progress group (use this inside pipeline()/parallel() stages to avoid races on the global phase() state — same phase string → same group box). opts.model overrides the model for this agent call. Default to omitting it — the agent inherits the main-loop model (the resolved session model), which is almost always correct. Only set it when you're highly confident a different tier fits the task; when unsure, omit. opts.effort overrides the reasoning effort for this agent call ('minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max') — omit to inherit the agent definition's own level, then the parent's; use 'low' for cheap mechanical stages and higher tiers only for the hardest verify/judge stages. opts.isolation: 'worktree' runs the agent in a fresh git worktree — EXPENSIVE (setup time + disk per agent), use ONLY when agents mutate files in parallel and would otherwise conflict; the worktree is removed when the agent settles, its changes preserved on a branch. opts.gate: '<command>' runs a shell command after the agent finishes and requires it to pass — a non-zero exit marks the agent failed and the command's output becomes the error; prefer gate: 'npm test' over asking another agent whether the code looks right. opts.resume: '<label>' continues the child that ran under that label instead of starting fresh, so an iterative loop keeps its context — it cannot be combined with agentType, model, effort, isolation, gate or schema. opts.agentType uses a custom subagent type instead of the default workflow subagent — resolved from the same registry as the Agent tool; composes with schema. Available types:
+{{typeList}}
+- pipeline(items, stage1, stage2, ...): Promise<any[]> — run each item through all stages independently, NO barrier between stages. Item A can be in stage 3 while item B is still in stage 1. This is the DEFAULT for multi-stage work. Wall-clock = slowest single-item chain, not sum-of-slowest-per-stage. Every stage callback receives (prevResult, originalItem, index) — use originalItem/index in later stages to label work without threading context through stage 1's return value. A stage that throws drops that item to \`null\` and skips its remaining stages.
+- parallel(thunks: Array<() => Promise<any>>): Promise<any[]> — run tasks concurrently. This is a BARRIER: awaits all thunks before returning. A thunk that throws (or whose agent errors) resolves to \`null\` in the result array, so \`.filter(Boolean)\` before using the results; only a fatal run error — a cap breach, or a nested workflow that could not load — propagates instead of being folded into a null. Use ONLY when you genuinely need all results together.
+- log(message: string): void — emit a progress message to the user (shown as a narrator line above the progress tree)
+- phase(title: string): void — start a new phase; subsequent agent() calls are grouped under this title in the progress display
+- args: any — the value passed as SubagentWorkflow's \`args\` input, verbatim (undefined if not provided). Pass arrays/objects as actual JSON values in the tool call, NOT as a JSON-encoded string — \`args: ["a.ts", "b.ts"]\`, not \`args: "[\\"a.ts\\", ...]"\` (a stringified list reaches the script as one string, so \`args.filter\`/\`args.map\` throw). Use this to parameterize named workflows — e.g. pass a research question, target path, or config object directly instead of via a side-channel file.
+- budget: {total: number|null, spent(): number, remaining(): number} — \`budget.total\` is always null here: it comes from a token-target directive pi does not have, so guards like \`while (budget.total && budget.remaining() > 50_000) { ... }\` correctly do not fire rather than throwing on a missing global. \`budget.spent()\` returns output tokens spent by this run's agents. \`budget.remaining()\` returns \`Infinity\` with no target.
+- workflow(nameOrRef: string | {scriptPath: string}, args?: any): Promise<any> — run another workflow inline as a sub-step and return whatever it returns. Pass a name to invoke a saved workflow (same registry as {name: "..."}), or {scriptPath} to run a script file you Wrote earlier. The child shares this run's concurrency cap, agent counter, abort signal, and token budget — its agents appear under a "▸ name" group in /agents → Workflows and its tokens count toward budget.spent(). The args param becomes the child's \`args\` global. Nesting is one level only: workflow() inside a child throws. Throws on unknown name / unreadable scriptPath / child syntax error; catch to handle gracefully.
+
+Any agent() option not listed above is rejected by name at the call.
+
+Subagents are told their final text IS the return value (not a human-facing message), so they return raw data. For structured output, use the schema option — validation happens at the tool-call layer so the model retries on mismatch.
+
+Scripts are plain JavaScript, NOT TypeScript — type annotations (\`: string[]\`), interfaces, and generics fail to parse. The script body runs in an async context — use await directly. Standard JS built-ins (JSON, Math, Array, etc.) are available — EXCEPT \`Date.now()\`/\`Math.random()\`/argless \`new Date()\`, which throw (they would break resume); pass timestamps in via \`args\`, stamp results after the workflow returns, and for randomness vary the agent prompt/label by index. \`eval\` and \`Function(...)\` throw. No filesystem or Node.js API access.
+
+DEFAULT TO pipeline(). Only reach for a barrier (parallel between stages) when you genuinely need ALL prior-stage results together.
+
+A barrier is correct ONLY when stage N needs cross-item context from all of stage N-1:
+- Dedup/merge across the full result set before expensive downstream work
+- Early-exit if the total count is zero ("0 bugs found → skip verification entirely")
+- Stage N's prompt references "the other findings" for comparison
+
+A barrier is NOT justified by:
+- "I need to flatten/map/filter first" — do it inside a pipeline stage: pipeline(items, stageA, r => transform([r]).flat(), stageB)
+- "The stages are conceptually separate" — that's what pipeline() models. Separate stages ≠ synchronized stages.
+- "It's cleaner code" — barrier latency is real. If 5 finders run and the slowest takes 3× the fastest, a barrier wastes 2/3 of the fast finders' idle time.
+
+Smell test: if you wrote
+  const a = await parallel(...)
+  const b = transform(a)        // flatten, map, filter — no cross-item dependency
+  const c = await parallel(b.map(...))
+that middle transform doesn't need the barrier. Rewrite as a pipeline with the transform inside a stage. When in doubt: pipeline.
+
+Concurrent agent() calls are capped at min(16, available CPUs - 2) per workflow — excess calls queue and run as slots free up. You can still pass 100 items to parallel()/pipeline() and they all complete; only ~10 run at any moment. Total agent count across a workflow's lifetime is capped at 1000 — a runaway-loop backstop set far above any real workflow. A single parallel()/pipeline() call accepts at most 4096 items; passing more is an explicit error, not a silent truncation.
+
+The canonical multi-stage pattern — pipeline by default, each dimension verifies as soon as its review completes:
+  export const meta = {
+    name: 'review-changes',
+    description: 'Review changed files across dimensions, verify each finding',
+    phases: [{ title: 'Review' }, { title: 'Verify' }],
+  }
+  const DIMENSIONS = [{key: 'bugs', prompt: '...'}, {key: 'perf', prompt: '...'}]
+  const results = await pipeline(
+    DIMENSIONS,
+    d => agent(d.prompt, {label: \`review:\${d.key}\`, phase: 'Review', schema: FINDINGS_SCHEMA}),
+    review => parallel(review.findings.map(f => () =>
+      agent(\`Adversarially verify: \${f.title}\`, {label: \`verify:\${f.file}\`, phase: 'Verify', schema: VERDICT_SCHEMA})
+        .then(v => ({...f, verdict: v}))
+    ))
+  )
+  const confirmed = results.flat().filter(Boolean).filter(f => f.verdict?.isReal)
+  return { confirmed }
+  // Dimension 'bugs' findings verify while dimension 'perf' is still reviewing. No wasted wall-clock.
+
+When a barrier IS correct — dedup across all findings before expensive verification:
+  const all = await parallel(DIMENSIONS.map(d => () => agent(d.prompt, {schema: FINDINGS_SCHEMA})))
+  const deduped = dedupeByFileAndLine(all.filter(Boolean).flatMap(r => r.findings))  // <-- genuinely needs ALL at once
+  const verified = await parallel(deduped.map(f => () => agent(verifyPrompt(f), {schema: VERDICT_SCHEMA})))
+
+Loop-until-count pattern — accumulate to a target:
+  const bugs = []
+  while (bugs.length < 10) {
+    const result = await agent("Find bugs in this codebase.", {schema: BUGS_SCHEMA})
+    bugs.push(...result.bugs)
+    log(\`\${bugs.length}/10 found\`)
+  }
+
+Gate-and-retry pattern — verify by running, and keep the agent's context across attempts:
+  let fixed = await agent('Find and fix the failing test.', {label: 'fix', gate: 'npm test'})
+  if (fixed === null) {                        // a non-zero exit failed the agent
+    // Resume keeps everything the child already learned. It cannot carry the
+    // gate, so re-verification needs its own gated call, in the same tree.
+    fixed = await agent('\`npm test\` is still failing. Fix the cause.', {label: 'fix', resume: 'fix'})
+    const verified = await agent('Run \`npm test\` and report the result. Change nothing.',
+      {label: 'verify', phase: 'Verify', gate: 'npm test', effort: 'low'})
+    return { passed: verified !== null, summary: fixed }
+  }
+  return { passed: true, summary: fixed }
+  // An LLM judging whether a fix works is a weaker signal than the test suite.
+
+Composing patterns — exhaustive review (find → dedup vs seen → diverse-lens panel → loop-until-dry):
+  const seen = new Set(), confirmed = []
+  let dry = 0
+  while (dry < 2) {                                              // loop-until-dry
+    const found = (await parallel(FINDERS.map(f => () =>          // barrier: collect all finders this round
+      agent(f.prompt, {phase: 'Find', schema: BUGS})))).filter(Boolean).flatMap(r => r.bugs)
+    const fresh = found.filter(b => !seen.has(key(b)))           // dedup vs ALL seen — plain code, not an agent
+    if (!fresh.length) { dry++; continue }
+    dry = 0; fresh.forEach(b => seen.add(key(b)))
+    const judged = await parallel(fresh.map(b => () =>           // every fresh bug judged concurrently...
+      parallel(['correctness','security','repro'].map(lens => () =>   // ...each by 3 distinct lenses
+        agent(\`Judge "\${b.desc}" via the \${lens} lens — real?\`, {phase: 'Verify', schema: VERDICT})))
+        .then(vs => ({ b, real: vs.filter(Boolean).filter(v => v.real).length >= 2 }))))
+    confirmed.push(...judged.filter(v => v.real).map(v => v.b))
+  }
+  return confirmed
+  // dedup vs \`seen\`, NOT \`confirmed\` — else judge-rejected findings reappear every round and it never converges.
+
+Quality patterns — common shapes; pick by task and compose freely:
+- Adversarial verify: spawn N independent skeptics per finding, each prompted to REFUTE. Kill if ≥majority refute. Prevents plausible-but-wrong findings from surviving.
+    const votes = await parallel(Array.from({length: 3}, () => () =>
+      agent(\`Try to refute: \${claim}. Default to refuted=true if uncertain.\`, {schema: VERDICT})))
+    const survives = votes.filter(Boolean).filter(v => !v.refuted).length >= 2
+- Verify by running, not by asking: when a claim is testable, \`gate\` it rather than asking another model whether it holds.
+- Perspective-diverse verify: when a finding can fail in more than one way, give each verifier a distinct lens (correctness, security, perf, does-it-reproduce) instead of N identical refuters — diversity catches failure modes redundancy can't.
+- Judge panel: generate N independent attempts from different angles (e.g. MVP-first, risk-first, user-first), score with parallel judges, synthesize from the winner while grafting the best ideas from runners-up. Beats one-attempt-iterated when the solution space is wide.
+- Loop-until-dry: for unknown-size discovery (bugs, issues, edge cases), keep spawning finders until K consecutive rounds return nothing new. Simple counters (while count < N) miss the tail.
+- Multi-modal sweep: parallel agents each searching a different way (by-container, by-content, by-entity, by-time). Each is blind to what the others surface; useful when one search angle won't find everything.
+- Completeness critic: a final agent that asks "what's missing — modality not run, claim unverified, source unread?" What it finds becomes the next round of work.
+- No silent caps: if a workflow bounds coverage (top-N, no-retry, sampling), \`log()\` what was dropped — silent truncation reads as "covered everything" when it didn't.
+
+Scale to what the user asked for. "find any bugs" → a few finders, single-vote verify. "thoroughly audit this" or "be comprehensive" → larger finder pool, 3–5 vote adversarial pass, synthesis stage. When unsure, lean toward thoroughness for research/review/audit requests and toward brevity for quick checks.
+
+These patterns aren't exhaustive — compose novel harnesses when the task calls for it (tournament brackets, self-repair loops, staged escalation, whatever fits).
+
+Use this tool for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.
+
+## Resume
+
+The tool result includes a runId. To resume after a pause, kill, or script edit, relaunch with SubagentWorkflow({scriptPath, resumeFromRunId}) — the longest unchanged prefix of agent() calls returns cached results instantly; the first edited/new call and everything after it runs live. Same script + same args → 100% cache hit. It is a prefix and not a lookup: a later call that still matches is not reused once an earlier one has changed. A journaled failure ends the prefix, so resuming a run that died at agent 5 retries exactly agent 5. Same session only, and the run must have finished — stop it from /agents → Workflows first. Before diagnosing why a completed workflow returned an empty or unexpected result, Read the run's \`<run id>.workflow.jsonl\` beside its script — it records each agent's actual return value; do not assume cached results are non-empty. Date.now()/Math.random()/new Date() are unavailable in scripts (they would break this) — stamp results after the workflow returns, or pass timestamps via args.`;
+//# sourceMappingURL=tool-description.js.map

package/dist/workflow/tool-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-description.js","sourceRoot":"","sources":["../../src/workflow/tool-description.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ogCAiKy9B,CAAC"}

package/dist/workflow/worker-source.d.ts

@@ -0,0 +1,48 @@
+/**
+ * worker-source.ts — the JavaScript that runs inside the workflow worker thread.
+ *
+ * The host spawns this with `new Worker(WORKER_SOURCE, { eval: true })`, so the
+ * source has to be an inlined string: `AGENTS.md` forbids dynamic `import()`,
+ * and a file path would have to survive bundling. Keeping it as a template
+ * literal costs editor tooling but nothing else — the worker is plain CommonJS
+ * JavaScript and never sees the TypeScript pipeline.
+ *
+ * Two boundaries stack here, and they are not the same boundary:
+ *
+ *   host thread  ←postMessage→  worker thread  ←vm context→  workflow script
+ *
+ * The worker/host split exists for *killability*: `worker.terminate()` stops a
+ * runaway script mid-loop, which an in-process `vm` timeout cannot do once the
+ * script is inside an `await`. The vm context exists for *determinism and
+ * accident-avoidance*, not security — see the note on `codeGeneration` below.
+ *
+ * ## Why the context gets no host built-ins
+ *
+ * `vm.createContext(sandbox)` gives the script a fresh realm that already owns
+ * `Object`, `Array`, `JSON`, `Math`, `Date`, `Promise`, `Map`, `Set`. We inject
+ * *only* our own globals on top. Injecting host built-ins instead would hand the
+ * script `Object.constructor` → the **host** `Function`, i.e. a compiler for
+ * arbitrary host-realm code.
+ *
+ * That said: our injected globals are themselves host closures, so
+ * `agent.constructor` is still the host `Function`. The hygiene shrinks the
+ * surface; it does not close the hole. **`codeGeneration: { strings: false }` is
+ * the load-bearing defense** — it makes `Function("…")` and `eval("…")` throw
+ * `EvalError`, so a captured host `Function` cannot compile anything. Treat this
+ * as a determinism boundary, not a security boundary against a hostile script.
+ *
+ * ## Why determinism is a prelude and not a stub
+ *
+ * Because `Date` and `Math` come *from the realm*, they cannot be neutered by
+ * injection — there is nothing to inject over. So the compiled source is
+ * prefixed with a prelude that runs inside the realm and reassigns `Date.now`
+ * and `Math.random` in place, then lexically shadows `Date` with a subclass
+ * whose zero-argument constructor throws. Lexical shadowing rather than a global
+ * assignment because a `const` in the IIFE scope cannot be reached around.
+ *
+ * Determinism is enforced because a workflow's journal is replayed by prefix on
+ * resume: a script that reads the clock produces a different prefix on the
+ * second run and the replay silently diverges.
+ */
+export declare const WORKER_SOURCE: string;
+//# sourceMappingURL=worker-source.d.ts.map

package/dist/workflow/worker-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-source.d.ts","sourceRoot":"","sources":["../../src/workflow/worker-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAuBH,eAAO,MAAM,aAAa,QAwsBzB,CAAC"}