@namzu/cli 36.2.0 → 36.3.1

package/dist/chunks/{chunk-H7VJHF5S.js → chunk-H6MWKPHM.js}

@@ -2,24 +2,35 @@ import { createRequire as __namzuCreateRequire } from 'node:module';
 const require = __namzuCreateRequire(import.meta.url);
 import {
   openManagedWorktrees
-} from "./chunk-PT7TZNBV.js";
+} from "./chunk-52OVP5BG.js";
 import {
   createBrowserControl
 } from "./chunk-WHODOMXA.js";
 import {
   connectMcpServers
-} from "./chunk-HIZ7F6BT.js";
+} from "./chunk-JCDTR2ZU.js";
 import {
   createSessionSkillCatalog
-} from "./chunk-YTJO7G24.js";
+} from "./chunk-XCWZZZOW.js";
 import {
   SAVE_SKILL_TOOL_NAME,
+  WORKFLOW_TOOL_DESCRIPTION,
+  WORKFLOW_TOOL_NAME,
+  attachAgentView,
+  closeOpenAgents,
+  completionNotice,
+  initialRunView,
+  launchedText,
   readStoredTurnGuards,
-  resolveTurnGuards
-} from "./chunk-L6FMG3R6.js";
+  reduceRunView,
+  resolveTurnGuards,
+  viewFromJournal,
+  workflowOffered,
+  workflowRefusal
+} from "./chunk-74KMYYM2.js";
 import {
   openInBrowser
-} from "./chunk-XAKL7C7B.js";
+} from "./chunk-AP5KD43Y.js";
 import {
   CredentialRefreshRejectedError,
   CredentialWithdrawnError,
@@ -27,7 +38,7 @@ import {
   ensureFreshStoredCodexCredential,
   readSubscriptionCredential,
   sameOAuthCredential
-} from "./chunk-HJ42RG5U.js";
+} from "./chunk-5URT3ZM2.js";
 import {
   debugRequested
 } from "./chunk-GNBMKISG.js";
@@ -35,7 +46,7 @@ import {
   configuredPassthroughTools,
   resolveToolResultScreens,
   unmatchedPassthroughTools
-} from "./chunk-U5AWHJ7O.js";
+} from "./chunk-MBBFX64S.js";
 import {
   formatSize,
   homePath,
@@ -63,7 +74,7 @@ import {
   requiresCredentialForModel,
   resolveChainCapabilities,
   unresolvedMembers
-} from "./chunk-CFN7CUD3.js";
+} from "./chunk-DYUOXP5Q.js";
 import {
   PROVIDER_REGISTRY,
   missingCredentialMessage,
@@ -71,11 +82,11 @@ import {
 } from "./chunk-6LLJQ3KY.js";
 import {
   cliLogger
-} from "./chunk-2VXA7GZU.js";
+} from "./chunk-FU4GQ7K2.js";
 import {
   isPermissionMode,
   permissionModeLabel
-} from "./chunk-AGHVC2IJ.js";
+} from "./chunk-LBH5WVXU.js";
 import {
   probeCapabilities
 } from "./chunk-OH6TB27S.js";
