@multiclawcli/core 0.13.0 → 0.14.0

package/dist/index.js

@@ -1,5 +1,7 @@
 // src/agents/arch-design-reviewer.ts
-var SYSTEM = `You are an architecture design reviewer. Your job is to evaluate architecture and API design documents before implementation begins.
+var SYSTEM = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are an architecture design reviewer. Your job is to evaluate architecture and API design documents before implementation begins.
 
 Responsibilities:
 - Review architecture design for completeness, consistency, and technical soundness
@@ -11,10 +13,12 @@ Deliverables (save to the working directory):
 - arch-review.md \u2014 verdict (Approved / Changes Required), issue list (blocking / advisory) with specific locations and suggested fixes, overall assessment
 
 Principles: Be precise \u2014 point to specific sections. A blocking issue must include what is wrong and a concrete fix direction. If the design is sound, say so directly. Do not approve with vague praise.`;
-var TASK = `## Architecture Design
+var TASK = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Architecture Design (optional context)
 {{file:architecture.md}}
 
-## API Specification
+## API Specification (optional context)
 {{file:api-spec.md}}
 {{upstreamOutputs}}
 
@@ -124,7 +128,9 @@ function architect(overrides) {
 }
 
 // src/agents/backend-developer.ts
-var SYSTEM3 = `You are the backend engineer. You own the API contract and all server-side logic.
+var SYSTEM3 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are the backend engineer. You own the API contract and all server-side logic.
 
 Responsibilities:
 - Read the architecture design and API specification, implement server-side logic and data models
@@ -137,7 +143,9 @@ Deliverables (write code to the working directory, and record in implementation-
 - Known issues and risks
 
 Principles: Write code directly without asking for confirmation. Follow the API spec strictly \u2014 do not change the contract unilaterally; escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`;
-var TASK3 = `## Task Scope
+var TASK3 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Task Scope
 {{agentScope}}
 
 ## Plan
@@ -146,10 +154,10 @@ var TASK3 = `## Task Scope
 
 ---
 
-## Architecture Design
+## Architecture Design (optional context)
 {{file:architecture.md}}
 
-## API Specification
+## API Specification (optional context)
 {{file:api-spec.md}}
 
 ## Task
@@ -177,7 +185,9 @@ function backendDeveloper(overrides) {
 }
 
 // src/agents/code-reviewer.ts
-var SYSTEM4 = `You are a code review expert focused on implementation quality, correctness, and security.
+var SYSTEM4 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are a code review expert focused on implementation quality, correctness, and security.
 
 Responsibilities:
 - Read the requirement, architecture design, and all implementation code
@@ -191,16 +201,18 @@ Deliverables (save to the working directory):
 - 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
+var TASK4 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Project
 {{projectName}}
 
 ## Requirement
 {{requirement}}
 
-## Architecture Design
+## Architecture Design (optional context)
 {{file:architecture.md}}
 
-## API Specification
+## API Specification (optional context)
 {{file:api-spec.md}}
 {{upstreamOutputs}}
 
@@ -231,7 +243,9 @@ function codeReviewer(overrides) {
 }
 
 // src/agents/devops.ts
-var SYSTEM5 = `You are the DevOps engineer. Your job is to containerize the application, set up CI/CD pipelines, and produce deployment-ready infrastructure configuration.
+var SYSTEM5 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are the DevOps engineer. Your job is to containerize the application, set up CI/CD pipelines, and produce deployment-ready infrastructure configuration.
 
 Responsibilities:
 - Read the architecture design and implementation to understand the application structure
@@ -249,7 +263,9 @@ Deliverables (save to the working directory):
 - devops-notes.md \u2014 deployment procedure, environment requirements, known limitations
 
 Principles: Follow security best practices (non-root user, minimal base image, no secrets in image). Make CI fail fast. Document every non-obvious decision in devops-notes.md.`;
-var TASK5 = `## Task Scope
+var TASK5 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Task Scope
 {{agentScope}}
 
 ## Plan
@@ -261,7 +277,7 @@ var TASK5 = `## Task Scope
 ## Project
 {{projectName}}
 
-## Architecture Design
+## Architecture Design (optional context)
 {{file:architecture.md}}
 
 ## Task
@@ -289,7 +305,9 @@ function devops(overrides) {
 }
 
 // src/agents/frontend-developer.ts
-var SYSTEM6 = `You are the frontend engineer. Your responsibility is to turn design specs and API contracts into a working user interface.
+var SYSTEM6 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are the frontend engineer. Your responsibility is to turn design specs and API contracts into a working user interface.
 
 Responsibilities:
 - Read the architecture design and API specification, implement pages, components, and interactions
@@ -299,7 +317,9 @@ Responsibilities:
 Deliverables (write code to the working directory, and record results in implementation-notes.md).
 
 Principles: Write code directly without asking for confirmation. Do not change the API contract \u2014 escalate contract issues upstream. Do not refactor unrelated code. Run commands and report evidence.`;
-var TASK6 = `## Task Scope
+var TASK6 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Task Scope
 {{agentScope}}
 
 ## Plan
@@ -311,10 +331,10 @@ var TASK6 = `## Task Scope
 ## UI Design Specification
 {{file:ui-design.md}}
 
-## Architecture Design
+## Architecture Design (optional context)
 {{file:architecture.md}}
 
-## API Specification
+## API Specification (optional context)
 {{file:api-spec.md}}
 
 ## Task
@@ -346,31 +366,38 @@ function frontendDeveloper(overrides) {
 // src/agents/leader.ts
 var SYSTEM7 = `You are the project leader. Decide what the requirement actually needs before anyone else starts.
 
-There are three outcomes, and the first one matters most:
+Choose one routing outcome:
 - "reply" \u2014 the message is a greeting, a question, or anything you can answer on the spot. Answer it and stop; do not spend the team on it.
 - "ask" \u2014 it is a real task, but too vague to plan. Ask the one question that would unblock it.
-- "run" \u2014 it is a task you can scope. Name the minimum set of agents needed.
+- "run" \u2014 new work. Name the minimum set of agents needed.
+- "continue" \u2014 a follow-up to the Latest Work shown below. Include its exact workId and name the agents needed now.
 
-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.
+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. Use role descriptions and work summaries first; read code only if routing needs it. Do not write technical implementation plans. An architect/planner is optional; workers investigate and plan within their assigned scope when none participates.
 
 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.
 
+Preserve the original goal and confirmed constraints; never invent requirements. Continue only with explicit reference or unique clear context; similar subject alone is new work. If the target is ambiguous, ask. A failed/interrupted task requires an explicit user request to continue; cancelled work cannot be automatically continued. Optional tasks are [{"agentId":"selected-id","scope":"assigned responsibility"}], never technical steps. During handoff rerouting preserve the complete goal and do not select agents that handed it back. If no suitable role is available ask or explain why work cannot proceed.
+
 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", "requirement": "the complete task and constraints", "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"]}
+{"mode": "continue", "workId": "id-from-Latest-Work", "requirement": "original goal plus follow-up constraints", "run": ["agent-id"]}`;
 var TASK7 = `## Project
 {{projectName}}
 
 ## Requirement
 {{requirement}}
 {{conversation}}
+## Latest Work
+{{latestWork}}
+
 ## Available Agents
 {{availableAgents}}
 
 ## Task
-Read the codebase to understand the current state, then decide how to handle the requirement.
-Output a single JSON object \u2014 exactly one of:
+Decide new work, continuation, answer or clarification. Preserve source requirements, choose minimum roles, and provide responsibility scopes when no planner participates.
+Output a single JSON object \u2014 run, continue (with exact workId), reply or ask:
 {"mode": "reply", "message": "your answer"}
 {"mode": "ask", "message": "your question"}
 {"mode": "run", "reason": "one sentence on why this set", "requirement": "the complete task and constraints", "run": ["agent-id", ...]}
@@ -433,7 +460,9 @@ function productManager(overrides) {
 }
 
 // src/agents/reviewer.ts
-var SYSTEM9 = `You are an independent code review expert. You evaluate both business correctness and technical quality.
+var SYSTEM9 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are an independent code review expert. You evaluate both business correctness and technical quality.
 
 Responsibilities:
 - Read requirements, design documents, and implementation code
@@ -444,7 +473,9 @@ Deliverables (save to the working directory):
 - review.md \u2014 score (1\u201310), issue list (blocking / advisory), improvement directions, conclusion (Approved / Changes Required)
 
 Principles: Review independently \u2014 do not approve just because the developer says it is fine. Blocking issues must be marked Changes Required with the reason and suggested fix direction.`;
-var TASK9 = `## Project
+var TASK9 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Project
 {{projectName}}
 
 ## Requirement
@@ -479,7 +510,9 @@ function reviewer(overrides) {
 }
 
 // src/agents/tester.ts
-var SYSTEM10 = `You are the test engineer. Your responsibility is to verify that requirements have actually been implemented.
+var SYSTEM10 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are the test engineer. Your responsibility is to verify that requirements have actually been implemented.
 
 Responsibilities:
 - Read requirements (acceptance criteria AC-) and the implementation code
@@ -490,7 +523,9 @@ Deliverables (save to the working directory):
 - test-report.md \u2014 overall verdict (PASS / FAIL / BLOCKED), test results per feature, reproduction steps and evidence for failures
 
 Principles: Do not PASS just because the code compiles or because a developer says it is fine. Every core feature must be verified with actual execution. When BLOCKED, state exactly what is missing.`;
-var TASK10 = `## Task Scope
+var TASK10 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Task Scope
 {{agentScope}}
 
 ## Plan
@@ -531,7 +566,9 @@ function tester(overrides) {
 }
 
 // src/agents/ui-design-reviewer.ts
-var SYSTEM11 = `You are a UI/UX design reviewer. Your job is to evaluate a UI design specification before implementation begins.
+var SYSTEM11 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are a UI/UX design reviewer. Your job is to evaluate a UI design specification before implementation begins.
 
 Responsibilities:
 - Review the design specification for completeness, consistency, and feasibility
@@ -544,7 +581,9 @@ Deliverables (save to the working directory):
 - ui-review.md \u2014 verdict (Approved / Changes Required), issue list (blocking / advisory) with component names and fix directions
 
 Principles: Be specific \u2014 reference component names or section titles in ui-design.md. A blocking issue must include what is missing or wrong and a fix direction. If the design is thorough and implementable, say so directly.`;
-var TASK11 = `## Requirement
+var TASK11 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Requirement
 {{requirement}}
 
 ## UI Design Specification
@@ -578,7 +617,9 @@ function uiDesignReviewer(overrides) {
 }
 
 // src/agents/ui-designer.ts
-var SYSTEM12 = `You are a UI/UX designer. Your job is to translate architecture and requirements into a detailed, developer-ready UI design specification.
+var SYSTEM12 = `The complete requirement and assigned responsibility govern your work. Role deliverable lists apply only within that scope. Existing architecture, API and UI designs are optional context; when absent, work from the requirement and existing code, investigate, plan and verify without requiring an architect or creating missing architecture documents.
+
+You are a UI/UX designer. Your job is to translate architecture and requirements into a detailed, developer-ready UI design specification.
 
 Responsibilities:
 - Define the component inventory: every page, section, and reusable component
@@ -592,7 +633,9 @@ Deliverables (save to the working directory):
 - ui-design.md \u2014 full UI design specification: component inventory, page layouts, interaction flows, design tokens, accessibility requirements
 
 Principles: Be specific enough that a developer can implement without guessing. Every component gets a name, purpose, props/variants, and states. Flag anything that depends on backend data.`;
-var TASK12 = `## Task Scope
+var TASK12 = `The current requirement and assigned scope govern this work. The role checklist below is guidance, not additional work. Architecture, API and UI design documents are optional context: use them if present and relevant; otherwise investigate the existing code, plan within your role, implement and verify. Do not require an architect or create design documents just because they are absent.
+
+## Task Scope
 {{agentScope}}
 
 ## Plan
@@ -607,10 +650,10 @@ var TASK12 = `## Task Scope
 ## Requirement
 {{requirement}}
 
-## Architecture Design
+## Architecture Design (optional context)
 {{file:architecture.md}}
 
-## API Specification
+## API Specification (optional context)
 {{file:api-spec.md}}
 
 ## Task
@@ -686,6 +729,9 @@ var EventBus = class {
   }
 };
 
+// src/orchestrator/AgentSessionManager.ts
+import { randomUUID } from "crypto";
+
 // src/utils/abort.ts
 var ABORT_ERROR_NAME = "AbortError";
 function abortError(message = "Operation aborted") {
@@ -697,83 +743,287 @@ function isAbortError(err) {
   return err instanceof Error && err.name === ABORT_ERROR_NAME;
 }
 
+// src/utils/errors.ts
+var PermanentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PermanentError";
+  }
+};
+function isPermanent(err) {
+  return err instanceof PermanentError;
+}
+
+// src/utils/session.ts
+import { createHash } from "crypto";
+import * as path from "path";
+function sessionCompatibilityKey(runtime, task) {
+  return createHash("sha256").update(
+    JSON.stringify([
+      runtime.name,
+      task.provider,
+      task.command,
+      task.args,
+      task.model,
+      path.resolve(task.workDir),
+      task.systemPrompt,
+      Boolean(task.onQuestion)
+    ])
+  ).digest("hex");
+}
+function isSessionRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  const capabilities = record.capabilities;
+  const failure = record.failure;
+  return ["bindingId", "agentId", "runtime", "compatibilityKey", "observedAt"].every(
+    (key) => typeof record[key] === "string" && !!record[key]
+  ) && (record.sessionId === void 0 || typeof record.sessionId === "string" && !!record.sessionId) && (record.workId === void 0 || typeof record.workId === "string") && (record.reason === void 0 || typeof record.reason === "string") && ["opening", "idle", "running", "cancelling", "closing", "closed", "unknown"].includes(
+    String(record.state)
+  ) && ["created", "loaded", "reused"].includes(String(record.action)) && !!capabilities && ["continuation", "load", "supplement"].every((key) => typeof capabilities[key] === "boolean") && (failure === void 0 || !!failure && [
+    "incompatible",
+    "unsupported",
+    "opening_failed",
+    "load_failed",
+    "turn_failed",
+    "cleanup_failed"
+  ].includes(String(failure.code)) && typeof failure.message === "string");
+}
+function isSessionEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const event = value;
+  return isSessionRecord(event.record) && [
+    "opening",
+    "created",
+    "load_requested",
+    "loaded",
+    "reused",
+    "state_changed",
+    "opening_failed",
+    "load_failed",
+    "closing",
+    "closed",
+    "cleanup_failed"
+  ].includes(String(event.action)) && typeof event.executionId === "string" && !!event.executionId && Number.isInteger(event.attempt) && event.attempt > 0 && (event.requestedSessionId === void 0 || typeof event.requestedSessionId === "string") && (event.reason === void 0 || typeof event.reason === "string");
+}
+function describeSession(record) {
+  if (record.failure)
+    return "Session " + record.failure.code.replaceAll("_", " ") + ": " + record.failure.message;
+  if (record.state === "opening") return "Session opening";
+  if (!record.sessionId) return "Session not established \xB7 " + record.state;
+  return "Session " + record.action + (record.sessionId ? " " + record.sessionId : "") + " \xB7 " + record.state;
+}
+
 // src/orchestrator/AgentSessionManager.ts
 var AgentSessionManager = class {
   constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
     this.entries = /* @__PURE__ */ new Map();
     this.closed = false;
   }
