@namzu/cli 36.1.2 → 36.3.0

package/dist/chunks/{chunk-TJJUB7VQ.js → chunk-SFUUN6B3.js}

@@ -2,24 +2,34 @@ import { createRequire as __namzuCreateRequire } from 'node:module';
 const require = __namzuCreateRequire(import.meta.url);
 import {
   openManagedWorktrees
-} from "./chunk-GMCOZ3CU.js";
+} from "./chunk-52OVP5BG.js";
 import {
   createBrowserControl
 } from "./chunk-WHODOMXA.js";
 import {
   connectMcpServers
-} from "./chunk-FXS3AG6B.js";
+} from "./chunk-JCDTR2ZU.js";
 import {
   createSessionSkillCatalog
-} from "./chunk-LQMHASKR.js";
+} from "./chunk-XCWZZZOW.js";
 import {
   SAVE_SKILL_TOOL_NAME,
+  WORKFLOW_TOOL_DESCRIPTION,
+  WORKFLOW_TOOL_NAME,
+  attachAgentView,
+  closeOpenAgents,
+  initialRunView,
+  launchedText,
   readStoredTurnGuards,
-  resolveTurnGuards
-} from "./chunk-PYG7DZ2D.js";
+  reduceRunView,
+  resolveTurnGuards,
+  viewFromJournal,
+  workflowOffered,
+  workflowRefusal
+} from "./chunk-QBAISLAD.js";
 import {
   openInBrowser
-} from "./chunk-3P5PF6XE.js";
+} from "./chunk-AP5KD43Y.js";
 import {
   CredentialRefreshRejectedError,
   CredentialWithdrawnError,
@@ -27,7 +37,7 @@ import {
   ensureFreshStoredCodexCredential,
   readSubscriptionCredential,
   sameOAuthCredential
-} from "./chunk-4BZMQ2VD.js";
+} from "./chunk-5URT3ZM2.js";
 import {
   debugRequested
 } from "./chunk-GNBMKISG.js";
@@ -35,7 +45,7 @@ import {
   configuredPassthroughTools,
   resolveToolResultScreens,
   unmatchedPassthroughTools
-} from "./chunk-K76WV7TN.js";
+} from "./chunk-MBBFX64S.js";
 import {
   formatSize,
   homePath,
@@ -63,7 +73,7 @@ import {
   requiresCredentialForModel,
   resolveChainCapabilities,
   unresolvedMembers
-} from "./chunk-YXLD46UI.js";
+} from "./chunk-DYUOXP5Q.js";
 import {
   PROVIDER_REGISTRY,
   missingCredentialMessage,
@@ -71,11 +81,11 @@ import {
 } from "./chunk-6LLJQ3KY.js";
 import {
   cliLogger
-} from "./chunk-HBBB2CAC.js";
+} from "./chunk-FU4GQ7K2.js";
 import {
   isPermissionMode,
   permissionModeLabel
-} from "./chunk-5GRV6P5C.js";
+} from "./chunk-LBH5WVXU.js";
 import {
   probeCapabilities
 } from "./chunk-OH6TB27S.js";
