@multiclawcli/core 0.5.1 → 0.6.1

package/dist/index.js

@@ -191,6 +191,7 @@ Responsibilities:
 
 Deliverables (save to the working directory):
 - code-review.md \u2014 score (1\u201310), blocking issues, advisory issues, conclusion (Approved / Changes Required)
+- When the task includes a Delivery acceptance review contract, the final response must be only its JSON verdict, not the prose report. Approve only with no unresolved blocking issues; include file locations and fix directions in changes_required issues. The verdict is a review judgment, not proof that unexecuted tests passed.
 
 Principles: Judge the code, not the developer. A blocking issue must include the file path, the specific problem, and a fix direction. Advisory items should be actionable, not vague. If the code is solid, say so.`;
 var TASK4 = `## Project
@@ -358,12 +359,12 @@ There are three outcomes, and the first one matters most:
 
 Do not apply fixed rules \u2014 use your judgment based on the actual requirement and the code. A minor bug fix may need only a developer and code-reviewer; a complex new feature may need the full pipeline. Read the code to understand the impact before deciding.
 
-The console hands you the turns that came before this one. A requirement is often only interpretable next to them: "Postgres" is an answer, not a task, and the turn list is what tells you which question it answers. Read it as your own conversation \u2014 "you asked" is you. If you asked and got an answer, decide now; do not ask the same question again.
+The console hands you the turns that came before this one. A requirement is often only interpretable next to them: "Postgres" is an answer, not a task, and the turn list is what tells you which question it answers. Read it as your own conversation \u2014 "you asked" is you. If you asked and got an answer, decide now; do not ask the same question again. For every "run" decision, include a complete, standalone "requirement" that combines the original task goal with all clarification answers and constraints. Never pass only the latest short answer to the team.
 
 Output ONLY a single JSON object on its own line \u2014 no prose, no markdown fences:
 {"mode": "reply", "message": "your answer"}
 {"mode": "ask", "message": "your question"}
-{"mode": "run", "reason": "one sentence on why this set", "run": ["agent-id-1", "agent-id-2"]}`;
+{"mode": "run", "reason": "one sentence on why this set", "requirement": "the complete task and constraints", "run": ["agent-id-1", "agent-id-2"]}`;
 var TASK7 = `## Project
 {{projectName}}
 
@@ -378,7 +379,7 @@ Read the codebase to understand the current state, then decide how to handle the
 Output a single JSON object \u2014 exactly one of:
 {"mode": "reply", "message": "your answer"}
 {"mode": "ask", "message": "your question"}
-{"mode": "run", "reason": "one sentence on why this set", "run": ["agent-id", ...]}
+{"mode": "run", "reason": "one sentence on why this set", "requirement": "the complete task and constraints", "run": ["agent-id", ...]}
 Agent IDs must come from the Available Agents list above.`;
 function leader(overrides) {
   return {
@@ -692,6 +693,215 @@ var EventBus = class {
   }
 };
 
+// src/utils/abort.ts
+var ABORT_ERROR_NAME = "AbortError";
+function abortError(message = "Operation aborted") {
+  const err = new Error(message);
+  err.name = ABORT_ERROR_NAME;
+  return err;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === ABORT_ERROR_NAME;
+}
+
+// src/orchestrator/AgentSessionManager.ts
+var AgentSessionManager = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.closed = false;
+  }
+  async execute(runtime, task) {
+    if (this.closed) throw new Error("AgentSessionManager is closed");
+    if (this.resetting) throw new Error("AgentSessionManager is resetting");
+    if (task.signal?.aborted) throw abortError();
+    let entry3 = this.entries.get(task.agentId);
+    if (entry3?.busy || entry3?.session && entry3.session.state !== "idle" && entry3.session.state !== "closed") {
+      throw new Error(`Agent session ${task.agentId} is busy`);
+    }
+    if (entry3?.closing) await entry3.closing;
+    const fingerprint = JSON.stringify([
+      task.command,
+      task.args,
+      task.model,
+      task.workDir,
+      task.systemPrompt,
+      task.tools,
+      task.sessionId,
+      task.resume,
+      Boolean(task.onQuestion)
+    ]);
+    if (entry3 && (entry3.runtime !== runtime || entry3.fingerprint !== fingerprint || entry3.session?.state === "closed" || !runtime.openSession)) {
+      entry3.busy = true;
+      try {
+        await this.closeEntry(entry3);
+        this.entries.delete(task.agentId);
+      } finally {
+        entry3.busy = false;
+      }
+      entry3 = void 0;
+      if (this.closed || this.resetting) throw abortError();
+    }
+    if (task.signal?.aborted) throw abortError();
+    const openSession = runtime.openSession;
+    if (!openSession) return runtime.execute(task);
+    let detach;
+    if (!entry3) {
+      const startup = new AbortController();
+      const forwardAbort = () => startup.abort(task.signal?.reason);
+      task.signal?.addEventListener("abort", forwardAbort, { once: true });
+      detach = () => task.signal?.removeEventListener("abort", forwardAbort);
+      const created = {
+        runtime,
+        fingerprint,
+        startup,
+        busy: true,
+        onWarning: task.onWarning,
+        // Defer opening until the cache entry is installed, including synchronous failures.
+        opening: Promise.resolve().then(
+          () => openSession.call(runtime, {
+            agentId: task.agentId,
+            systemPrompt: task.systemPrompt,
+            tools: task.tools,
+            workDir: task.workDir,
+            command: task.command,
+            args: task.args,
+            model: task.model,
+            sessionId: task.sessionId,
+            resume: task.resume,
+            timeout: task.timeout,
+            questionForms: Boolean(task.onQuestion),
+            signal: startup.signal,
+            onWarning: (message) => created.onWarning?.(message)
+          })
+        ).then((session) => {
+          created.session = session;
+          return session;
+        })
+      };
+      entry3 = created;
+      this.entries.set(task.agentId, entry3);
+    } else {
+      entry3.busy = true;
+      entry3.onWarning = task.onWarning;
+    }
+    try {
+      const session = await entry3.opening;
+      detach?.();
+      detach = void 0;
+      if (entry3.startup.signal.aborted || this.closed || this.resetting) {
+        await this.closeEntry(entry3);
+        throw abortError();
+      }
+      if (session.state !== "idle") throw new Error(`Agent session ${task.agentId} is busy`);
+      return await session.prompt(task.prompt, {
+        signal: task.signal,
+        timeout: task.timeout,
+        onEvent: task.onEvent,
+        permissionMode: task.permissionMode,
+        onPermission: task.onPermission,
+        onQuestion: task.onQuestion
+      });
+    } finally {
+      detach?.();
+      entry3.onWarning = void 0;
+      try {
+        if (entry3.session?.state === "closed") {
+          await this.closeEntry(entry3);
+          if (this.entries.get(task.agentId) === entry3) this.entries.delete(task.agentId);
+        } else if (!entry3.session) {
+          if (this.entries.get(task.agentId) === entry3) this.entries.delete(task.agentId);
+        }
+      } finally {
+        entry3.busy = false;
+      }
+    }
+  }
+  /**
+   * Deliver a message into every session that is running a turn right now.
+   *
+   * Only `running` sessions are candidates, and that is the whole safety
+   * argument: a session between turns has nothing to inject into, and asking a
+   * provider to steer an idle session makes it *start* a turn that this manager
+   * never scheduled — one whose output belongs to no turn and which nothing
+   * would ever settle. Sessions that are idle are therefore not reported as
+   * failures but simply absent, and the caller sees an empty list.
+   *
+   * One agent failing never stops the others: each report stands alone, because
+   * the caller has to be able to say "architect took it, qa did not" rather than
+   * "steering failed".
+   */
+  async supplement(text) {
+    if (this.closed) return [];
+    const targets = [...this.entries.entries()].filter(
+      ([, entry3]) => entry3.session?.state === "running"
+    );
+    return await Promise.all(
+      targets.map(async ([agentId, entry3]) => {
+        const session = entry3.session;
+        if (!session) return { agentId, status: "idle" };
+        if (!session.capabilities.supplement || !session.supplement) {
+          return { agentId, status: "unsupported" };
+        }
+        try {
+          return { agentId, status: (await session.supplement(text)).status };
+        } catch (error) {
+          return {
+            agentId,
+            status: "error",
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      })
+    );
+  }
+  /** Closes all sessions and permits a fresh conversation after cleanup completes. */
+  reset() {
+    if (this.closing) return this.closing;
+    if (this.resetting) return this.resetting;
+    this.resetting = this.drain().finally(() => {
+      this.resetting = void 0;
+    });
+    return this.resetting;
+  }
+  /** Terminal, idempotent cleanup barrier. No new executions may start. */
+  close() {
+    if (this.closing) return this.closing;
+    this.closed = true;
+    this.closing = this.resetting ?? this.drain();
+    return this.closing;
+  }
+  async drain() {
+    const entries = [...this.entries.entries()];
+    for (const [, entry3] of entries) entry3.startup.abort();
+    const results = await Promise.allSettled(
+      entries.map(async ([id, entry3]) => {
+        await this.closeEntry(entry3);
+        if (this.entries.get(id) === entry3) this.entries.delete(id);
+      })
+    );
+    const errors = results.flatMap(
+      (result) => result.status === "rejected" ? [result.reason] : []
+    );
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1) throw new AggregateError(errors, "Agent session cleanup failed");
+  }
+  closeEntry(entry3) {
+    if (!entry3.closing) {
+      entry3.closing = (async () => {
+        let session;
+        try {
+          session = await entry3.opening;
+        } catch (error) {
+          if (isAbortError(error)) return;
+          throw error;
+        }
+        await session.close();
+      })();
+    }
+    return entry3.closing;
+  }
+};
+
 // src/orchestrator/Orchestrator.ts
 import * as fs4 from "fs";
 import * as path5 from "path";