-  async execute(runtime, task) {
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  publish(entry3, action, requestedSessionId) {
+    entry3.record.observedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (entry3.session && action !== "closing" && action !== "closed" && entry3.record.failure?.code !== "cleanup_failed")
+      entry3.record.state = entry3.session.state;
+    const event = {
+      action,
+      executionId: entry3.executionId,
+      attempt: entry3.attempt,
+      record: structuredClone(entry3.record),
+      ...requestedSessionId ? { requestedSessionId } : {},
+      reason: entry3.record.reason
+    };
+    for (const listener of this.listeners) listener(event);
+  }
+  compatible(record, runtime, task, key) {
+    return record.agentId === task.agentId && record.workId === task.workId && record.runtime === runtime.name && record.compatibilityKey === key;
+  }
+  inspect(runtime, task, context = {}) {
+    const intent = (action, reason) => ({
+      agentId: task.agentId,
+      action,
+      reason
+    });
+    const entry3 = this.entries.get(task.agentId);
+    if (this.closed || this.resetting || entry3?.busy || entry3?.closing || entry3?.session && !["idle", "closed"].includes(entry3.session.state))
+      return intent("unavailable", "A Session is busy or cleanup is pending.");
+    let candidate = context.session;
+    if (candidate?.failure?.code === "cleanup_failed" || entry3?.record.failure?.code === "cleanup_failed")
+      return intent("unavailable", "Previous Session cleanup was not acknowledged.");
+    if (!candidate?.sessionId) candidate = void 0;
+    const key = sessionCompatibilityKey(runtime, task);
+    const compatible = (record) => this.compatible(record, runtime, task, key);
+    if (candidate && !compatible(candidate))
+      return intent(
+        context.strict ? "unavailable" : "create",
+        "Recorded work identity or immutable Session settings differ."
+      );
+    if (entry3 && compatible(entry3.record)) {
+      if (runtime.openSession && entry3.runtime === runtime && entry3.session?.state === "idle" && entry3.session.capabilities.continuation && (!candidate?.sessionId || candidate.sessionId === entry3.session.sessionId))
+        return intent("reuse", "Will reuse the matching live Session if still idle.");
+      candidate ??= entry3.record;
+    }
+    if (candidate) {
+      if (!runtime.openSession || !candidate.capabilities.load)
+        return intent(
+          context.strict ? "unavailable" : "create",
+          "Recorded Session loading is unsupported."
+        );
+      return intent(
+        "load",
+        "Will attempt to load the recorded conversation; restoration is not yet confirmed."
+      );
+    }
+    return intent(
+      "create",
+      "Will start a new executor conversation; any previous worker must first acknowledge cleanup."
+    );
+  }
+  async execute(runtime, task, context = {}) {
     if (this.closed) throw new Error("AgentSessionManager is closed");
     if (this.resetting) throw new Error("AgentSessionManager is resetting");
     if (task.signal?.aborted) throw abortError();
+    const compatibilityKey = sessionCompatibilityKey(runtime, task);
+    const executionId = context.executionId ?? randomUUID();
+    const attempt = context.attempt ?? 1;
     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?.busy || entry3?.session && !["idle", "closed"].includes(entry3.session.state))
+      throw new Error("Agent session is busy: " + task.agentId);
     if (entry3?.closing) await entry3.closing;
-    const fingerprint = JSON.stringify([
-      task.command,
-      task.args,
-      task.model,
-      task.workDir,
-      task.systemPrompt,
-      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;
-      }
+    let candidate = context.session;
+    let reason;
+    const compatible = (record) => this.compatible(record, runtime, task, compatibilityKey);
+    const observation = () => ({
+      record: {
+        bindingId: randomUUID(),
+        agentId: task.agentId,
+        workId: task.workId,
+        runtime: runtime.name,
+        compatibilityKey,
+        state: "opening",
+        capabilities: { continuation: false, load: false, supplement: false },
+        action: "created",
+        observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        reason
+      },
+      executionId,
+      attempt
+    });
+    const rejectTarget = (code, message) => {
+      const failure = observation();
+      failure.record.state = "unknown";
+      failure.record.failure = { code, message };
+      this.publish(failure, "load_failed", candidate?.sessionId);
+      throw new PermanentError(message);
+    };
+    if (candidate?.failure?.code === "cleanup_failed")
+      rejectTarget(
+        "unsupported",
+        "Previous Session cleanup was not acknowledged; refusing to start a replacement executor."
+      );
+    if (!candidate?.sessionId) candidate = void 0;
+    if (candidate && !compatible(candidate)) {
+      reason = "The recorded Session belongs to different work or has incompatible creation settings.";
+      if (context.strict) rejectTarget("incompatible", reason);
+      candidate = void 0;
+    }
+    const requested = candidate?.sessionId;
+    if (entry3 && (entry3.runtime !== runtime || !compatible(entry3.record) || entry3.session?.state === "closed" || !entry3.session?.capabilities.continuation || requested && requested !== entry3.session.sessionId || task.resume === "fork" || !runtime.openSession)) {
+      reason ??= !compatible(entry3.record) ? "Work identity or immutable Session settings changed." : "The previous live Session cannot continue.";
+      if (!candidate && compatible(entry3.record) && entry3.record.failure?.code !== "cleanup_failed")
+        candidate = structuredClone(entry3.record);
+      await this.closeEntry(entry3);
+      this.entries.delete(task.agentId);
       entry3 = void 0;
-      if (this.closed || this.resetting) throw abortError();
+      if (this.closed || this.resetting || task.signal?.aborted) throw abortError();
+    }
+    if (!entry3 && candidate && !candidate.capabilities.load) {
+      reason = "The recorded provider Session does not support loading.";
+      if (context.strict) rejectTarget("unsupported", reason);
+      candidate = void 0;
+    }
+    if (!runtime.openSession) {
+      if (candidate) rejectTarget("unsupported", "This runtime cannot load a live Session.");
+      const output = await runtime.execute(task);
+      if (output.sessionId) {
+        const observed = observation();
+        observed.record.sessionId = output.sessionId;
+        observed.record.state = "unknown";
+        observed.record.reason = "The execute-only runtime reported an ID without a managed Session.";
+        this.publish(observed, "state_changed");
+      }
+      return output;
     }
-    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 sessionId = candidate?.sessionId;
       const created = {
+        ...observation(),
         runtime,
-        fingerprint,
-        startup,
+        startup: new AbortController(),
         busy: true,
         onWarning: task.onWarning,
-        // Defer opening until the cache entry is installed, including synchronous failures.
-        opening: Promise.resolve().then(
-          () => openSession.call(runtime, {
+        opening: Promise.resolve().then(() => open())
+      };
+      const open = async () => {
+        try {
+          const session = await runtime.openSession({
             agentId: task.agentId,
+            provider: task.provider,
             systemPrompt: task.systemPrompt,
             workDir: task.workDir,
             command: task.command,
             args: task.args,
             model: task.model,
-            sessionId: task.sessionId,
+            sessionId,
             resume: task.resume,
             timeout: task.timeout,
             questionForms: Boolean(task.onQuestion),
-            signal: startup.signal,
+            signal: created.startup.signal,
             onWarning: (message) => created.onWarning?.(message)
-          })
-        ).then((session) => {
+          });
           created.session = session;
+          created.record.capabilities = { ...session.capabilities };
+          if (sessionId && session.sessionId !== sessionId) {
+            created.record.failure = {
+              code: "load_failed",
+              message: "Provider returned a different Session ID; the requested conversation was not restored."
+            };
+            await this.closeSession(created, session);
+            throw new PermanentError(created.record.failure.message);
+          }
+          created.record.sessionId = session.sessionId;
+          this.publish(created, sessionId ? "loaded" : "created", sessionId);
           return session;
-        })
+        } catch (error) {
+          created.record.failure ??= {
+            code: sessionId ? "load_failed" : "opening_failed",
+            message: error instanceof Error ? error.message : String(error)
+          };
+          if (!created.session) created.record.state = "unknown";
+          this.publish(created, sessionId ? "load_failed" : "opening_failed", sessionId);
+          throw error;
+        }
       };
+      created.record.action = sessionId ? "loaded" : "created";
+      const forwardAbort = () => created.startup.abort(task.signal?.reason);
+      task.signal?.addEventListener("abort", forwardAbort, { once: true });
+      detach = () => task.signal?.removeEventListener("abort", forwardAbort);
+      this.entries.set(task.agentId, created);
+      this.publish(created, sessionId ? "load_requested" : "opening", sessionId);
       entry3 = created;
-      this.entries.set(task.agentId, entry3);
     } else {
       entry3.busy = true;
       entry3.onWarning = task.onWarning;
+      entry3.executionId = executionId;
+      entry3.attempt = attempt;
+      entry3.record.action = "reused";
+      entry3.record.failure = void 0;
+      this.publish(entry3, "reused");
     }
     try {
       const session = await entry3.opening;
@@ -783,8 +1033,9 @@ var AgentSessionManager = class {
         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, {
+      if (session.state !== "idle") throw new Error("Agent session is busy: " + task.agentId);
+      const prompt = task.workId ? task.prompt + "\n\n## Session continuity\n" + (entry3.record.action === "created" ? "A new executor Session was created; no old conversation was restored. Inspect the workspace before repeating operations." : entry3.record.action === "loaded" ? "The recorded provider conversation was loaded successfully. Inspect current workspace state before continuing." : "The matching live executor conversation is being reused.") + (entry3.record.reason ? "\n" + entry3.record.reason : "") : task.prompt;
+      const turn = session.prompt(prompt, {
         signal: task.signal,
         timeout: task.timeout,
         onEvent: task.onEvent,
@@ -792,6 +1043,17 @@ var AgentSessionManager = class {
         onPermission: task.onPermission,
         onQuestion: task.onQuestion
       });
+      this.publish(entry3, "state_changed");
+      return await turn;
+    } catch (error) {
+      if (entry3.session) {
+        entry3.record.failure ??= {
+          code: "turn_failed",
+          message: error instanceof Error ? error.message : String(error)
+        };
+        this.publish(entry3, "state_changed");
+      }
+      throw error;
     } finally {
       detach?.();
       entry3.onWarning = void 0;
@@ -801,25 +1063,12 @@ var AgentSessionManager = class {
           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);
-        }
+        } else this.publish(entry3, "state_changed");
       } finally {
         entry3.busy = false;
       }
     }
   }