@@ -86,7 +96,7 @@ import {
 import {
   conversationLogPath,
   ensureSessionStarted
-} from "./chunk-TIGWWAJI.js";
+} from "./chunk-EKUJUPFA.js";
 import {
   INSTRUCTIONS_FILENAME,
   MAX_CHARS_PER_FILE,
@@ -96,13 +106,13 @@ import {
 } from "./chunk-H6B6AROX.js";
 import {
   ensurePrivateStateDirectory
-} from "./chunk-A5UXODFL.js";
+} from "./chunk-S6MZK4LD.js";
 import {
   restrictToOwner
-} from "./chunk-Q24K7536.js";
+} from "./chunk-BOV53LZO.js";
 import {
   namzuHomePath
-} from "./chunk-NQY5P2EB.js";
+} from "./chunk-HKDPP2JF.js";
 import {
   AgentManager,
   AgentRegistry,
@@ -111,6 +121,7 @@ import {
   CODING_AGENT_DELEGATION_DOCTRINE,
   CODING_AGENT_HYPERMODE_DOCTRINE,
   CODING_AGENT_WORKING_DOCTRINE,
+  COMPUTER_USE_TOOL_NAME,
   CompletionInbox,
   DefaultCapacityValidator,
   DiskMemoryStore,
@@ -123,6 +134,7 @@ import {
   EXPLORE_AGENT_DESCRIPTION,
   EXPLORE_AGENT_ID,
   EXPLORE_AGENT_PROMPT,
+  FileWorkflowJournal,
   GitWorktreeDriver,
   GuardedFetchProvider,
   InMemorySessionLog,
@@ -155,6 +167,8 @@ import {
   TopicManager,
   TurnCancelled,
   WebFetchTool,
+  WorkflowRuntime,
+  WorkflowScriptError,
   WorkspaceBackendRegistry,
   abandonTurn,
   asSessionId,
@@ -190,6 +204,7 @@ import {
   discoverAgentDefinitions,
   discoverAllPluginDirs,
   ensureProject,
+  external_exports,
   filtered,
   generateSessionId,
   generateSummaryId,
@@ -211,6 +226,7 @@ import {
   mapTools,
   mcpJsonSchemaToZod,
   openSessionTokenBudget,
+  parseWorkflowMeta,
   query,
   readSessionLog,
   readyWhen,
@@ -228,9 +244,10 @@ import {
   toolset,
   untrustedEnvelopeBody,
   webGuidanceContribution,
+  windowsShellNotice,
   withProviderFallback,
   wrapUntrusted
-} from "./chunk-EWKJGHRO.js";
+} from "./chunk-V3ZLK3XQ.js";
 import {
   __name
 } from "./chunk-76FLAFCG.js";
@@ -619,6 +636,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;
@@ -632,7 +650,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 = [];
@@ -646,7 +665,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) {
@@ -682,21 +712,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) {
@@ -820,14 +862,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;
@@ -882,7 +924,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";
@@ -2626,6 +2668,499 @@ function composeTurnSnapshot(snapshot) {
 }
 __name(composeTurnSnapshot, "composeTurnSnapshot");
 
+// ../decision/dist/contract.js
+var DecisionError = class extends Error {
+  static {
+    __name(this, "DecisionError");
+  }
+  status;
+  code;
+  constructor(message2, status, code) {
+    super(message2);
+    this.status = status;
+    this.code = code;
+    this.name = "DecisionError";
+  }
+};
+
+// ../decision/dist/drivers/wire.js
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+__name(isRecord, "isRecord");
+function numberRecord(v) {
+  const out = {};
+  if (isRecord(v)) {
+    for (const [k, val] of Object.entries(v))
+      if (typeof val === "number")
+        out[k] = val;
+  }
+  return out;
+}
+__name(numberRecord, "numberRecord");
+async function postDecision(post) {
+  const res = await post.fetch(post.url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...post.headers },
+    body: JSON.stringify(post.body),
+    signal: post.signal
+  });
+  let json;
+  try {
+    json = await res.json();
+  } catch {
+    json = void 0;
+  }
+  if (!res.ok) {
+    const err = isRecord(json) && isRecord(json.error) ? json.error : {};
+    throw new DecisionError(typeof err.message === "string" ? err.message : `Decision request failed (${res.status})`, res.status, typeof err.code === "string" ? err.code : void 0);
+  }
+  const answers = isRecord(json) ? json.answers : void 0;
+  return isRecord(answers) ? answers.q : void 0;
+}
+__name(postDecision, "postDecision");
+function yesnoQuestion(instructions) {
+  return { type: "noul", instructions };
+}
+__name(yesnoQuestion, "yesnoQuestion");
+function choiceQuestion(instructions, options) {
+  return { type: "choice", instructions, options: [...options] };
+}
+__name(choiceQuestion, "choiceQuestion");
+function scoreQuestion(instructions, levels2) {
+  return { type: "score", instructions, levels: [...levels2] };
+}
+__name(scoreQuestion, "scoreQuestion");
+function parseYesNo(answer) {
+  const noul = isRecord(answer) ? answer.noul : void 0;
+  if (typeof noul !== "number") {
+    throw new DecisionError('Decision response carried no "noul" probability');
+  }
+  return { p: noul };
+}
+__name(parseYesNo, "parseYesNo");
+function parseChoice(answer) {
+  const body = isRecord(answer) && isRecord(answer.choice) ? answer.choice : answer;
+  const probabilities = numberRecord(isRecord(body) ? body.probabilities : void 0);
+  let option = isRecord(body) ? body.option : void 0;
+  if (typeof option !== "string") {
+    option = Object.entries(probabilities).sort((a, b) => b[1] - a[1])[0]?.[0];
+  }
+  if (typeof option !== "string") {
+    throw new DecisionError('Decision response carried no "choice" answer');
+  }
+  return { option, probabilities };
+}
+__name(parseChoice, "parseChoice");
+function parseScore(answer) {
+  const body = isRecord(answer) && isRecord(answer.score) ? answer.score : answer;
+  const raw = isRecord(body) ? body : {};
+  const probabilities = Array.isArray(raw.probabilities) ? raw.probabilities.filter((x) => typeof x === "number") : [];
+  let level = raw.level;
+  if (typeof level !== "number") {
+    let best = -1;
+    probabilities.forEach((p, i) => {
+      if (best < 0 || p > (probabilities[best] ?? 0))
+        best = i;
+    });
+    level = best >= 0 ? best : void 0;
+  }
+  if (typeof level !== "number") {
+    throw new DecisionError('Decision response carried no "score" answer');
+  }
+  return { level, probabilities };
+}
+__name(parseScore, "parseScore");
+
+// ../decision/dist/drivers/azure-foundry.js
+var AzureFoundryDecisionModel = class {
+  static {
+    __name(this, "AzureFoundryDecisionModel");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async yesno(state, instructions, opts) {
+    return parseYesNo(await this.ask(state, yesnoQuestion(instructions), opts));
+  }
+  async choice(state, instructions, options, opts) {
+    return parseChoice(await this.ask(state, choiceQuestion(instructions, options), opts));
+  }
+  async score(state, instructions, levels2, opts) {
+    return parseScore(await this.ask(state, scoreQuestion(instructions, levels2), opts));
+  }
+  async ask(state, question, opts) {
+    const token = await this.config.getToken();
+    return postDecision({
+      url: `${this.config.endpoint.replace(/\/$/, "")}/providers/microsoft/v1/systemone`,
+      headers: { Authorization: `Bearer ${token}` },
+      body: { model: this.config.deployment, state, questions: { q: question } },
+      fetch: this.config.fetch ?? globalThis.fetch,
+      ...opts?.signal ? { signal: opts.signal } : {}
+    });
+  }
+};
+
+// ../decision/dist/drivers/http.js
+var HttpDecisionModel = class {
+  static {
+    __name(this, "HttpDecisionModel");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async yesno(state, instructions, opts) {
+    return parseYesNo(await this.ask(state, yesnoQuestion(instructions), opts));
+  }
+  async choice(state, instructions, options, opts) {
+    return parseChoice(await this.ask(state, choiceQuestion(instructions, options), opts));
+  }
+  async score(state, instructions, levels2, opts) {
+    return parseScore(await this.ask(state, scoreQuestion(instructions, levels2), opts));
+  }
+  async ask(state, question, opts) {
+    return postDecision({
+      url: this.config.url,
+      headers: {
+        ...this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {},
+        ...this.config.headers
+      },
+      body: {
+        ...this.config.model ? { model: this.config.model } : {},
+        state,
+        questions: { q: question }
+      },
+      fetch: this.config.fetch ?? globalThis.fetch,
+      ...opts?.signal ? { signal: opts.signal } : {}
+    });
+  }
+};
+
+// ../decision/dist/create.js
+function createDecisionModel(config) {
+  switch (config.provider) {
+    case "azure":
+      return new AzureFoundryDecisionModel({
+        endpoint: config.endpoint,
+        deployment: config.deployment,
+        getToken: config.getToken,
+        ...config.fetch ? { fetch: config.fetch } : {}
+      });
+    case "http":
+      return new HttpDecisionModel({
+        url: config.url,
+        ...config.model ? { model: config.model } : {},
+        ...config.apiKey ? { apiKey: config.apiKey } : {},
+        ...config.headers ? { headers: config.headers } : {},
+        ...config.fetch ? { fetch: config.fetch } : {}
+      });
+    default: {
+      const unknown = config;
+      throw new Error(`Unknown decision provider: ${JSON.stringify(unknown.provider)}`);
+    }
+  }
+}
+__name(createDecisionModel, "createDecisionModel");
+
+// ../decision/dist/tool.js
+var DECIDE_TOOL_NAME = "decide";
+var inputSchema3 = external_exports.object({
+  kind: external_exports.enum(["yesno", "choice", "score"]).describe("yesno = probability a statement is true; choice = pick one of `options`; score = pick one of ordered `levels`."),
+  context: external_exports.string().describe("The situation to judge: the state, the evidence, whatever the decision turns on."),
+  question: external_exports.string().describe("What to decide, phrased for the chosen kind (a yes/no claim, a pick instruction, a scoring rubric)."),
+  options: external_exports.array(external_exports.string()).optional().describe('kind="choice" only: the options to pick exactly one of (2 or more).'),
+  levels: external_exports.array(external_exports.string()).optional().describe('kind="score" only: the ordered levels, lowest first (2 or more).')
+});
+function round(n) {
+  return n.toFixed(4);
+}
+__name(round, "round");
+function distribution(probabilities) {
+  return Object.entries(probabilities).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}=${round(v)}`).join(", ");
+}
+__name(distribution, "distribution");
+var ADVISORY = "This is a fast, advisory System-1 judgment \u2014 you remain responsible for hard constraints; weigh low-confidence results with your own reasoning.";
+function createDecisionTool(model, options = {}) {
+  return defineTool({
+    name: options.name ?? DECIDE_TOOL_NAME,
+    description: "Ask a fast System-1 decision model for a typed judgment: a yes/no probability, a choice among options, or a score across ordered levels. Optional and advisory \u2014 reach for it when a quick, well-scoped classification, routing, safety pre-screen, element pick or ranking would help, then act on your own reasoning. If the model is unavailable the tool says so and you simply proceed.",
+    inputSchema: inputSchema3,
+    category: "analysis",
+    permissions: [],
+    readOnly: true,
+    destructive: false,
+    concurrencySafe: true,
+    async execute(input, context) {
+      const opts = context.abortSignal ? { signal: context.abortSignal } : void 0;
+      try {
+        if (input.kind === "yesno") {
+          const { p } = await model.yesno(input.context, input.question, opts);
+          return {
+            success: true,
+            output: `P(true) = ${round(p)}. ${ADVISORY}`,
+            data: { kind: "yesno", p }
+          };
+        }
+        if (input.kind === "choice") {
+          const choices = input.options ?? [];
+          if (choices.length < 2) {
+            return {
+              success: true,
+              output: "decide(choice) needs 2 or more `options`. None judged \u2014 decide with your own reasoning."
+            };
+          }
+          const { option, probabilities: probabilities2 } = await model.choice(input.context, input.question, choices, opts);
+          return {
+            success: true,
+            output: `Pick: ${option}  (${distribution(probabilities2)}). ${ADVISORY}`,
+            data: { kind: "choice", option, probabilities: probabilities2 }
+          };
+        }
+        const levels2 = input.levels ?? [];
+        if (levels2.length < 2) {
+          return {
+            success: true,
+            output: "decide(score) needs 2 or more `levels`. None judged \u2014 decide with your own reasoning."
+          };
+        }
+        const { level, probabilities } = await model.score(input.context, input.question, levels2, opts);
+        const name = levels2[level] ?? `level ${level}`;
+        return {
+          success: true,
+          output: `Score: ${name} (index ${level})  [${probabilities.map(round).join(", ")}]. ${ADVISORY}`,
+          data: { kind: "score", level, name, probabilities }
+        };
+      } catch (error) {
+        const why = error instanceof DecisionError ? error.message : String(error);
+        return {
+          success: true,
+          output: `The decision model is unavailable (${why}). Decide using your own reasoning; this tool is advisory only.`,
+          data: { kind: "unavailable", reason: why }
+        };
+      }
+    }
+  });
+}
+__name(createDecisionTool, "createDecisionTool");
+
+// src/integrations/decision/model.ts
+function buildDecisionProviderConfig(cfg, env) {
+  if (cfg.provider === "azure") {
+    return {
+      provider: "azure",
+      endpoint: cfg.endpoint,
+      deployment: cfg.deployment,
+      getToken: /* @__PURE__ */ __name(async () => env[cfg.tokenEnv ?? "AZURE_FOUNDRY_TOKEN"] ?? "", "getToken")
+    };
+  }
+  return {
+    provider: "http",
+    url: cfg.url,
+    ...cfg.model !== void 0 ? { model: cfg.model } : {},
+    ...cfg.apiKeyEnv ? { apiKey: env[cfg.apiKeyEnv] } : {}
+  };
+}
+__name(buildDecisionProviderConfig, "buildDecisionProviderConfig");
+function maybeCreateDecisionTool(cfg, env) {
+  if (!cfg) return void 0;
+  return createDecisionTool(createDecisionModel(buildDecisionProviderConfig(cfg, env)));
+}
+__name(maybeCreateDecisionTool, "maybeCreateDecisionTool");
+function maybeCreateDecisionModel(cfg, env) {
+  if (!cfg) return void 0;
+  return createDecisionModel(buildDecisionProviderConfig(cfg, env));
+}
+__name(maybeCreateDecisionModel, "maybeCreateDecisionModel");
+
+// src/integrations/decision/routing.ts
+var DEFAULT_ROUTING_TIMEOUT_MS = 1500;
+var DEFAULT_ROUTING_THRESHOLD = 0.7;
+var ROUTING_TASK_CHARS = 1500;
+var FAST_MAX_CONVERSATION = 40;
+var ROUTING_FAST_QUESTION = "Is this task simple enough for a small, fast model to complete correctly? Answer yes only for short chat, a lookup, or a single small step.";
+var ROUTING_BIG_QUESTION = "Does this task need deep multi-step reasoning or large-scale code changes across many files?";
+var ROUTING_SCORE_LEVELS = [
+  "trivial: chat, lookup, or one step",
+  "small: a single-file or single-tool task",
+  "medium: multi-step work across several files",
+  "large: open-ended, architectural, or long-horizon work"
+];
+function truncate(task) {
+  return task.length > ROUTING_TASK_CHARS ? task.slice(0, ROUTING_TASK_CHARS) : task;
+}
+__name(truncate, "truncate");
+function describeState(task, features) {
+  const facts = [];
+  if (features?.attachmentCount) facts.push(`attachments: ${features.attachmentCount}`);
+  if (features?.usesComputerUse) facts.push("drives the desktop");
+  if (features?.usesPal) facts.push("runs in a Pal");
+  if (features?.conversationLength) facts.push(`messages so far: ${features.conversationLength}`);
+  if (features?.voice) facts.push("spoken");
+  return facts.length > 0 ? `${truncate(task)}
+
+[${facts.join("; ")}]` : truncate(task);
+}
+__name(describeState, "describeState");
+function probability(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    throw new RangeError("malformed probability");
+  }
+  return value;
+}
+__name(probability, "probability");
+function massAtOrBelow(probabilities, last) {
+  const total = probabilities.reduce((sum, p) => sum + p, 0);
+  if (!(total > 0)) throw new RangeError("malformed probabilities");
+  return probabilities.slice(0, last + 1).reduce((sum, p) => sum + p, 0) / total;
+}
+__name(massAtOrBelow, "massAtOrBelow");
+var RouteInterrupted = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+  }
+  reason;
+  static {
+    __name(this, "RouteInterrupted");
+  }
+};
+async function withinBudget(run2, timeoutMs, outer) {
+  const controller = new AbortController();
+  let timer;
+  let onOuterAbort;
+  const interrupted = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new RouteInterrupted("timeout"));
+    }, timeoutMs);
+    onOuterAbort = /* @__PURE__ */ __name(() => {
+      controller.abort();
+      reject(new RouteInterrupted("aborted"));
+    }, "onOuterAbort");
+    if (outer?.aborted) onOuterAbort();
+    else outer?.addEventListener("abort", onOuterAbort, { once: true });
+  });
+  try {
+    return await Promise.race([run2(controller.signal), interrupted]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+    if (onOuterAbort) outer?.removeEventListener("abort", onOuterAbort);
+  }
+}
+__name(withinBudget, "withinBudget");
+async function askOnce(call, signal) {
+  try {
+    return await call(signal);
+  } catch (err) {
+    if (signal.aborted) throw err;
+    return await call(signal);
+  }
+}
+__name(askOnce, "askOnce");
+async function routeModel(input, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const started = now();
+  const { config } = input;
+  const result = /* @__PURE__ */ __name((tier, target, confidence, reason, error) => {
+    const routed = {
+      tier,
+      provider: target.provider,
+      model: target.model,
+      confidence,
+      reason
+    };
+    try {
+      deps.logger?.debug("auto model routed", {
+        "namzu.routing.tier": tier,
+        "namzu.routing.reason": reason,
+        "namzu.routing.confidence": confidence,
+        "namzu.routing.duration_ms": Math.max(0, now() - started),
+        "gen_ai.request.model": target.model,
+        "namzu.provider.id": target.provider,
+        // The class of what made it fall back, never its message: that can carry an endpoint.
+        ...error instanceof Error ? { "error.type": error.name } : {}
+      });
+    } catch {
+    }
+    return routed;
+  }, "result");
+  const fallback = /* @__PURE__ */ __name((reason, error) => result("default", config.default, 0, reason, error), "fallback");
+  try {
+    if (input.pin) return result("default", input.pin, 1, "pinned");
+    const usable = /* @__PURE__ */ __name((target) => target && (deps.isAvailable?.(target) ?? true) ? target : void 0, "usable");
+    const features = input.features;
+    const failedOn = features?.previousTurnFailedOnTier;
+    const big = usable(config.tiers?.big);
+    const fastBarred = features?.usesComputerUse === true || features?.usesPal === true || (features?.attachmentCount ?? 0) > 0 || (features?.conversationLength ?? 0) > FAST_MAX_CONVERSATION || failedOn === "fast" || failedOn === "default";
+    const fast = fastBarred ? void 0 : usable(config.tiers?.fast);
+    if (failedOn === "fast") return result("default", config.default, 1, "escalated-after-failure");
+    if (failedOn === "default") {
+      return big ? result("big", big, 1, "escalated-after-failure") : fallback("failed-no-bigger-tier");
+    }
+    if (!fast && !big) return fallback(fastBarred ? "fast-tier-barred" : "no-tier-available");
+    if (!deps.model) return fallback("no-decision-model");
+    const model = deps.model;
+    const timeoutMs = config.timeoutMs ?? DEFAULT_ROUTING_TIMEOUT_MS;
+    const fastThreshold = config.thresholds?.fast ?? DEFAULT_ROUTING_THRESHOLD;
+    const bigThreshold = config.thresholds?.big ?? DEFAULT_ROUTING_THRESHOLD;
+    const state = describeState(input.task, features);
+    let pFast;
+    let pBig;
+    if (config.strategy === "score") {
+      const decision = await withinBudget(
+        (signal) => askOnce(
+          (inner) => model.score(state, "", ROUTING_SCORE_LEVELS, { signal: inner }),
+          signal
+        ),
+        timeoutMs,
+        input.signal
+      );
+      const { probabilities } = decision;
+      if (!Array.isArray(probabilities) || probabilities.length !== ROUTING_SCORE_LEVELS.length) {
+        throw new RangeError("malformed probabilities");
+      }
+      for (const p of probabilities) probability(p);
+      if (fast) pFast = massAtOrBelow(probabilities, 1);
+      if (big) pBig = 1 - massAtOrBelow(probabilities, 2);
+    } else {
+      const [fastDecision, bigDecision] = await withinBudget(
+        (signal) => Promise.all([
+          fast ? askOnce(
+            (inner) => model.yesno(state, ROUTING_FAST_QUESTION, { signal: inner }),
+            signal
+          ) : Promise.resolve(void 0),
+          big ? askOnce(
+            (inner) => model.yesno(state, ROUTING_BIG_QUESTION, { signal: inner }),
+            signal
+          ) : Promise.resolve(void 0)
+        ]),
+        timeoutMs,
+        input.signal
+      );
+      if (fastDecision) pFast = probability(fastDecision.p);
+      if (bigDecision) pBig = probability(bigDecision.p);
+    }
+    const wantsFast = fast !== void 0 && pFast !== void 0 && pFast >= fastThreshold;
+    const wantsBig = big !== void 0 && pBig !== void 0 && pBig >= bigThreshold;
+    if (wantsFast && wantsBig) return fallback("contradictory-decision");
+    if (wantsFast && fast) return result("fast", fast, pFast ?? 0, "simple-task");
+    if (wantsBig && big) return result("big", big, pBig ?? 0, "demanding-task");
+    const leaning = Math.max(pFast ?? 0, pBig ?? 0);
+    return result("default", config.default, Math.max(0, 1 - leaning), "ordinary-task");
+  } catch (err) {
+    if (err instanceof RouteInterrupted) return fallback(err.reason);
+    if (err instanceof RangeError) return fallback("malformed-decision", err);
+    return fallback("decision-unavailable", err);
+  }
+}
+__name(routeModel, "routeModel");
+function resolveAutoDefault(config, isAvailable) {
+  return isAvailable(config.default) ? config.default : void 0;
+}
+__name(resolveAutoDefault, "resolveAutoDefault");
+
 // src/integrations/plugins/settings.ts
 import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import {
@@ -4163,6 +4698,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));
@@ -5250,6 +5806,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);
@@ -5545,6 +6102,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: [
@@ -5558,7 +6303,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(" "),
@@ -5642,202 +6387,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.",
@@ -6324,10 +6983,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,
@@ -6351,6 +7021,7 @@ ${persona}` : persona || (explore ? EXPLORE_PROMPT : SUBAGENT_PROMPT),
       return type === EXPLORE_SUBAGENT;
     },
     activity,
+    launchWorkflowAgent,
     close
   };
 }
@@ -6371,7 +7042,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");
@@ -6568,9 +7239,403 @@ ${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);
+    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);
+        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 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 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`. 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");
+      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 outcome = 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: outcome.state,
+              ...outcome.text !== void 0 ? { text: outcome.text } : {},
+              tokens: outcome.tokens,
+              toolCalls: outcome.toolCalls,
+              ...outcome.error !== void 0 ? { error: outcome.error } : {}
+            };
+          }, "spawn"),
+          onEnd: /* @__PURE__ */ __name(async (end) => {
+            await turn.release().catch(() => void 0);
+            options.onEnd?.(end);
+          }, "onEnd")
+        });
+        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) {
+        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 {
@@ -6584,7 +7649,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";
@@ -6617,7 +7682,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 {
@@ -6747,11 +7812,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) {
@@ -6762,9 +7827,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) {
@@ -6794,15 +7859,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");
@@ -6814,7 +7879,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) {
@@ -6963,8 +8028,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;
@@ -6988,7 +8053,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`) } : {}
       };
     }
   }