@@ -967,7 +1177,14 @@ function asDecision(value) {
     const run = record.run;
     if (!Array.isArray(run) || !run.every((id) => typeof id === "string")) return void 0;
     const reason = typeof record.reason === "string" ? record.reason.trim() : "";
-    return reason ? { mode: "run", run, reason } : { mode: "run", run };
+    const requirement = typeof record.requirement === "string" ? record.requirement.trim() : "";
+    if ("requirement" in record && !requirement) return void 0;
+    return {
+      mode: "run",
+      run,
+      ...reason ? { reason } : {},
+      ...requirement ? { requirement } : {}
+    };
   }
   return void 0;
 }
@@ -1064,17 +1281,6 @@ function resolveExecutable(command) {
   return resolveBridgeBinary(command);
 }
 
-// src/utils/abort.ts
-var ABORT_ERROR_NAME = "AbortError";
-function abortError(message = "Operation aborted") {
-  const err = new Error(message);
-  err.name = ABORT_ERROR_NAME;
-  return err;
-}
-function isAbortError(err) {
-  return err instanceof Error && err.name === ABORT_ERROR_NAME;
-}
-
 // src/utils/errors.ts
 var PermanentError = class extends Error {
   constructor(message) {
@@ -1094,8 +1300,16 @@ var RuntimeBase = class {
 var discoveredModels = /* @__PURE__ */ new Map();
 var KILL_ESCALATION_MS = 3e3;
 var CANCEL_GRACE_MS = 2e3;
+var CLEANUP_ACK_MS = 3e3;
+var STEER_ACK_MS = 15e3;
+var DEFAULT_TIMEOUT_MS = 6e5;
 var DEFAULT_COMMAND2 = "opencode";
 var DEFAULT_ARGS = ["acp"];
+var STEER_METHOD = "_session/steering";
+function advertisesSteering(init) {
+  const steering = init._meta?.steering;
+  return isRecord(steering) && steering.supported === true;
+}
 var BASE_CAPABILITIES = {
   streaming: true,
   sessions: true,
@@ -1142,15 +1356,23 @@ var KIND_TO_TOOLS = {
   search: ["Grep", "Glob"],
   fetch: ["WebFetch"]
 };
+function toolPermitted(params, tools) {
+  const allowed = new Set(tools.map((tool) => tool.toLowerCase()));
+  const name = params.toolCall.name ?? void 0;
+  return name !== void 0 ? allowed.has(name.toLowerCase()) : (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some(
+    (tool) => allowed.has(tool.toLowerCase())
+  );
+}
 function decidePermission(params, tools, sessionId) {
   if (sessionId !== void 0 && params.sessionId !== sessionId) {
     return { response: { outcome: { outcome: "cancelled" } } };
   }
-  const allowed = new Set(tools.map((tool) => tool.toLowerCase()));
   const name = params.toolCall.name ?? void 0;
   const kind = params.toolCall.kind ?? void 0;
-  const approved = name !== void 0 ? allowed.has(name.toLowerCase()) : (KIND_TO_TOOLS[kind ?? ""] ?? []).some((candidate) => allowed.has(candidate.toLowerCase()));
-  const option = approved ? params.options.find((o) => o.kind === "allow_always") ?? params.options.find((o) => o.kind === "allow_once") : params.options.find((o) => o.kind === "reject_always") ?? params.options.find((o) => o.kind === "reject_once");
+  const approved = toolPermitted(params, tools);
+  const option = params.options.find(
+    (o) => approved ? o.kind === "allow_once" : o.kind === "reject_once"
+  );
   const response = option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
   if (approved) return { response };
   return {
@@ -1163,6 +1385,68 @@ function decidePermission(params, tools, sessionId) {
     }
   };
 }
+var FORM_ANNOTATIONS = ["title", "description", "default", "_meta"];
+function knownFormKeys(value, keys) {
+  return Object.keys(value).every((key) => keys.includes(key) || FORM_ANNOTATIONS.includes(key));
+}
+function validFormBound(value, integer = false) {
+  return value == null || typeof value === "number" && Number.isFinite(value) && (!integer || Number.isInteger(value) && value >= 0);
+}
+function titledChoices(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(
+    (option) => isRecord(option) && knownFormKeys(option, ["const"]) && typeof option.const === "string"
+  );
+}
+function supportedQuestionSchema(schema) {
+  if (!isRecord(schema) || schema.type !== void 0 && schema.type !== "object" || !knownFormKeys(schema, ["type", "properties", "required"]))
+    return false;
+  const properties = schema.properties ?? {};
+  if (!isRecord(properties)) return false;
+  if (schema.required != null && (!Array.isArray(schema.required) || !schema.required.every(
+    (key) => typeof key === "string" && Object.getOwnPropertyDescriptor(properties, key) !== void 0
+  )))
+    return false;
+  return Object.values(properties).every((field) => {
+    if (!isRecord(field)) return false;
+    if (field.type === "string") {
+      return knownFormKeys(field, ["type", "enum", "oneOf", "minLength", "maxLength"]) && validFormBound(field.minLength, true) && validFormBound(field.maxLength, true) && (field.enum == null || Array.isArray(field.enum) && field.enum.length > 0 && field.enum.every((value) => typeof value === "string")) && (field.oneOf == null || titledChoices(field.oneOf));
+    }
+    if (field.type === "boolean") return knownFormKeys(field, ["type"]);
+    if (field.type === "number" || field.type === "integer") {
+      return knownFormKeys(field, ["type", "minimum", "maximum"]) && validFormBound(field.minimum) && validFormBound(field.maximum);
+    }
+    if (field.type !== "array" || !isRecord(field.items) || !knownFormKeys(field, ["type", "items", "minItems", "maxItems"]) || !validFormBound(field.minItems, true) || !validFormBound(field.maxItems, true))
+      return false;
+    return knownFormKeys(field.items, ["type", "enum"]) && field.items.type === "string" && Array.isArray(field.items.enum) && field.items.enum.length > 0 && field.items.enum.every((value) => typeof value === "string") || knownFormKeys(field.items, ["anyOf"]) && field.items.type === void 0 && titledChoices(field.items.anyOf);
+  });
+}
+function validateRuntimeQuestionContent(schema, content) {
+  if (!supportedQuestionSchema(schema) || !isRecord(content)) return false;
+  if (Object.getOwnPropertySymbols(content).length > 0 || Object.getOwnPropertyNames(content).some((key) => {
+    const descriptor = Object.getOwnPropertyDescriptor(content, key);
+    return !descriptor?.enumerable || !("value" in descriptor);
+  }))
+    return false;
+  const properties = schema.properties ?? {};
+  if ((schema.required ?? []).some(
+    (key) => Object.getOwnPropertyDescriptor(content, key) === void 0
+  ))
+    return false;
+  return Object.entries(content).every(([key, value]) => {
+    if (Object.getOwnPropertyDescriptor(properties, key) === void 0) return false;
+    const field = properties[key];
+    if (field.type === "boolean") return typeof value === "boolean";
+    if (field.type === "number" || field.type === "integer") {
+      return typeof value === "number" && Number.isFinite(value) && (field.type !== "integer" || Number.isInteger(value)) && (typeof field.minimum !== "number" || value >= field.minimum) && (typeof field.maximum !== "number" || value <= field.maximum);
+    }
+    if (field.type === "string") {
+      return typeof value === "string" && (typeof field.minLength !== "number" || [...value].length >= field.minLength) && (typeof field.maxLength !== "number" || [...value].length <= field.maxLength) && (!Array.isArray(field.enum) || field.enum.includes(value)) && (!Array.isArray(field.oneOf) || field.oneOf.some((option) => isRecord(option) && option.const === value));
+    }
+    const items = field.items;
+    const choices = Array.isArray(items.enum) ? items.enum : items.anyOf.map((option) => option.const);
+    return Array.isArray(value) && value.every((item) => typeof item === "string" && choices.includes(item)) && new Set(value).size === value.length && (typeof field.minItems !== "number" || value.length >= field.minItems) && (typeof field.maxItems !== "number" || value.length <= field.maxItems);
+  });
+}
 function withAuthHint(acp, err) {
   const error = err instanceof Error ? err : new Error(String(err));
   if (error instanceof acp.RequestError && error.code === acp.RequestError.authRequired().code) {
@@ -1173,6 +1457,13 @@ function withAuthHint(acp, err) {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
+function timeoutMs(value) {
+  const timeout = value ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeout) || timeout < 0 || timeout > 2147483647) {
+    throw new PermanentError("ACP timeout must be a finite non-negative timer duration");
+  }
+  return timeout;
+}
 var AcpRuntime = class extends RuntimeBase {
   constructor() {
     super(...arguments);
@@ -1183,10 +1474,6 @@ var AcpRuntime = class extends RuntimeBase {
     return {
       name: this.name,
       available: resolveExecutable(command) !== null,
-      // `tools` is the one capability that depends on the bridge: only some of
-      // them read an allowlist out of `_meta`, and none negotiates it. Claiming
-      // it for a bridge that ignores `task.tools` would let a caller believe a
-      // restriction landed when the agent is running unrestricted.
       capabilities: {
         ...BASE_CAPABILITIES,
         tools: specForCommand(command)?.tools ?? false,
@@ -1195,126 +1482,216 @@ var AcpRuntime = class extends RuntimeBase {
     };
   }
   async execute(task) {
-    const acp = await import("@agentclientprotocol/sdk");
-    const command = task.command ?? DEFAULT_COMMAND2;
-    const args = task.args ?? DEFAULT_ARGS;
-    const exe = resolveExecutable(command) ?? command;
-    const spec = specForCommand(command);
-    const meta = spec?.meta?.(task);
-    const promptText = meta === void 0 && task.systemPrompt ? `${task.systemPrompt}
-
----
-
-${task.prompt}` : task.prompt;
-    return new Promise((resolve4, reject) => {
-      const child = spawn(exe, args, {
-        cwd: task.workDir,
+    const { prompt, onEvent, signal, permissionMode, onPermission, onQuestion, ...options } = task;
+    const startup = new AbortController();
+    const forward = () => startup.abort();
+    if (signal?.aborted) startup.abort();
+    signal?.addEventListener("abort", forward, { once: true });
+    let session;
+    try {
+      session = await this.openSession({
+        ...options,
+        questionForms: Boolean(onQuestion),
+        signal: startup.signal
+      });
+    } finally {
+      signal?.removeEventListener("abort", forward);
+    }
+    try {
+      return await session.prompt(prompt, {
+        signal,
+        timeout: task.timeout,
+        onEvent,
+        permissionMode,
+        onPermission,
+        onQuestion
+      });
+    } finally {
+      await session.close();
+    }
+  }
+  async openSession(options) {
+    if (options.signal?.aborted) throw abortError();
+    if (options.resume === "fork") {
+      throw new PermanentError("ACP does not support forked sessions");
+    }
+    const defaultTimeout = timeoutMs(options.timeout);
+    const questionForms = options.questionForms === true;
+    let startupReject;
+    const startupFailure = new Promise((_, reject) => {
+      startupReject = reject;
+    });
+    let failSession;
+    const failStartup = (error) => {
+      startupReject(error);
+      failSession?.(error);
+    };
+    const onSessionAbort = () => failStartup(abortError());
+    options.signal?.addEventListener("abort", onSessionAbort, { once: true });
+    const startupTimer = setTimeout(
+      () => failStartup(new Error(`acp startup timed out (${defaultTimeout}ms)`)),
+      defaultTimeout
+    );
+    let cleanup;
+    try {
+      const acp = await Promise.race([import("@agentclientprotocol/sdk"), startupFailure]);
+      if (options.signal?.aborted) throw abortError();
+      const command = options.command ?? DEFAULT_COMMAND2;
+      const spec = specForCommand(command);
+      const meta = spec?.meta?.({ ...options, prompt: "", timeout: defaultTimeout });
+      const child = spawn(resolveExecutable(command) ?? command, options.args ?? DEFAULT_ARGS, {
+        cwd: options.workDir,
         env: process.env,
-        // Own process group, so a kill reaches whatever the agent spawned too.
         detached: true
       });
-      const signalChild = (signal) => {
-        try {
-          child.kill(signal);
-        } catch {
-        }
-      };
+      let state = "idle";
+      let sessionId = "";
+      let steeringSupported = false;
+      let active;
+      let childClosed = false;
+      let terminalError;
+      let errorOutput = "";
+      let escalation;
+      let acknowledgement;
+      let closePromise;
+      let closeResolve;
+      let closeReject;
+      let connection;
       const killTree = (signal) => {
-        if (child.pid === void 0) {
-          signalChild(signal);
-          return;
+        if (child.pid !== void 0) {
+          try {
+            process.kill(-child.pid, signal);
+            return;
+          } catch {
+          }
         }
         try {
-          process.kill(-child.pid, signal);
+          child.kill(signal);
         } catch {
-          signalChild(signal);
         }
       };
-      let stopped = false;
-      let escalation;
-      const stop = (signal) => {
-        if (stopped) return;
-        stopped = true;
-        killTree(signal);
-        escalation = setTimeout(() => killTree("SIGKILL"), KILL_ESCALATION_MS);
-        escalation.unref();
-      };
-      let timedOut = false;
-      const timer = task.timeout === void 0 ? void 0 : setTimeout(() => {
-        timedOut = true;
-        stop("SIGTERM");
-      }, task.timeout);
-      let cancelGrace;
-      const clearTimers = () => {
-        if (timer) clearTimeout(timer);
-        if (escalation) clearTimeout(escalation);
-        if (cancelGrace) clearTimeout(cancelGrace);
+      const emitForTurn = (turn, event) => {
+        turn.options.onEvent?.({
+          ...event,
+          runId: turn.runId,
+          agentId: options.agentId,
+          seq: turn.seq++
+        });
       };
-      const runId = randomUUID();
-      let seq = 0;
       const emit = (event) => {
-        task.onEvent?.({ ...event, runId, agentId: task.agentId, seq: seq++ });
+        if (active) emitForTurn(active, event);
       };
-      const warn = (message) => {
-        if (task.onWarning) {
-          task.onWarning(message);
-          return;
-        }
-        process.stderr.write(`[multiclaw] Warning: ${message}
-`);
+      const settleTurn = (turn, output, error) => {
+        if (active !== turn) return;
+        turn.decisions.abort();
+        if (turn.timer) clearTimeout(turn.timer);
+        if (turn.cancelTimer) clearTimeout(turn.cancelTimer);
+        if (turn.onAbort) turn.options.signal?.removeEventListener("abort", turn.onAbort);
+        active = void 0;
+        if (state === "running" || state === "cancelling") state = "idle";
+        if (error) {
+          if (closePromise) {
+            void closePromise.then(
+              () => turn.reject(error),
+              (cleanupError) => turn.reject(cleanupError)
+            );
+          } else turn.reject(error);
+        } else if (output) turn.resolve(output);
       };
-      let sessionId;
-      let agentText = "";
-      let errorOutput = "";
-      let connectionError;
-      let settled = false;
-      let lastUsage;
-      let lastCost;
-      const settleResolve = (output) => {
-        if (settled) return;
-        settled = true;
-        clearTimers();
-        resolve4(output);
+      const clearCleanupTimers = () => {
+        if (escalation) clearTimeout(escalation);
+        if (acknowledgement) clearTimeout(acknowledgement);
+      };
+      const close = () => {
+        if (closePromise) return closePromise;
+        closePromise = new Promise((resolve4, reject) => {
+          closeResolve = resolve4;
+          closeReject = reject;
+        });
+        options.signal?.removeEventListener("abort", onSessionAbort);
+        clearTimeout(startupTimer);
+        state = "closing";
+        if (active) settleTurn(active, void 0, active.error ?? terminalError ?? abortError());
+        if (childClosed) {
+          state = "closed";
+          closeResolve?.();
+          return closePromise;
+        }
+        escalation = setTimeout(() => {
+          killTree("SIGKILL");
+          if (childClosed) return;
+          acknowledgement = setTimeout(() => {
+            state = "closed";
+            clearCleanupTimers();
+            closeReject?.(new Error(`${command} cleanup failed: no child close after SIGKILL`));
+          }, CLEANUP_ACK_MS);
+        }, KILL_ESCALATION_MS);
+        try {
+          connection?.close();
+        } catch {
+        }
+        killTree("SIGTERM");
+        return closePromise;
       };
-      const settleReject = (error) => {
-        if (settled) return;
-        settled = true;
-        clearTimers();
-        reject(error);
+      const fail = (error) => {
+        terminalError ??= error;
+        startupReject(terminalError);
+        void close().catch(() => {
+        });
       };
+      failSession = fail;
+      cleanup = close;
+      const stderrDecoder = new StringDecoder("utf8");
+      child.stderr.on("data", (data) => {
+        errorOutput += stderrDecoder.write(data);
+      });
+      child.on("close", (code) => {
+        childClosed = true;
+        errorOutput += stderrDecoder.end();
+        clearCleanupTimers();
+        clearTimeout(startupTimer);
+        options.signal?.removeEventListener("abort", onSessionAbort);
+        if (!closePromise) {
+          fail(new Error(`${command} exited with code ${code}: ${errorOutput}`));
+        }
+        state = "closed";
+        try {
+          connection?.close();
+        } catch {
+        }
+        closeResolve?.();
+      });
+      child.on("error", (error) => {
+        fail(new PermanentError(`Failed to start ${command}: ${error.message}`));
+      });
       const handleUpdate = (notification) => {
-        if (sessionId && notification.sessionId !== sessionId) return;
+        const turn = active;
+        if (!turn || notification.sessionId !== sessionId) return;
         const update = notification.update;
         switch (update.sessionUpdate) {
           case "agent_message_chunk": {
             const text = textOf(update.content);
-            if (text === void 0) {
-              emit({ type: "raw", vendor: "acp", payload: update });
-              break;
+            if (text === void 0) emit({ type: "raw", vendor: "acp", payload: update });
+            else {
+              turn.output += text;
+              emit({ type: "message_delta", role: "agent", text });
             }
-            agentText += text;
-            emit({ type: "message_delta", role: "agent", text });
-            break;
-          }
-          case "user_message_chunk": {
-            const text = textOf(update.content);
-            if (text === void 0) {
-              emit({ type: "raw", vendor: "acp", payload: update });
-              break;
-            }
-            emit({ type: "message_delta", role: "user", text });
             break;
           }
+          case "user_message_chunk":
           case "agent_thought_chunk": {
             const text = textOf(update.content);
-            if (text === void 0) {
-              emit({ type: "raw", vendor: "acp", payload: update });
-              break;
+            if (text === void 0) emit({ type: "raw", vendor: "acp", payload: update });
+            else {
+              emit({
+                type: "message_delta",
+                role: update.sessionUpdate === "user_message_chunk" ? "user" : "thought",
+                text
+              });
             }
-            emit({ type: "message_delta", role: "thought", text });
             break;
           }
-          case "tool_call": {
+          case "tool_call":
             emit({
               type: "tool_call",
               id: update.toolCallId,
@@ -1322,8 +1699,7 @@ ${task.prompt}` : task.prompt;
               input: update.rawInput
             });
             break;
-          }
-          case "tool_call_update": {
+          case "tool_call_update":
             emit({
               type: "tool_result",
               id: update.toolCallId,
@@ -1331,29 +1707,21 @@ ${task.prompt}` : task.prompt;
               isError: update.status === "failed"
             });
             break;
-          }
-          case "plan": {
+          case "plan":
             emit({ type: "plan", entries: update.entries.map((entry3) => entry3.content) });
             break;
-          }
           case "usage_update": {
-            const contextTokens = typeof update.used === "number" ? update.used : void 0;
-            const contextSize = typeof update.size === "number" ? update.size : void 0;
-            if (contextTokens !== void 0 && contextSize !== void 0) {
-              lastUsage = { contextTokens, contextSize };
-              emit({ type: "usage", contextTokens, contextSize });
+            if (typeof update.used === "number" && typeof update.size === "number") {
+              turn.usage = { contextTokens: update.used, contextSize: update.size };
+              emit({ type: "usage", ...turn.usage });
             }
             const cost = isRecord(update.cost) ? update.cost : void 0;
-            const amount = typeof cost?.amount === "number" ? cost.amount : void 0;
-            const currency = typeof cost?.currency === "string" ? cost.currency : void 0;
-            if (amount !== void 0 && currency !== void 0) {
-              lastCost = { amount, currency };
-              const costUsd = currency.toLowerCase() === "usd" ? amount : void 0;
+            if (typeof cost?.amount === "number" && typeof cost.currency === "string") {
+              turn.cost = { amount: cost.amount, currency: cost.currency };
               emit({
                 type: "cost",
-                amount,
-                currency,
-                ...costUsd !== void 0 ? { costUsd } : {}
+                ...turn.cost,
+                ...cost.currency.toLowerCase() === "usd" ? { costUsd: cost.amount } : {}
               });
             }
             break;
@@ -1363,154 +1731,372 @@ ${task.prompt}` : task.prompt;
         }
       };
       const app = acp.client({ name: "multiclaw" });
-      app.onNotification(acp.methods.client.session.update, (nctx) => {
-        handleUpdate(nctx.params);
+      app.onNotification(acp.methods.client.session.update, (context) => {
+        handleUpdate(context.params);
       });
-      app.onRequest(acp.methods.client.session.requestPermission, (rctx) => {
-        const { response, rejected } = decidePermission(rctx.params, task.tools, sessionId);
+      app.onRequest(acp.methods.client.session.requestPermission, async (context) => {
+        const cancelled = { outcome: { outcome: "cancelled" } };
+        const turn = active;
+        const params = context.params;
+        if (state !== "running" || !turn || params.sessionId !== sessionId || context.signal.aborted)
+          return cancelled;
+        const mode = turn.options.permissionMode ?? "auto";
+        const { response, rejected } = decidePermission(params, options.tools, sessionId);
         if (rejected) {
+          warn("Tool permission denied by the configured tools policy.");
           emit({
             type: "raw",
             vendor: "acp",
             payload: { type: "permission_rejected", ...rejected }
           });
+          return response;
+        }
+        if (mode === "auto") return response;
+        if (mode !== "ask" || !turn.options.onPermission) {
+          warn(
+            mode === "ask" ? "Tool permission cancelled: no approval handler is available." : "Tool permission denied by the configured approval mode."
+          );
+          return cancelled;
+        }
+        const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
+        const offered = new Set(params.options.map((option) => option.optionId));
+        const request = {
+          requestId: randomUUID(),
+          runId: turn.runId,
+          agentId: options.agentId,
+          seq: turn.seq++,
+          sessionId,
+          toolCallId: params.toolCall.toolCallId,
+          title: params.toolCall.title ?? params.toolCall.name ?? "Tool permission",
+          toolName: params.toolCall.name ?? void 0,
+          kind: params.toolCall.kind ?? void 0,
+          input: params.toolCall.rawInput,
+          options: params.options.map(({ optionId, name, kind }) => ({ optionId, name, kind }))
+        };
+        let onAbort;
+        const aborted = new Promise((resolve4) => {
+          onAbort = () => resolve4(void 0);
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted) onAbort();
+        });
+        try {
+          const optionId = await Promise.race([
+            Promise.resolve().then(
+              () => signal.aborted ? void 0 : turn.options.onPermission?.(request, signal)
+            ),
+            aborted
+          ]);
+          if (signal.aborted || active !== turn || state !== "running") return cancelled;
+          return optionId !== void 0 && offered.has(optionId) ? { outcome: { outcome: "selected", optionId } } : cancelled;
+        } catch {
+          return cancelled;
+        } finally {
+          signal.removeEventListener("abort", onAbort);
         }
-        return response;
-      });
-      const stderrDecoder = new StringDecoder("utf8");
-      child.stderr.on("data", (d) => {
-        errorOutput += stderrDecoder.write(d);
       });
-      const stream = acp.ndJsonStream(
-        Writable.toWeb(child.stdin),
-        Readable.toWeb(child.stdout)
-      );
-      const connection = app.connect(stream);
-      const ctx = connection.agent;
-      const teardown = () => {
+      app.onRequest(acp.methods.client.elicitation.create, async (context) => {
+        const cancelled = {
+          action: "cancel"
+        };
+        const turn = active;
+        const params = context.params;
+        if (state !== "running" || !turn || context.signal.aborted || !("sessionId" in params) || params.sessionId !== sessionId)
+          return cancelled;
+        if (params.mode !== "form" || !supportedQuestionSchema(params.requestedSchema)) {
+          warn("Structured question cancelled: unsupported form mode or schema.");
+          return cancelled;
+        }
+        if (!questionForms || !turn.options.onQuestion) {
+          warn("Structured question cancelled: no negotiated question handler is available.");
+          return cancelled;
+        }
+        const schema = structuredClone(params.requestedSchema);
+        const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
+        const request = {
+          requestId: randomUUID(),
+          runId: turn.runId,
+          agentId: options.agentId,
+          seq: turn.seq++,
+          sessionId,
+          toolCallId: "toolCallId" in params && typeof params.toolCallId === "string" ? params.toolCallId : void 0,
+          message: params.message,
+          requestedSchema: structuredClone(schema)
+        };
+        let onAbort;
+        const aborted = new Promise((resolve4) => {
+          onAbort = () => resolve4(void 0);
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted) onAbort();
+        });
         try {
-          connection.close();
+          const response = await Promise.race([
+            Promise.resolve().then(
+              () => signal.aborted ? void 0 : turn.options.onQuestion?.(request, signal)
+            ),
+            aborted
+          ]);
+          if (signal.aborted || active !== turn || state !== "running" || !response)
+            return cancelled;
+          if (response.action === "accept") {
+            if (!validateRuntimeQuestionContent(schema, response.content)) {
+              warn("Structured question cancelled: the answer does not match the requested schema.");
+              return cancelled;
+            }
+            return { action: "accept", content: structuredClone(response.content) };
+          }
+          return response.action === "decline" ? { action: "decline" } : cancelled;
         } catch {
+          return cancelled;
+        } finally {
+          signal.removeEventListener("abort", onAbort);
         }
-        stop("SIGTERM");
+      });
+      connection = app.connect(
+        acp.ndJsonStream(
+          Writable.toWeb(child.stdin),
+          Readable.toWeb(child.stdout)
+        )
+      );
+      const ctx = connection.agent;
+      const onConnectionClosed = () => {
+        if (!closePromise) fail(new Error(`${command} ACP connection closed: ${errorOutput}`));
       };
-      task.signal?.addEventListener(
-        "abort",
-        () => {
-          if (sessionId) {
-            void ctx.notify(acp.methods.agent.session.cancel, { sessionId }).catch(() => {
+      connection.closed?.then(onConnectionClosed, onConnectionClosed);
+      const cancelTurn = () => {
+        const turn = active;
+        if (!turn) return closePromise ?? Promise.resolve();
+        if (turn.cancellation) return turn.cancellation;
+        state = "cancelling";
+        turn.decisions.abort();
+        const waitForCleanup = async () => {
+          if (closePromise) await closePromise;
+        };
+        turn.cancellation = turn.promise.then(waitForCleanup, waitForCleanup);
+        turn.cancelTimer = setTimeout(() => {
+          fail(turn.error ?? abortError());
+        }, CANCEL_GRACE_MS);
+        void Promise.resolve().then(() => {
+          if (active === turn) return ctx.notify(acp.methods.agent.session.cancel, { sessionId });
+        }).catch((error) => {
+          if (active === turn) fail(withAuthHint(acp, error));
+        });
+        return turn.cancellation;
+      };
+      const supplement = async (text, supplementOptions = {}) => {
+        if (!steeringSupported) {
+          throw new Error(`${command} does not accept mid-turn input`);
+        }
+        const turn = active;
+        if (!turn || state !== "running") return { status: "idle" };
+        if (supplementOptions.signal?.aborted) throw abortError();
+        let timer;
+        try {
+          const response = await Promise.race([
+            ctx.request(STEER_METHOD, {
+              sessionId,
+              prompt: [{ type: "text", text }],
+              _meta: { steering: { idleBehavior: "promptRequired" } }
+            }),
+            new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error(`steering was not acknowledged within ${STEER_ACK_MS}ms`)),
+                STEER_ACK_MS
+              );
+            })
+          ]);
+          if (active !== turn) return { status: "idle" };
+          const outcome = response?.outcome;
+          if (outcome === "injected") return { status: "injected" };
+          if (outcome === "promptRequired") return { status: "idle" };
+          if (outcome === "startedNewTurn") {
+            await Promise.resolve().then(() => ctx.notify(acp.methods.agent.session.cancel, { sessionId })).catch(() => {
             });
+            return { status: "idle" };
           }
-          cancelGrace = setTimeout(() => stop("SIGTERM"), CANCEL_GRACE_MS);
-          cancelGrace.unref();
-        },
-        { once: true }
-      );
-      child.on("close", (code) => {
-        errorOutput += stderrDecoder.end();
-        if (settled) return;
-        if (task.signal?.aborted) {
-          settleReject(abortError());
-          return;
+          if (outcome === "failed") {
+            throw new Error("the agent could not apply the mid-turn message");
+          }
+          throw new Error(`unexpected steering outcome: ${JSON.stringify(outcome ?? null)}`);
+        } finally {
+          if (timer) clearTimeout(timer);
         }
-        if (timedOut) {
-          settleReject(new Error(`acp timed out (${task.timeout}ms)`));
-          return;
+      };
+      const prompt = (text, promptOptions = {}) => {
+        if (state !== "idle") {
+          return Promise.reject(new Error(`Cannot prompt ACP session while ${state}`));
         }
-        if (connectionError) {
-          settleReject(connectionError);
-          return;
+        if (options.signal?.aborted || promptOptions.signal?.aborted) {
+          return Promise.reject(abortError());
         }
-        settleReject(new Error(`${command} exited with code ${code}: ${errorOutput}`));
-      });
-      child.on("error", (err) => {
-        settleReject(new PermanentError(`Failed to start ${command}: ${err.message}`));
-      });
-      const run = async () => {
+        let duration;
+        try {
+          duration = timeoutMs(promptOptions.timeout ?? defaultTimeout);
+        } catch (error) {
+          return Promise.reject(error);
+        }
+        let resolve4;
+        let reject;
+        const promise = new Promise((res, rej) => {
+          resolve4 = res;
+          reject = rej;
+        });
+        const turn = {
+          runId: randomUUID(),
+          seq: 0,
+          options: promptOptions,
+          output: "",
+          decisions: new AbortController(),
+          promise,
+          resolve: resolve4,
+          reject
+        };
+        active = turn;
+        state = "running";
+        turn.onAbort = () => {
+          turn.error = abortError();
+          void cancelTurn().catch(() => {
+          });
+        };
+        promptOptions.signal?.addEventListener("abort", turn.onAbort, { once: true });
+        turn.timer = setTimeout(() => {
+          turn.error = new Error(`acp timed out (${duration}ms)`);
+          fail(turn.error);
+        }, duration);
+        const run = async () => {
+          emit({ type: "run_started", model: options.model });
+          if (active !== turn) return;
+          const response = await ctx.request(acp.methods.agent.session.prompt, {
+            sessionId,
+            prompt: [
+              {
+                type: "text",
+                text: meta === void 0 && options.systemPrompt ? `${options.systemPrompt}
+
+---
+
+${text}` : text
+              }
+            ]
+          });
+          if (active !== turn) return;
+          if (turn.error) {
+            settleTurn(turn, void 0, turn.error);
+            return;
+          }
+          const stopReason = mapStopReason(response.stopReason);
+          settleTurn(turn, {
+            output: turn.output,
+            exitCode: stopReason === "success" ? 0 : 1,
+            sessionId,
+            stopReason,
+            ...turn.usage ? { usage: turn.usage } : {},
+            ...turn.cost?.currency.toLowerCase() === "usd" ? { costUsd: turn.cost.amount } : {}
+          });
+          emitForTurn(turn, { type: "run_finished", stopReason });
+        };
+        void run().catch((error) => {
+          if (active === turn) fail(withAuthHint(acp, error));
+        });
+        return promise;
+      };
+      const session = {
+        get sessionId() {
+          return sessionId;
+        },
+        get state() {
+          return state;
+        },
+        get capabilities() {
+          return { continuation: true, supplement: steeringSupported };
+        },
+        prompt,
+        supplement,
+        cancelTurn,
+        close
+      };
+      const warn = (message) => {
+        if (options.onWarning) options.onWarning(message);
+        else process.stderr.write(`[multiclaw] Warning: ${message}
+`);
+      };
+      const initialize = async () => {
         const init = await ctx.request(acp.methods.agent.initialize, {
-          protocolVersion: acp.PROTOCOL_VERSION
+          protocolVersion: acp.PROTOCOL_VERSION,
+          ...questionForms ? { clientCapabilities: { elicitation: { form: {} } } } : {}
         });
-        emit({ type: "run_started", model: task.model });
-        if (task.sessionId) {
+        if (terminalError) throw terminalError;
+        steeringSupported = advertisesSteering(init);
+        if (options.sessionId) {
           if (init.agentCapabilities?.loadSession !== true) {
             throw new PermanentError(
-              `Agent does not support session/load (loadSession=false); cannot resume session ${task.sessionId}`
+              `Agent does not support session/load (loadSession=false); cannot resume session ${options.sessionId}`
             );
           }
           await ctx.request(acp.methods.agent.session.load, {
-            sessionId: task.sessionId,
-            cwd: task.workDir,
+            sessionId: options.sessionId,
+            cwd: options.workDir,
             mcpServers: [],
-            // Both session-defining requests carry `_meta`: the bridge's own
-            // session fingerprint includes it, so a changed prompt rebuilds the
-            // session on resume.
             ...meta ? { _meta: meta } : {}
           });
-          sessionId = task.sessionId;
+          sessionId = options.sessionId;
         } else {
           const created = await ctx.request(acp.methods.agent.session.new, {
-            cwd: task.workDir,
+            cwd: options.workDir,
             mcpServers: [],
             ...meta ? { _meta: meta } : {}
           });
           sessionId = created.sessionId;
           const modelOpt = created.configOptions?.find(
-            (o) => o.category === "model" || o.id === "model"
+            (option) => option.category === "model" || option.id === "model"
           );
           if (modelOpt && "options" in modelOpt && Array.isArray(modelOpt.options)) {
-            const ids = (modelOpt.options ?? []).map(
-              (o) => o.value ?? String(o)
+            discoveredModels.set(
+              command,
+              (modelOpt.options ?? []).map(
+                (option) => option.value ?? String(option)
+              )
             );
-            discoveredModels.set(command, ids);
           }
         }
-        if (task.model && spec?.modelSelection === "config-option" && sessionId) {
+        if (terminalError) throw terminalError;
+        if (options.model && spec?.modelSelection === "config-option") {
           const known = discoveredModels.get(command);
-          if (known && !known.includes(task.model)) {
+          if (known && !known.includes(options.model)) {
             warn(
-              `model "${task.model}" is not offered by ${command}; running with the provider's default.`
+              `model "${options.model}" is not offered by ${command}; running with the provider's default.`
             );
           } else {
             try {
               await ctx.request(acp.methods.agent.session.setConfigOption, {
                 sessionId,
                 configId: "model",
-                value: task.model
+                value: options.model
               });
-            } catch (err) {
+            } catch (error) {
+              if (terminalError) throw terminalError;
               warn(
-                `Could not set model "${task.model}" on ${command}; running with the provider's default (${errorMessage(err)}).`
+                `Could not set model "${options.model}" on ${command}; running with the provider's default (${errorMessage(error)}).`
               );
             }
           }
         }
-        const response = await ctx.request(acp.methods.agent.session.prompt, {
-          sessionId,
-          prompt: [{ type: "text", text: promptText }]
-        });
-        if (task.signal?.aborted) {
-          settleReject(abortError());
-          teardown();
-          return;
-        }
-        const stopReason = mapStopReason(response.stopReason);
-        emit({ type: "run_finished", stopReason });
-        settleResolve({
-          output: agentText,
-          exitCode: 0,
-          sessionId,
-          stopReason,
-          ...lastUsage ? { usage: lastUsage } : {},
-          ...lastCost?.currency.toLowerCase() === "usd" ? { costUsd: lastCost.amount } : {}
-        });
-        teardown();
+        if (terminalError) throw terminalError;
+        if (options.signal?.aborted) throw abortError();
       };
-      void run().catch((err) => {
-        connectionError = withAuthHint(acp, err);
-        settleReject(connectionError);
-        teardown();
-      });
-    });
+      await Promise.race([
+        initialize().catch((error) => {
+          throw withAuthHint(acp, error);
+        }),
+        startupFailure
+      ]);
+      clearTimeout(startupTimer);
+      return session;
+    } catch (error) {
+      clearTimeout(startupTimer);
+      options.signal?.removeEventListener("abort", onSessionAbort);
+      if (cleanup) await cleanup();
+      throw error;
+    }
   }
 };
 
@@ -1610,16 +2196,18 @@ function retryBudgetMs(perAttemptMs, retries, delayMs = DEFAULT_RETRY_DELAY_MS)
 }
 
 // src/utils/timeout.ts
-function withTimeout(factory, ms, label, signal) {
+function withTimeout(factory, ms, label, signal, options) {
   if (signal?.aborted) return Promise.reject(abortError());
   const controller = new AbortController();
   const forward = () => controller.abort();
   signal?.addEventListener("abort", forward, { once: true });
   let timer;
+  let timeoutError;
   const timeout = new Promise((_, reject) => {
     timer = setTimeout(() => {
+      timeoutError = new Error(`[${label}] timed out (${ms / 1e3}s)`);
       controller.abort();
-      reject(new Error(`[${label}] timed out (${ms / 1e3}s)`));
+      if (!options?.waitForCleanup) reject(timeoutError);
     }, ms);
   });
   let onCancel;
@@ -1628,7 +2216,18 @@ function withTimeout(factory, ms, label, signal) {
     onCancel = () => reject(abortError());
     signal.addEventListener("abort", onCancel, { once: true });
   });
-  return Promise.race([factory(controller.signal), timeout, cancelled]).finally(() => {
+  const work = factory(controller.signal);
+  const completion = options?.waitForCleanup ? work.then(
+    (result) => {
+      if (timeoutError) throw timeoutError;
+      return result;
+    },
+    (error) => {
+      if (timeoutError && isAbortError(error)) throw timeoutError;
+      throw error;
+    }
+  ) : work;
+  return Promise.race([completion, timeout, cancelled]).finally(() => {
     clearTimeout(timer);
     signal?.removeEventListener("abort", forward);
     if (onCancel) signal?.removeEventListener("abort", onCancel);
@@ -1662,13 +2261,14 @@ function summarizeToolOutput(output) {
 
 // src/orchestrator/AgentRunner.ts
 var AgentRunner = class {
-  constructor(eventBus, contextManager, globalWorkDir, config) {
+  constructor(eventBus, contextManager, globalWorkDir, config, sessionManager) {
     this.eventBus = eventBus;
     this.contextManager = contextManager;
     this.globalWorkDir = globalWorkDir;
     this.config = config;
+    this.sessionManager = sessionManager;
   }
-  async run(agent, signal) {
+  async run(agent, signal, instruction) {
     const startTime = /* @__PURE__ */ new Date();
     const model = resolveModel(agent, this.config);
     this.eventBus.emit({
@@ -1697,6 +2297,7 @@ var AgentRunner = class {
         (innerSignal) => withRetry(
           async (attempt) => {
             attempts = attempt;
+            if (signal?.aborted) throw abortError();
             const agentContext = {
               ...this.contextManager.snapshot(),
               // Every built-in task template references both. The leader only
@@ -1707,15 +2308,28 @@ var AgentRunner = class {
               agentScope: agent.agentScope ?? "Not narrowed down \u2014 cover the whole task.",
               agentPlan: agent.agentPlan ?? "No step-by-step plan was provided \u2014 use your judgement."
             };
-            const prompt = await renderPrompt(agent.taskPrompt, agentContext, this.globalWorkDir);
-            return await runtime.execute({
+            let prompt = await renderPrompt(agent.taskPrompt, agentContext, this.globalWorkDir);
+            const requirement = this.contextManager.get("requirement") ?? this.config.context?.requirement;
+            if (agent.id !== this.config.leader?.id && requirement !== void 0) {
+              prompt = `## Current task
+${requirement}
+
+${prompt}`;
+            }
+            if (instruction) prompt += `
+
+${instruction}`;
+            const task = {
               agentId: agent.id,
               systemPrompt: agent.systemPrompt,
               prompt,
               tools,
+              permissionMode: this.config.permissions?.mode,
+              onPermission: this.config.permissions?.onRequest,
+              onQuestion: this.config.questions?.onRequest,
               workDir,
               timeout,
-              signal: innerSignal,
+              signal: runtime.openSession && signal ? AbortSignal.any([innerSignal, signal]) : innerSignal,
               model,
               // Only the caller knows which session to continue; absent means a
               // fresh one. It must stay `undefined` rather than `""` — the ACP
@@ -1766,7 +2380,8 @@ var AgentRunner = class {
                   );
                 }
               }
-            });
+            };
+            return await (this.sessionManager ? this.sessionManager.execute(runtime, task) : runtime.execute(task));
           },
           retries,
           (attempt, err) => {
@@ -1783,7 +2398,7 @@ var AgentRunner = class {
             });
           },
           DEFAULT_RETRY_DELAY_MS,
-          innerSignal,
+          runtime.openSession && signal ? AbortSignal.any([innerSignal, signal]) : innerSignal,
           // A permanent failure (a missing binary, an unsupported capability)
           // will fail the same way on every attempt, so let the loop fail fast
           // instead of burning the whole backoff budget on a doomed run.
@@ -1791,17 +2406,25 @@ var AgentRunner = class {
         ),
         retryBudgetMs(timeout + KILL_ESCALATION_MS, retries),
         agent.name,
-        signal
+        // Session runtimes acknowledge cancellation only after process cleanup.
+        // Neither caller cancellation nor the outer timeout may race that barrier.
+        runtime.openSession ? void 0 : signal,
+        { waitForCleanup: !!runtime.openSession }
       );
       output = completed.output;
       usage = completed.usage;
       costUsd = completed.costUsd;
       const sessionId = completed.sessionId;
+      const incomplete = completed.stopReason !== void 0 && completed.stopReason !== "success";
+      const cancelled = completed.stopReason === "cancelled";
+      const failed = completed.exitCode !== 0 || incomplete;
+      const error = failed ? `Runtime turn did not complete (${completed.stopReason ?? `exit code ${completed.exitCode}`})` : void 0;
       const endTime = /* @__PURE__ */ new Date();
       const result = {
         agentId: agent.id,
         agentName: agent.name,
-        status: "success",
+        status: cancelled ? "cancelled" : failed ? "failed" : "success",
+        ...error ? { error } : {},
         output,
         duration: endTime.getTime() - startTime.getTime(),
         attempts,
@@ -1813,7 +2436,7 @@ var AgentRunner = class {
         ...sessionId ? { sessionId } : {}
       };
       this.eventBus.emit({
-        type: "agent:complete",
+        type: failed ? "agent:failed" : "agent:complete",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         payload: result
       });
@@ -1902,7 +2525,7 @@ function buildStages(agents2) {
 
 // src/orchestrator/Orchestrator.ts
 var Orchestrator = class {
-  constructor(config) {
+  constructor(config, sessions) {
     this.config = config;
     this.eventBus = new EventBus();
     this.workDir = path5.resolve(config.workDir);
@@ -1910,11 +2533,22 @@ var Orchestrator = class {
     this.contextManager = new ContextManager(config.context);
     this.contextManager.set("conversation", renderConversation(config.history));
     this.contextManager.set("upstreamOutputs", "");
-    this.runner = new AgentRunner(this.eventBus, this.contextManager, this.workDir, config);
+    this.runner = new AgentRunner(
+      this.eventBus,
+      this.contextManager,
+      this.workDir,
+      config,
+      sessions
+    );
   }
   async preview(options = {}) {
+    const policyError = this.reviewPolicyError();
+    if (policyError) throw new Error(policyError);
     this.clearStaleTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
+    if (resolution.kind === "cancelled" || options.signal?.aborted) {
+      return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
+    }
     if (resolution.kind === "message") {
       return {
         name: this.config.name,
@@ -1927,10 +2561,12 @@ var Orchestrator = class {
     const agents2 = resolution.agents;
     this.contextManager.set("pipelineAgents", agents2.map((a) => `${a.id}: ${a.name}`).join("\n"));
     const stages = this.buildStagesOrFallback(agents2, "Could not order the configured agents");
+    const reviewer2 = this.config.agents.find((agent) => agent.id === this.config.review?.reviewer);
+    if (reviewer2 && agents2.length) stages.push([reviewer2]);
     const stageInfos = this.stageInfos(stages);
     return {
       name: this.config.name,
-      totalAgents: agents2.length,
+      totalAgents: agents2.length + (reviewer2 && agents2.length ? 1 : 0),
       stages: stageInfos,
       ...this.reasonField(resolution.reason),
       ...this.requirementField()
@@ -1938,13 +2574,39 @@ var Orchestrator = class {
   }
   async run(options = {}) {
     const startTime = /* @__PURE__ */ new Date();
+    if (options.signal?.aborted) return this.finishCancelled(startTime);
+    const policyError = this.reviewPolicyError();
+    if (policyError) {
+      this.warn(policyError);
+      const result2 = this.finishEmpty(startTime, {
+        status: "failed",
+        reviewer: this.config.review?.reviewer ?? "",
+        repairRounds: 0,
+        reviews: [],
+        reason: policyError
+      });
+      return result2;
+    }
     this.clearStaleTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
+    if (resolution.kind === "cancelled" || options.signal?.aborted) {
+      return this.finishCancelled(startTime);
+    }
     if (resolution.kind === "message") {
       return this.finishWithMessage(resolution.mode, resolution.message, startTime);
     }
     const agents2 = resolution.agents;
-    if (agents2.length === 0) return this.finishEmpty(startTime);
+    if (agents2.length === 0)
+      return this.finishEmpty(
+        startTime,
+        this.config.review ? {
+          status: "failed",
+          reviewer: this.config.review.reviewer,
+          repairRounds: 0,
+          reviews: [],
+          reason: "No worker was selected for the review-gated task."
+        } : void 0
+      );
     this.contextManager.set("pipelineAgents", agents2.map((a) => `${a.id}: ${a.name}`).join("\n"));
     let stages = this.buildStagesOrFallback(agents2, "Could not order the configured agents");
     const toStageInfos = (list) => this.stageInfos(list);
@@ -1953,7 +2615,7 @@ var Orchestrator = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       payload: {
         name: this.config.name,
-        requirement: this.config.context?.requirement,
+        requirement: this.contextManager.get("requirement"),
         totalAgents: agents2.length,
         stages: toStageInfos(stages),
         ...this.reasonField(resolution.reason)
@@ -1963,7 +2625,13 @@ var Orchestrator = class {
     let allSuccess = true;
     let cancelled = false;
     let planApplied = false;
+    const executedIds = /* @__PURE__ */ new Set();
     for (let i = 0; i < stages.length; i++) {
+      if (options.signal?.aborted) {
+        cancelled = true;
+        allSuccess = false;
+        break;
+      }
       const stage = stages[i];
       this.eventBus.emit({
         type: "stage:start",
@@ -1972,24 +2640,32 @@ var Orchestrator = class {
       });
       const stageResults = await this.runStage(stage, options.signal);
       results.push(...stageResults);
+      for (const result2 of stageResults) executedIds.add(result2.agentId);
       this.contextManager.set(
         "upstreamOutputs",
         renderUpstreamOutputs(
           results.filter((r) => r.status === "success").map((r) => ({ agentId: r.agentId, name: r.agentName, output: r.output }))
         )
       );
-      if (options.signal?.aborted) {
+      if (options.signal?.aborted || stageResults.some((r) => r.status === "cancelled")) {
         cancelled = true;
         allSuccess = false;
         break;
       }
-      if (!planApplied && stage.some((a) => this.isPlanner(a)) && stageResults.some((r) => r.status === "success")) {
+      if (!planApplied && stage.some((a) => this.isPlanner(a)) && stageResults.some(
+        (r) => r.status === "success" && stage.some((a) => a.id === r.agentId && this.isPlanner(a))
+      )) {
         planApplied = true;
-        await this.applyTaskPlan(agents2);
-        stages = this.buildStagesOrFallback(
-          agents2,
+        await this.applyTaskPlan(agents2, executedIds);
+        const remaining = agents2.filter((a) => !executedIds.has(a.id)).map((a) => ({
+          ...a,
+          dependsOn: a.dependsOn?.filter((dep) => !executedIds.has(dep))
+        }));
+        const rebuilt = this.buildStagesOrFallback(
+          remaining,
           "The task plan's dependencies could not be satisfied"
         );
+        stages = [...stages.slice(0, i + 1), ...rebuilt];
         this.eventBus.emit({
           type: "orchestration:stages",
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2020,11 +2696,25 @@ var Orchestrator = class {
         break;
       }
     }
+    let acceptance;
+    if (this.config.review) {
+      acceptance = await this.reviewDelivery(
+        agents2,
+        results,
+        stages,
+        allSuccess,
+        cancelled,
+        options.signal
+      );
+      cancelled ||= acceptance.status === "cancelled";
+      allSuccess = allSuccess && acceptance.status === "approved";
+    }
     const endTime = /* @__PURE__ */ new Date();
     const totalCostUsd = sumCosts(results);
     const result = {
       name: this.config.name,
       success: allSuccess,
+      ...acceptance ? { acceptance } : {},
       totalDuration: endTime.getTime() - startTime.getTime(),
       agentResults: results,
       startTime: startTime.toISOString(),
@@ -2041,6 +2731,137 @@ var Orchestrator = class {
     });
     return result;
   }
+  reviewPolicyError() {
+    const policy = this.config.review;
+    if (!policy) return void 0;
+    const ids = this.config.agents.map((agent) => agent.id);
+    if (new Set(ids).size !== ids.length) return "Review policy requires unique agent ids.";
+    if (!ids.includes(policy.reviewer) || policy.reviewer === this.config.leader?.id) {
+      return "Review policy must name a configured non-leader reviewer.";
+    }
+    if (!Array.isArray(policy.repairAgents) || !policy.repairAgents.length || new Set(policy.repairAgents).size !== policy.repairAgents.length || policy.repairAgents.some(
+      (id) => !ids.includes(id) || id === policy.reviewer || id === this.config.leader?.id
+    )) {
+      return "Review policy must name unique configured repair workers, excluding the reviewer and leader.";
+    }
+    const limit = policy.maxRepairRounds ?? 1;
+    if (!Number.isInteger(limit) || limit < 0 || limit > 5) {
+      return "Review policy maxRepairRounds must be an integer from 0 to 5.";
+    }
+    return void 0;
+  }
+  async reviewDelivery(agents2, results, stages, executionSuccess, cancelled, signal) {
+    const policy = this.config.review;
+    if (!policy) throw new Error("Delivery review requires a configured policy.");
+    const acceptance = {
+      status: "failed",
+      reviewer: policy.reviewer,
+      repairRounds: 0,
+      reviews: []
+    };
+    if (cancelled || signal?.aborted) return { ...acceptance, status: "cancelled" };
+    if (!executionSuccess)
+      return { ...acceptance, reason: "Pipeline execution failed; delivery was not reviewed." };
+    const reviewer2 = this.config.agents.find((agent) => agent.id === policy.reviewer);
+    if (!reviewer2) return { ...acceptance, reason: "Configured reviewer is unavailable." };
+    const repairs = agents2.filter((agent) => policy.repairAgents.includes(agent.id));
+    const repairIds = new Set(repairs.map((agent) => agent.id));
+    const repairStages = this.buildStagesOrFallback(
+      repairs.map((agent) => ({
+        ...agent,
+        dependsOn: agent.dependsOn?.filter((id) => repairIds.has(id))
+      })),
+      "Could not order repair workers"
+    ).flatMap((stage) => stage.map((agent) => [agent]));
+    let stageIndex = stages.length;
+    const execute = async (stage, instruction) => {
+      if (signal?.aborted) {
+        acceptance.status = "cancelled";
+        return false;
+      }
+      stages.push(stage);
+      this.eventBus.emit({
+        type: "orchestration:stages",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: {
+          totalAgents: new Set(stages.flat().map((agent) => agent.id)).size,
+          stages: this.stageInfos(stages)
+        }
+      });
+      const index = stageIndex++;
+      this.eventBus.emit({
+        type: "stage:start",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { stageIndex: index, agentIds: stage.map((agent) => agent.id) }
+      });
+      for (const agent of stage) {
+        if (signal?.aborted) {
+          acceptance.status = "cancelled";
+          return false;
+        }
+        const result = await this.runner.run(
+          agent,
+          signal,
+          `${instruction}
+
+## Latest worker outputs
+${this.contextManager.get("upstreamOutputs") ?? ""}`
+        );
+        results.push(result);
+        const latest = /* @__PURE__ */ new Map();
+        for (const item of results) latest.set(item.agentId, item);
+        this.contextManager.set(
+          "upstreamOutputs",
+          renderUpstreamOutputs(
+            [...latest.values()].filter((item) => item.status === "success" && item.agentId !== policy.reviewer).map((item) => ({ agentId: item.agentId, name: item.agentName, output: item.output }))
+          )
+        );
+        if (result.status !== "success" || signal?.aborted) {
+          acceptance.status = result.status === "cancelled" || signal?.aborted ? "cancelled" : "failed";
+          acceptance.reason = result.error ?? `${agent.name} did not complete.`;
+          return false;
+        }
+      }
+      this.eventBus.emit({
+        type: "stage:complete",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { stageIndex: index }
+      });
+      return true;
+    };
+    while (true) {
+      if (!await execute(
+        [reviewer2],
+        `## Delivery acceptance review
+Inspect the current workspace against the complete task and verify the changes. Do not repair files. Return ONLY a JSON object with this exact contract:
+{"verdict":"approved"|"changes_required","summary":"non-empty explanation","issues":["actionable unresolved issue"]}
+Approval requires an empty issues array; changes_required requires at least one issue. A successful process exit is not approval.`
+      ))
+        return acceptance;
+      const verdict = parseReviewVerdict(results[results.length - 1].output);
+      if (!verdict) {
+        acceptance.reason = "Reviewer returned an invalid delivery verdict; acceptance is blocked.";
+        this.warn(acceptance.reason);
+        return acceptance;
+      }
+      acceptance.reviews.push(verdict);
+      if (verdict.verdict === "approved") return { ...acceptance, status: "approved" };
+      acceptance.status = "changes_required";
+      if (acceptance.repairRounds >= (policy.maxRepairRounds ?? 1) || !repairs.length) {
+        acceptance.reason = !repairs.length ? "No configured repair worker was selected for this task." : "Repair budget exhausted.";
+        return acceptance;
+      }
+      acceptance.repairRounds++;
+      this.warn(
+        `Delivery requires changes \u2014 repair pass ${acceptance.repairRounds}/${policy.maxRepairRounds ?? 1}.`
+      );
+      const instruction = `## Repair requested by delivery review
+${JSON.stringify(verdict)}
+Address these findings within your assigned scope, preserve the complete task requirements, and report what you changed and verified.`;
+      for (const stage of repairStages) if (!await execute(stage, instruction)) return acceptance;
+      acceptance.status = "failed";
+    }
+  }
   stageInfos(stages) {
     const getModel = (agent) => resolveModel(agent, this.config);
     return stages.map((stage, i) => ({
@@ -2069,7 +2890,7 @@ var Orchestrator = class {
       return buildStages(agents2);
     } catch (err) {
       this.warn(`${context} (${errorMessage2(err)}) \u2014 running the agents in declaration order.`);
-      return [agents2];
+      return agents2.map((agent) => [agent]);
     }
   }
   /**
@@ -2092,6 +2913,7 @@ var Orchestrator = class {
    * job, and that is what `message` records.
    */
   async resolveTurn(signal) {
+    if (signal?.aborted) return { kind: "cancelled" };
     if (this.config.resume) {
       return {
         kind: "run",
@@ -2103,9 +2925,10 @@ var Orchestrator = class {
     }
     this.contextManager.set(
       "availableAgents",
-      this.config.agents.map((a) => `${a.id}: ${a.name}`).join("\n")
+      this.configuredAgents().map((a) => `${a.id}: ${a.name}`).join("\n")
     );
     const result = await this.runner.run(this.config.leader, signal);
+    if (signal?.aborted || result.status === "cancelled") return { kind: "cancelled" };
     if (result.status !== "success") {
       this.warn("The leader could not be reached \u2014 running the full configured team.");
       return { kind: "run", agents: this.configuredAgents() };
@@ -2115,6 +2938,7 @@ var Orchestrator = class {
       if (decision.mode !== "run") {
         return { kind: "message", mode: decision.mode, message: decision.message };
       }
+      if (decision.requirement) this.contextManager.set("requirement", decision.requirement);
       return { kind: "run", agents: this.selectAgents(decision.run), reason: decision.reason };
     }
     const message = result.output.trim();
@@ -2134,8 +2958,11 @@ var Orchestrator = class {
    * prevent, but for the in-memory fields rather than the file.
    */
   configuredAgents() {
-    return this.config.agents.map(
-      (a) => a.dependsOn ? { ...a, dependsOn: [...a.dependsOn] } : { ...a }
+    return this.config.agents.filter((a) => a.id !== this.config.review?.reviewer).map(
+      (a) => a.dependsOn ? {
+        ...a,
+        dependsOn: a.dependsOn.filter((id) => id !== this.config.review?.reviewer)
+      } : { ...a }
     );
   }
   /**
@@ -2150,7 +2977,7 @@ var Orchestrator = class {
    * reader looking in the wrong place.
    */
   selectAgents(run, namedBy = "The leader") {
-    const runSet = new Set(run);
+    const runSet = new Set(run.filter((id) => id !== this.config.review?.reviewer));
     const known = new Set(this.config.agents.map((a) => a.id));
     for (const id of run) {
       if (!known.has(id)) {
@@ -2158,34 +2985,41 @@ var Orchestrator = class {
       }
     }
     const skippedIds = new Set(this.config.agents.filter((a) => !runSet.has(a.id)).map((a) => a.id));
-    for (const agent of this.config.agents.filter((a) => skippedIds.has(a.id))) {
+    for (const agent of this.config.agents.filter(
+      (a) => skippedIds.has(a.id) && a.id !== this.config.review?.reviewer
+    )) {
       this.eventBus.emit({
         type: "agent:skipped",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         payload: { agentId: agent.id, agentName: agent.name, icon: agent.icon }
       });
     }
-    return this.config.agents.filter((a) => runSet.has(a.id)).map((a) => ({
+    return this.config.agents.filter((a) => runSet.has(a.id) && a.id !== this.config.review?.reviewer).map((a) => ({
       ...a,
-      dependsOn: a.dependsOn?.filter((dep) => !skippedIds.has(dep))
+      dependsOn: a.dependsOn?.filter(
+        (dep) => !skippedIds.has(dep) && dep !== this.config.review?.reviewer
+      )
     }));
   }
   async runStage(agents2, signal) {
     const { maxConcurrency } = this.config;
-    if (!maxConcurrency || agents2.length <= maxConcurrency) {
-      return Promise.all(agents2.map((a) => this.runner.run(a, signal)));
-    }
-    const results = new Array(agents2.length);
+    const results = /* @__PURE__ */ new Map();
     let next = 0;
-    const workers = Array.from({ length: Math.min(maxConcurrency, agents2.length) }, async () => {
-      while (next < agents2.length) {
-        const index = next;
-        next += 1;
-        results[index] = await this.runner.run(agents2[index], signal);
+    let cancelled = false;
+    const workers = Array.from(
+      { length: Math.min(maxConcurrency || agents2.length, agents2.length) },
+      async () => {
+        while (next < agents2.length && !signal?.aborted && !cancelled) {
+          const index = next;
+          next += 1;
+          const result = await this.runner.run(agents2[index], signal);
+          results.set(index, result);
+          if (result.status === "cancelled") cancelled = true;
+        }
       }
-    });
+    );
     await Promise.all(workers);
-    return results;
+    return [...results.entries()].sort(([a], [b]) => a - b).map(([, result]) => result);
   }
   /**
    * Whether `agent` owns task decomposition.
@@ -2197,7 +3031,7 @@ var Orchestrator = class {
   isPlanner(agent) {
     return agent.role === "planner" || agent.id === "architect";
   }
-  async applyTaskPlan(agents2) {
+  async applyTaskPlan(agents2, executedIds) {
     const taskPlanPath = path5.join(this.workDir, "task-plan.json");
     if (!fs4.existsSync(taskPlanPath)) return;
     let taskPlan;
@@ -2209,16 +3043,37 @@ var Orchestrator = class {
       );
       return;
     }
-    if (!Array.isArray(taskPlan.tasks)) {
+    if (typeof taskPlan !== "object" || taskPlan === null || !("tasks" in taskPlan) || !Array.isArray(taskPlan.tasks)) {
       this.warn("task-plan.json has no `tasks` array \u2014 ignoring it.");
       return;
     }
-    const taskMap = new Map(taskPlan.tasks.map((t) => [t.id, t]));
+    const taskMap = /* @__PURE__ */ new Map();
     const selected = new Set(agents2.map((a) => a.id));
+    for (const [index, entry3] of taskPlan.tasks.entries()) {
+      if (typeof entry3 !== "object" || entry3 === null || Array.isArray(entry3)) {
+        this.warn(`task-plan.json contains a malformed task at index ${index} \u2014 ignoring it.`);
+        continue;
+      }
+      const task = entry3;
+      if (typeof task.id !== "string" || !task.id.trim() || task.title !== void 0 && typeof task.title !== "string" || task.scope !== void 0 && typeof task.scope !== "string" || task.dependsOn !== void 0 && (!Array.isArray(task.dependsOn) || !task.dependsOn.every((dep) => typeof dep === "string")) || task.plan !== void 0 && (!Array.isArray(task.plan) || !task.plan.every((step) => typeof step === "string"))) {
+        this.warn(`task-plan.json contains a malformed task at index ${index} \u2014 ignoring it.`);
+        continue;
+      }
+      if (!selected.has(task.id)) {
+        this.warn(
+          `The task plan names "${task.id}", which is not in this run \u2014 ignoring that task.`
+        );
+        continue;
+      }
+      if (taskMap.has(task.id)) {
+        this.warn(`The task plan contains a duplicate task for "${task.id}" \u2014 ignoring that task.`);
+        continue;
+      }
+      taskMap.set(task.id, task);
+    }
     for (const agent of agents2) {
       const task = taskMap.get(agent.id);
       if (task) {
-        agent.taskTitle = task.title;
         const dependsOn = task.dependsOn?.filter((dep) => selected.has(dep));
         for (const dep of task.dependsOn ?? []) {
           if (!selected.has(dep)) {
@@ -2227,6 +3082,8 @@ var Orchestrator = class {
             );
           }
         }
+        if (executedIds.has(agent.id)) continue;
+        agent.taskTitle = task.title;
         agent.dependsOn = dependsOn;
         agent.agentScope = task.scope;
         if (task.plan?.length) {
@@ -2243,7 +3100,7 @@ var Orchestrator = class {
    * and a requirement that never reaches the report cannot be resumed.
    */
   requirementField() {
-    const requirement = this.config.context?.requirement;
+    const requirement = this.contextManager.get("requirement");
     return requirement !== void 0 ? { requirement } : {};
   }
   /**
@@ -2288,6 +3145,25 @@ var Orchestrator = class {
       payload: { message }
     });
   }
+  finishCancelled(startTime) {
+    const endTime = /* @__PURE__ */ new Date();
+    const result = {
+      name: this.config.name,
+      success: false,
+      cancelled: true,
+      totalDuration: endTime.getTime() - startTime.getTime(),
+      agentResults: [],
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      ...this.requirementField()
+    };
+    this.eventBus.emit({
+      type: "orchestration:complete",
+      timestamp: endTime.toISOString(),
+      payload: result
+    });
+    return result;
+  }
   /**
    * Close out a turn that scheduled no agents.
    *
@@ -2295,15 +3171,17 @@ var Orchestrator = class {
    * only honest outcome is to say that none was done. Running the whole team
    * instead would contradict the leader's explicit choice.
    */
-  finishEmpty(startTime) {
+  finishEmpty(startTime, acceptance) {
     const usedLeader = this.config.leader !== void 0 && this.config.useLeader !== false;
-    this.warn(
-      usedLeader ? "The leader selected none of the configured agents \u2014 nothing to run." : "The config lists no agents \u2014 nothing to run."
-    );
+    if (!acceptance?.reason)
+      this.warn(
+        usedLeader ? "The leader selected none of the configured agents \u2014 nothing to run." : "The config lists no agents \u2014 nothing to run."
+      );
     const endTime = /* @__PURE__ */ new Date();
     const result = {
       name: this.config.name,
       success: false,
+      ...acceptance ? { acceptance } : {},
       totalDuration: endTime.getTime() - startTime.getTime(),
       agentResults: [],
       startTime: startTime.toISOString(),
@@ -2318,6 +3196,31 @@ var Orchestrator = class {
     return result;
   }
 };
+function parseReviewVerdict(output) {
+  let text = output.trim();
+  if (text.includes("```")) {
+    const blocks = [...text.matchAll(/```(?:json)?\s*\n([\s\S]*?)\n```/g)];
+    if (blocks.length !== 1 || !text.endsWith(blocks[0][0])) return void 0;
+    const prefix = text.slice(0, blocks[0].index);
+    if (prefix.includes("```") || /"verdict"\s*:/.test(prefix)) return void 0;
+    text = blocks[0][1];
+  }
+  try {
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+    const item = value;
+    if (item.verdict !== "approved" && item.verdict !== "changes_required" || typeof item.summary !== "string" || !item.summary.trim() || !Array.isArray(item.issues) || !item.issues.every((issue) => typeof issue === "string" && issue.trim()))
+      return void 0;
+    if (item.verdict === "approved" !== (item.issues.length === 0)) return void 0;
+    return {
+      verdict: item.verdict,
+      summary: item.summary.trim(),
+      issues: item.issues.map((issue) => issue.trim())
+    };
+  } catch {
+    return void 0;
+  }
+}
 function errorMessage2(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -2335,6 +3238,14 @@ function sumCosts(results) {
 
 // src/providers/detect.ts
 import { spawn as spawn2 } from "child_process";
+function parseVersion(raw) {
+  if (!raw) return void 0;
+  const plain = raw.replace(SGR_RE, "");
+  const firstLine = plain.split("\n")[0].trim();
+  if (!firstLine) return void 0;
+  return firstLine.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0] ?? firstLine;
+}
+var SGR_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 async function versionFor(command) {
   return new Promise((resolve4) => {
     let out = "";
@@ -2374,7 +3285,7 @@ async function detectProviders(opts) {
           const v = await versionFor(exe);
           if (v && spec.confirm(v)) {
             matched = cmd;
-            version = v;
+            version = parseVersion(v);
             source = bundled ? "bundled" : "path";
             resolvedPath = bundled ? exe : void 0;
             break;
@@ -2386,7 +3297,7 @@ async function detectProviders(opts) {
       source = bundled ? "bundled" : "path";
       resolvedPath = bundled ? exe : void 0;
       if (opts?.withVersion) {
-        version = await versionFor(exe);
+        version = parseVersion(await versionFor(exe));
       }
       break;
     }
@@ -2435,6 +3346,7 @@ function describeResumePlan({ agents: agents2, sessions = {}, team }) {
 export {
   ABORT_ERROR_NAME,
   AcpRuntime,
+  AgentSessionManager,
   BRIDGE_PACKAGES,
   EventBus,
   Orchestrator,
@@ -2461,5 +3373,6 @@ export {
   runtimeRegistry,
   specForCommand,
   specForProvider,
-  tierModel
+  tierModel,
+  validateRuntimeQuestionContent
 };