-  /**
-   * Whether this manager still holds a session for `agentId`.
-   *
-   * A caller about to continue a past conversation uses this to avoid naming a
-   * session it already has open: passing the id would change the entry's
-   * fingerprint, and the manager would close a perfectly good session and
-   * `session/load` it straight back.
-   */
-  has(agentId) {
-    if (this.closed) return false;
-    const entry3 = this.entries.get(agentId);
-    return entry3 !== void 0 && !entry3.closing && entry3.session?.state !== "closed";
-  }
   /**
    * Deliver a message into every session that is running a turn right now.
    *
@@ -858,6 +1107,16 @@ var AgentSessionManager = class {
       })
     );
   }
+  /** Close selected idle conversations without resetting the leader. */
+  async resetAgents(agentIds) {
+    for (const id of agentIds) {
+      const entry3 = this.entries.get(id);
+      if (!entry3) continue;
+      if (entry3.busy) throw new Error("Cannot reset a busy agent: " + id);
+      await this.closeEntry(entry3);
+      if (this.entries.get(id) === entry3) this.entries.delete(id);
+    }
+  }
   /** Closes all sessions and permits a fresh conversation after cleanup completes. */
   reset() {
     if (this.closing) return this.closing;
@@ -894,26 +1153,49 @@ var AgentSessionManager = class {
       entry3.closing = (async () => {
         let session;
         try {
-          session = await entry3.opening;
+          session = entry3.session ?? await entry3.opening;
         } catch (error) {
-          if (isAbortError(error)) return;
-          throw error;
+          if (entry3.session) session = entry3.session;
+          else if (isAbortError(error)) return;
+          else throw error;
         }
-        await session.close();
+        await this.closeSession(entry3, session);
       })();
     }
     return entry3.closing;
   }