@@ -86,7 +97,7 @@ import {
 import {
   conversationLogPath,
   ensureSessionStarted
-} from "./chunk-ABD2DOO2.js";
+} from "./chunk-EKUJUPFA.js";
 import {
   INSTRUCTIONS_FILENAME,
   MAX_CHARS_PER_FILE,
@@ -96,13 +107,13 @@ import {
 } from "./chunk-H6B6AROX.js";
 import {
   ensurePrivateStateDirectory
-} from "./chunk-WW4VKEBD.js";
+} from "./chunk-S6MZK4LD.js";
 import {
   restrictToOwner
-} from "./chunk-QQLB573I.js";
+} from "./chunk-BOV53LZO.js";
 import {
   namzuHomePath
-} from "./chunk-3OZ2OBGU.js";
+} from "./chunk-HKDPP2JF.js";
 import {
   AgentManager,
   AgentRegistry,
@@ -124,6 +135,7 @@ import {
   EXPLORE_AGENT_DESCRIPTION,
   EXPLORE_AGENT_ID,
   EXPLORE_AGENT_PROMPT,
+  FileWorkflowJournal,
   GitWorktreeDriver,
   GuardedFetchProvider,
   InMemorySessionLog,
@@ -156,6 +168,8 @@ import {
   TopicManager,
   TurnCancelled,
   WebFetchTool,
+  WorkflowRuntime,
+  WorkflowScriptError,
   WorkspaceBackendRegistry,
   abandonTurn,
   asSessionId,
@@ -213,6 +227,7 @@ import {
   mapTools,
   mcpJsonSchemaToZod,
   openSessionTokenBudget,
+  parseWorkflowMeta,
   query,
   readSessionLog,
   readyWhen,
@@ -230,9 +245,10 @@ import {
   toolset,
   untrustedEnvelopeBody,
   webGuidanceContribution,
+  windowsShellNotice,
   withProviderFallback,
   wrapUntrusted
-} from "./chunk-ZKTLXAQK.js";
+} from "./chunk-V3ZLK3XQ.js";
 import {
   __name
 } from "./chunk-76FLAFCG.js";
@@ -621,6 +637,7 @@ __name(isAuthoredSentence, "isAuthoredSentence");
 
 // src/tui/tidy-tool-output.ts
 import { stripVTControlCharacters } from "node:util";
+var BACKGROUND_NOTE = "Running in the background (\u2193 to manage)";
 function looksBinary(text) {
   if (text.includes("\0")) return true;
   if (text.length === 0) return false;
@@ -634,7 +651,8 @@ function looksBinary(text) {
 __name(looksBinary, "looksBinary");
 function tidyTerminalOutput(raw) {
   if (looksBinary(raw)) {
-    return { output: "The command printed binary data, which is not shown." };
+    const output2 = "The command printed binary data, which is not shown.";
+    return { output: output2, shell: { stdout: [], stderr: [], failed: false, note: output2 } };
   }
   let failure;
   const kept = [];
@@ -648,7 +666,18 @@ function tidyTerminalOutput(raw) {
     kept.push(line);
   }
   while (kept.length > 0 && kept[kept.length - 1]?.trim() === "") kept.pop();
-  return { output: kept.join("\n"), ...failure ? { failure } : {} };
+  const output = kept.join("\n");
+  const background = /^Started background job /.test(output);
+  const code = failure ? /\d+/.exec(failure)?.[0] : void 0;
+  const shell = {
+    stdout: background || output.length === 0 ? [] : kept,
+    stderr: [],
+    failed: failure !== void 0,
+    ...background ? { note: BACKGROUND_NOTE } : {},
+    ...failure ? { note: code ? `Exit code ${code}` : failure } : {},
+    ...failure && output.length > 0 && !background ? { status: code ? `Exit code ${code}` : failure } : {}
+  };
+  return { output, ...failure ? { failure } : {}, shell };
 }
 __name(tidyTerminalOutput, "tidyTerminalOutput");
 function shortCommand(command) {
@@ -684,21 +713,33 @@ function tidyCommandOutput(facts, raw) {
   const how = endedHow(facts);
   const label = shortCommand(facts.command);
   const failure = how ? label ? `Ran ${label} \xB7 ${how}` : `${how.charAt(0).toUpperCase()}${how.slice(1)}` : void 0;
-  const withFailure = /* @__PURE__ */ __name((output) => ({ output, ...failure ? { failure } : {} }), "withFailure");
+  const status = !how ? void 0 : facts.timedOut ? "Timed out" : facts.signal ? "Stopped before it finished" : `Exit code ${facts.exitCode}`;
+  const cell = /* @__PURE__ */ __name((stdout2, stderr2, note) => ({
+    stdout: stdout2,
+    stderr: stderr2,
+    failed: how !== void 0,
+    ...status && (stdout2.length > 0 || stderr2.length > 0) ? { status } : {},
+    ...status ? { note: status } : note ? { note } : {}
+  }), "cell");
+  const withFailure = /* @__PURE__ */ __name((output, shell) => ({
+    output,
+    ...failure ? { failure } : {},
+    shell
+  }), "withFailure");
   if (facts.binary) {
-    return withFailure(
-      `The command printed binary data (${formatSize(facts.binary.bytes)}), which is not shown.`
-    );
-  }
-  const streams = [facts.stdout, facts.stderr].filter(
-    (w) => w !== void 0 && w.totalBytes > 0
+    const sentence = `The command printed binary data (${formatSize(facts.binary.bytes)}), which is not shown.`;
+    return withFailure(sentence, cell([], [], sentence));
+  }
+  const clean = /* @__PURE__ */ __name((window) => window && window.totalBytes > 0 ? windowLines(window).map((line) => stripVTControlCharacters(line)) : [], "clean");
+  const stdout = clean(facts.stdout);
+  const stderr = clean(facts.stderr);
+  if (stdout.length > 0 || stderr.length > 0) {
+    return withFailure([...stdout, ...stderr].join("\n"), cell(stdout, stderr));
+  }
+  return withFailure(
+    tidyTerminalOutput(raw).output,
+    cell([], [], facts.background ? BACKGROUND_NOTE : void 0)
   );
-  if (streams.length > 0) {
-    return withFailure(
-      streams.flatMap(windowLines).map((line) => stripVTControlCharacters(line)).join("\n")
-    );
-  }
-  return withFailure(tidyTerminalOutput(raw).output);
 }
 __name(tidyCommandOutput, "tidyCommandOutput");
 function unknownToolNotice(result) {
@@ -822,14 +863,14 @@ function formatCompactCount(value) {
 __name(formatCompactCount, "formatCompactCount");
 
 // src/tui/web-activity.ts
-function webActivityKind(toolName) {
-  if (toolName === "web_search") return "search";
-  if (toolName === "web_fetch") return "fetch";
+function webActivityKind(toolName2) {
+  if (toolName2 === "web_search") return "search";
+  if (toolName2 === "web_fetch") return "fetch";
   return void 0;
 }
 __name(webActivityKind, "webActivityKind");
-function webActivityFromInput(toolName, input) {
-  const kind = webActivityKind(toolName);
+function webActivityFromInput(toolName2, input) {
+  const kind = webActivityKind(toolName2);
   if (!kind) return void 0;
   const field = kind === "search" ? "query" : "url";
   const value = input !== null && typeof input === "object" ? input[field] : void 0;
@@ -884,7 +925,7 @@ __name(oneLine, "oneLine");
 // src/tui/agent.ts
 import { SubprocessComputerUseHost } from "@namzu/computer-use";
 import { realpath as realpath4, stat as stat4 } from "node:fs/promises";
-import { parse, resolve as resolve8 } from "node:path";
+import { join as join13, parse, resolve as resolve8 } from "node:path";
 
 // src/checkpoints/store.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -4658,6 +4699,27 @@ var SubagentActivityMonitor = class {
   getNarration() {
     return [...this.narration];
   }
+  /**
+   * The cheap facts a progress line needs about one child, without copying
+   * its transcript: spend, tool executions and the tool it ran last.
+   */
+  progressOf(viewId) {
+    const record = this.records.get(viewId);
+    if (!record) return void 0;
+    let lastTool;
+    for (let index = record.rows.length - 1; index >= 0; index -= 1) {
+      const row = record.rows[index];
+      if (row?.kind === "tool") {
+        lastTool = row.text;
+        break;
+      }
+    }
+    return {
+      ...record.tokens !== void 0 ? { tokens: record.tokens } : {},
+      ...record.toolCalls !== void 0 ? { toolCalls: record.toolCalls } : {},
+      ...lastTool !== void 0 ? { lastTool } : {}
+    };
+  }
   getSnapshot() {
     return [...this.records.values()].sort((left, right) => {
       const live = Number(isTerminal(left.status)) - Number(isTerminal(right.status));
@@ -5745,6 +5807,7 @@ var SUBAGENT_PROMPT = [
   // the parent does not is the same defect in the other direction.
   CODING_AGENT_WORKING_DOCTRINE
 ].join("\n");
+var WORKFLOW_RUN_GROUP_PREFIX = "wf:";
 var ParentTaskScheduler = class extends LocalTaskScheduler {
   constructor(manager, context, onEvent, validateParent) {
     super(manager, context, onEvent);
@@ -6040,6 +6103,194 @@ async function createSubagentRuntime(opts) {
   }, "completionInboxForTurn");
   const activity = new SubagentActivityMonitor();
   let dynCounter = 0;
+  const launchChild = /* @__PURE__ */ __name(async (input, context, hooks = {}) => {
+    const {
+      description,
+      prompt,
+      subagent_type,
+      role,
+      workflow,
+      phase,
+      phase_order,
+      phase_detail,
+      run_in_background,
+      workspace,
+      model: requestedModel,
+      provider: requestedProvider,
+      effort: requestedEffort
+    } = input;
+    if (!requestedModel && (requestedProvider || requestedEffort))
+      throw new Error("Supply model when selecting a child provider or effort.");
+    const explore = subagent_type === EXPLORE_SUBAGENT;
+    const fileAgent = subagent_type !== void 0 ? fileAgents.get(subagent_type) : void 0;
+    const inherited = opts.resolveTurnModel?.(context.turnId);
+    const parentModel = inherited?.model ?? opts.model;
+    const selects = requestedModel !== void 0 && (requestedModel !== parentModel || requestedProvider !== void 0 || requestedEffort !== void 0 || fileAgent?.model !== void 0 && fileAgent.model !== parentModel);
+    if (selects && !opts.resolveModel)
+      throw new Error("Child model selection is unavailable in this host.");
+    const selection = selects ? await opts.resolveModel?.(
+      {
+        model: requestedModel,
+        provider: requestedProvider,
+        effort: requestedEffort
+      },
+      context.abortSignal
+    ) : (
+      // A file agent that pins its own model keeps it; any other child
+      // of a turn on another model than the session's runs on that one.
+      fileAgent?.model === void 0 ? inherited : void 0
+    );
+    let agentId = fileAgent?.name ?? (explore ? EXPLORE_SUBAGENT : GENERAL_PURPOSE_SUBAGENT);
+    const persona = typeof role === "string" ? role.trim() : "";
+    const dynamic = persona.length > 0 || selection !== void 0;
+    if (dynamic) {
+      agentId = `dyn-${++dynCounter}`;
+      registry.register(
+        buildDefinition(
+          agentId,
+          `Dynamic specialist: ${agentId}`,
+          fileAgent ? `${fileAgent.prompt}
+
+${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
+          opts,
+          fileAgent ? fileAgentTools(fileAgent, opts) : explore ? () => opts.buildTools().map(
+            (ts) => filtered(
+              ts,
+              (tool) => isTrustedReadOnly(tool, void 0, toToolSourceRef(ts.source))
+            )
+          ) : opts.buildTools,
+          selection?.model ?? fileAgent?.model ?? parentModel,
+          selection
+        )
+      );
+    }
+    const seed = {
+      agentId,
+      model: selection?.model ?? fileAgent?.model ?? parentModel,
+      description,
+      prompt,
+      batchId: context.toolBatchId,
+      toolUseId: context.toolUseId,
+      workflowId: hooks.workflowId ?? String(context.turnId),
+      workflow,
+      phase,
+      phaseOrder: phase_order,
+      phaseDetail: phase_detail
+    };
+    const tracker = activity.begin(seed);
+    hooks.onView?.(tracker.viewId);
+    const resumeHandler = opts.resolveResumeHandler?.(context.turnId) ?? refuseUnownedChildReview;
+    const configOverrides = {
+      ...resolveTurnGuards(opts, opts.resolveLimits?.(context.turnId)),
+      ...selection ? { model: selection.model, effort: selection.effort } : {},
+      ...Object.keys(context.env ?? {}).length > 0 ? { env: context.env } : {},
+      // The parent turn's tool-result screens, so a sub-agent judges a
+      // connected answer the way the turn that asked for the work
+      // does. Without it the child's executor installs the shipped
+      // default, and `toolResultScreens: []` — the operator's off
+      // switch — would hold for the parent and not for anything it
+      // delegated to, which is the half an operator does not watch.
+      //
+      // `[]` is carried rather than skipped: empty is a decision, and
+      // a `length` test — which is the shape that gets this wrong,
+      // since `[]` is truthy — would turn it back into absent.
+      ...context.toolResultGuardrails ? { toolResultGuardrails: context.toolResultGuardrails } : {},
+      resumeHandler
+    };
+    let taskOwnsCleanup = false;
+    let retained;
+    const cleanupDefinition = /* @__PURE__ */ __name(() => {
+      if (dynamic && !retained) registry.unregister(agentId);
+    }, "cleanupDefinition");
+    try {
+      const parentKey = sessionKey(await resolveParent(context.turnId));
+      const gateway = await gatewayForTurn(context.turnId);
+      const completionInbox = await completionInboxForTurn(context.turnId);
+      const subdirectory = workspace === "worktree" ? await worktreeDriver.selectedSubdirectory() : void 0;
+      const outcome = await runBlockingAgentTask({
+        gateway: await gatewayForTurn(context.turnId),
+        signal: context.abortSignal,
+        waitForInbound: opts.resolveWaitForInbound?.(context.turnId),
+        background: run_in_background === true,
+        ...hooks.cancelCause ? { cancelCause: hooks.cancelCause } : {},
+        completionInbox,
+        onCreated: /* @__PURE__ */ __name((task) => {
+          taskOwnsCleanup = true;
+          retained = {
+            parentKey,
+            agentId,
+            dynamic,
+            seed,
+            config: {
+              ...selection ? { model: selection.model, effort: selection.effort } : {},
+              ...configOverrides.env ? { env: configOverrides.env } : {},
+              ...configOverrides.toolResultGuardrails ? {
+                toolResultGuardrails: configOverrides.toolResultGuardrails
+              } : {}
+            },
+            workspace: workspace ?? "shared",
+            gateway,
+            task,
+            turnId: context.turnId,
+            busy: false
+          };
+          conversations.set(tracker.viewId, retained);
+          const visible = new Set(activity.getSnapshot().map((value) => value.viewId));
+          for (const [id, previous] of conversations) {
+            if (visible.has(id) || previous.busy || !isTerminalAgentTaskState(previous.task.state))
+              continue;
+            conversations.delete(id);
+            if (previous.dynamic) registry.unregister(previous.agentId);
+          }
+          tracker.settle(task);
+        }, "onCreated"),
+        onSettled: /* @__PURE__ */ __name((completed) => {
+          if (retained) retained.task = completed;
+          tracker.settle(completed);
+        }, "onSettled"),
+        onFailed: /* @__PURE__ */ __name((error) => tracker.fail(error), "onFailed"),
+        onFinished: cleanupDefinition,
+        create: {
+          agentId,
+          prompt,
+          workingDirectory: opts.cwd,
+          workspace: workspace === "worktree" ? {
+            mode: "isolated",
+            backend: "git-worktree",
+            retention: "retain",
+            ...subdirectory ? { subdirectory } : {}
+          } : { mode: "shared" },
+          // The same labels the monitor was seeded with, sent down so the
+          // child's `agent_pending` carries them: a listener or SSE
+          // consumer outside this process then groups the child the way
+          // the operator sees it here, instead of the grouping living
+          // only in the closure above. Display-only on both paths — no
+          // dependency, barrier or serial execution follows from any.
+          ...workflow ? { workflow } : {},
+          ...phase ? { phase } : {},
+          ...phase_detail ? { phaseDetail: phase_detail } : {},
+          ...phase_order !== void 0 ? { phaseOrder: phase_order } : {},
+          // Hang the child session off THIS tool's span, so the delegation
+          // shows up inside the turn that asked for it. Without it a
+          // sub-agent opens its OWN root trace, and the one structure
+          // a delegation trace exists to record — who dispatched whom
+          // — is the thing that goes missing.
+          ...context.parentSpan ? { parentSpan: context.parentSpan } : {},
+          configOverrides,
+          onEvent: hooks.onEvent ? (event) => {
+            tracker.onEvent(event);
+            hooks.onEvent?.(event);
+          } : tracker.onEvent
+        }
+      });
+      return { outcome, agentId };
+    } catch (error) {
+      tracker.fail(error);
+      throw error;
+    } finally {
+      if (!taskOwnsCleanup) cleanupDefinition();
+    }
+  }, "launchChild");
   const agentTool = defineTool({
     name: "Agent",
     description: [
@@ -6053,7 +6304,7 @@ async function createSubagentRuntime(opts) {
       "Omit `role` for the plain sub-agent.",
       "The sub-agent runs in its own context with its own tools and cannot see this conversation \u2014 put everything it needs in `prompt`.",
       "Call this multiple times in one response to run specialists in parallel. Tasks beyond the project's live-agent capacity wait in a queue and start as slots become available. Queued tasks have not started execution; do not relaunch them.",
-      "When coordinating several specialists, give them the same `workflow` label and an explicit `phase` plus `phase_order` so the operator can follow the work in the agent cockpit.",
+      "When coordinating several specialists, give them the same `workflow` label and an explicit `phase` plus `phase_order` so the operator can follow the work in the agent cockpit. For work with several phases or many agents, use the `workflow` tool instead when it is in your tool list, and keep these labels for a small fan-out.",
       "These fields are display annotations only; they do not create dependencies, barriers, or serial execution.",
       fileAgentSummary.length > 0 ? `Project-defined types: ${fileAgentSummary}.` : ""
     ].filter((part) => part.length > 0).join(" "),
@@ -6137,202 +6388,116 @@ async function createSubagentRuntime(opts) {
     concurrencySafe: true,
     timeoutMs: opts.resolveLimits ? 0 : opts.timeoutMs ?? CLI_INTERACTIVE_TURN_TIMEOUT_MS,
     async execute(input, context) {
-      const {
-        description,
-        prompt,
-        subagent_type,
-        role,
-        workflow,
-        phase,
-        phase_order,
-        phase_detail,
-        run_in_background,
-        workspace,
-        model: requestedModel,
-        provider: requestedProvider,
-        effort: requestedEffort
-      } = input;
-      if (!requestedModel && (requestedProvider || requestedEffort))
-        throw new Error("Supply model when selecting a child provider or effort.");
-      const explore = subagent_type === EXPLORE_SUBAGENT;
-      const fileAgent = subagent_type !== void 0 ? fileAgents.get(subagent_type) : void 0;
-      const inherited = opts.resolveTurnModel?.(context.turnId);
-      const parentModel = inherited?.model ?? opts.model;
-      const selects = requestedModel !== void 0 && (requestedModel !== parentModel || requestedProvider !== void 0 || requestedEffort !== void 0 || fileAgent?.model !== void 0 && fileAgent.model !== parentModel);
-      if (selects && !opts.resolveModel)
-        throw new Error("Child model selection is unavailable in this host.");
-      const selection = selects ? await opts.resolveModel?.(
+      const { description, run_in_background } = input;
+      const { outcome, agentId } = await launchChild(input, context);
+      if (outcome.kind === "yielded") {
+        const progress = outcome.handle.state === "pending" ? "queued for an available slot" : "still running";
+        return {
+          success: true,
+          output: `Sub-agent ${agentId} for task ${JSON.stringify(description)} is ${progress} as task ${outcome.handle.taskId}; it has not completed.${workspaceNote(outcome.handle)} ${run_in_background ? "Continue independent work while this task runs in the background." : "Waiting was released because the operator sent a message. Answer their question or status request before making further tool calls; preserve existing work unless they ask to cancel or change it."} Its actual result will arrive as a task notification; do not launch the same work again.`,
+          data: {
+            task_id: outcome.handle.taskId,
+            state: outcome.handle.state,
+            ...workspaceData(outcome.handle),
+            wait_released: run_in_background ? "background" : "operator_input"
+          }
+        };
+      }
+      return completedAgentResult(outcome.handle);
+    }
+  });
+  const launchWorkflowAgent = /* @__PURE__ */ __name(async (launch) => {
+    if (launch.agentType !== void 0 && !agentTypeIds.includes(launch.agentType)) {
+      throw new Error(
+        `Unknown agent type "${launch.agentType}". Available: ${agentTypeIds.join(", ")}.`
+      );
+    }
+    if (launch.effort !== void 0 && launch.model === void 0) {
+      throw new Error("Supply model when selecting an agent effort.");
+    }
+    const prompt = launch.schema === void 0 ? launch.prompt : `${launch.prompt}
+
+Answer with one JSON value that satisfies this JSON Schema and nothing else:
+${JSON.stringify(launch.schema)}`;
+    const label = launch.workflowName === DEFAULT_AGENT_WORKFLOW ? "Workflow" : launch.workflowName;
+    let viewId;
+    let lastReport = 0;
+    const report = /* @__PURE__ */ __name((force) => {
+      if (!viewId || !launch.onProgress) return;
+      const at = Date.now();
+      if (!force && at - lastReport < 250) return;
+      lastReport = at;
+      const progress = activity.progressOf(viewId);
+      if (progress) launch.onProgress(progress);
+    }, "report");
+    try {
+      const { outcome } = await launchChild(
         {
-          model: requestedModel,
-          provider: requestedProvider,
-          effort: requestedEffort
+          description: launch.label,
+          prompt,
+          run_in_background: false,
+          ...launch.agentType !== void 0 ? { subagent_type: launch.agentType } : {},
+          ...launch.model !== void 0 ? { model: launch.model } : {},
+          ...launch.effort !== void 0 ? { effort: launch.effort } : {},
+          workflow: label,
+          ...launch.phaseTitle !== void 0 ? { phase: launch.phaseTitle } : {},
+          ...launch.phaseIndex !== void 0 ? { phase_order: launch.phaseIndex } : {},
+          ...launch.phaseDetail !== void 0 ? { phase_detail: launch.phaseDetail } : {}
         },
-        context.abortSignal
-      ) : (
-        // A file agent that pins its own model keeps it; any other child
-        // of a turn on another model than the session's runs on that one.
-        fileAgent?.model === void 0 ? inherited : void 0
+        {
+          turnId: launch.turnId,
+          abortSignal: launch.signal,
+          toolBatchId: launch.runId,
+          ...launch.inherit?.env ? { env: launch.inherit.env } : {},
+          ...launch.inherit?.toolResultGuardrails ? { toolResultGuardrails: launch.inherit.toolResultGuardrails } : {}
+        },
+        {
+          workflowId: `${WORKFLOW_RUN_GROUP_PREFIX}${launch.runId}`,
+          cancelCause: "user",
+          onView: /* @__PURE__ */ __name((id) => {
+            viewId = id;
+            launch.onView?.(id);
+          }, "onView"),
+          onEvent: /* @__PURE__ */ __name(() => report(false), "onEvent")
+        }
       );
-      let agentId = fileAgent?.name ?? (explore ? EXPLORE_SUBAGENT : GENERAL_PURPOSE_SUBAGENT);
-      const persona = typeof role === "string" ? role.trim() : "";
-      const dynamic = persona.length > 0 || selection !== void 0;
-      if (dynamic) {
-        agentId = `dyn-${++dynCounter}`;
-        registry.register(
-          buildDefinition(
-            agentId,
-            `Dynamic specialist: ${agentId}`,
-            fileAgent ? `${fileAgent.prompt}
-
-${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
-            opts,
-            fileAgent ? fileAgentTools(fileAgent, opts) : explore ? () => opts.buildTools().map(
-              (ts) => filtered(
-                ts,
-                (tool) => isTrustedReadOnly(tool, void 0, toToolSourceRef(ts.source))
-              )
-            ) : opts.buildTools,
-            selection?.model ?? fileAgent?.model ?? parentModel,
-            selection
-          )
-        );
+      report(true);
+      const stats = viewId ? activity.progressOf(viewId) : void 0;
+      const tokens = stats?.tokens ?? 0;
+      const toolCalls = stats?.toolCalls ?? 0;
+      if (outcome.kind !== "completed") {
+        return {
+          state: "error",
+          tokens,
+          toolCalls,
+          error: "The agent did not finish."
+        };
       }
-      const seed = {
-        agentId,
-        model: selection?.model ?? fileAgent?.model ?? parentModel,
-        description,
-        prompt,
-        batchId: context.toolBatchId,
-        toolUseId: context.toolUseId,
-        workflowId: String(context.turnId),
-        workflow,
-        phase,
-        phaseOrder: phase_order,
-        phaseDetail: phase_detail
-      };
-      const tracker = activity.begin(seed);
-      const resumeHandler = opts.resolveResumeHandler?.(context.turnId) ?? refuseUnownedChildReview;
-      const configOverrides = {
-        ...resolveTurnGuards(opts, opts.resolveLimits?.(context.turnId)),
-        ...selection ? { model: selection.model, effort: selection.effort } : {},
-        ...Object.keys(context.env ?? {}).length > 0 ? { env: context.env } : {},
-        // The parent turn's tool-result screens, so a sub-agent judges a
-        // connected answer the way the turn that asked for the work
-        // does. Without it the child's executor installs the shipped
-        // default, and `toolResultScreens: []` — the operator's off
-        // switch — would hold for the parent and not for anything it
-        // delegated to, which is the half an operator does not watch.
-        //
-        // `[]` is carried rather than skipped: empty is a decision, and
-        // a `length` test — which is the shape that gets this wrong,
-        // since `[]` is truthy — would turn it back into absent.
-        ...context.toolResultGuardrails ? { toolResultGuardrails: context.toolResultGuardrails } : {},
-        resumeHandler
-      };
-      let taskOwnsCleanup = false;
-      let retained;
-      const cleanupDefinition = /* @__PURE__ */ __name(() => {
-        if (dynamic && !retained) registry.unregister(agentId);
-      }, "cleanupDefinition");
-      try {
-        const parentKey = sessionKey(await resolveParent(context.turnId));
-        const gateway = await gatewayForTurn(context.turnId);
-        const completionInbox = await completionInboxForTurn(context.turnId);
-        const subdirectory = workspace === "worktree" ? await worktreeDriver.selectedSubdirectory() : void 0;
-        const outcome = await runBlockingAgentTask({
-          gateway: await gatewayForTurn(context.turnId),
-          signal: context.abortSignal,
-          waitForInbound: opts.resolveWaitForInbound?.(context.turnId),
-          background: run_in_background === true,
-          completionInbox,
-          onCreated: /* @__PURE__ */ __name((task) => {
-            taskOwnsCleanup = true;
-            retained = {
-              parentKey,
-              agentId,
-              dynamic,
-              seed,
-              config: {
-                ...selection ? { model: selection.model, effort: selection.effort } : {},
-                ...configOverrides.env ? { env: configOverrides.env } : {},
-                ...configOverrides.toolResultGuardrails ? {
-                  toolResultGuardrails: configOverrides.toolResultGuardrails
-                } : {}
-              },
-              workspace: workspace ?? "shared",
-              gateway,
-              task,
-              turnId: context.turnId,
-              busy: false
-            };
-            conversations.set(tracker.viewId, retained);
-            const visible = new Set(activity.getSnapshot().map((value) => value.viewId));
-            for (const [id, previous] of conversations) {
-              if (visible.has(id) || previous.busy || !isTerminalAgentTaskState(previous.task.state))
-                continue;
-              conversations.delete(id);
-              if (previous.dynamic) registry.unregister(previous.agentId);
-            }
-            tracker.settle(task);
-          }, "onCreated"),
-          onSettled: /* @__PURE__ */ __name((completed) => {
-            if (retained) retained.task = completed;
-            tracker.settle(completed);
-          }, "onSettled"),
-          onFailed: /* @__PURE__ */ __name((error) => tracker.fail(error), "onFailed"),
-          onFinished: cleanupDefinition,
-          create: {
-            agentId,
-            prompt,
-            workingDirectory: opts.cwd,
-            workspace: workspace === "worktree" ? {
-              mode: "isolated",
-              backend: "git-worktree",
-              retention: "retain",
-              ...subdirectory ? { subdirectory } : {}
-            } : { mode: "shared" },
-            // The same labels the monitor was seeded with, sent down so the
-            // child's `agent_pending` carries them: a listener or SSE
-            // consumer outside this process then groups the child the way
-            // the operator sees it here, instead of the grouping living
-            // only in the closure above. Display-only on both paths — no
-            // dependency, barrier or serial execution follows from any.
-            ...workflow ? { workflow } : {},
-            ...phase ? { phase } : {},
-            ...phase_detail ? { phaseDetail: phase_detail } : {},
-            ...phase_order !== void 0 ? { phaseOrder: phase_order } : {},
-            // Hang the child session off THIS tool's span, so the delegation
-            // shows up inside the turn that asked for it. Without it a
-            // sub-agent opens its OWN root trace, and the one structure
-            // a delegation trace exists to record — who dispatched whom
-            // — is the thing that goes missing.
-            ...context.parentSpan ? { parentSpan: context.parentSpan } : {},
-            configOverrides,
-            onEvent: tracker.onEvent
-          }
-        });
-        if (outcome.kind === "yielded") {
-          const progress = outcome.handle.state === "pending" ? "queued for an available slot" : "still running";
-          return {
-            success: true,
-            output: `Sub-agent ${agentId} for task ${JSON.stringify(description)} is ${progress} as task ${outcome.handle.taskId}; it has not completed.${workspaceNote(outcome.handle)} ${run_in_background ? "Continue independent work while this task runs in the background." : "Waiting was released because the operator sent a message. Answer their question or status request before making further tool calls; preserve existing work unless they ask to cancel or change it."} Its actual result will arrive as a task notification; do not launch the same work again.`,
-            data: {
-              task_id: outcome.handle.taskId,
-              state: outcome.handle.state,
-              ...workspaceData(outcome.handle),
-              wait_released: run_in_background ? "background" : "operator_input"
-            }
-          };
-        }
-        return completedAgentResult(outcome.handle);
-      } catch (error) {
-        tracker.fail(error);
-        throw error;
-      } finally {
-        if (!taskOwnsCleanup) cleanupDefinition();
+      const handle = outcome.handle;
+      const status = agentTaskOutcome(handle);
+      const turn = handle.result;
+      const value = turn?.structuredOutput ?? turn?.result;
+      const text = typeof value === "string" ? value : value === void 0 ? "" : JSON.stringify(value);
+      if (status !== "completed") {
+        return {
+          state: "error",
+          tokens,
+          toolCalls,
+          error: `The agent ended as ${status}${turn?.lastError ? `: ${turn.lastError}` : "."}`
+        };
       }
+      return { state: "done", text, tokens, toolCalls };
+    } catch (error) {
+      if (launch.signal.aborted) throw error;
+      const stats = viewId ? activity.progressOf(viewId) : void 0;
+      return {
+        state: "error",
+        tokens: stats?.tokens ?? 0,
+        toolCalls: stats?.toolCalls ?? 0,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
-  });
+  }, "launchWorkflowAgent");
   const agentTaskListTool = defineTool({
     name: "agent_task_list",
     description: "List the agent invocations launched by this turn and their current status, without waiting or starting work. Use this for agent progress questions. task_list contains planning items, not agent invocations. Use wait_for_task with a live ID for its result. Set history: true to inspect agents saved from earlier turns of this conversation, optionally session_id for one saved result; saved agents are not live.",
@@ -6406,7 +6571,7 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
       properties: {
         task_id: {
           type: "string",
-          description: "The task_id from the Agent launch receipt or task notification metadata."
+          description: "The task_id from the Agent launch receipt or task notification metadata. A workflow run id is not a task id."
         }
       },
       required: ["task_id"]
@@ -6420,8 +6585,16 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
     async execute(input, context) {
       const gateway = await gatewayForTurn(context.turnId);
       let taskId;
+      const asked = input.task_id;
+      if (typeof asked === "string" && /^w[0-9a-z]{8}$/.test(asked.trim())) {
+        return {
+          success: true,
+          output: `${asked.trim()} is a workflow run, not a task, so there is nothing to wait for here. You get one message when it ends, with what it returned. End your turn or do other work; do not call wait_for_task for it.`,
+          data: { run_id: asked.trim(), waited: false }
+        };
+      }
       try {
-        taskId = asTaskId(input.task_id);
+        taskId = asTaskId(asked);
       } catch {
         return {
           success: false,
@@ -6819,10 +6992,21 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
       };
     }
   }) : void 0;
+  const stopChild = /* @__PURE__ */ __name((viewId) => {
+    if (closed) return false;
+    const owned = conversations.get(viewId);
+    const shown = activity.getSnapshot().find((value) => value.viewId === viewId);
+    if (!owned || !shown || shown.replayed) return false;
+    const current = owned.gateway.getTask(owned.task.taskId) ?? owned.task;
+    if (isTerminalAgentTaskState(current.state)) return false;
+    owned.gateway.cancelTask(owned.task.taskId, "user");
+    return true;
+  }, "stopChild");
   return {
     cancelAgentTool,
     modelCatalogueTool,
     messageChild,
+    stopChild,
     gatewayForTurn,
     completionInboxForTurn,
     releaseTurn,
@@ -6846,6 +7030,7 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
       return type === EXPLORE_SUBAGENT;
     },
     activity,
+    launchWorkflowAgent,
     close
   };
 }
@@ -6866,7 +7051,7 @@ async function runBlockingAgentTask(input) {
     if (taskCancellationAttempted) return;
     taskCancellationAttempted = true;
     try {
-      gateway.cancelTask(task.taskId, "parent");
+      gateway.cancelTask(task.taskId, input.cancelCause ?? "parent");
     } catch {
     }
   }, "cancel");
@@ -7063,9 +7248,465 @@ ${SUBAGENT_PROMPT}`;
 }
 __name(buildDefinition, "buildDefinition");
 
+// src/integrations/workflows/doctrine.ts
+var WORKFLOW_DOCTRINE = [
+  "The `workflow` tool is available this turn because the operator asked for orchestration.",
+  "Use it for work with several phases or many agents: write the script once, call `workflow`, and the runtime schedules the agents and groups them by phase. Keep `Agent` calls (with a `workflow` label and a `phase`) for a small fan-out of a few agents, and for a single subagent.",
+  "A workflow runs in the background and the operator approves the script before it starts. After you start one, tell the operator in one sentence that it is running; its result reaches you in a single message when it ends, and you then report the outcome."
+].join("\n");
+
+// src/integrations/workflows/history.ts
+import { readFile as readFile3, readdir as readdir2 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+var RUN_ID = /^w[0-9a-z]{8}$/;
+async function readWorkflowJournal(file) {
+  let text;
+  try {
+    text = await readFile3(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const records = [];
+  for (const line of text.split("\n")) {
+    if (line.trim().length === 0) continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed === "object" && parsed !== null && "type" in parsed) {
+        records.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return records;
+}
+__name(readWorkflowJournal, "readWorkflowJournal");
+async function readWorkflowRun(runsDirectory, runId) {
+  if (!RUN_ID.test(runId)) return void 0;
+  const records = await readWorkflowJournal(join8(runsDirectory, runId, "workflow", "journal.jsonl"));
+  return viewFromJournal(records);
+}
+__name(readWorkflowRun, "readWorkflowRun");
+async function listWorkflowRuns(runsDirectory) {
+  let entries;
+  try {
+    entries = await readdir2(runsDirectory);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const views = await Promise.all(
+    entries.filter((name) => RUN_ID.test(name)).map((name) => readWorkflowRun(runsDirectory, name))
+  );
+  return views.filter((view) => view !== void 0).sort((a, b) => b.startedAt - a.startedAt);
+}
+__name(listWorkflowRuns, "listWorkflowRuns");
+
+// src/integrations/workflows/host.ts
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { join as join9 } from "node:path";
+
+// src/integrations/workflows/registry.ts
+var WorkflowRunRegistry = class {
+  static {
+    __name(this, "WorkflowRunRegistry");
+  }
+  runs = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  runtime;
+  now;
+  notifyTimer;
+  closed = false;
+  constructor(options = {}) {
+    this.now = options.now ?? Date.now;
+    this.runtime = options.runtime ?? new WorkflowRuntime();
+  }
+  list() {
+    return [...this.runs.values()].map((run2) => run2.view);
+  }
+  get(runId) {
+    return this.runs.get(runId)?.view;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Runs that have not ended. */
+  running() {
+    return this.list().filter((view) => view.status === "running");
+  }
+  /** Begin a run. Returns at once; the run goes on in the background. */
+  start(input) {
+    if (this.closed) throw new Error("Workflows are closed for this session.");
+    const run2 = {
+      view: initialRunView({
+        runId: input.runId,
+        name: input.meta.name,
+        description: input.meta.description,
+        phases: input.meta.phases,
+        at: this.now()
+      }),
+      abort: new AbortController(),
+      finalized: false
+    };
+    this.runs.set(input.runId, run2);
+    this.notifySoon(true);
+    let firstAgentSeen = false;
+    const settle = /* @__PURE__ */ __name(async (result, error) => {
+      const at = this.now();
+      if (run2.view.status === "running") {
+        run2.view = {
+          ...run2.view,
+          status: run2.abort.signal.aborted ? "stopped" : "failed",
+          endedAt: at,
+          ...error !== void 0 ? { error } : {}
+        };
+      }
+      run2.view = closeOpenAgents(run2.view, at);
+      try {
+        await input.onEnd?.({ view: run2.view, ...result ? { result } : {} });
+      } catch {
+      }
+      run2.finalized = true;
+      this.notifySoon(true);
+    }, "settle");
+    void this.runtime.run({
+      script: input.script,
+      ...input.args !== void 0 ? { args: input.args } : {},
+      ...input.limits ? { limits: input.limits } : {},
+      ...input.journal ? { journal: input.journal } : {},
+      runId: input.runId,
+      signal: run2.abort.signal,
+      onControl: /* @__PURE__ */ __name((control) => {
+        run2.control = control;
+      }, "onControl"),
+      onEvent: /* @__PURE__ */ __name((event) => {
+        run2.view = reduceRunView(run2.view, event);
+        if (event.type === "workflow_agent" && !firstAgentSeen) {
+          firstAgentSeen = true;
+          input.onFirstAgent?.();
+        }
+        this.notifySoon(event.type !== "workflow_agent" || event.state !== "progress");
+      }, "onEvent"),
+      spawnAgent: /* @__PURE__ */ __name((request, signal) => input.spawn(request, signal, (viewId) => {
+        run2.view = attachAgentView(run2.view, request.index, viewId);
+        this.notifySoon(false);
+      }), "spawnAgent")
+    }).then(
+      (result) => settle(result),
+      (error) => settle(void 0, error instanceof Error ? error.message : String(error))
+    );
+    return run2.view;
+  }
+  /**
+   * Resolves once no run is going, or when `signal` aborts (whichever is first).
+   * A run's own limits bound the wait: the runtime stops one at its duration cap.
+   */
+  whenIdle(signal) {
+    const going = /* @__PURE__ */ __name(() => [...this.runs.values()].some((run2) => !run2.finalized), "going");
+    if (!going() || signal?.aborted) return Promise.resolve();
+    return new Promise((resolve9) => {
+      const done = /* @__PURE__ */ __name(() => {
+        off();
+        signal?.removeEventListener("abort", done);
+        resolve9();
+      }, "done");
+      const off = this.subscribe(() => {
+        if (!going()) done();
+      });
+      signal?.addEventListener("abort", done, { once: true });
+    });
+  }
+  /** Stop a run: queued agents never start, running ones are aborted. False when it is not running. */
+  stop(runId) {
+    const run2 = this.runs.get(runId);
+    if (!run2 || run2.view.status !== "running") return false;
+    run2.abort.abort(new Error("The operator stopped this workflow."));
+    return true;
+  }
+  /** Skip one agent of a run. False when it is not running or already settled. */
+  skipAgent(runId, index) {
+    const run2 = this.runs.get(runId);
+    if (!run2 || run2.view.status !== "running") return false;
+    return run2.control?.skipAgent(index) ?? false;
+  }
+  /** Which run and agent a monitor row stands for, if any. */
+  agentOf(viewId) {
+    for (const run2 of this.runs.values()) {
+      const agent = run2.view.agents.find((item) => item.viewId === viewId);
+      if (agent) return { runId: run2.view.runId, index: agent.index };
+    }
+    return void 0;
+  }
+  /**
+   * Forget one run that has ended, so nothing lists it. For a run the tool
+   * answered inline: it never became background work. False when the run is
+   * unknown or still going.
+   */
+  discard(runId) {
+    const run2 = this.runs.get(runId);
+    if (!run2 || run2.view.status === "running") return false;
+    this.runs.delete(runId);
+    this.notifySoon(true);
+    return true;
+  }
+  /** Forget runs that have ended (a new conversation). Running ones are stopped first. */
+  reset() {
+    for (const run2 of this.runs.values()) run2.abort.abort(new Error("The conversation changed."));
+    this.runs.clear();
+    this.notifySoon(true);
+  }
+  close() {
+    this.closed = true;
+    for (const run2 of this.runs.values()) run2.abort.abort(new Error("The session ended."));
+    if (this.notifyTimer) clearTimeout(this.notifyTimer);
+    this.notifyTimer = void 0;
+    this.listeners.clear();
+  }
+  notifySoon(now) {
+    if (this.closed) return;
+    if (now) {
+      if (this.notifyTimer) clearTimeout(this.notifyTimer);
+      this.notifyTimer = void 0;
+      for (const listener of [...this.listeners]) listener();
+      return;
+    }
+    if (this.notifyTimer) return;
+    this.notifyTimer = setTimeout(() => {
+      this.notifyTimer = void 0;
+      for (const listener of [...this.listeners]) listener();
+    }, 100);
+    this.notifyTimer.unref?.();
+  }
+};
+
+// src/integrations/workflows/host.ts
+var MAX_WORKFLOW_SCRIPT_CHARS = 262144;
+var MAX_WORKFLOW_ARGS_CHARS = 65536;
+var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+function createWorkflowRunId(isTaken = () => false) {
+  for (; ; ) {
+    let body = "";
+    while (body.length < 8) {
+      for (const byte of randomBytes3(16)) {
+        if (byte >= 252) continue;
+        body += ALPHABET[byte % 36];
+        if (body.length === 8) break;
+      }
+    }
+    const id = `w${body}`;
+    if (!isTaken(id)) return id;
+  }
+}
+__name(createWorkflowRunId, "createWorkflowRunId");
+function endedBeforeAgents(end, noArgs) {
+  const { view } = end;
+  if (view.status === "completed") {
+    return {
+      success: true,
+      output: completionNotice(view),
+      data: { run_id: view.runId, name: view.name, status: "completed", inline: true }
+    };
+  }
+  const reason = view.error ?? "no reason was given";
+  const hint = view.status === "failed" && noArgs ? '\nThis call passed no "args", so `args` was undefined in the script.' : "";
+  return {
+    success: false,
+    output: "",
+    error: view.status === "stopped" ? `Workflow "${view.name}" was stopped before it started any agent${view.error ? `: ${reason}` : "."}` : `${reason}${hint}`
+  };
+}
+__name(endedBeforeAgents, "endedBeforeAgents");
+function toolName(label) {
+  if (!label) return { name: "tool" };
+  const open3 = label.indexOf("(");
+  return open3 > 0 ? { name: label.slice(0, open3), summary: label } : { name: label, summary: label };
+}
+__name(toolName, "toolName");
+function describeWorkflowCall(input) {
+  if (typeof input.description === "string" && input.description.trim().length > 0) {
+    return input.description.trim().replace(/\s+/g, " ");
+  }
+  if (typeof input.script === "string") {
+    try {
+      return parseWorkflowMeta(input.script).description.replace(/\s+/g, " ");
+    } catch {
+      const first = input.script.split("\n").find((line) => line.trim().length > 0);
+      if (first) return first.trim().slice(0, 80);
+    }
+  }
+  return "workflow";
+}
+__name(describeWorkflowCall, "describeWorkflowCall");
+function createWorkflowHost(options) {
+  const registry = options.registry ?? new WorkflowRunRegistry();
+  const tool = defineTool({
+    name: WORKFLOW_TOOL_NAME,
+    description: WORKFLOW_TOOL_DESCRIPTION,
+    inputSchema: mcpJsonSchemaToZod({
+      type: "object",
+      properties: {
+        script: {
+          type: "string",
+          maxLength: MAX_WORKFLOW_SCRIPT_CHARS,
+          description: "The workflow script: `export const meta = {...}` first, then the code. Plain JavaScript, not wrapped in a function or a code fence."
+        },
+        args: {
+          description: "JSON the script reads as `args`; undefined when omitted, so pass it or hard-code the values. Keep it small; the operator reads it before the run starts."
+        },
+        description: {
+          type: "string",
+          maxLength: 200,
+          description: "Optional one-line summary shown to the operator instead of meta.description."
+        }
+      },
+      required: ["script"],
+      additionalProperties: false
+    }),
+    largeStringArguments: { script: 2e4 },
+    truncatedInputHint: "Write a shorter script: shared helpers, loops instead of repeated lines, and prompts built from args.",
+    malformedInputHint: 'Every character of "script" goes inside a JSON string: write a newline as \\n, a tab as \\t, a double quote as \\" and a backslash as \\\\.',
+    // The person reads `Workflow(<what it is for>)`, never the script.
+    presentCall: /* @__PURE__ */ __name((input) => ({
+      kind: "generic",
+      label: `Workflow(${describeWorkflowCall(input)})`,
+      presentation: "activity"
+    }), "presentCall"),
+    category: "custom",
+    permissions: [],
+    readOnly: false,
+    destructive: false,
+    concurrencySafe: false,
+    async execute(input, context) {
+      const { script, args } = input;
+      const refused = options.refusal(context.turnId);
+      if (refused !== void 0) return { success: false, output: "", error: refused };
+      if (args !== void 0 && JSON.stringify(args).length > MAX_WORKFLOW_ARGS_CHARS) {
+        return {
+          success: false,
+          output: "",
+          error: `args is larger than ${MAX_WORKFLOW_ARGS_CHARS} characters. Pass less, or have the agents read a file.`
+        };
+      }
+      let meta;
+      try {
+        meta = parseWorkflowMeta(script);
+      } catch (error) {
+        if (error instanceof WorkflowScriptError) {
+          return { success: false, output: "", error: error.message };
+        }
+        throw error;
+      }
+      const runId = createWorkflowRunId((id) => registry.get(id) !== void 0);
+      const turn = options.openRunTurn(context.turnId, runId);
+      const runs = options.runsDirectory(context.turnId);
+      const limits = options.limitsFor?.(context.turnId);
+      const journal = runs === void 0 ? void 0 : new FileWorkflowJournal(join9(runs, runId, "workflow"));
+      const phaseDetail = /* @__PURE__ */ __name((title) => title === void 0 ? void 0 : meta.phases.find((phase) => phase.title.trim() === title.trim())?.detail, "phaseDetail");
+      let launching = true;
+      let settleLaunch = /* @__PURE__ */ __name(() => {
+      }, "settleLaunch");
+      const launch = new Promise((resolve9) => {
+        settleLaunch = resolve9;
+      });
+      const detach = /* @__PURE__ */ __name(() => {
+        if (!launching) return;
+        launching = false;
+        settleLaunch({ kind: "background" });
+      }, "detach");
+      const onAbort = /* @__PURE__ */ __name(() => detach(), "onAbort");
+      context.abortSignal.addEventListener("abort", onAbort, { once: true });
+      try {
+        const view = registry.start({
+          runId,
+          meta,
+          script,
+          ...args !== void 0 ? { args } : {},
+          ...limits ? { limits } : {},
+          ...journal ? { journal } : {},
+          spawn: /* @__PURE__ */ __name(async (request, signal, viewed) => {
+            const detail = phaseDetail(request.phaseTitle);
+            const outcome2 = await options.subagents.launchWorkflowAgent({
+              turnId: turn.turnId,
+              runId,
+              workflowName: meta.name,
+              label: request.label,
+              prompt: request.prompt,
+              ...request.phaseTitle !== void 0 ? { phaseTitle: request.phaseTitle } : {},
+              ...request.phaseIndex !== void 0 ? { phaseIndex: request.phaseIndex } : {},
+              ...detail !== void 0 ? { phaseDetail: detail } : {},
+              ...request.agentType !== void 0 ? { agentType: request.agentType } : {},
+              ...request.model !== void 0 ? { model: request.model } : {},
+              ...request.effort !== void 0 ? { effort: request.effort } : {},
+              ...request.schema !== void 0 ? { schema: request.schema } : {},
+              signal,
+              inherit: {
+                ...context.env ? { env: context.env } : {},
+                ...context.toolResultGuardrails ? { toolResultGuardrails: context.toolResultGuardrails } : {}
+              },
+              onView: viewed,
+              onProgress: /* @__PURE__ */ __name((progress) => {
+                const last = toolName(progress.lastTool);
+                request.onProgress({
+                  ...progress.tokens !== void 0 ? { tokens: progress.tokens } : {},
+                  ...progress.toolCalls !== void 0 ? { toolCalls: progress.toolCalls } : {},
+                  ...progress.lastTool !== void 0 ? {
+                    lastToolName: last.name,
+                    lastToolSummary: last.summary ?? last.name
+                  } : {}
+                });
+              }, "onProgress")
+            });
+            return {
+              state: outcome2.state,
+              ...outcome2.text !== void 0 ? { text: outcome2.text } : {},
+              tokens: outcome2.tokens,
+              toolCalls: outcome2.toolCalls,
+              ...outcome2.error !== void 0 ? { error: outcome2.error } : {}
+            };
+          }, "spawn"),
+          onFirstAgent: detach,
+          onEnd: /* @__PURE__ */ __name(async (end) => {
+            await turn.release().catch(() => void 0);
+            if (launching) {
+              launching = false;
+              settleLaunch({ kind: "ended", end });
+              return;
+            }
+            options.onEnd?.(end);
+          }, "onEnd")
+        });
+        void view;
+        const outcome = await launch;
+        context.abortSignal.removeEventListener("abort", onAbort);
+        if (outcome.kind === "ended") {
+          registry.discard(runId);
+          return endedBeforeAgents(outcome.end, args === void 0);
+        }
+        return {
+          success: true,
+          output: launchedText(view),
+          data: {
+            run_id: runId,
+            name: meta.name,
+            description: input && typeof input.description === "string" ? input.description : meta.description,
+            phases: meta.phases.map((phase) => phase.title)
+          }
+        };
+      } catch (error) {
+        context.abortSignal.removeEventListener("abort", onAbort);
+        await turn.release();
+        throw error;
+      }
+    }
+  });
+  return { registry, tool };
+}
+__name(createWorkflowHost, "createWorkflowHost");
+
 // src/memory/store.ts
 import { realpathSync as realpathSync3 } from "node:fs";
-import { join as join9, resolve as resolve7 } from "node:path";
+import { join as join11, resolve as resolve7 } from "node:path";
 
 // src/memory/io.ts
 import {
@@ -7079,7 +7720,7 @@ import {
   realpathSync as realpathSync2,
   writeSync
 } from "node:fs";
-import { isAbsolute as isAbsolute5, join as join8, relative as relative5, resolve as resolve6, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join10, relative as relative5, resolve as resolve6, sep as sep4 } from "node:path";
 var MEMORY_FILE_MAX_BYTES = 1024 * 1024;
 function missing(error) {
   return error.code === "ENOENT";
@@ -7112,7 +7753,7 @@ function resolveMemoryPath(location, createParents = false) {
   for (let i = 0; i < parts.length; i += 1) {
     const part = parts[i];
     if (part === void 0) throw new Error("Memory path has an invalid segment.");
-    candidate = join8(candidate, part);
+    candidate = join10(candidate, part);
     const leaf = i === parts.length - 1;
     let stat5;
     try {
@@ -7242,11 +7883,11 @@ function memoryDir(home) {
 }
 __name(memoryDir, "memoryDir");
 function userFilePath(home) {
-  return join9(memoryDir(home), "USER.md");
+  return join11(memoryDir(home), "USER.md");
 }
 __name(userFilePath, "userFilePath");
 function memoryFilePath(home) {
-  return join9(memoryDir(home), "MEMORY.md");
+  return join11(memoryDir(home), "MEMORY.md");
 }
 __name(memoryFilePath, "memoryFilePath");
 function projectMemoryFilePath(cwd) {
@@ -7257,9 +7898,9 @@ function projectMemoryFilePath(cwd) {
     if (error.code !== "ENOENT") throw error;
   }
   const root = cliProjectRoot(directory);
-  const local = join9(directory, ".namzu", "MEMORY.md");
+  const local = join11(directory, ".namzu", "MEMORY.md");
   if (resolveMemoryPath({ path: local, root }) !== null) return local;
-  return join9(root, ".namzu", "MEMORY.md");
+  return join11(root, ".namzu", "MEMORY.md");
 }
 __name(projectMemoryFilePath, "projectMemoryFilePath");
 function projectMemoryLocation(cwd) {
@@ -7289,15 +7930,15 @@ function readMemory(home, cwd) {
     }
   }, "read");
   const userRoot = memoryDir(home);
-  const user = read(join9(userRoot, "USER.md"), () => ({
+  const user = read(join11(userRoot, "USER.md"), () => ({
     root: userRoot,
-    path: join9(userRoot, "USER.md")
+    path: join11(userRoot, "USER.md")
   }));
-  const memory = read(join9(userRoot, "MEMORY.md"), () => ({
+  const memory = read(join11(userRoot, "MEMORY.md"), () => ({
     root: userRoot,
-    path: join9(userRoot, "MEMORY.md")
+    path: join11(userRoot, "MEMORY.md")
   }));
-  const project = cwd && !isUserMemoryFile(join9(resolve7(cwd), ".namzu", "MEMORY.md"), userRoot) ? read(join9(resolve7(cwd), ".namzu", "MEMORY.md"), () => projectLocation(cwd)) : null;
+  const project = cwd && !isUserMemoryFile(join11(resolve7(cwd), ".namzu", "MEMORY.md"), userRoot) ? read(join11(resolve7(cwd), ".namzu", "MEMORY.md"), () => projectLocation(cwd)) : null;
   return { user, memory, project, ...diagnostics.length > 0 ? { diagnostics } : {} };
 }
 __name(readMemory, "readMemory");
@@ -7309,7 +7950,7 @@ function isUserMemoryFile(projectPath, userRoot) {
       return resolve7(path);
     }
   }, "canonical");
-  return canonical(projectPath) === canonical(join9(userRoot, "MEMORY.md"));
+  return canonical(projectPath) === canonical(join11(userRoot, "MEMORY.md"));
 }
 __name(isUserMemoryFile, "isUserMemoryFile");
 function capped(text, file) {
@@ -7458,8 +8099,8 @@ __name(renderStoredMemorySection, "renderStoredMemorySection");
 
 // src/memory/typed.ts
 import { createHash as createHash4 } from "node:crypto";
-import { access, readFile as readFile3, rename as rename3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { access, readFile as readFile4, rename as rename3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join12 } from "node:path";
 function firstLine2(text, limit) {
   const line = (text.split(/\r?\n/).find((part) => part.trim()) ?? "").replace(/\s+/g, " ").trim();
   if (line.length <= limit) return line;
@@ -7483,7 +8124,7 @@ async function saveTypedNote(store, text, type = "project") {
         saved: false,
         duplicate: true,
         type: record.entry.type ?? type,
-        ...record.entry.name ? { name: record.entry.name, path: join10(store.path, `${record.entry.name}.md`) } : {}
+        ...record.entry.name ? { name: record.entry.name, path: join12(store.path, `${record.entry.name}.md`) } : {}
       };
     }
   }
@@ -7498,7 +8139,7 @@ async function saveTypedNote(store, text, type = "project") {
   return {
     saved: true,
     type,
-    ...entry.name ? { name: entry.name, path: join10(store.path, `${entry.name}.md`) } : {}
+    ...entry.name ? { name: entry.name, path: join12(store.path, `${entry.name}.md`) } : {}
   };
 }
 __name(saveTypedNote, "saveTypedNote");
@@ -7516,7 +8157,7 @@ __name(composeStoredMemoryPrompt, "composeStoredMemoryPrompt");
 var MARKER = "migration.json";
 async function readMarker(directory) {
   try {
-    const parsed = JSON.parse(await readFile3(join10(directory, MARKER), "utf8"));
+    const parsed = JSON.parse(await readFile4(join12(directory, MARKER), "utf8"));
     return parsed !== null && typeof parsed === "object" ? parsed : {};
   } catch (error) {
     if (error.code === "ENOENT") return {};
@@ -7529,7 +8170,7 @@ async function markCuratedFile(directory, path, state) {
   const files = { ...marker.curatedFiles ?? {} };
   files[path] = { ...files[path] ?? {}, ...state };
   await writeFile2(
-    join10(directory, MARKER),
+    join12(directory, MARKER),
     `${JSON.stringify({ ...marker, curatedFiles: files }, null, 2)}
 `,
     { mode: 384 }
@@ -7596,7 +8237,7 @@ async function migrateMemoryOnce(options) {
   const skippedRecords = [];
   let importedRecords = 0;
   let notesOffer;
-  const indexPath = join10(directory, "index.json");
+  const indexPath = join12(directory, "index.json");
   if (await exists(indexPath)) {
     try {
       const disk = new DiskMemoryStore({ baseDir: directory, directory });
@@ -7619,11 +8260,11 @@ async function migrateMemoryOnce(options) {
         }
       }
       await retire(indexPath);
-      const content = join10(directory, "content");
+      const content = join12(directory, "content");
       const retiredContent = await exists(content) ? await retire(content) : content;
       for (const record of refused) {
         skippedRecords.push(
-          `"${record.title}" (${record.id}) was not moved: ${record.reason} It is kept in ${join10(retiredContent, `${record.id}.json`)}.`
+          `"${record.title}" (${record.id}) was not moved: ${record.reason} It is kept in ${join12(retiredContent, `${record.id}.json`)}.`
         );
       }
     } catch (error) {
@@ -7985,25 +8626,25 @@ __name(admitToolView, "admitToolView");
 function createCliToolPresenter(registry) {
   const log = cliLogger().child({ [SCOPE_ATTRIBUTE]: "cli/tool-presentation" });
   const presenter = createToolPresenter(registry, log);
-  const admit = /* @__PURE__ */ __name((toolName, hook, present) => {
+  const admit = /* @__PURE__ */ __name((toolName2, hook, present) => {
     try {
       const view = admitToolView(present());
       if (view) return view;
     } catch {
     }
     log.warn("Tool presentation was invalid; using a plain view", {
-      "namzu.tool.name": toolName,
+      "namzu.tool.name": toolName2,
       "namzu.tool.presenter_hook": hook
     });
     return void 0;
   }, "admit");
   return {
-    presentCall: /* @__PURE__ */ __name((toolName, input) => admit(toolName, "presentCall", () => presenter.presentCall(toolName, input)) ?? {
+    presentCall: /* @__PURE__ */ __name((toolName2, input) => admit(toolName2, "presentCall", () => presenter.presentCall(toolName2, input)) ?? {
       kind: "generic",
       // Never stringify unreadable input as a replacement for a broken label.
-      label: toolName
+      label: toolName2
     }, "presentCall"),
-    presentResult: /* @__PURE__ */ __name((toolName, input, result) => admit(toolName, "presentResult", () => presenter.presentResult(toolName, input, result)) ?? {
+    presentResult: /* @__PURE__ */ __name((toolName2, input, result) => admit(toolName2, "presentResult", () => presenter.presentResult(toolName2, input, result)) ?? {
       kind: "terminal",
       output: (result.success ? result.output : result.error ?? result.output) ?? ""
     }, "presentResult")
@@ -8360,10 +9001,10 @@ function clipRequestContext(prompt, limit, kind) {
 __name(clipRequestContext, "clipRequestContext");
 async function createAgentSession(prefs, detected, options = {}) {
   if (options.palEnvironment) {
-    const { createPalAgentSession } = await import("./agent-session-C2HDOXK4.js");
+    const { createPalAgentSession } = await import("./agent-session-DU55LD4P.js");
     return createPalAgentSession(prefs, detected, options);
   }
-  const { palAtWorkspace } = await import("./store-2PDDGKYZ.js");
+  const { palAtWorkspace } = await import("./store-7WZWQXKX.js");
   if (palAtWorkspace(options.cwd ?? process.cwd()))
     throw new Error("This Pal requires its owned virtual computer. Open it with namzu pal chat.");
   const fileObservations = /* @__PURE__ */ new Map();
@@ -8843,6 +9484,9 @@ async function createAgentSession(prefs, detected, options = {}) {
   const goalAuthorities = /* @__PURE__ */ new Map();
   const delegatedResumeHandlers = /* @__PURE__ */ new Map();
   const delegatedReviewAllowedCalls = /* @__PURE__ */ new Map();
+  const delegatedWorkflowAuth = /* @__PURE__ */ new Map();
+  let workflowHost;
+  const workflowEndListeners = /* @__PURE__ */ new Set();
   const goalToolNames = new Set(SESSION_GOAL_TOOL_NAMES);
   if (options.sessionGoals) {
     toolsets.push(
@@ -9152,6 +9796,73 @@ async function createAgentSession(prefs, detected, options = {}) {
     new ToolManager({ toolsets: agentToolsets, messages: /* @__PURE__ */ __name(() => [], "messages") }).dispose();
     toolsets.push(...agentToolsets);
     allowedAgentIds = sub.allowedAgentIds;
+    workflowHost = createWorkflowHost({
+      subagents: sub,
+      runsDirectory: /* @__PURE__ */ __name((turnId) => {
+        if (options.ephemeral) return void 0;
+        const owner = delegationScopes.get(turnId) ?? scope;
+        return join13(paths.sessionDir({ sessionId: owner.sessionId }), "runs");
+      }, "runsDirectory"),
+      refusal: /* @__PURE__ */ __name((turnId) => {
+        const auth = delegatedWorkflowAuth.get(turnId);
+        if (!auth) return "This turn cannot start a workflow.";
+        return workflowRefusal({ interactive: auth.interactive, mode: auth.mode() });
+      }, "refusal"),
+      openRunTurn: /* @__PURE__ */ __name((originTurnId, runId) => {
+        const runTurnId = generateTurnId();
+        const origin = delegatedWorkflowAuth.get(originTurnId);
+        const ownerScope = delegationScopes.get(originTurnId) ?? { ...scope };
+        const control = createLiveModeControl({
+          initial: origin?.mode() ?? "prompt",
+          ...origin ? { read: origin.mode } : {},
+          handlerFor: /* @__PURE__ */ __name((mode) => makeResumeHandler(
+            approval,
+            origin?.reviewer?.onPermission,
+            mode,
+            reviewExemptionFor(mode, manager, (input) => sub.launchesReadOnlyAgent(input)),
+            { unattendedSandboxEscape },
+            screenPolicyFor(() => manager)
+          ), "handlerFor")
+        });
+        liveModeControls.add(control);
+        delegationScopes.set(runTurnId, ownerScope);
+        delegationLimits.set(
+          runTurnId,
+          delegationLimits.get(originTurnId) ?? resolveTurnGuards(options.limits, void 0)
+        );
+        delegatedResumeHandlers.set(runTurnId, control.handler);
+        delegatedReviewAllowedCalls.set(runTurnId, control.reviewAllowedCalls);
+        const model2 = delegationModels.get(originTurnId);
+        if (model2) delegationModels.set(runTurnId, model2);
+        void runId;
+        let released;
+        return {
+          turnId: runTurnId,
+          release: /* @__PURE__ */ __name(() => {
+            released ??= (async () => {
+              liveModeControls.delete(control);
+              delegationScopes.delete(runTurnId);
+              delegationLimits.delete(runTurnId);
+              delegatedResumeHandlers.delete(runTurnId);
+              delegatedReviewAllowedCalls.delete(runTurnId);
+              delegationModels.delete(runTurnId);
+              await sub.releaseTurn(runTurnId);
+            })();
+            return released;
+          }, "release")
+        };
+      }, "openRunTurn"),
+      limitsFor: /* @__PURE__ */ __name((turnId) => {
+        const budget = delegationLimits.get(turnId)?.tokenBudget;
+        return {
+          ...budget !== void 0 && budget > 0 ? { tokenBudget: budget } : {},
+          ...options.workflow
+        };
+      }, "limitsFor"),
+      onEnd: /* @__PURE__ */ __name((end) => {
+        for (const listener of [...workflowEndListeners]) listener(end);
+      }, "onEnd")
+    });
   } catch (err) {
     try {
       await subagentRuntime?.close();
@@ -9223,7 +9934,7 @@ async function createAgentSession(prefs, detected, options = {}) {
   if (options.openUrl) toolsets.push(toolset("open-url", [createOpenUrlTool()]));
   const decisionTool = maybeCreateDecisionTool(options.decision, process.env);
   if (decisionTool) toolsets.push(toolset("decide", [decisionTool]));
-  const operatorPals = await import("./operator-tools-GI63VOXH.js");
+  const operatorPals = await import("./operator-tools-H4MYC5PE.js");
   toolsets.push(
     readyWhen(
       toolset(
@@ -9356,6 +10067,7 @@ async function createAgentSession(prefs, detected, options = {}) {
   const reasoningLookup = new AbortController();
   const operations = new SessionOperationOwner(async () => {
     reasoningLookup.abort();
+    workflowHost?.registry.close();
     const results = await Promise.allSettled([
       Promise.resolve().then(() => manager.dispose()),
       options.conversationSessions ? releaseConversationEvidence(options.conversationSessions, scope.sessionId) : void 0,
@@ -9828,6 +10540,32 @@ async function createAgentSession(prefs, detected, options = {}) {
       if (job.owner === jobOwner) listener(job);
     }) ?? (() => {
     }), "onJobExit"),
+    ...workflowHost ? {
+      workflows: /* @__PURE__ */ ((host) => ({
+        runs: /* @__PURE__ */ __name(() => host.registry.list(), "runs"),
+        subscribe: /* @__PURE__ */ __name((listener) => host.registry.subscribe(listener), "subscribe"),
+        stop: /* @__PURE__ */ __name((runId) => host.registry.stop(runId), "stop"),
+        skipAgent: /* @__PURE__ */ __name((runId, index) => host.registry.skipAgent(runId, index), "skipAgent"),
+        agentOf: /* @__PURE__ */ __name((viewId) => host.registry.agentOf(viewId), "agentOf"),
+        history: /* @__PURE__ */ __name(async () => {
+          const live = host.registry.list();
+          const known = new Set(live.map((view) => view.runId));
+          const saved = options.ephemeral ? [] : await listWorkflowRuns(
+            join13(paths.sessionDir({ sessionId: scope.sessionId }), "runs")
+          ).catch(() => []);
+          return [
+            ...[...live].sort((a, b) => b.startedAt - a.startedAt),
+            ...saved.filter((view) => !known.has(view.runId))
+          ];
+        }, "history"),
+        onEnd: /* @__PURE__ */ __name((listener) => {
+          workflowEndListeners.add(listener);
+          return () => workflowEndListeners.delete(listener);
+        }, "onEnd"),
+        idle: /* @__PURE__ */ __name((signal) => host.registry.whenIdle(signal), "idle"),
+        reset: /* @__PURE__ */ __name(() => host.registry.reset(), "reset")
+      }))(workflowHost)
+    } : {},
     ...subagentRuntime ? {
       subagents: subagentRuntime.activity,
       onSubagentReport: /* @__PURE__ */ __name((listener) => {
@@ -9836,6 +10574,7 @@ async function createAgentSession(prefs, detected, options = {}) {
           directChildReports.delete(listener);
         };
       }, "onSubagentReport"),
+      stopSubagent: /* @__PURE__ */ __name((viewId) => subagentRuntime?.stopChild(viewId) ?? false, "stopSubagent"),
       messageSubagent: /* @__PURE__ */ __name((viewId, message2, opts) => operations.promise(opts?.signal, async (signal) => {
         const runtime = subagentRuntime;
         if (!runtime) throw new Error("Delegation is unavailable.");
@@ -9976,6 +10715,8 @@ async function createAgentSession(prefs, detected, options = {}) {
     mcpStatus: /* @__PURE__ */ __name(() => mcp.current(), "mcpStatus"),
     ...browserControl ? { browser: browserControl } : {},
     configNotices: [
+      // Git for Windows is missing and the shell tool runs cmd.exe: said once, here.
+      ...sandbox.provider === void 0 && windowsShellNotice() !== void 0 ? [windowsShellNotice()] : [],
       ...capabilityNotice ? [capabilityNotice] : [],
       ...effortNotice ? [effortNotice] : [],
       ...passthroughNotice ? [passthroughNotice] : [],
@@ -10084,6 +10825,11 @@ async function createAgentSession(prefs, detected, options = {}) {
           if (opts?.waitForInbound) delegatedInputWaiters.set(turnId2, opts.waitForInbound);
           delegationScopes.set(turnId2, turnScope);
           delegationLimits.set(turnId2, turnLimits);
+          delegatedWorkflowAuth.set(turnId2, {
+            interactive: opts?.workflowReview?.onPermission !== void 0,
+            mode: /* @__PURE__ */ __name(() => modeControl.current(), "mode"),
+            reviewer: opts?.workflowReview
+          });
           if (capturedAuthority) {
             if (goalAuthorities.has(turnId2)) {
               throw new Error(`Turn ${turnId2} already owns goal-round authority.`);
@@ -10198,6 +10944,19 @@ async function createAgentSession(prefs, detected, options = {}) {
               render: /* @__PURE__ */ __name(() => invocationContext, "render")
             });
           }
+          const workflowOffer = workflowHost !== void 0 && opts?.workflowReview !== void 0 && !residentContext && workflowOffered({
+            hypermode: opts?.hypermode === true,
+            userText: lastUserText(messages)
+          });
+          if (workflowOffer && workflowHost) {
+            runToolsets = [...runToolsets, toolset("workflow", [workflowHost.tool])];
+            if (runManager !== manager) runManager.dispose();
+            runManager = new ToolManager({
+              toolsets: runToolsets,
+              ...screensConfig !== void 0 ? { resultGuardrails: screensConfig } : {},
+              messages: /* @__PURE__ */ __name(() => [], "messages")
+            });
+          }
           const systemPrompt = [
             NAMZU_IDENTITY,
             residentContext ? void 0 : CODING_AGENT_WORKING_DOCTRINE,
@@ -10207,6 +10966,7 @@ async function createAgentSession(prefs, detected, options = {}) {
             // to use a tool it was not sent.
             residentContext || options.withheldTools?.includes(AGENT_LAUNCH_TOOL) ? void 0 : CODING_AGENT_DELEGATION_DOCTRINE,
             !residentContext && opts?.hypermode ? CODING_AGENT_HYPERMODE_DOCTRINE : void 0,
+            workflowOffer ? WORKFLOW_DOCTRINE : void 0,
             residentContext ? void 0 : palPromptBlock(),
             options.conversationSessions ? CONVERSATION_EVIDENCE_GUIDANCE : void 0,
             options.toolLoading === "deferred" ? DEFERRED_TOOL_GUIDANCE : void 0,
@@ -10374,6 +11134,7 @@ async function createAgentSession(prefs, detected, options = {}) {
             delegatedInputWaiters.delete(turnId2);
             delegationScopes.delete(turnId2);
             delegationLimits.delete(turnId2);
+            delegatedWorkflowAuth.delete(turnId2);
             await subagentRuntime?.releaseTurn(turnId2);
           }
         }
@@ -11054,9 +11815,9 @@ function confirmsItself(name, input) {
 }
 __name(confirmsItself, "confirmsItself");
 function declaredReadOnly(manager) {
-  return (toolName, input) => {
+  return (toolName2, input) => {
     try {
-      return manager.get(toolName)?.isReadOnly?.(input) === true;
+      return manager.get(toolName2)?.isReadOnly?.(input) === true;
     } catch {
       return false;
     }
@@ -11127,6 +11888,10 @@ function toAgentEvent(event, presenter, readsOnly) {
           if (view.kind === "diff") rememberCallDiff(event.toolUseId, view);
           return {
             summary: viewToSummary(view),
+            ...(() => {
+              const command = view.kind === "terminal" ? view.command : view.kind === "generic" && view.facts?.kind === "command" ? view.facts.command : void 0;
+              return command ? { command } : {};
+            })(),
             ...view.kind === "generic" && view.activity ? { activity: view.activity } : {},
             detail: viewToLines(view),
             ...view.kind === "generic" && view.presentation === "activity" ? { standalone: true } : {}
@@ -11195,6 +11960,7 @@ function toAgentEvent(event, presenter, readsOnly) {
         summary: headline ?? summary,
         ...headline ? { headline } : {},
         ...plainFailure ? { plainFailure } : {},
+        ...tidy?.shell ? { shell: tidy.shell } : {},
         ...event.durationMs !== void 0 ? { durationMs: event.durationMs } : {},
         ...view.kind === "generic" && view.visibility === "hidden" ? { hidden: true } : {},
         ...event.isError && view.kind === "generic" && view.outcome === "cancelled" ? { cancelled: true } : {},
@@ -11680,4 +12446,4 @@ export {
   RESULT_SUMMARY_WHOLE_MAX,
   resultSummaryLine
 };
-//# sourceMappingURL=chunk-H7VJHF5S.js.map
+//# sourceMappingURL=chunk-H6MWKPHM.js.map