@@ -7003,7 +8068,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");
@@ -7021,7 +8086,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 {};
@@ -7034,7 +8099,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 }
@@ -7101,7 +8166,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 });
@@ -7124,11 +8189,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) {
@@ -7490,25 +8555,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")
@@ -7865,10 +8930,10 @@ function clipRequestContext(prompt, limit, kind) {
 __name(clipRequestContext, "clipRequestContext");
 async function createAgentSession(prefs, detected, options = {}) {
   if (options.palEnvironment) {
-    const { createPalAgentSession } = await import("./agent-session-UNUZAMRW.js");
+    const { createPalAgentSession } = await import("./agent-session-PLIPF3XG.js");
     return createPalAgentSession(prefs, detected, options);
   }
-  const { palAtWorkspace } = await import("./store-GDP2EW27.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();
@@ -8167,6 +9232,8 @@ async function createAgentSession(prefs, detected, options = {}) {
     }
     return readCurrentAuxiliaryCredential(found, signal);
   }, "currentCredentialFor");
+  let turnRouteTarget;
+  let lastAutoRoute;
   const providerForSession = /* @__PURE__ */ __name((sessionId) => primary.id === "zen" || primary.id === "zen-go" ? constructProvider(primary.id, det, model, { sessionId }) : provider, "providerForSession");
   const projectInstructions = new ProjectInstructionTracker(cwd);
   let sandbox;
@@ -8346,6 +9413,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(
@@ -8393,9 +9463,10 @@ async function createAgentSession(prefs, detected, options = {}) {
   const nativeSearchAvailable = provider.capabilities?.supportsHostedWebSearch === true && !options.structuredOutput && (provider.supportsHostedWebSearchFor?.(
     model,
     options.web?.search === "cached" ? "cached" : "live"
-  ) ?? true) && prefs.providers.length === 1;
+  ) ?? true) && prefs.providers.length === 1 && !options.routing;
   const webSearch = resolveWebSearch(options.web, nativeSearchAvailable);
   const nativeWebSearch = webSearch.mode !== "off" && webSearch.backend === "native" ? { mode: webSearch.mode } : void 0;
+  const routedWebSearch = /* @__PURE__ */ __name((routed) => nativeWebSearch && routed.provider.capabilities?.supportsHostedWebSearch === true && (routed.provider.supportsHostedWebSearchFor?.(routed.model, nativeWebSearch.mode) ?? true) ? nativeWebSearch : void 0, "routedWebSearch");
   let webSearchTool;
   if (webSearch.mode !== "off" && webSearch.backend === "exa") {
     webSearchTool = createWebSearchTool();
@@ -8607,8 +9678,8 @@ async function createAgentSession(prefs, detected, options = {}) {
         });
       }, "listModels"),
       buildProvider: /* @__PURE__ */ __name(async (invokingSessionId, selection) => {
-        const providerId = selection ? selection.provider : primary.id;
-        const selectedModel = selection?.model ?? model;
+        const providerId = selection ? selection.provider : turnRouteTarget?.provider ?? primary.id;
+        const selectedModel = selection?.model ?? turnRouteTarget?.model ?? model;
         if (!invokingSessionId && (providerId === "zen" || providerId === "zen-go"))
           throw new Error("A delegated provider requires its invoking conversation.");
         await ensureRegistered(providerId);
@@ -8654,6 +9725,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();
@@ -8723,7 +9861,9 @@ async function createAgentSession(prefs, detected, options = {}) {
     toolsets.push(toolset("extra", options.extraTools));
   }
   if (options.openUrl) toolsets.push(toolset("open-url", [createOpenUrlTool()]));
-  const operatorPals = await import("./operator-tools-LTPV3CH5.js");
+  const decisionTool = maybeCreateDecisionTool(options.decision, process.env);
+  if (decisionTool) toolsets.push(toolset("decide", [decisionTool]));
+  const operatorPals = await import("./operator-tools-H4MYC5PE.js");
   toolsets.push(
     readyWhen(
       toolset(
@@ -8856,6 +9996,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,
@@ -8914,6 +10055,58 @@ async function createAgentSession(prefs, detected, options = {}) {
       ...effort ? { effort } : {}
     };
   }, "pinnedResumeRoute");
+  const routingDecisionModel = options.routing ? maybeCreateDecisionModel(options.decision, process.env) : void 0;
+  const autoRouteFor = /* @__PURE__ */ __name(async (messages, sessionId, signal) => {
+    const routing = options.routing;
+    if (!routing) return void 0;
+    try {
+      const routed = await routeModel(
+        {
+          task: lastUserText(messages),
+          config: routing,
+          features: {
+            conversationLength: messages.length,
+            // Mounted is not used: the tool is on in every interactive session,
+            // so only a conversation that has driven the desktop keeps the small
+            // tier out.
+            usesComputerUse: options.enableComputerUse === true && conversationDrovePc(messages),
+            usesPal: false
+          },
+          signal
+        },
+        {
+          ...routingDecisionModel ? { model: routingDecisionModel } : {},
+          isAvailable: /* @__PURE__ */ __name((target) => {
+            const found = findDetected(detected, target.provider);
+            if (!found) return false;
+            return found.entry.constructible && canSelectModel(found.entry, found.apiKey, target.model);
+          }, "isAvailable"),
+          logger: cliLogger()
+        }
+      );
+      lastAutoRoute = { tier: routed.tier, model: routed.model };
+      if (routed.provider === primary.id && routed.model === model) {
+        turnRouteTarget = void 0;
+        return void 0;
+      }
+      const route = await pinnedResumeRoute(
+        { provider: routed.provider, model: routed.model },
+        sessionId,
+        signal
+      );
+      turnRouteTarget = route ? { provider: routed.provider, model: route.model } : void 0;
+      return route;
+    } catch (err) {
+      signal.throwIfAborted();
+      turnRouteTarget = void 0;
+      lastAutoRoute = void 0;
+      cliLogger().warn(
+        "auto model routing failed, using the session model",
+        exceptionAttributes(err)
+      );
+      return void 0;
+    }
+  }, "autoRouteFor");
   const kernelResume = /* @__PURE__ */ __name(({
     entry: entry2,
     sessionLog,
@@ -8935,6 +10128,7 @@ async function createAgentSession(prefs, detected, options = {}) {
     const resumedLimits = await readStoredTurnGuards(sessionLog, entry2.turnId) ?? resolveTurnGuards(options.limits);
     await prepareProviderCredential(ownedSignal);
     const route = await pinnedResumeRoute(pinned, entry2.sessionId, ownedSignal);
+    const resumeWebSearch = route ? routedWebSearch(route) : nativeWebSearch;
     const turnSkills = await turnSkillsFor(route?.model ?? model);
     const curatedMemory = readMemory(void 0, cwd);
     for (const notice of formatMemoryDiagnostics(curatedMemory)) cliLogger().warn(notice);
@@ -9054,7 +10248,7 @@ async function createAgentSession(prefs, detected, options = {}) {
         turnConfig: {
           model: route?.model ?? model,
           ...route?.effort ? { effort: route.effort } : {},
-          ...nativeWebSearch ? { webSearch: nativeWebSearch } : {},
+          ...resumeWebSearch ? { webSearch: resumeWebSearch } : {},
           ...sandbox.provider ? { sandbox: { workspace: sandboxWorkspace } } : {},
           ...resumedLimits,
           maxResponseTokens: 8192,
@@ -9201,6 +10395,9 @@ async function createAgentSession(prefs, detected, options = {}) {
     },
     providerSummary: entry.label,
     modelSummary: model,
+    get autoRoute() {
+      return lastAutoRoute;
+    },
     get imageAttachmentsSupported() {
       return providerForSession(scope.sessionId).capabilities?.supportsVision;
     },
@@ -9272,6 +10469,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) => {
@@ -9280,6 +10503,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.");
@@ -9420,6 +10644,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] : [],
@@ -9528,6 +10754,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.`);
@@ -9537,7 +10768,9 @@ async function createAgentSession(prefs, detected, options = {}) {
         }, "claimTurn");
         try {
           await prepareProviderCredential(signal);
-          const turnSkills = await turnSkillsFor(model);
+          const autoRoute = await autoRouteFor(messages, turnScope.sessionId, signal);
+          const turnWebSearch = autoRoute ? routedWebSearch(autoRoute) : nativeWebSearch;
+          const turnSkills = await turnSkillsFor(autoRoute?.model ?? model);
           const curatedMemory = readMemory(void 0, cwd);
           for (const notice of formatMemoryDiagnostics(curatedMemory)) {
             yield { kind: "context", text: notice, shed: false };
@@ -9640,6 +10873,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,
@@ -9649,6 +10895,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,
@@ -9700,7 +10947,7 @@ async function createAgentSession(prefs, detected, options = {}) {
           }
           try {
             for await (const event of runTurn({
-              provider: providerForSession(turnScope.sessionId),
+              provider: autoRoute?.provider ?? providerForSession(turnScope.sessionId),
               fileReadTracker: await observationsFor(turnScope.sessionId, messages),
               compactionConfig: compactionConfigFor(options.compaction),
               retainedToolPreviewChars: options.conversationSessions ? options.compaction?.retainedToolPreviewChars ?? 4e3 : void 0,
@@ -9716,8 +10963,9 @@ async function createAgentSession(prefs, detected, options = {}) {
               // that expired hours ago — and a chain whose own members are stale
               // is a fallback that fails for the reason the fallback exists to
               // survive. Building a driver is a client object, not a request.
-              fallbackProviders: fallbackPlan.build(currentToken, turnScope.sessionId),
-              model,
+              // A routed turn has no fallback chain, like a pinned resume.
+              fallbackProviders: autoRoute ? [] : fallbackPlan.build(currentToken, turnScope.sessionId),
+              model: autoRoute?.model ?? model,
               toolsets: runToolsets,
               ...screensConfig !== void 0 ? { toolResultGuardrails: screensConfig } : {},
               pluginManager: pluginRuntime?.manager,
@@ -9769,7 +11017,7 @@ async function createAgentSession(prefs, detected, options = {}) {
               completionInbox: await subagentRuntime?.completionInboxForTurn(turnId),
               promptContributions,
               ...webCapability ? { web: webCapability } : {},
-              ...nativeWebSearch ? { webSearch: nativeWebSearch } : {},
+              ...turnWebSearch ? { webSearch: turnWebSearch } : {},
               // Tasks join this turn's registry inside query, after the fork.
               // Keep the existing eager path unless deferral was requested.
               runtimeToolOverrides: {
@@ -9815,6 +11063,7 @@ async function createAgentSession(prefs, detected, options = {}) {
             delegatedInputWaiters.delete(turnId2);
             delegationScopes.delete(turnId2);
             delegationLimits.delete(turnId2);
+            delegatedWorkflowAuth.delete(turnId2);
             await subagentRuntime?.releaseTurn(turnId2);
           }
         }
@@ -10153,6 +11402,16 @@ async function listProviderModels(id, det) {
   return listing.kind === "ok" ? [...listing.models] : [];
 }
 __name(listProviderModels, "listProviderModels");
+var DESKTOP_USE_LOOKBACK = 20;
+function conversationDrovePc(messages) {
+  for (let i = messages.length - 1; i >= 0 && i >= messages.length - DESKTOP_USE_LOOKBACK; i--) {
+    const m = messages[i];
+    if (m?.role === "assistant" && m.toolCalls?.some((call) => call.function.name === COMPUTER_USE_TOOL_NAME))
+      return true;
+  }
+  return false;
+}
+__name(conversationDrovePc, "conversationDrovePc");
 function lastUserText(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
     const m = messages[i];
@@ -10485,9 +11744,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;
     }
@@ -10558,6 +11817,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 } : {}
@@ -10626,6 +11889,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 } : {},
@@ -10844,29 +12108,29 @@ __name(takeCallDiff, "takeCallDiff");
 function viewToSummary(view) {
   switch (view.kind) {
     case "generic":
-      return truncate(view.label, 120);
+      return truncate2(view.label, 120);
     case "diff":
-      return truncate(view.label ?? view.path ?? view.after.split("\n")[0] ?? "", 120);
+      return truncate2(view.label ?? view.path ?? view.after.split("\n")[0] ?? "", 120);
     case "terminal":
-      return truncate(view.command ?? view.output.split("\n")[0] ?? "", 120);
+      return truncate2(view.command ?? view.output.split("\n")[0] ?? "", 120);
   }
 }
 __name(viewToSummary, "viewToSummary");
 var RESULT_SUMMARY_WHOLE_MAX = 300;
 function resultSummaryLine(line) {
   const flat = line.replace(/\s+/g, " ");
-  return flat.length <= RESULT_SUMMARY_WHOLE_MAX ? flat : truncate(line, 120);
+  return flat.length <= RESULT_SUMMARY_WHOLE_MAX ? flat : truncate2(line, 120);
 }
 __name(resultSummaryLine, "resultSummaryLine");
 function summarySaysAll(line, summary) {
   return line === summary || line.replace(/\s+/g, " ") === summary;
 }
 __name(summarySaysAll, "summarySaysAll");
-function truncate(value, max) {
+function truncate2(value, max) {
   const oneLine3 = value.replace(/\s+/g, " ");
   return oneLine3.length > max ? `${oneLine3.slice(0, max - 1)}\u2026` : oneLine3;
 }
-__name(truncate, "truncate");
+__name(truncate2, "truncate");
 function diffContentLines(value) {
   if (value === "") return [];
   const lines = value.split("\n");
@@ -10913,16 +12177,16 @@ __name(resultToLines, "resultToLines");
 function firstLine3(result) {
   const payload = payloadString(result);
   if (payload !== null) {
-    return truncate(payload.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
+    return truncate2(payload.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
   }
   const obj = parseJsonObject(result);
   if (obj) {
-    if (obj.success === false && typeof obj.error === "string") return truncate(obj.error, 120);
+    if (obj.success === false && typeof obj.error === "string") return truncate2(obj.error, 120);
     const keys = Object.keys(obj);
     return keys.length > 0 ? `{ ${keys.slice(0, 6).join(", ")}${keys.length > 6 ? ", \u2026" : ""} }` : "{}";
   }
   const cleaned = cleanToolText(result.trim());
-  return truncate(cleaned.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
+  return truncate2(cleaned.split("\n").find((l) => l.trim().length > 0) ?? "", 120);
 }
 __name(firstLine3, "firstLine");
 function exceptionAttributes(err) {
@@ -11053,6 +12317,8 @@ export {
   renderRestoreNote,
   PluginSettingsStore,
   validateComposerSendSettings,
+  maybeCreateDecisionTool,
+  resolveAutoDefault,
   createCurrentCredentialReader,
   createTaskContextStep,
   createLiveModeControl,
@@ -11094,6 +12360,7 @@ export {
   computerUseHasControl,
   isCredentialRejection,
   listProviderModels,
+  conversationDrovePc,
   makeResumeHandler,
   makeHoldingResumeHandler,
   isPromptExempt,
@@ -11108,4 +12375,4 @@ export {
   RESULT_SUMMARY_WHOLE_MAX,
   resultSummaryLine
 };
-//# sourceMappingURL=chunk-TJJUB7VQ.js.map
+//# sourceMappingURL=chunk-SFUUN6B3.js.map