+  async closeSession(entry3, session) {
+    if (entry3.cleanupComplete) return;
+    if (entry3.record.failure?.code === "cleanup_failed")
+      throw new Error(entry3.record.failure.message);
+    entry3.record.state = "closing";
+    this.publish(entry3, "closing");
+    try {
+      await session.close();
+      entry3.cleanupComplete = true;
+      entry3.record.state = "closed";
+      this.publish(entry3, "closed");
+    } catch (error) {
+      entry3.record.state = "unknown";
+      entry3.record.failure = {
+        code: "cleanup_failed",
+        message: error instanceof Error ? error.message : String(error)
+      };
+      this.publish(entry3, "cleanup_failed");
+      throw error;
+    }
+  }
 };
 
 // src/orchestrator/Orchestrator.ts
+import { randomUUID as randomUUID4 } from "crypto";
 import * as fs4 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 
 // src/providers/catalog.ts
-import * as path from "path";
+import * as path2 from "path";
 function normalizeCommandKey(command) {
-  return path.basename(command).toLowerCase().replace(/\.(cmd|exe|bat)$/i, "");
+  return path2.basename(command).toLowerCase().replace(/\.(cmd|exe|bat)$/i, "");
 }
 var PROVIDERS = [
   {
@@ -1199,14 +1481,25 @@ function asDecision(value) {
     const message = typeof record.message === "string" ? record.message.trim() : "";
     return message ? { mode, message } : void 0;
   }
-  if (mode === "run" || mode === void 0) {
+  if (mode === "run" || mode === "continue" || mode === void 0) {
     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() : "";
     const requirement = typeof record.requirement === "string" ? record.requirement.trim() : "";
     if ("requirement" in record && !requirement) return void 0;
+    const workId = typeof record.workId === "string" ? record.workId.trim() : "";
+    if (mode === "continue" && !workId) return void 0;
+    const tasks = record.tasks;
+    if (tasks !== void 0 && (!Array.isArray(tasks) || !tasks.every(
+      (task) => typeof task === "object" && task !== null && typeof task.agentId === "string" && task.agentId.trim() && typeof task.scope === "string" && task.scope.trim()
+    )))
+      return void 0;
+    if (Array.isArray(tasks) && (new Set(tasks.map((task) => task.agentId)).size !== tasks.length || tasks.some((task) => !run.includes(task.agentId))))
+      return void 0;
     return {
-      mode: "run",
+      mode: mode === "continue" ? "continue" : "run",
+      ...workId ? { workId } : {},
+      ...Array.isArray(tasks) ? { tasks: tasks.map((task) => ({ agentId: task.agentId, scope: task.scope.trim() })) } : {},
       run,
       ...reason ? { reason } : {},
       ...requirement ? { requirement } : {}
@@ -1255,32 +1548,61 @@ function renderUpstreamOutputs(outputs) {
   return block(entries);
 }
 
+// src/utils/work.ts
+function isWorkContext(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const work = value;
+  if (typeof work.id !== "string" || !work.id.trim() || typeof work.originalRequirement !== "string" || typeof work.requirement !== "string" || !Array.isArray(work.agents))
+    return false;
+  if (!work.agents.every((item) => {
+    if (typeof item !== "object" || item === null) return false;
+    const agent = item;
+    return typeof agent.agentId === "string" && !!agent.agentId.trim() && ["scope", "plan", "taskTitle"].every(
+      (key) => agent[key] === void 0 || typeof agent[key] === "string"
+    ) && (agent.session === void 0 || isSessionRecord(agent.session) && agent.session.agentId === agent.agentId && agent.session.workId === work.id) && (agent.dependsOn === void 0 || Array.isArray(agent.dependsOn) && agent.dependsOn.every((id) => typeof id === "string"));
+  }))
+    return false;
+  if (new Set(work.agents.map((item) => item.agentId)).size !== work.agents.length) return false;
+  if (work.outcome !== void 0) {
+    if (typeof work.outcome !== "object" || work.outcome === null) return false;
+    const outcome = work.outcome;
+    if (!["success", "failed", "cancelled", "interrupted", "unknown"].includes(
+      String(outcome.execution)
+    ) || !Array.isArray(outcome.completedAgents) || !outcome.completedAgents.every((id) => typeof id === "string") || !Array.isArray(outcome.failedAgents) || !outcome.failedAgents.every(
+      (item) => item && typeof item.agentId === "string" && (item.reason === void 0 || typeof item.reason === "string")
+    ))
+      return false;
+  }
+  return true;
+}
+
 // src/orchestrator/AgentRunner.ts
+import { randomUUID as randomUUID3 } from "crypto";
 import * as fs3 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/runtime/AcpRuntime.ts
 import { spawn } from "child_process";
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { Readable, Writable } from "stream";
 import { StringDecoder } from "string_decoder";
 
 // src/providers/bridge.ts
 import * as fs from "fs";
 import { createRequire } from "module";
-import * as path2 from "path";
+import * as path3 from "path";
 var BRIDGE_PACKAGES = {
   "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
   "codex-acp": "@agentclientprotocol/codex-acp"
 };
 function resolvesOnPath(command) {
-  const dirs = (process.env.PATH ?? "").split(path2.delimiter).filter(Boolean);
+  const dirs = (process.env.PATH ?? "").split(path3.delimiter).filter(Boolean);
   const exts = (process.env.PATHEXT ?? "").split(";").filter(Boolean);
   const suffixes = exts.length > 0 ? exts : [""];
   for (const dir of dirs) {
     for (const ext of suffixes) {
       try {
-        fs.accessSync(path2.join(dir, command + ext), fs.constants.X_OK);
+        fs.accessSync(path3.join(dir, command + ext), fs.constants.X_OK);
         return true;
       } catch {
       }
@@ -1297,7 +1619,7 @@ function resolveBridgeBinary(command) {
     const bin = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8")).bin;
     const binRel = typeof bin === "string" ? bin : bin?.[command] ?? Object.values(bin)[0];
     if (!binRel) return null;
-    return path2.join(path2.dirname(pkgJsonPath), binRel);
+    return path3.join(path3.dirname(pkgJsonPath), binRel);
   } catch {
     return null;
   }
@@ -1307,17 +1629,6 @@ function resolveExecutable(command) {
   return resolveBridgeBinary(command);
 }
 
-// src/utils/errors.ts
-var PermanentError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PermanentError";
-  }
-};
-function isPermanent(err) {
-  return err instanceof PermanentError;
-}
-
 // src/utils/toolSummary.ts
 var MAX_SUMMARY_COLUMNS = 120;
 function stringifySafe(value) {
@@ -1582,6 +1893,7 @@ var AcpRuntime = class extends RuntimeBase {
       let state = "idle";
       let sessionId = "";
       let steeringSupported = false;
+      let loadSupported = false;
       let active;
       let childClosed = false;
       let terminalError;
@@ -1641,8 +1953,8 @@ var AcpRuntime = class extends RuntimeBase {
       };
       const close = () => {
         if (closePromise) return closePromise;
-        closePromise = new Promise((resolve4, reject) => {
-          closeResolve = resolve4;
+        closePromise = new Promise((resolve5, reject) => {
+          closeResolve = resolve5;
           closeReject = reject;
         });
         options.signal?.removeEventListener("abort", onSessionAbort);
@@ -1806,7 +2118,7 @@ var AcpRuntime = class extends RuntimeBase {
         const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
         const offered = new Set(params.options.map((option) => option.optionId));
         const request = {
-          requestId: randomUUID(),
+          requestId: randomUUID2(),
           runId: turn.runId,
           agentId: options.agentId,
           seq: turn.seq++,
@@ -1819,8 +2131,8 @@ var AcpRuntime = class extends RuntimeBase {
           options: params.options.map(({ optionId, name, kind }) => ({ optionId, name, kind }))
         };
         let onAbort;
-        const aborted = new Promise((resolve4) => {
-          onAbort = () => resolve4(void 0);
+        const aborted = new Promise((resolve5) => {
+          onAbort = () => resolve5(void 0);
           signal.addEventListener("abort", onAbort, { once: true });
           if (signal.aborted) onAbort();
         });
@@ -1865,7 +2177,7 @@ var AcpRuntime = class extends RuntimeBase {
         const schema = structuredClone(params.requestedSchema);
         const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
         const request = {
-          requestId: randomUUID(),
+          requestId: randomUUID2(),
           runId: turn.runId,
           agentId: options.agentId,
           seq: turn.seq++,
@@ -1875,8 +2187,8 @@ var AcpRuntime = class extends RuntimeBase {
           requestedSchema: structuredClone(schema)
         };
         let onAbort;
-        const aborted = new Promise((resolve4) => {
-          onAbort = () => resolve4(void 0);
+        const aborted = new Promise((resolve5) => {
+          onAbort = () => resolve5(void 0);
           signal.addEventListener("abort", onAbort, { once: true });
           if (signal.aborted) onAbort();
         });
@@ -1986,20 +2298,20 @@ var AcpRuntime = class extends RuntimeBase {
         } catch (error) {
           return Promise.reject(error);
         }
-        let resolve4;
+        let resolve5;
         let reject;
         const promise = new Promise((res, rej) => {
-          resolve4 = res;
+          resolve5 = res;
           reject = rej;
         });
         const turn = {
-          runId: randomUUID(),
+          runId: randomUUID2(),
           seq: 0,
           options: promptOptions,
           output: "",
           decisions: new AbortController(),
           promise,
-          resolve: resolve4,
+          resolve: resolve5,
           reject
         };
         active = turn;
@@ -2059,7 +2371,7 @@ ${text}` : text
           return state;
         },
         get capabilities() {
-          return { continuation: true, supplement: steeringSupported };
+          return { continuation: true, load: loadSupported, supplement: steeringSupported };
         },
         prompt,
         supplement,
@@ -2078,6 +2390,7 @@ ${text}` : text
         });
         if (terminalError) throw terminalError;
         steeringSupported = advertisesSteering(init);
+        loadSupported = init.agentCapabilities?.loadSession === true;
         if (options.sessionId) {
           if (init.agentCapabilities?.loadSession !== true) {
             throw new PermanentError(
@@ -2178,13 +2491,44 @@ var RuntimeRegistry = class {
 };
 var runtimeRegistry = new RuntimeRegistry();
 
+// src/utils/handoff.ts
+var HANDOFF_INSTRUCTION = [
+  "## Routing handoff",
+  "If this assignment belongs to another role or needs rerouting beyond your scope, explain what remains and end with exactly:",
+  '<multiclaw-handoff>{"reason":"specific reason and remaining work"}</multiclaw-handoff>',
+  "Do not use this for routine implementation choices, progress, or provider errors. Do not rewrite the original requirement. Otherwise finish normally."
+].join("\n");
+function parseHandoff(output) {
+  const text = output.trim();
+  const unfenced = text.replace(/```[\s\S]*?```/g, "[quoted example]");
+  const lastLine = unfenced.trim().split("\n").slice(-1)[0] ?? "";
+  const terminal = unfenced.match(/(?:^|\n)<multiclaw-handoff>([\s\S]*?)<\/multiclaw-handoff>$/);
+  const unclosed = /(?:^|\n)<multiclaw-handoff>(?:(?!<\/multiclaw-handoff>)[\s\S])*$/.test(unfenced);
+  if (!terminal && !unclosed && !/^<\/?multiclaw-handoff(?:>|\s)/.test(lastLine.trim()))
+    return void 0;
+  const lines = unfenced.split("\n").filter((line) => /^<multiclaw-handoff(?:>|\s)/.test(line.trim()));
+  if (text.split(String.fromCharCode(96).repeat(3)).length % 2 === 0) return void 0;
+  const match = text.match(/(?:^|\n)<multiclaw-handoff>([\s\S]*?)<\/multiclaw-handoff>$/);
+  if (lines.length !== 1 || !match) return { error: "Invalid terminal handoff marker." };
+  try {
+    const item = JSON.parse(match[1]);
+    if (typeof item !== "object" || item === null || Array.isArray(item)) throw new Error();
+    const fields = item;
+    if (Object.keys(fields).length !== 1 || typeof fields.reason !== "string" || !fields.reason.trim())
+      throw new Error();
+    return { reason: fields.reason.trim() };
+  } catch {
+    return { error: "Handoff requires a JSON object with a non-empty reason." };
+  }
+}
+
 // src/utils/prompt.ts
 import * as fs2 from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 function resolveInWorkspace(workDir, reference) {
-  const root = path3.resolve(workDir);
-  const resolved = path3.resolve(root, reference);
-  if (resolved !== root && !resolved.startsWith(root + path3.sep)) return void 0;
+  const root = path4.resolve(workDir);
+  const resolved = path4.resolve(root, reference);
+  if (resolved !== root && !resolved.startsWith(root + path4.sep)) return void 0;
   return resolved;
 }
 async function renderPrompt(template, context, workDir) {
@@ -2213,14 +2557,14 @@ async function renderPrompt(template, context, workDir) {
 var DEFAULT_RETRY_DELAY_MS = 2e3;
 function sleep(ms, signal) {
   if (signal?.aborted) return Promise.reject(abortError());
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const onAbort = () => {
       clearTimeout(timer);
       reject(abortError());
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve4();
+      resolve5();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -2295,8 +2639,45 @@ var AgentRunner = class {
     this.config = config;
     this.sessionManager = sessionManager;
   }
+  sessionTask(agent) {
+    return {
+      agentId: agent.id,
+      workId: agent.id === this.config.leader?.id ? void 0 : this.contextManager.get("workId"),
+      systemPrompt: agent.systemPrompt,
+      prompt: "",
+      workDir: agent.workDir ? path5.resolve(this.globalWorkDir, agent.workDir) : this.globalWorkDir,
+      timeout: agent.timeout ?? 6e5,
+      model: resolveModel(agent, this.config),
+      provider: resolveProvider(agent, this.config),
+      command: resolveCommand(agent, this.config),
+      args: resolveArgs(agent, this.config),
+      onQuestion: this.config.questions?.onRequest
+    };
+  }
+  previewSession(agent) {
+    const task = this.sessionTask(agent);
+    return (this.sessionManager ?? new AgentSessionManager()).inspect(
+      runtimeRegistry.get(agent.runtime ?? "acp"),
+      task,
+      { session: this.config.resume?.sessions?.[agent.id], strict: !!this.config.resume?.agents }
+    );
+  }
   async run(agent, signal, instruction) {
     const startTime = /* @__PURE__ */ new Date();
+    const executionId = randomUUID3();
+    const manager = this.sessionManager ?? new AgentSessionManager();
+    let session;
+    let finalResult;
+    const offSession = manager.subscribe((event) => {
+      if (event.executionId !== executionId) return;
+      session = event.record;
+      if (!this.sessionManager)
+        this.eventBus.emit({
+          type: "agent:session",
+          timestamp: event.record.observedAt,
+          payload: event
+        });
+    });
     const model = resolveModel(agent, this.config);
     this.eventBus.emit({
       type: "agent:start",
@@ -2314,7 +2695,7 @@ var AgentRunner = class {
     let usage;
     let costUsd;
     try {
-      const workDir = agent.workDir ? path4.resolve(this.globalWorkDir, agent.workDir) : this.globalWorkDir;
+      const workDir = agent.workDir ? path5.resolve(this.globalWorkDir, agent.workDir) : this.globalWorkDir;
       fs3.mkdirSync(workDir, { recursive: true });
       const runtime = runtimeRegistry.get(agent.runtime ?? "acp");
       const retries = agent.retries ?? 0;
@@ -2332,8 +2713,8 @@ var AgentRunner = class {
               // agent, and the no-leader path has no plan at all — so without a
               // default the model is handed the literal text `{{agentScope}}`
               // and has to guess what it was supposed to say.
-              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."
+              agentScope: agent.agentScope?.trim() || "Fulfil the current requirement within your role: " + (agent.description ?? agent.name),
+              agentPlan: agent.agentPlan?.trim() || "No step-by-step plan was provided \u2014 use your judgement."
             };
             let prompt = await renderPrompt(agent.taskPrompt, agentContext, this.globalWorkDir);
             const requirement = this.contextManager.get("requirement") ?? this.config.context?.requirement;
@@ -2343,6 +2724,10 @@ ${requirement}
 
 ${prompt}`;
             }
+            if (agent.id !== this.config.leader?.id && agent.id !== this.config.review?.reviewer)
+              prompt = "## Assigned responsibility\n" + agentContext.agentScope + "\n\n## Planning\n" + agentContext.agentPlan + "\n\n" + prompt;
+            if (agent.id !== this.config.leader?.id && agent.id !== this.config.review?.reviewer)
+              prompt += "\n\n" + HANDOFF_INSTRUCTION;
             if (instruction) prompt += `
 
 ${instruction}`;
@@ -2357,28 +2742,14 @@ ${instruction}`;
 `, "tool");
             };
             const task = {
-              agentId: agent.id,
-              systemPrompt: agent.systemPrompt,
+              ...this.sessionTask(agent),
               prompt,
               permissionMode,
               onPermission: this.config.permissions?.onRequest,
               onQuestion: this.config.questions?.onRequest,
-              workDir,
-              timeout,
               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
-              // runtime tests `if (task.sessionId)`, so an empty string would
-              // read as "load this session" for a session that does not exist.
-              sessionId: this.config.resume?.sessions?.[agent.id],
-              // Resolve through provider/defaults exactly as the CLI's
-              // availability gate does — an agent that pins `provider` (or
-              // leans on `defaults`) must launch that provider's bridge, not
-              // the runtime's built-in default. Passing the raw `agent.command`
-              // here sent a `provider: "claude"` config straight to `opencode`.
-              command: resolveCommand(agent, this.config),
-              args: resolveArgs(agent, this.config),
+              provider: resolveProvider(agent, this.config),
               // A runtime's diagnostics travel on the event bus rather than
               // stderr: under the TUI's alternate screen a stderr write is
               // never seen. The agent name prefixes the line so it is
@@ -2413,7 +2784,12 @@ ${instruction}`;
                 }
               }
             };
-            return await (this.sessionManager ? this.sessionManager.execute(runtime, task) : runtime.execute(task));
+            return await manager.execute(runtime, task, {
+              session: this.config.resume?.sessions?.[agent.id],
+              strict: !!this.config.resume?.agents,
+              executionId,
+              attempt
+            });
           },
           retries,
           (attempt, err) => {
@@ -2446,16 +2822,17 @@ ${instruction}`;
       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 handoff = completed.exitCode === 0 && !incomplete && agent.id !== this.config.leader?.id && agent.id !== this.config.review?.reviewer ? parseHandoff(output) : void 0;
+      const failed = completed.exitCode !== 0 || incomplete || !!(handoff && "error" in handoff);
+      const error = handoff && "error" in handoff ? handoff.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: cancelled ? "cancelled" : failed ? "failed" : "success",
+        status: cancelled ? "cancelled" : failed ? "failed" : handoff ? "handed_back" : "success",
+        ...handoff && "reason" in handoff ? { handoffReason: handoff.reason } : {},
         ...error ? { error } : {},
         output,
         duration: endTime.getTime() - startTime.getTime(),
@@ -2465,13 +2842,9 @@ ${instruction}`;
         model,
         ...usage ? { usage } : {},
         ...costUsd !== void 0 ? { costUsd } : {},
-        ...sessionId ? { sessionId } : {}
+        ...session ? { session } : {}
       };
-      this.eventBus.emit({
-        type: failed ? "agent:failed" : "agent:complete",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: result
-      });
+      finalResult = result;
       return result;
     } catch (err) {
       const endTime = /* @__PURE__ */ new Date();
@@ -2487,14 +2860,29 @@ ${instruction}`;
         error: err.message,
         startTime: startTime.toISOString(),
         endTime: endTime.toISOString(),
-        model
+        model,
+        ...session ? { session } : {}
       };
-      this.eventBus.emit({
-        type: "agent:failed",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        payload: result
-      });
+      finalResult = result;
       return result;
+    } finally {
+      try {
+        if (!this.sessionManager) await manager.close();
+      } catch (error) {
+        if (finalResult) {
+          finalResult.status = "failed";
+          finalResult.error = (finalResult.error ? finalResult.error + "; " : "") + "Session cleanup failed: " + String(error);
+        }
+      } finally {
+        if (finalResult && session) finalResult.session = session;
+        offSession();
+        if (finalResult)
+          this.eventBus.emit({
+            type: finalResult.status === "success" ? "agent:complete" : finalResult.status === "handed_back" ? "agent:handed-back" : "agent:failed",
+            timestamp: finalResult.endTime,
+            payload: finalResult
+          });
+      }
     }
   }
   /**
@@ -2559,10 +2947,51 @@ function buildStages(agents2) {
 var Orchestrator = class {
   constructor(config, sessions) {
     this.config = config;
+    this.sessions = sessions;
     this.eventBus = new EventBus();
     /** Which configured checkpoints have already been triggered this run. */
     this.checkpointTriggered = /* @__PURE__ */ new Set();
-    this.workDir = path5.resolve(config.workDir);
+    this.assignments = /* @__PURE__ */ new Map();
+    this.excluded = /* @__PURE__ */ new Set();
+    this.rerouting = false;
+    this.repairSpent = 0;
+    this.leaderCosts = [];
+    this.cleanupAttempted = false;
+    this.sessionRecords = /* @__PURE__ */ new Map();
+    this.recovery = "";
+    config = {
+      ...config,
+      latestWork: isWorkContext(config.latestWork) ? config.latestWork : void 0,
+      resume: config.resume ? { ...config.resume } : void 0
+    };
+    this.config = config;
+    this.ownsSessions = !sessions;
+    this.sessions = sessions ?? new AgentSessionManager();
+    this.offSessions = this.sessions.subscribe((event) => {
+      this.sessionRecords.set(event.record.bindingId, event.record);
+      if (event.record.sessionId && this.work && this.work.id === event.record.workId) {
+        let entry3 = this.work.agents.find((item) => item.agentId === event.record.agentId);
+        if (!entry3) {
+          entry3 = { agentId: event.record.agentId };
+          this.work.agents.push(entry3);
+        }
+        if (!entry3.session || entry3.session.bindingId === event.record.bindingId || event.action === "created" || event.action === "loaded")
+          entry3.session = event.record;
+      }
+      this.eventBus.emit({
+        type: "agent:session",
+        timestamp: event.record.observedAt,
+        payload: event
+      });
+      if (event.record.sessionId && this.work && this.work.id === event.record.workId && this.routing)
+        this.eventBus.emit({
+          type: "orchestration:route",
+          timestamp: event.record.observedAt,
+          payload: { routing: { ...this.routing }, work: structuredClone(this.work) }
+        });
+    });
+    this.originalRequirement = config.context?.requirement ?? "";
+    this.workDir = path6.resolve(config.workDir);
     fs4.mkdirSync(this.workDir, { recursive: true });
     this.contextManager = new ContextManager(config.context);
     this.contextManager.set("conversation", renderConversation(config.history));
@@ -2572,21 +3001,32 @@ var Orchestrator = class {
       this.contextManager,
       this.workDir,
       config,
-      sessions
+      this.sessions
     );
   }
   async preview(options = {}) {
+    try {
+      return await this.previewManaged(options);
+    } finally {
+      try {
+        if (this.ownsSessions) await this.sessions?.close();
+      } finally {
+        this.offSessions();
+      }
+    }
+  }
+  async previewManaged(options = {}) {
     if (options.signal?.aborted)
       return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
     const policyError = this.reviewPolicyError();
     if (policyError) throw new Error(policyError);
     if (options.signal?.aborted)
       return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
-    this.prepareTaskPlan();
     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 === "error") throw new Error(resolution.message);
     if (resolution.kind === "message") {
       return {
         name: this.config.name,
@@ -2606,11 +3046,135 @@ var Orchestrator = class {
       name: this.config.name,
       totalAgents: agents2.length + (reviewer2 && agents2.length ? 1 : 0),
       stages: stageInfos,
+      sessions: [...agents2, ...reviewer2 && agents2.length ? [reviewer2] : []].map(
+        (agent) => this.runner.previewSession(agent)
+      ),
       ...this.reasonField(resolution.reason),
-      ...this.requirementField()
+      ...this.requirementField(),
+      originalRequirement: this.originalRequirement,
+      routing: this.routing
     };
   }
   async run(options = {}) {
+    try {
+      return await this.runManaged(options);
+    } finally {
+      try {
+        if (this.ownsSessions && !this.cleanupAttempted) await this.sessions?.close();
+      } finally {
+        this.offSessions();
+      }
+    }
+  }
+  async runManaged(options = {}) {
+    const started = /* @__PURE__ */ new Date();
+    const audit = [];
+    let result;
+    for (; ; ) {
+      this.checkpointTriggered.clear();
+      result = await this.runPass(options);
+      const effective2 = [
+        ...new Map(result.agentResults.map((item) => [item.agentId, item])).values()
+      ];
+      audit.push(...result.agentResults);
+      const handbacks = effective2.filter((item) => item.status === "handed_back");
+      const failure = effective2.some(
+        (item) => item.status === "failed" || item.status === "cancelled"
+      );
+      if (!handbacks.length || failure || result.cancelled || options.signal?.aborted) break;
+      if (this.rerouting || !this.config.leader || this.config.useLeader === false || this.config.resume?.agents) {
+        this.routeError = this.rerouting ? "Work handed back again; rerouting budget exhausted." : "Work handed back; automatic rerouting is unavailable for this fixed team.";
+        result.success = false;
+        break;
+      }
+      this.rerouting = true;
+      for (const item of handbacks) this.excluded.add(item.agentId);
+      if (this.routing) this.routing.reroutes = 1;
+      this.recovery = "## Rerouting after worker handoff\nPreserve the complete requirement. Check the workspace before repeating completed operations.\n" + JSON.stringify({
+        originalRequirement: this.work?.originalRequirement,
+        requirement: this.contextManager.get("requirement"),
+        handbacks: handbacks.map((item) => ({
+          agentId: item.agentId,
+          handoffReason: item.handoffReason,
+          session: item.session
+        })),
+        completed: effective2.filter((item) => item.status === "success").map((item) => ({ agentId: item.agentId, output: item.output.slice(-4e3) })),
+        assignments: this.work?.agents
+      });
+      this.contextManager.set("rerouting", this.recovery);
+      this.contextManager.set("upstreamOutputs", "");
+    }
+    const effective = [...new Map(result.agentResults.map((item) => [item.agentId, item])).values()];
+    result.effectiveAgentResults = effective;
+    result.agentResults = audit;
+    if (this.rerouting && result.reply)
+      this.routeError = "Work remains incomplete: " + result.reply.message;
+    result.originalRequirement = this.originalRequirement;
+    result.routing = this.routing;
+    if (this.routeError) {
+      result.success = false;
+      result.routing = {
+        mode: this.routing?.mode ?? "run",
+        workId: this.work?.id,
+        reroutes: this.rerouting ? 1 : 0,
+        error: this.routeError
+      };
+      this.eventBus.emit({
+        type: "orchestration:routing-error",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        payload: { message: this.routeError }
+      });
+    }
+    if (this.work) {
+      this.work.requirement = this.contextManager.get("requirement") ?? this.work.requirement;
+      const workers = effective.filter((item) => item.agentId !== this.config.review?.reviewer);
+      this.work.outcome = {
+        execution: result.cancelled ? "cancelled" : !this.routeError && workers.length > 0 && workers.every((item) => item.status === "success") ? "success" : "failed",
+        completedAgents: effective.filter(
+          (item) => item.status === "success" && item.agentId !== this.config.review?.reviewer
+        ).map((item) => item.agentId),
+        failedAgents: workers.filter((item) => item.status !== "success").map((item) => ({ agentId: item.agentId, reason: item.error ?? item.handoffReason })),
+        ...result.acceptance ? { acceptance: { status: result.acceptance.status, reason: result.acceptance.reason } } : {}
+      };
+      result.work = this.work;
+    }
+    if (this.ownsSessions) {
+      this.cleanupAttempted = true;
+      try {
+        await this.sessions?.close();
+      } catch (error) {
+        result.success = false;
+        result.routing = {
+          mode: this.routing?.mode ?? "run",
+          workId: this.work?.id,
+          reroutes: this.rerouting ? 1 : 0,
+          error: "Session cleanup failed: " + errorMessage2(error)
+        };
+        if (this.work?.outcome) this.work.outcome.execution = "failed";
+        this.eventBus.emit({
+          type: "orchestration:routing-error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: { message: result.routing.error }
+        });
+      }
+      for (const item of [...result.agentResults, ...result.effectiveAgentResults ?? []]) {
+        const latest = item.session && this.sessionRecords.get(item.session.bindingId);
+        if (latest) item.session = { ...latest, action: item.session.action };
+      }
+    }
+    const cost = sumCosts([...audit, ...this.leaderCosts]);
+    if (cost !== void 0) result.totalCostUsd = cost;
+    result.startTime = started.toISOString();
+    result.endTime = (/* @__PURE__ */ new Date()).toISOString();
+    result.totalDuration = Date.now() - started.getTime();
+    this.eventBus.emit({
+      type: "orchestration:complete",
+      timestamp: result.endTime,
+      payload: result
+    });
+    return result;
+  }
+  async runPass(options) {
     const startTime = /* @__PURE__ */ new Date();
     if (options.signal?.aborted) return this.finishCancelled(startTime);
     const policyError = this.reviewPolicyError();
@@ -2626,16 +3190,38 @@ var Orchestrator = class {
       return result2;
     }
     if (options.signal?.aborted) return this.finishCancelled(startTime);
-    this.prepareTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
     if (resolution.kind === "cancelled" || options.signal?.aborted) {
       return this.finishCancelled(startTime);
     }
+    if (resolution.kind === "error") {
+      this.routeError = resolution.message;
+      return this.finishEmpty(startTime, void 0, false);
+    }
     if (resolution.kind === "message") {
       return this.finishWithMessage(resolution.mode, resolution.message, startTime);
     }
     const agents2 = resolution.agents;
-    if (this.config.resume) this.applyResumeTaskPlan(agents2);
+    if (this.routing?.mode === "run" && !this.rerouting && !this.config.resume?.agents) {
+      try {
+        await this.sessions?.resetAgents(
+          this.config.agents.filter((agent) => agent.id !== this.config.leader?.id).map((agent) => agent.id)
+        );
+        this.prepareTaskPlan();
+      } catch (error) {
+        this.routeError = "Routing incomplete: could not prepare new work: " + errorMessage2(error);
+        return this.finishEmpty(startTime, void 0, false);
+      }
+    }
+    if (!this.config.resume?.agents && (this.rerouting || this.routing?.mode === "continue") && agents2.some((agent) => this.isPlanner(agent))) {
+      try {
+        fs4.rmSync(path6.join(this.workDir, "task-plan.json"), { force: true });
+      } catch (error) {
+        this.routeError = "Routing incomplete: could not clear the previous plan: " + errorMessage2(error);
+        return this.finishEmpty(startTime, void 0, false);
+      }
+    }
+    if (this.config.resume?.agents && !this.config.latestWork) this.applyResumeTaskPlan(agents2);
     if (agents2.length === 0)
       return this.finishEmpty(
         startTime,
@@ -2666,6 +3252,7 @@ var Orchestrator = class {
     let cancelled = false;
     let planApplied = false;
     const executedIds = /* @__PURE__ */ new Set();
+    let handedBack = false;
     for (let i = 0; i < stages.length; i++) {
       if (options.signal?.aborted) {
         cancelled = true;
@@ -2692,11 +3279,29 @@ var Orchestrator = class {
         allSuccess = false;
         break;
       }
+      this.captureWork(agents2, results);
+      handedBack = stageResults.some((item) => item.status === "handed_back");
+      if (handedBack) {
+        allSuccess = false;
+        this.eventBus.emit({
+          type: "stage:complete",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: { stageIndex: i }
+        });
+        for (const pending of stages.slice(i + 1).flat())
+          this.eventBus.emit({
+            type: "agent:skipped",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            payload: { agentId: pending.id, agentName: pending.name, icon: pending.icon }
+          });
+        break;
+      }
       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, executedIds);
+        this.captureWork(agents2, results);
         const remaining = agents2.filter((a) => !executedIds.has(a.id)).map((a) => ({
           ...a,
           dependsOn: a.dependsOn?.filter((dep) => !executedIds.has(dep))
@@ -2761,7 +3366,7 @@ var Orchestrator = class {
       }
     }
     let acceptance;
-    if (this.config.review) {
+    if (this.config.review && !handedBack) {
       acceptance = await this.reviewDelivery(
         agents2,
         results,
@@ -2773,6 +3378,7 @@ var Orchestrator = class {
       cancelled ||= acceptance.status === "cancelled";
       allSuccess = allSuccess && acceptance.status === "approved";
     }
+    this.captureWork(agents2, results);
     const endTime = /* @__PURE__ */ new Date();
     const totalCostUsd = sumCosts(results);
     const result = {
@@ -2788,11 +3394,6 @@ var Orchestrator = class {
       ...this.reasonField(resolution.reason),
       ...this.requirementField()
     };
-    this.eventBus.emit({
-      type: "orchestration:complete",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      payload: result
-    });
     return result;
   }
   reviewPolicyError() {
@@ -2820,7 +3421,7 @@ var Orchestrator = class {
     const acceptance = {
       status: "failed",
       reviewer: policy.reviewer,
-      repairRounds: 0,
+      repairRounds: this.repairSpent,
       reviews: []
     };
     if (cancelled || signal?.aborted) return { ...acceptance, status: "cancelled" };
@@ -2866,7 +3467,8 @@ var Orchestrator = class {
         const result = await this.runner.run(
           agent,
           signal,
-          `${instruction}
+          `${this.recovery}
+${instruction}
 
 ## Latest worker outputs
 ${this.contextManager.get("upstreamOutputs") ?? ""}`
@@ -2916,6 +3518,7 @@ Approval requires an empty issues array; changes_required requires at least one
         return acceptance;
       }
       acceptance.repairRounds++;
+      this.repairSpent++;
       this.warn(
         `Delivery requires changes \u2014 repair pass ${acceptance.repairRounds}/${policy.maxRepairRounds ?? 1}.`
       );
@@ -2986,8 +3589,8 @@ Address these findings within your assigned scope, preserve the complete task re
    * generic "no plan was provided" fallback.
    */
   prepareTaskPlan() {
-    if (this.config.resume) return;
-    fs4.rmSync(path5.join(this.workDir, "task-plan.json"), { force: true });
+    if (this.config.resume?.agents) return;
+    fs4.rmSync(path6.join(this.workDir, "task-plan.json"), { force: true });
   }
   /**
    * Decide what this turn is: a pipeline, an answer, or a question.
@@ -3000,38 +3603,132 @@ Address these findings within your assigned scope, preserve the complete task re
   async resolveTurn(signal) {
     if (signal?.aborted) return { kind: "cancelled" };
     if (this.config.resume?.agents) {
-      return {
-        kind: "run",
-        agents: this.selectAgents(this.config.resume.agents, "The resume list")
-      };
+      const agents2 = this.selectAgents(this.config.resume.agents, "The resume list");
+      this.beginWork(agents2, "continue", this.config.latestWork);
+      return { kind: "run", agents: agents2 };
     }
     if (!this.config.leader || this.config.useLeader === false) {
-      return { kind: "run", agents: this.configuredAgents() };
+      const agents2 = this.configuredAgents();
+      this.beginWork(agents2, "run");
+      return { kind: "run", agents: agents2 };
     }
+    const available = this.configuredAgents().filter((agent) => !this.excluded.has(agent.id));
     this.contextManager.set(
       "availableAgents",
-      this.configuredAgents().map((a) => `${a.id}: ${a.name}`).join("\n")
+      available.map((agent) => agent.id + ": " + agent.name + " \u2014 " + (agent.description ?? "")).join("\n")
+    );
+    this.contextManager.set(
+      "latestWork",
+      JSON.stringify(this.rerouting ? this.work : this.config.latestWork) ?? "No previous work."
     );
-    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() };
-    }
-    const decision = parseLeaderDecision(result.output);
-    if (decision) {
-      if (decision.mode !== "run") {
+    const leader2 = this.config.leader;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const result = await this.runner.run(
+        leader2,
+        signal,
+        (this.recovery || "") + (attempt ? "\nYour previous routing decision was invalid or unavailable. Return exactly one valid run, continue, reply or ask decision. Do not select unavailable agents." : "")
+      );
+      this.leaderCosts.push(result);
+      if (signal?.aborted || result.status === "cancelled") return { kind: "cancelled" };
+      const decision = result.status === "success" ? parseLeaderDecision(result.output) : void 0;
+      if (decision && (decision.mode === "run" || decision.mode === "continue")) {
+        const known = new Set(available.map((agent) => agent.id));
+        if (!decision.run.length || decision.run.some((id) => !known.has(id)) || new Set(decision.run).size !== decision.run.length) {
+          this.warn("Invalid routing agents: " + decision.run.join(", "));
+          continue;
+        }
+        const previous = this.rerouting ? this.work : this.config.latestWork;
+        if (decision.mode === "continue" && (!previous || previous.outcome?.execution === "cancelled" || decision.workId !== previous.id))
+          continue;
+        if (decision.requirement) this.contextManager.set("requirement", decision.requirement);
+        else if (decision.mode === "continue" && previous)
+          this.contextManager.set(
+            "requirement",
+            previous.requirement + "\n\n[Follow-up] " + this.originalRequirement
+          );
+        const agents2 = this.selectAgents(decision.run);
+        this.beginWork(agents2, decision.mode, previous);
+        this.assignments = new Map((decision.tasks ?? []).map((task) => [task.agentId, task.scope]));
+        for (const task of decision.tasks ?? []) {
+          const agent = agents2.find((item) => item.id === task.agentId);
+          if (agent)
+            agent.agentScope = this.assignments.get(agent.id) ?? task.scope ?? agent.agentScope;
+        }
+        this.captureWork(agents2, []);
+        return { kind: "run", agents: agents2, reason: decision.reason };
+      }
+      if (decision && (decision.mode === "reply" || decision.mode === "ask"))
         return { kind: "message", mode: decision.mode, message: decision.message };
+      const message = result.output.trim();
+      if (result.status === "success" && message && !/^[{[]|"(?:mode|run|tasks|workId)"\s*:|multiclaw-handoff/.test(message))
+        return { kind: "message", mode: "reply", message };
+    }
+    return {
+      kind: "error",
+      message: "Routing incomplete: the leader did not return a valid decision after one retry."
+    };
+  }
+  beginWork(agents2, mode, previous) {
+    const continuing = mode === "continue" || this.rerouting || !!this.config.resume?.agents;
+    this.work = continuing && previous ? structuredClone(previous) : {
+      id: randomUUID4(),
+      originalRequirement: this.originalRequirement,
+      requirement: this.contextManager.get("requirement") ?? this.originalRequirement,
+      agents: []
+    };
+    this.routing = {
+      mode: continuing ? "continue" : "run",
+      workId: this.work.id,
+      reroutes: this.rerouting ? 1 : 0
+    };
+    this.contextManager.set("workId", this.work.id);
+    if (continuing) {
+      const sessions = {
+        ...this.config.resume?.agents ? this.config.resume.sessions : {}
+      };
+      for (const agent of agents2) {
+        const prior = this.work.agents.find((item) => item.agentId === agent.id);
+        if (prior) {
+          agent.agentScope = prior.scope ?? agent.agentScope;
+          agent.agentPlan = prior.plan ?? agent.agentPlan;
+          agent.taskTitle = prior.taskTitle ?? agent.taskTitle;
+          if (prior.dependsOn)
+            agent.dependsOn = prior.dependsOn.filter((id) => agents2.some((item) => item.id === id));
+          if (prior.session) sessions[agent.id] = prior.session;
+        }
       }
-      if (decision.requirement) this.contextManager.set("requirement", decision.requirement);
-      return { kind: "run", agents: this.selectAgents(decision.run), reason: decision.reason };
+      this.config.resume = {
+        ...this.config.resume?.agents ? { agents: this.config.resume.agents } : {},
+        sessions
+      };
+      this.recovery = this.recovery || "## Continued work\nInspect the workspace and git state before repeating operations. Previous execution and acceptance facts (partial output is not verified):\n" + JSON.stringify(this.work);
+    } else {
+      this.config.resume = void 0;
+      this.recovery = "";
     }
-    const message = result.output.trim();
-    if (!message) {
-      this.warn("The leader returned no output \u2014 running the full configured team.");
-      return { kind: "run", agents: this.configuredAgents() };
+  }
+  captureWork(agents2, results) {
+    if (!this.work || !this.routing) return;
+    this.work.requirement = this.contextManager.get("requirement") ?? this.work.requirement;
+    for (const agent of agents2) {
+      const result = [...results].reverse().find((item) => item.agentId === agent.id);
+      const old = this.work.agents.find((item) => item.agentId === agent.id);
+      const entry3 = {
+        agentId: agent.id,
+        scope: agent.agentScope,
+        plan: agent.agentPlan,
+        taskTitle: agent.taskTitle,
+        dependsOn: agent.dependsOn ? [...agent.dependsOn] : void 0,
+        session: result?.session?.sessionId || result?.session?.failure?.code === "cleanup_failed" ? result.session : old?.session ?? result?.session
+      };
+      this.work.agents = this.work.agents.filter((item) => item.agentId !== agent.id);
+      this.work.agents.push(entry3);
     }
-    return { kind: "message", mode: "reply", message };
+    this.eventBus.emit({
+      type: "orchestration:route",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { routing: { ...this.routing }, work: structuredClone(this.work) }
+    });
   }
   /**
    * The configured team, as copies.
@@ -3122,7 +3819,7 @@ Address these findings within your assigned scope, preserve the complete task re
         while (next < agents2.length && !signal?.aborted && !cancelled) {
           const index = next;
           next += 1;
-          const result = await this.runner.run(agents2[index], signal);
+          const result = await this.runner.run(agents2[index], signal, this.recovery || void 0);
           results.set(index, result);
           if (result.status === "cancelled") cancelled = true;
         }
@@ -3154,7 +3851,7 @@ Address these findings within your assigned scope, preserve the complete task re
    * it deliberately left out.
    */
   readTaskPlan() {
-    const taskPlanPath = path5.join(this.workDir, "task-plan.json");
+    const taskPlanPath = path6.join(this.workDir, "task-plan.json");
     if (!fs4.existsSync(taskPlanPath)) return void 0;
     let taskPlan;
     try {
@@ -3210,8 +3907,8 @@ Address these findings within your assigned scope, preserve the complete task re
         }
         if (executedIds.has(agent.id)) continue;
         agent.taskTitle = task.title;
-        agent.dependsOn = dependsOn;
-        agent.agentScope = task.scope;
+        agent.dependsOn = dependsOn ?? agent.dependsOn;
+        agent.agentScope = this.assignments.get(agent.id) ?? task.scope ?? agent.agentScope;
         if (task.plan?.length) {
           agent.agentPlan = task.plan.map((s, i) => `${i + 1}. ${s}`).join("\n");
         }
@@ -3233,7 +3930,7 @@ Address these findings within your assigned scope, preserve the complete task re
       const task = taskMap.get(agent.id);
       if (!task) continue;
       agent.taskTitle = task.title;
-      agent.agentScope = task.scope;
+      agent.agentScope = this.assignments.get(agent.id) ?? task.scope ?? agent.agentScope;
       if (task.plan?.length) {
         agent.agentPlan = task.plan.map((s, i) => `${i + 1}. ${s}`).join("\n");
       }
@@ -3278,11 +3975,6 @@ Address these findings within your assigned scope, preserve the complete task re
       reply: { mode, message },
       ...this.requirementField()
     };
-    this.eventBus.emit({
-      type: "orchestration:complete",
-      timestamp: endTime.toISOString(),
-      payload: result
-    });
     return result;
   }
   warn(message) {
@@ -3304,11 +3996,6 @@ Address these findings within your assigned scope, preserve the complete task re
       endTime: endTime.toISOString(),
       ...this.requirementField()
     };
-    this.eventBus.emit({
-      type: "orchestration:complete",
-      timestamp: endTime.toISOString(),
-      payload: result
-    });
     return result;
   }
   /**
@@ -3335,11 +4022,6 @@ Address these findings within your assigned scope, preserve the complete task re
       endTime: endTime.toISOString(),
       ...this.requirementField()
     };
-    this.eventBus.emit({
-      type: "orchestration:complete",
-      timestamp: endTime.toISOString(),
-      payload: result
-    });
     return result;
   }
 };
@@ -3394,24 +4076,24 @@ function parseVersion(raw) {
 }
 var SGR_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 async function versionFor(command) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let out = "";
     const child = spawn2(command, ["--version"], { env: process.env });
     child.stdout.on("data", (d) => {
       out += d.toString();
     });
     child.on("close", () => {
-      resolve4(out.trim() || void 0);
+      resolve5(out.trim() || void 0);
     });
     child.on("error", () => {
-      resolve4(void 0);
+      resolve5(void 0);
     });
     setTimeout(() => {
       try {
         child.kill("SIGKILL");
       } catch {
       }
-      resolve4(void 0);
+      resolve5(void 0);
     }, 3e3);
   });
 }
@@ -3480,7 +4162,7 @@ function describeResumePlan({ agents: agents2, sessions = {}, team }) {
   const teamById = new Map(team.map((member) => [member.id, member]));
   const running = new Set(agents2);
   const clauses = agents2.map(
-    (id) => sessions[id] ? `${id} continues its session` : `${id} starts fresh`
+    (id) => sessions[id]?.sessionId ? `${id} will attempt to resume its session` : `${id} starts fresh`
   );
   for (const id of agents2) {
     const dropped = (teamById.get(id)?.dependsOn ?? []).filter(
@@ -3504,8 +4186,12 @@ export {
   buildStages,
   defineConfig,
   describeResumePlan,
+  describeSession,
   detectProviders,
   isAbortError,
+  isSessionEvent,
+  isSessionRecord,
+  isWorkContext,
   presentProviders,
   providerCommands,
   providerIds,
@@ -3519,6 +4205,7 @@ export {
   resolveProvider,
   resolvesOnPath,
   runtimeRegistry,
+  sessionCompatibilityKey,
   specForCommand,
   specForProvider,
   tierModel,