@wrongstack/core 0.303.0 → 0.305.1

package/dist/defaults/index.js

@@ -1733,6 +1733,12 @@ function normalizeForComparison(text) {
 }
 
 // src/coordination/agents/project-agent-learning-structured.ts
+function directiveTrials(entry) {
+  const count = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : 0;
+  const applied = count(entry.applied);
+  const wins = Math.min(applied, count(entry.wins));
+  return { applied, wins, losses: applied - wins };
+}
 function parseLearnedEntryStamp(entry) {
   const structuredMatch = entry.match(
     /<!--\s*learned-stamp:\s*category=([\w-]+);\s*capturedAt=([^;]+?)\s*-->/
@@ -1851,6 +1857,10 @@ function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLear
     const category = parseLearnedCategory(attributes["category"]) ?? "fact";
     const capturedAt = attributes["capturedAt"] ?? "";
     const skill = attributes["skill"];
+    const trials = directiveTrials({
+      applied: Number(attributes["applied"]),
+      wins: Number(attributes["wins"])
+    });
     const start = (stamp.index ?? 0) + stamp[0].length;
     const end = stamps[index + 1]?.index ?? raw.length;
     const parsed = parseEntryBody(raw.slice(start, end));
@@ -1862,7 +1872,8 @@ function parseStructuredLearnedEntriesFromContent(raw, legacyEntries = splitLear
       why: parsed.why || WHY_BY_CATEGORY[category],
       how: parsed.how,
       capturedAt,
-      ...skill ? { skill } : {}
+      ...skill ? { skill } : {},
+      ...trials.applied > 0 ? { applied: trials.applied, wins: trials.wins } : {}
     });
   }
   if (structured.length === 0) {
@@ -1992,7 +2003,8 @@ function loadProjectAgentLearningPolicy(role, projectRoot) {
       enabled: parsed.enabled !== false,
       lifetimeCaptureCount: typeof parsed.lifetimeCaptureCount === "number" && Number.isInteger(parsed.lifetimeCaptureCount) && parsed.lifetimeCaptureCount >= 0 ? parsed.lifetimeCaptureCount : 0,
       ...typeof parsed.lastCaptureAt === "string" ? { lastCaptureAt: parsed.lastCaptureAt } : {},
-      ...parsed.lastCaptureSource === "automatic" || parsed.lastCaptureSource === "manual" || parsed.lastCaptureSource === "taught" ? { lastCaptureSource: parsed.lastCaptureSource } : {}
+      ...parsed.lastCaptureSource === "automatic" || parsed.lastCaptureSource === "manual" || parsed.lastCaptureSource === "taught" ? { lastCaptureSource: parsed.lastCaptureSource } : {},
+      ...typeof parsed.lastOptimizeAt === "string" ? { lastOptimizeAt: parsed.lastOptimizeAt } : {}
     };
   } catch {
     return { ...DEFAULT_LEARNING_POLICY };
@@ -2407,6 +2419,8 @@ The file below stores **learning data for this project's "${role}" agent** \u201
 - **Self-contained** \u2014 understandable without the surrounding session context.
 - **Front-load concrete anchors** \u2014 commands in backticks, package names like \`@wrongstack/core\`, file paths like \`packages/core/src/.../foo.ts\`. The structured-list renderer extracts these as the "how" for the entry.
 
+**Your directives are scored against real outcomes.** After every task the runtime checks which stored directives were actually exercised \u2014 it matches their anchors against the report \u2014 and folds that task's success or failure into each one's record. A directive that keeps correlating with success outlives newer arrivals and survives rewording; one that has been exercised repeatedly and kept correlating with failure is retired and stops being injected. Two consequences for how you write them: anchors are what make a directive *measurable*, not just runnable, so an anchorless directive can never earn a record; and a directive you are unsure about costs nothing to write, because the loop will find out.
+
 **Tag the skill you are developing.** When a directive refines one of your skills, mark it: \`## LEARNED [skill: testing]\`. Tagged directives are distilled into that skill's project addendum, so the lesson arrives as part of the skill itself on every future run instead of as a loose fact. Untagged directives are routed automatically when the wording makes the target obvious, and stay role-level otherwise.
 
 **Bad** (session log \u2014 rejected at capture time):
@@ -2691,8 +2705,16 @@ var TOOLS = {
     "test",
     "mailbox"
   ],
-  /** Version control. */
-  vcs: ["read", "grep", "glob", "git", "diff"],
+  /**
+   * Version control.
+   *
+   * `mailbox` is in every preset on purpose: a subagent that hits a wall must
+   * be able to say so. This was the one preset without it, which left the `git`
+   * and `release` roles able to fail but not to ask — the two roles whose work
+   * most often needs a decision from the leader (force-push, tag collision,
+   * dirty tree) and least often has a safe default.
+   */
+  vcs: ["read", "grep", "glob", "git", "diff", "mailbox"],
   /** Dependency management + CVE audit. */
   deps: ["read", "grep", "glob", "install", "outdated", "audit", "json", "mailbox"],
   /** Documentation authoring. */
@@ -5303,6 +5325,14 @@ var SHADOW_AGENT = {
 };
 var CRITIC_AGENT = defineAgent("critic", "Critic");
 var GENERIC_AGENT = defineAgent("generic", "Generic Project Agent");
+function withDispatchMetadata(definition) {
+  const summary = definition.capability?.summary?.trim();
+  if (!summary) return definition.config;
+  return {
+    ...definition.config,
+    dispatch: { summary, keywords: [...definition.capability.keywords ?? []] }
+  };
+}
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
@@ -5312,7 +5342,7 @@ var FLEET_ROSTER = {
   generic: GENERIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
-    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
+    ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, withDispatchMetadata(d)])
   )
 };
 var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
@@ -7952,9 +7982,6 @@ import {
   updateTaskAssignment
 } from "@wrongstack/kanban";
 
-// src/coordination/director-kanban-queue-helpers.ts
-import { describeKanbanBoundary } from "@wrongstack/kanban";
-
 // src/coordination/director-input-helpers.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 function stringArray2(value) {
@@ -7975,6 +8002,7 @@ function instantiateRosterConfig2(role, base) {
 }
 
 // src/coordination/director-kanban-queue-helpers.ts
+import { describeKanbanBoundary } from "@wrongstack/kanban";
 function normalizeKanbanQueueInput(input) {
   const raw = input ?? {};
   return {
@@ -8309,378 +8337,336 @@ function makeLLMClassifier(complete) {
   };
 }
 
-// src/coordination/director-quality-gate-tool.ts
+// src/coordination/director-basic-tools.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-function makeQualityGateTool(director, roster) {
+function makeAssignTool(director) {
+  const inputSchema = {
+    type: "object",
+    properties: {
+      subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
+      description: {
+        type: "string",
+        minLength: 1,
+        description: "The task in natural language \u2014 what you want this subagent to do."
+      },
+      maxToolCalls: {
+        type: "number",
+        minimum: 1,
+        description: "Optional per-task tool-call budget override."
+      },
+      timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
+    },
+    required: ["subagentId", "description"]
+  };
   return {
-    name: "quality_gate",
-    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
-    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
+    name: "assign_task",
+    description: "Queue a task on a previously spawned subagent. NON-BLOCKING: returns a `taskId` IMMEDIATELY \u2014 the subagent processes the task on its next iteration with its own LLM budget. The `taskId` is the durable handle for retrieving the result later via `await_tasks`, `roll_up`, or `ask_result`. Many `assign_task` calls can be in flight in parallel against the same or different subagents. This is the primary tool for fan-out work; do NOT use `delegate` to spawn multiple investigations sequentially.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema,
+    async execute(input) {
+      const i = input;
+      const task = {
+        id: randomUUID6(),
+        description: i.description,
+        subagentId: i.subagentId,
+        maxToolCalls: i.maxToolCalls,
+        timeoutMs: i.timeoutMs
+      };
+      const taskId = await director.assign(task);
+      return { taskId, subagentId: i.subagentId };
+    }
+  };
+}
+function makeAwaitTasksTool(director) {
+  return {
+    name: "await_tasks",
+    description: 'Block until one or more `taskId`s complete, then return their results. The subagents keep running in the background \u2014 only the leader\'s iteration pauses, which is the point: this is the correct tool to retrieve a result you started earlier with `assign_task`. mode:"all" (default) blocks until EVERY named task completes. mode:"any" returns as soon as AT LEAST ONE completes \u2014 use it for independent tasks so you can handle each finisher immediately (reassign work, spawn helpers) instead of idling on the slowest; call again with the returned `pending` ids to pick up the next finisher. The pattern "fan out via assign_task, then await_tasks({mode:\'any\'})" is the async replacement for serial `delegate` calls.',
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
-        task: {
-          type: "string",
-          description: "Original implementation task or acceptance goal being gated."
-        },
-        implementerTaskIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
-        },
-        repairSubagentId: {
-          type: "string",
-          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
-        },
-        maxRepairAttempts: {
-          type: "number",
-          minimum: 0,
-          maximum: 5,
-          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
-        },
-        targets: {
-          type: "array",
-          items: { type: "string" },
-          description: "Files, packages, or paths that reviewer/verifier should focus on."
-        },
-        commands: {
+        taskIds: {
           type: "array",
           items: { type: "string" },
-          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
-        },
-        expected: {
-          type: "string",
-          description: "Expected behavior or acceptance criteria."
+          description: "One or more task ids returned by `assign_task`."
         },
-        evidence: {
+        mode: {
           type: "string",
-          description: "Known implementation notes, diff summary, or commands already run."
-        },
-        reviewer: {
-          type: "boolean",
-          description: "Whether to run the reviewer lane. Default true."
-        },
-        verifier: {
-          type: "boolean",
-          description: "Whether to run the verifier lane. Default true."
+          enum: ["all", "any"],
+          description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.'
         },
         timeoutMs: {
           type: "number",
           minimum: 1,
-          description: "Optional per reviewer/verifier/repair task timeout."
-        },
-        reviewerWorktree: {
-          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Reviewer worktree override. Default off because reviewer is read-only."
-        },
-        verifierWorktree: {
-          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
-          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
+          description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.'
         }
-      }
+      },
+      required: ["taskIds"]
     },
     async execute(input) {
-      const i = normalizeQualityGateInput(input);
-      const runReviewer = i.reviewer !== false;
-      const runVerifier = i.verifier !== false;
-      if (!runReviewer && !runVerifier) {
+      const i = input;
+      if (i.mode === "any") {
+        const r = await director.awaitTasksAny(
+          i.taskIds,
+          i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0
+        );
         return {
-          verdict: "inconclusive",
-          passed: false,
-          error: "quality_gate requires reviewer, verifier, or both."
+          mode: "any",
+          completed: r.completed,
+          pending: r.pending,
+          ...r.timedOut ? { timedOut: true } : {},
+          ...r.pending.length > 0 ? {
+            hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.'
+          } : {}
         };
       }
-      const implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
-      const maxRepairAttempts = clampRepairAttempts(
-        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
-      );
-      const repairResults = [];
-      const attempts = [];
-      for (let attempt = 1; ; attempt++) {
-        const gateTaskIds = [];
-        const taskRoleById = /* @__PURE__ */ new Map();
-        if (runVerifier) {
-          const subagentId = await director.spawn(
-            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
-          );
-          const taskId = await director.assign({
-            id: randomUUID6(),
-            subagentId,
-            description: buildVerifierTask(i, {
-              attempt,
-              implementerResults,
-              repairResults,
-              priorAttempts: attempts
-            }),
-            timeoutMs: i.timeoutMs
-          });
-          gateTaskIds.push(taskId);
-          taskRoleById.set(taskId, "verifier");
-        }
-        if (runReviewer) {
-          const subagentId = await director.spawn(
-            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
-          );
-          const taskId = await director.assign({
-            id: randomUUID6(),
-            subagentId,
-            description: buildReviewerTask(i, {
-              attempt,
-              implementerResults,
-              repairResults,
-              priorAttempts: attempts
-            }),
-            timeoutMs: i.timeoutMs
-          });
-          gateTaskIds.push(taskId);
-          taskRoleById.set(taskId, "reviewer");
-        }
-        const gateResults = await director.awaitTasks(gateTaskIds);
-        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
-        const assessment = assessQualityGate(reports);
-        attempts.push({ attempt, reports, ...assessment });
-        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
-          return {
-            verdict: assessment.verdict,
-            passed: assessment.passed,
-            attempts,
-            repairAttemptsUsed: repairResults.length,
-            implementerResults: implementerResults.map(summarizeTaskResult),
-            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
-          };
+      const results = await director.awaitTasks(i.taskIds);
+      return { results };
+    }
+  };
+}
+function makeAskTool(director) {
+  return {
+    name: "ask_subagent",
+    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: {
+          type: "string",
+          minLength: 1,
+          description: "Subagent to ask. Must be a previously spawned id."
+        },
+        question: { type: "string", minLength: 1, description: "The question or instruction." },
+        timeoutMs: {
+          type: "number",
+          minimum: 1,
+          description: "Optional timeout in ms (default 30s)."
         }
-        const repairTaskId = await director.assign({
-          id: randomUUID6(),
-          subagentId: i.repairSubagentId,
-          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
-          timeoutMs: i.timeoutMs
-        });
-        const [repairResult] = await director.awaitTasks([repairTaskId]);
-        if (repairResult) repairResults.push(repairResult);
-        if (repairResult?.status !== "success") {
-          return {
-            verdict: "fail",
-            passed: false,
-            attempts,
-            repairAttemptsUsed: repairResults.length,
-            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
-            implementerResults: implementerResults.map(summarizeTaskResult),
-            nextAction: "repair_failed"
-          };
+      },
+      required: ["subagentId", "question"]
+    },
+    async execute(input) {
+      const i = input;
+      try {
+        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
+        const stored = director.largeAnswerStore.storeAnswer(answer);
+        if (stored.inline) {
+          return { ok: true, answer: stored.summary };
         }
+        return {
+          ok: true,
+          answer: stored.summary,
+          _answerKey: stored.key,
+          _hint: "Response was large and stored. Use ask_result with the key to retrieve it."
+        };
+      } catch (err) {
+        return { ok: false, error: toErrorMessage(err) };
       }
     }
   };
 }
-function normalizeQualityGateInput(input) {
-  const raw = input ?? {};
+function makeAskResultTool(director) {
   return {
-    task: typeof raw.task === "string" ? raw.task : void 0,
-    implementerTaskIds: stringArray2(raw.implementerTaskIds),
-    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
-    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
-    targets: stringArray2(raw.targets),
-    commands: stringArray2(raw.commands),
-    expected: typeof raw.expected === "string" ? raw.expected : void 0,
-    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
-    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
-    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
-    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
-    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
-    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
+    name: "ask_result",
+    description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          minLength: 1,
+          description: "The `_answerKey` returned by `ask_subagent` for a large response."
+        }
+      },
+      required: ["key"]
+    },
+    async execute(input) {
+      const i = input;
+      const value = director.largeAnswerStore.retrieveAnswer(i.key);
+      if (value === void 0) {
+        return {
+          ok: false,
+          error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.`
+        };
+      }
+      return { ok: true, value };
+    }
   };
 }
-function clampRepairAttempts(value) {
-  if (!Number.isFinite(value)) return 0;
-  return Math.max(0, Math.min(5, Math.floor(value)));
-}
-function makeQualityGateSubagentConfig(role, roster, worktree) {
-  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
+function makeRollUpTool(director) {
   return {
-    ...instantiateRosterConfig2(role, base),
-    worktree
+    name: "roll_up",
+    description: "Aggregate completed task results into a single formatted summary.",
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        taskIds: {
+          type: "array",
+          items: { type: "string" },
+          description: "Completed task ids to aggregate."
+        },
+        style: {
+          type: "string",
+          enum: ["markdown", "json"],
+          description: "Output flavor \u2014 markdown (default) or json."
+        }
+      },
+      required: ["taskIds"]
+    },
+    async execute(input) {
+      const i = input;
+      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
+      return { summary, count: i.taskIds.length };
+    }
   };
 }
-function buildVerifierTask(input, state) {
-  return [
-    "Run the independent verification gate for this implementation.",
-    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
-    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
-    "",
-    `Gate attempt: ${state.attempt}`,
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.commands?.length ? `Required or suggested commands:
-${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    input.evidence ? `Known evidence:
-${input.evidence}` : void 0,
-    taskResultsBlock("Implementer results", state.implementerResults),
-    taskResultsBlock("Repair results so far", state.repairResults),
-    priorAttemptsBlock(state.priorAttempts)
-  ].filter((part) => !!part).join("\n\n");
-}
-function buildReviewerTask(input, state) {
-  return [
-    "Run independent code review for this implementation.",
-    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
-    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
-    "",
-    `Gate attempt: ${state.attempt}`,
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    input.evidence ? `Known evidence:
-${input.evidence}` : void 0,
-    taskResultsBlock("Implementer results", state.implementerResults),
-    taskResultsBlock("Repair results so far", state.repairResults),
-    priorAttemptsBlock(state.priorAttempts)
-  ].filter((part) => !!part).join("\n\n");
-}
-function buildRepairTask(input, attempt, attemptNumber) {
-  return [
-    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
-    "Address every must-fix item. Run relevant checks before returning.",
-    "Do not claim done unless verifier/reviewer feedback is resolved.",
-    "",
-    input.task ? `Original task:
-${input.task}` : void 0,
-    input.targets?.length ? `Targets:
-${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
-    input.commands?.length ? `Commands expected to pass:
-${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
-    input.expected ? `Expected behavior:
-${input.expected}` : void 0,
-    attempt.mustFix.length ? `Must fix:
-${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
-    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
-${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
-    `Reviewer/verifier reports:
-${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
-${r.summary}`).join("\n\n")}`
-  ].filter((part) => !!part).join("\n\n");
-}
-function taskResultsBlock(title, results) {
-  if (results.length === 0) return void 0;
-  return `${title}:
-${results.map((r) => `### ${r.subagentId}/${r.taskId}
-${summarizeTaskResult(r).summary}`).join("\n\n")}`;
-}
-function priorAttemptsBlock(attempts) {
-  if (attempts.length === 0) return void 0;
-  return `Prior quality gate attempts:
-${attempts.map(
-    (a) => `### Attempt ${a.attempt}
-${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
-  ).join("\n\n")}`;
-}
-function summarizeTaskResult(result) {
-  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
-  const error2 = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
+function makeTerminateTool(director) {
   return {
-    taskId: result.taskId,
-    subagentId: result.subagentId,
-    status: result.status,
-    summary: excerpt(text || error2 || "(no output)", 4e3),
-    error: error2
+    name: "terminate_subagent",
+    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: {
+      type: "object",
+      properties: { subagentId: { type: "string", description: "Subagent to abort." } },
+      required: ["subagentId"]
+    },
+    async execute(input) {
+      const i = input;
+      await director.terminate(i.subagentId);
+      return { ok: true };
+    }
   };
 }
-function assessRoleResult(role, result) {
-  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
-  const summary = summarizeTaskResult(result);
-  const text = summary.summary;
-  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
-  if (result.status !== "success") {
-    return {
-      role: resolvedRole,
-      subagentId: result.subagentId,
-      taskId: result.taskId,
-      status: result.status,
-      verdict: "fail",
-      summary: text,
-      uncertaintyFlags,
-      error: summary.error ?? result.status
-    };
-  }
+function makeTerminateAllTool(director) {
   return {
-    role: resolvedRole,
-    subagentId: result.subagentId,
-    taskId: result.taskId,
-    status: result.status,
-    verdict: parseQualityVerdict(resolvedRole, text),
-    summary: text,
-    uncertaintyFlags
-  };
-}
-function assessQualityGate(reports) {
-  const mustFix = [];
-  const uncertaintyFlags = [];
-  let hasFail = false;
-  let hasInconclusive = false;
-  for (const report of reports) {
-    if (report.verdict === "fail") hasFail = true;
-    if (report.verdict === "inconclusive") hasInconclusive = true;
-    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
-    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
-    if (report.uncertaintyFlags) {
-      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
+    name: "terminate_all",
+    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
+    permission: "auto",
+    mutating: true,
+    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      await director.terminateAll();
+      return {
+        ok: true,
+        message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.`
+      };
     }
-    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
-  }
-  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
-  if (hasInconclusive || reports.length === 0) {
-    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
-  }
-  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
+  };
 }
-function parseQualityVerdict(role, text) {
-  const normalized = text.toLowerCase();
-  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
-  if (role === "reviewer") {
-    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
-      verdictBlock
-    )) {
-      return "fail";
-    }
-    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
-    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
-      return "fail";
+function makeFleetTool(director) {
+  return {
+    name: "fleet",
+    description: 'Fleet observation tool. Use `action` to select what you need: "status" \u2014 snapshot of all subagents + coordinator counts + pending tasks; "usage" \u2014 token + cost breakdown per subagent and totals; "health" \u2014 per-subagent budget pressure, last activity, and status; "session" \u2014 read a subagent\'s JSONL transcript (requires subagentId).',
+    usageHint: 'action: "status" (default) | "usage" | "health" | "session".\nFor "session", pass subagentId (required) and optional tail (trailing JSONL lines).',
+    permission: "auto",
+    mutating: false,
+    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["status", "usage", "health", "session"],
+          description: "Observation to retrieve (default: status)."
+        },
+        subagentId: {
+          type: "string",
+          description: 'Subagent id (required for action: "session").'
+        },
+        tail: {
+          type: "number",
+          description: 'Number of trailing JSONL lines (action: "session" only). Omit for the full transcript.'
+        }
+      }
+    },
+    async execute(input) {
+      const i = input ?? {};
+      const action = i.action ?? "status";
+      switch (action) {
+        case "status": {
+          const base = director.status();
+          const fm = director.fleetManager;
+          const stats = fm?.getFleetStats();
+          const fleetStatus = fm?.getFleetStatus();
+          return {
+            action: "status",
+            subagents: base.subagents,
+            coordinatorStats: stats ? {
+              total: stats.total,
+              running: stats.running,
+              idle: stats.idle,
+              stopped: stats.stopped
+            } : void 0,
+            pending: fleetStatus?.pending ?? [],
+            usage: fm?.snapshot()
+          };
+        }
+        case "usage": {
+          return { action: "usage", ...director.snapshot() };
+        }
+        case "health": {
+          const status = director.status();
+          const snapshot = director.snapshot();
+          const subagents = status.subagents ?? [];
+          const perSubagent = snapshot.perSubagent ?? {};
+          return {
+            action: "health",
+            subagents: subagents.map((s) => {
+              const usage = perSubagent[s.id];
+              return {
+                id: s.id,
+                status: s.status,
+                lastEventAt: usage?.lastEventAt,
+                budgetPressure: {
+                  iterations: usage?.iterations,
+                  toolCalls: usage?.toolCalls,
+                  costUsd: usage?.cost
+                }
+              };
+            })
+          };
+        }
+        case "session": {
+          const subagentId = i.subagentId;
+          if (!subagentId) {
+            return {
+              action: "session",
+              error: 'fleet: subagentId is required for action: "session"'
+            };
+          }
+          const result = await director.readSession(subagentId, i.tail);
+          if (!result) {
+            return {
+              action: "session",
+              error: `fleet: transcript unavailable for "${subagentId}". Is sessionsRoot configured?`
+            };
+          }
+          return { action: "session", ...result };
+        }
+        default:
+          return {
+            error: `fleet: unknown action "${action}". Valid: status, usage, health, session.`
+          };
+      }
     }
-    return "inconclusive";
-  }
-  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
-  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
-  if (sectionHasBlockingContent(text, "Failures")) return "fail";
-  return "inconclusive";
-}
-function sectionHasBlockingContent(text, heading) {
-  const section = extractSection(text, heading);
-  if (!section) return false;
-  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
-}
-function extractSection(text, heading) {
-  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern = new RegExp(
-    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
-    "i"
-  );
-  const match = text.match(pattern);
-  const body = match?.[1]?.trim();
-  return body ? body : void 0;
-}
-function excerpt(text, max) {
-  if (text.length <= max) return text;
-  return `${text.slice(0, max - 20).trimEnd()}
-...(truncated)`;
+  };
 }
 
 // src/coordination/director-collab-tools.ts
@@ -8801,336 +8787,378 @@ function makeWorkCompleteTool(director) {
   };
 }
 
-// src/coordination/director-basic-tools.ts
+// src/coordination/director-quality-gate-tool.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-function makeAssignTool(director) {
-  const inputSchema = {
-    type: "object",
-    properties: {
-      subagentId: { type: "string", minLength: 1, description: "Target subagent id. Required." },
-      description: {
-        type: "string",
-        minLength: 1,
-        description: "The task in natural language \u2014 what you want this subagent to do."
-      },
-      maxToolCalls: {
-        type: "number",
-        minimum: 1,
-        description: "Optional per-task tool-call budget override."
-      },
-      timeoutMs: { type: "number", minimum: 1, description: "Optional per-task timeout in ms." }
-    },
-    required: ["subagentId", "description"]
-  };
+function makeQualityGateTool(director, roster) {
   return {
-    name: "assign_task",
-    description: "Queue a task on a previously spawned subagent. NON-BLOCKING: returns a `taskId` IMMEDIATELY \u2014 the subagent processes the task on its next iteration with its own LLM budget. The `taskId` is the durable handle for retrieving the result later via `await_tasks`, `roll_up`, or `ask_result`. Many `assign_task` calls can be in flight in parallel against the same or different subagents. This is the primary tool for fan-out work; do NOT use `delegate` to spawn multiple investigations sequentially.",
+    name: "quality_gate",
+    description: "Run a first-class implementation quality gate. It can await implementer task ids, spawn independent verifier/reviewer agents, summarize their verdicts, and optionally send must-fix feedback back to an implementer until the gate passes or the repair-attempt limit is reached.",
+    usageHint: "Use after code-changing work. Provide implementerTaskIds when available. Add repairSubagentId to iterate fixes automatically. Verdict only passes when every enabled reviewer/verifier explicitly passes.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema,
-    async execute(input) {
-      const i = input;
-      const task = {
-        id: randomUUID7(),
-        description: i.description,
-        subagentId: i.subagentId,
-        maxToolCalls: i.maxToolCalls,
-        timeoutMs: i.timeoutMs
-      };
-      const taskId = await director.assign(task);
-      return { taskId, subagentId: i.subagentId };
-    }
-  };
-}
-function makeAwaitTasksTool(director) {
-  return {
-    name: "await_tasks",
-    description: 'Block until one or more `taskId`s complete, then return their results. The subagents keep running in the background \u2014 only the leader\'s iteration pauses, which is the point: this is the correct tool to retrieve a result you started earlier with `assign_task`. mode:"all" (default) blocks until EVERY named task completes. mode:"any" returns as soon as AT LEAST ONE completes \u2014 use it for independent tasks so you can handle each finisher immediately (reassign work, spawn helpers) instead of idling on the slowest; call again with the returned `pending` ids to pick up the next finisher. The pattern "fan out via assign_task, then await_tasks({mode:\'any\'})" is the async replacement for serial `delegate` calls.',
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
     inputSchema: {
       type: "object",
       properties: {
-        taskIds: {
+        task: {
+          type: "string",
+          description: "Original implementation task or acceptance goal being gated."
+        },
+        implementerTaskIds: {
           type: "array",
           items: { type: "string" },
-          description: "One or more task ids returned by `assign_task`."
+          description: "Optional completed or in-flight implementer task ids to await and include as implementation evidence."
         },
-        mode: {
+        repairSubagentId: {
           type: "string",
-          enum: ["all", "any"],
-          description: '"all" (default): block until every task completes. "any": return on the first completion with the rest listed as pending.'
+          description: "Optional implementer subagent id. When set and the gate fails, quality_gate assigns a repair task with reviewer/verifier feedback and reruns the gate."
+        },
+        maxRepairAttempts: {
+          type: "number",
+          minimum: 0,
+          maximum: 5,
+          description: "Maximum automatic repair iterations. Default: 2 when repairSubagentId is set, otherwise 0."
+        },
+        targets: {
+          type: "array",
+          items: { type: "string" },
+          description: "Files, packages, or paths that reviewer/verifier should focus on."
+        },
+        commands: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Verification commands that should pass, e.g. ["pnpm --filter @wrongstack/core typecheck"].'
+        },
+        expected: {
+          type: "string",
+          description: "Expected behavior or acceptance criteria."
+        },
+        evidence: {
+          type: "string",
+          description: "Known implementation notes, diff summary, or commands already run."
+        },
+        reviewer: {
+          type: "boolean",
+          description: "Whether to run the reviewer lane. Default true."
+        },
+        verifier: {
+          type: "boolean",
+          description: "Whether to run the verifier lane. Default true."
         },
         timeoutMs: {
           type: "number",
           minimum: 1,
-          description: 'mode:"any" only \u2014 return {timedOut:true, completed:[]} if nothing completes within this window instead of blocking.'
+          description: "Optional per reviewer/verifier/repair task timeout."
+        },
+        reviewerWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Reviewer worktree override. Default off because reviewer is read-only."
+        },
+        verifierWorktree: {
+          anyOf: [{ type: "boolean" }, { type: "string", enum: ["auto", "required", "off"] }],
+          description: "Verifier worktree override. Default auto so test artifacts stay isolated when fleet policy wants it."
         }
-      },
-      required: ["taskIds"]
+      }
     },
     async execute(input) {
-      const i = input;
-      if (i.mode === "any") {
-        const r = await director.awaitTasksAny(
-          i.taskIds,
-          i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : void 0
-        );
+      const i = normalizeQualityGateInput(input);
+      const runReviewer = i.reviewer !== false;
+      const runVerifier = i.verifier !== false;
+      if (!runReviewer && !runVerifier) {
         return {
-          mode: "any",
-          completed: r.completed,
-          pending: r.pending,
-          ...r.timedOut ? { timedOut: true } : {},
-          ...r.pending.length > 0 ? {
-            hint: 'Handle the completed results now. Re-call await_tasks with the pending ids (mode:"any") for the next finisher \u2014 or assign new work to the now-idle subagent first.'
-          } : {}
+          verdict: "inconclusive",
+          passed: false,
+          error: "quality_gate requires reviewer, verifier, or both."
         };
       }
-      const results = await director.awaitTasks(i.taskIds);
-      return { results };
-    }
-  };
-}
-function makeAskTool(director) {
-  return {
-    name: "ask_subagent",
-    description: "Synchronously ask a subagent a question. Blocks until the subagent replies via the bridge.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        subagentId: {
-          type: "string",
-          minLength: 1,
-          description: "Subagent to ask. Must be a previously spawned id."
-        },
-        question: { type: "string", minLength: 1, description: "The question or instruction." },
-        timeoutMs: {
-          type: "number",
-          minimum: 1,
-          description: "Optional timeout in ms (default 30s)."
+      const implementerResults = i.implementerTaskIds && i.implementerTaskIds.length > 0 ? await director.awaitTasks(i.implementerTaskIds) : [];
+      const maxRepairAttempts = clampRepairAttempts(
+        i.maxRepairAttempts ?? (i.repairSubagentId ? 2 : 0)
+      );
+      const repairResults = [];
+      const attempts = [];
+      for (let attempt = 1; ; attempt++) {
+        const gateTaskIds = [];
+        const taskRoleById = /* @__PURE__ */ new Map();
+        if (runVerifier) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("verifier", roster, i.verifierWorktree ?? "auto")
+          );
+          const taskId = await director.assign({
+            id: randomUUID7(),
+            subagentId,
+            description: buildVerifierTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "verifier");
+        }
+        if (runReviewer) {
+          const subagentId = await director.spawn(
+            makeQualityGateSubagentConfig("reviewer", roster, i.reviewerWorktree ?? "off")
+          );
+          const taskId = await director.assign({
+            id: randomUUID7(),
+            subagentId,
+            description: buildReviewerTask(i, {
+              attempt,
+              implementerResults,
+              repairResults,
+              priorAttempts: attempts
+            }),
+            timeoutMs: i.timeoutMs
+          });
+          gateTaskIds.push(taskId);
+          taskRoleById.set(taskId, "reviewer");
         }
-      },
-      required: ["subagentId", "question"]
-    },
-    async execute(input) {
-      const i = input;
-      try {
-        const answer = await director.ask(i.subagentId, { question: i.question }, i.timeoutMs);
-        const stored = director.largeAnswerStore.storeAnswer(answer);
-        if (stored.inline) {
-          return { ok: true, answer: stored.summary };
+        const gateResults = await director.awaitTasks(gateTaskIds);
+        const reports = gateResults.map((r) => assessRoleResult(taskRoleById.get(r.taskId), r));
+        const assessment = assessQualityGate(reports);
+        attempts.push({ attempt, reports, ...assessment });
+        if (assessment.passed || !i.repairSubagentId || attempt > maxRepairAttempts) {
+          return {
+            verdict: assessment.verdict,
+            passed: assessment.passed,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: assessment.passed ? "accept" : i.repairSubagentId && attempt > maxRepairAttempts ? "manual_intervention_or_raise_repair_limit" : "inspect_failures"
+          };
+        }
+        const repairTaskId = await director.assign({
+          id: randomUUID7(),
+          subagentId: i.repairSubagentId,
+          description: buildRepairTask(i, attempts[attempts.length - 1], attempt),
+          timeoutMs: i.timeoutMs
+        });
+        const [repairResult] = await director.awaitTasks([repairTaskId]);
+        if (repairResult) repairResults.push(repairResult);
+        if (repairResult?.status !== "success") {
+          return {
+            verdict: "fail",
+            passed: false,
+            attempts,
+            repairAttemptsUsed: repairResults.length,
+            repairResult: repairResult ? summarizeTaskResult(repairResult) : void 0,
+            implementerResults: implementerResults.map(summarizeTaskResult),
+            nextAction: "repair_failed"
+          };
         }
-        return {
-          ok: true,
-          answer: stored.summary,
-          _answerKey: stored.key,
-          _hint: "Response was large and stored. Use ask_result with the key to retrieve it."
-        };
-      } catch (err) {
-        return { ok: false, error: toErrorMessage(err) };
       }
     }
   };
 }
-function makeAskResultTool(director) {
+function normalizeQualityGateInput(input) {
+  const raw = input ?? {};
   return {
-    name: "ask_result",
-    description: "Retrieve a large `ask_subagent` response that was stored out-of-context (>2K chars). Returns the full stored value.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        key: {
-          type: "string",
-          minLength: 1,
-          description: "The `_answerKey` returned by `ask_subagent` for a large response."
-        }
-      },
-      required: ["key"]
-    },
-    async execute(input) {
-      const i = input;
-      const value = director.largeAnswerStore.retrieveAnswer(i.key);
-      if (value === void 0) {
-        return {
-          ok: false,
-          error: `No stored answer found for key "${i.key}" \u2014 it may have been cleared or the key is invalid.`
-        };
-      }
-      return { ok: true, value };
-    }
+    task: typeof raw.task === "string" ? raw.task : void 0,
+    implementerTaskIds: stringArray2(raw.implementerTaskIds),
+    repairSubagentId: typeof raw.repairSubagentId === "string" && raw.repairSubagentId.trim() ? raw.repairSubagentId.trim() : void 0,
+    maxRepairAttempts: typeof raw.maxRepairAttempts === "number" ? raw.maxRepairAttempts : void 0,
+    targets: stringArray2(raw.targets),
+    commands: stringArray2(raw.commands),
+    expected: typeof raw.expected === "string" ? raw.expected : void 0,
+    evidence: typeof raw.evidence === "string" ? raw.evidence : void 0,
+    reviewer: typeof raw.reviewer === "boolean" ? raw.reviewer : void 0,
+    verifier: typeof raw.verifier === "boolean" ? raw.verifier : void 0,
+    timeoutMs: typeof raw.timeoutMs === "number" ? raw.timeoutMs : void 0,
+    reviewerWorktree: normalizeWorktreeOverride(raw.reviewerWorktree),
+    verifierWorktree: normalizeWorktreeOverride(raw.verifierWorktree)
   };
 }
-function makeRollUpTool(director) {
+function clampRepairAttempts(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(5, Math.floor(value)));
+}
+function makeQualityGateSubagentConfig(role, roster, worktree) {
+  const base = roster?.[role] ?? getAgentDefinition(role)?.config ?? { name: role, role };
   return {
-    name: "roll_up",
-    description: "Aggregate completed task results into a single formatted summary.",
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        taskIds: {
-          type: "array",
-          items: { type: "string" },
-          description: "Completed task ids to aggregate."
-        },
-        style: {
-          type: "string",
-          enum: ["markdown", "json"],
-          description: "Output flavor \u2014 markdown (default) or json."
-        }
-      },
-      required: ["taskIds"]
-    },
-    async execute(input) {
-      const i = input;
-      const summary = director.rollUp(i.taskIds, i.style ?? "markdown");
-      return { summary, count: i.taskIds.length };
-    }
+    ...instantiateRosterConfig2(role, base),
+    worktree
   };
 }
-function makeTerminateTool(director) {
+function buildVerifierTask(input, state) {
+  return [
+    "Run the independent verification gate for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict word exactly `pass`, `fail`, or `blocked`.",
+    "Do not edit code. Run the smallest meaningful command set and include exact failures.",
+    "",
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Required or suggested commands:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildReviewerTask(input, state) {
+  return [
+    "Run independent code review for this implementation.",
+    "Return Markdown with `## Verdict` and make the first verdict phrase exactly `approve`, `request changes`, or `needs verification`.",
+    "Do not edit code. Treat missing proof, vague tests, and uncertainty as blocking until verifier evidence exists.",
+    "",
+    `Gate attempt: ${state.attempt}`,
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    input.evidence ? `Known evidence:
+${input.evidence}` : void 0,
+    taskResultsBlock("Implementer results", state.implementerResults),
+    taskResultsBlock("Repair results so far", state.repairResults),
+    priorAttemptsBlock(state.priorAttempts)
+  ].filter((part) => !!part).join("\n\n");
+}
+function buildRepairTask(input, attempt, attemptNumber) {
+  return [
+    `Repair the implementation after quality gate attempt ${attemptNumber} failed.`,
+    "Address every must-fix item. Run relevant checks before returning.",
+    "Do not claim done unless verifier/reviewer feedback is resolved.",
+    "",
+    input.task ? `Original task:
+${input.task}` : void 0,
+    input.targets?.length ? `Targets:
+${input.targets.map((t) => `- ${t}`).join("\n")}` : void 0,
+    input.commands?.length ? `Commands expected to pass:
+${input.commands.map((c) => `- ${c}`).join("\n")}` : void 0,
+    input.expected ? `Expected behavior:
+${input.expected}` : void 0,
+    attempt.mustFix.length ? `Must fix:
+${attempt.mustFix.map((f) => `- ${f}`).join("\n")}` : void 0,
+    attempt.uncertaintyFlags.length ? `Uncertainty flags to resolve:
+${attempt.uncertaintyFlags.map((f) => `- ${f}`).join("\n")}` : void 0,
+    `Reviewer/verifier reports:
+${attempt.reports.map((r) => `### ${r.role} (${r.verdict})
+${r.summary}`).join("\n\n")}`
+  ].filter((part) => !!part).join("\n\n");
+}
+function taskResultsBlock(title, results) {
+  if (results.length === 0) return void 0;
+  return `${title}:
+${results.map((r) => `### ${r.subagentId}/${r.taskId}
+${summarizeTaskResult(r).summary}`).join("\n\n")}`;
+}
+function priorAttemptsBlock(attempts) {
+  if (attempts.length === 0) return void 0;
+  return `Prior quality gate attempts:
+${attempts.map(
+    (a) => `### Attempt ${a.attempt}
+${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : ""}`).join("\n")}`
+  ).join("\n\n")}`;
+}
+function summarizeTaskResult(result) {
+  const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
+  const error2 = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
   return {
-    name: "terminate_subagent",
-    description: 'Forcibly abort a subagent. The subagent finishes its current iteration then exits with status "stopped".',
-    permission: "auto",
-    mutating: true,
-    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema: {
-      type: "object",
-      properties: { subagentId: { type: "string", description: "Subagent to abort." } },
-      required: ["subagentId"]
-    },
-    async execute(input) {
-      const i = input;
-      await director.terminate(i.subagentId);
-      return { ok: true };
-    }
+    taskId: result.taskId,
+    subagentId: result.subagentId,
+    status: result.status,
+    summary: excerpt(text || error2 || "(no output)", 4e3),
+    error: error2
+  };
+}
+function assessRoleResult(role, result) {
+  const resolvedRole = role ?? (result.subagentId.includes("review") ? "reviewer" : "verifier");
+  const summary = summarizeTaskResult(result);
+  const text = summary.summary;
+  const uncertaintyFlags = extractSection(text, "Uncertainty Flags");
+  if (result.status !== "success") {
+    return {
+      role: resolvedRole,
+      subagentId: result.subagentId,
+      taskId: result.taskId,
+      status: result.status,
+      verdict: "fail",
+      summary: text,
+      uncertaintyFlags,
+      error: summary.error ?? result.status
+    };
+  }
+  return {
+    role: resolvedRole,
+    subagentId: result.subagentId,
+    taskId: result.taskId,
+    status: result.status,
+    verdict: parseQualityVerdict(resolvedRole, text),
+    summary: text,
+    uncertaintyFlags
   };
 }
-function makeTerminateAllTool(director) {
-  return {
-    name: "terminate_all",
-    description: 'Forcibly stop every subagent in the fleet and drain the pending task queue. In-flight tasks are terminated mid-execution; pending tasks receive "aborted_by_parent" completion immediately. Use this when the fleet is wedged, looping, or you need a clean slate. Compare: work_complete stops spawning but lets running agents finish naturally.',
-    permission: "auto",
-    mutating: true,
-    capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
-    inputSchema: { type: "object", properties: {}, required: [] },
-    async execute() {
-      await director.terminateAll();
-      return {
-        ok: true,
-        message: `Fleet shutdown complete \u2014 all subagents stopped, pending tasks drained.`
-      };
+function assessQualityGate(reports) {
+  const mustFix = [];
+  const uncertaintyFlags = [];
+  let hasFail = false;
+  let hasInconclusive = false;
+  for (const report of reports) {
+    if (report.verdict === "fail") hasFail = true;
+    if (report.verdict === "inconclusive") hasInconclusive = true;
+    const blocking = extractSection(report.summary, "Must Fix") || extractSection(report.summary, "Failures") || extractSection(report.summary, "Verification Gaps");
+    if (blocking) mustFix.push(`${report.role}: ${excerpt(blocking, 1e3)}`);
+    if (report.uncertaintyFlags) {
+      uncertaintyFlags.push(`${report.role}: ${excerpt(report.uncertaintyFlags, 1e3)}`);
     }
-  };
+    if (report.error) mustFix.push(`${report.role}: ${report.error}`);
+  }
+  if (hasFail) return { verdict: "fail", passed: false, mustFix, uncertaintyFlags };
+  if (hasInconclusive || reports.length === 0) {
+    return { verdict: "inconclusive", passed: false, mustFix, uncertaintyFlags };
+  }
+  return { verdict: "pass", passed: true, mustFix, uncertaintyFlags };
 }
-function makeFleetTool(director) {
-  return {
-    name: "fleet",
-    description: 'Fleet observation tool. Use `action` to select what you need: "status" \u2014 snapshot of all subagents + coordinator counts + pending tasks; "usage" \u2014 token + cost breakdown per subagent and totals; "health" \u2014 per-subagent budget pressure, last activity, and status; "session" \u2014 read a subagent\'s JSONL transcript (requires subagentId).',
-    usageHint: 'action: "status" (default) | "usage" | "health" | "session".\nFor "session", pass subagentId (required) and optional tail (trailing JSONL lines).',
-    permission: "auto",
-    mutating: false,
-    capabilities: [ToolCapabilities.COORDINATION_FLEET_READ],
-    inputSchema: {
-      type: "object",
-      properties: {
-        action: {
-          type: "string",
-          enum: ["status", "usage", "health", "session"],
-          description: "Observation to retrieve (default: status)."
-        },
-        subagentId: {
-          type: "string",
-          description: 'Subagent id (required for action: "session").'
-        },
-        tail: {
-          type: "number",
-          description: 'Number of trailing JSONL lines (action: "session" only). Omit for the full transcript.'
-        }
-      }
-    },
-    async execute(input) {
-      const i = input ?? {};
-      const action = i.action ?? "status";
-      switch (action) {
-        case "status": {
-          const base = director.status();
-          const fm = director.fleetManager;
-          const stats = fm?.getFleetStats();
-          const fleetStatus = fm?.getFleetStatus();
-          return {
-            action: "status",
-            subagents: base.subagents,
-            coordinatorStats: stats ? {
-              total: stats.total,
-              running: stats.running,
-              idle: stats.idle,
-              stopped: stats.stopped
-            } : void 0,
-            pending: fleetStatus?.pending ?? [],
-            usage: fm?.snapshot()
-          };
-        }
-        case "usage": {
-          return { action: "usage", ...director.snapshot() };
-        }
-        case "health": {
-          const status = director.status();
-          const snapshot = director.snapshot();
-          const subagents = status.subagents ?? [];
-          const perSubagent = snapshot.perSubagent ?? {};
-          return {
-            action: "health",
-            subagents: subagents.map((s) => {
-              const usage = perSubagent[s.id];
-              return {
-                id: s.id,
-                status: s.status,
-                lastEventAt: usage?.lastEventAt,
-                budgetPressure: {
-                  iterations: usage?.iterations,
-                  toolCalls: usage?.toolCalls,
-                  costUsd: usage?.cost
-                }
-              };
-            })
-          };
-        }
-        case "session": {
-          const subagentId = i.subagentId;
-          if (!subagentId) {
-            return {
-              action: "session",
-              error: 'fleet: subagentId is required for action: "session"'
-            };
-          }
-          const result = await director.readSession(subagentId, i.tail);
-          if (!result) {
-            return {
-              action: "session",
-              error: `fleet: transcript unavailable for "${subagentId}". Is sessionsRoot configured?`
-            };
-          }
-          return { action: "session", ...result };
-        }
-        default:
-          return {
-            error: `fleet: unknown action "${action}". Valid: status, usage, health, session.`
-          };
-      }
+function parseQualityVerdict(role, text) {
+  const normalized = text.toLowerCase();
+  const verdictBlock = normalized.match(/(?:^|\n)\s*(?:#+\s*)?verdict\b[^\n]*(?:\n|:|-)?([\s\S]{0,500})/)?.[0] ?? normalized.slice(0, 1e3);
+  if (role === "reviewer") {
+    if (/\b(request\s+changes|needs\s+verification|reject|rejected|fail|failed|blocked)\b/.test(
+      verdictBlock
+    )) {
+      return "fail";
     }
-  };
+    if (/\b(approve|approved|pass|passed)\b/.test(verdictBlock)) return "pass";
+    if (sectionHasBlockingContent(text, "Must Fix") || sectionHasBlockingContent(text, "Verification Gaps")) {
+      return "fail";
+    }
+    return "inconclusive";
+  }
+  if (/\b(fail|failed|blocked|red)\b/.test(verdictBlock)) return "fail";
+  if (/\b(pass|passed|green|approve|approved)\b/.test(verdictBlock)) return "pass";
+  if (sectionHasBlockingContent(text, "Failures")) return "fail";
+  return "inconclusive";
+}
+function sectionHasBlockingContent(text, heading) {
+  const section = extractSection(text, heading);
+  if (!section) return false;
+  return !/^\s*(none|n\/a|no\b|no issues|empty|\(none\))\s*\.?\s*$/i.test(section.trim());
+}
+function extractSection(text, heading) {
+  const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `(?:^|\\n)\\s*#{1,6}\\s*${escaped}\\s*\\n([\\s\\S]*?)(?=\\n\\s*#{1,6}\\s+|$)`,
+    "i"
+  );
+  const match = text.match(pattern);
+  const body = match?.[1]?.trim();
+  return body ? body : void 0;
+}
+function excerpt(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max - 20).trimEnd()}
+...(truncated)`;
 }
 
 // src/coordination/director-tools.ts
@@ -9165,13 +9193,13 @@ function makeSpawnTool(director, roster) {
   const inputSchema = {
     type: "object",
     properties: {
-      role: {
+      description: {
         type: "string",
-        description: "Roster role id. When set, the spawn uses the matching config from the roster and ignores other fields."
+        description: "What the subagent has to do, in free form. PREFER THIS over `role`: the dispatcher scores it against the capability metadata of every agent in the roster and picks the specialist, which is more reliable than recalling a role id from a list of 77. Only reach for `role` when you are certain which one you want."
       },
-      description: {
+      role: {
         type: "string",
-        description: "Free-form task description. When `role` is not set, the director uses the smart dispatcher to route this to the best-matching catalog agent. Use this when you don't know the exact role name."
+        description: "Roster role id. When set, the spawn uses the matching config from the roster, ignores other fields, and SKIPS DISPATCH ENTIRELY \u2014 so a half-remembered id silently costs you the specialist. Prefer `description` unless the id is certain."
       },
       name: {
         type: "string",
@@ -9217,7 +9245,7 @@ function makeSpawnTool(director, roster) {
   return {
     name: "spawn_subagent",
     description: "Create a new subagent under this director (own LLM context, own budget). NON-BLOCKING: returns a `subagentId` immediately without triggering any model call. Pair with `assign_task` to send work and `await_tasks` to retrieve the result later \u2014 this is the async-delegation pattern that lets the leader keep working while the subagent runs in its own context.",
-    usageHint: "Pass `role` (matches the roster), `description` (smart dispatch to best agent), or `name` + `provider`/`model`. Returns `{ subagentId }`. Use this instead of `delegate` when you want to fan out to multiple subagents or keep the leader unblocked while work runs in parallel.",
+    usageHint: "Pass `description` (what the work is \u2014 dispatched to the best-matching specialist), or `role` when you are certain of the id, or `name` + `provider`/`model`. Returns `{ subagentId }`. The roster is deep and specialised: there is very likely an agent built for this exact job, so describe the work rather than defaulting to a generalist. Use this instead of `delegate` when you want to fan out to multiple subagents or keep the leader unblocked while work runs in parallel.",
     permission: "auto",
     mutating: false,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
@@ -9721,8 +9749,9 @@ function composeDirectorPrompt(parts = {}) {
   const preamble = parts.directorPreamble ?? DEFAULT_DIRECTOR_PREAMBLE;
   if (preamble && preamble.trim().length > 0) sections.push(preamble.trim());
   if (parts.rosterSummary && parts.rosterSummary.trim().length > 0) {
-    sections.push(`Available roles you can spawn:
-${parts.rosterSummary.trim()}`);
+    sections.push(
+      "Roles you can spawn. This roster is deep and specialised \u2014 before handing work to a generalist, look for the agent built for exactly this job, and prefer describing the work (`description`) over recalling an id (`role`) so the dispatcher can find it:\n" + parts.rosterSummary.trim()
+    );
   }
   if (parts.basePrompt && parts.basePrompt.trim().length > 0) {
     sections.push(parts.basePrompt.trim());
@@ -9759,13 +9788,23 @@ ${parts.skills.trim()}`);
   }
   return sections.join("\n\n");
 }
+var ROSTER_SUMMARY_MAX_CHARS = 150;
+function nameAddsInformation(roleId, name) {
+  const flatten = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return flatten(name) !== flatten(roleId);
+}
 function rosterSummaryFromConfigs(roster) {
   const lines = [];
   for (const [roleId, cfg] of Object.entries(roster)) {
     const tag = cfg.provider && cfg.model ? ` (${cfg.provider}/${cfg.model})` : "";
-    const headline = cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").trim().slice(0, 80) : "";
+    const label = nameAddsInformation(roleId, cfg.name) ? ` (${cfg.name})` : "";
+    const capability = cfg.dispatch?.summary?.trim() || // Fallback headline: a role prompt that opens with a markdown heading
+    // would otherwise render as "# Generic Project Agent", which reads as
+    // formatting rather than as a capability.
+    (cfg.prompt ? (cfg.prompt.split("\n").find((l) => l.trim().length > 0) ?? "").replace(/^#+\s*/, "").trim() : "");
+    const headline = capability.length > ROSTER_SUMMARY_MAX_CHARS ? `${capability.slice(0, ROSTER_SUMMARY_MAX_CHARS - 1).trimEnd()}\u2026` : capability;
     const tail = headline ? ` \u2014 ${headline}` : "";
-    lines.push(`- ${roleId}: ${cfg.name}${tag}${tail}`);
+    lines.push(`- ${roleId}${label}${tag}${tail}`);
   }
   return lines.join("\n");
 }
@@ -11367,6 +11406,12 @@ function getModelFamilyRatio(calibrationKey) {
 }
 
 // src/core/conversation-state.ts
+function hasToolResultBlock(message) {
+  return message !== void 0 && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_result");
+}
+function hasToolUseBlock(message) {
+  return message?.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_use");
+}
 var ConversationState = class {
   ctx;
   listeners = /* @__PURE__ */ new Set();
@@ -11434,15 +11479,32 @@ var ConversationState = class {
    */
   overflowCount(arr) {
     let drop = Context.MAX_MESSAGES > 0 ? Math.max(0, arr.length - Context.MAX_MESSAGES) : 0;
-    if (Context.MAX_MESSAGE_TOKENS <= 0) return drop;
+    if (Context.MAX_MESSAGE_TOKENS <= 0) return this.protocolSafeDropCount(arr, drop);
     let total = 0;
     for (let i = drop; i < arr.length; i++) total += arr[i]?._estTokens ?? 0;
-    if (total <= Context.MAX_MESSAGE_TOKENS) return drop;
+    if (total <= Context.MAX_MESSAGE_TOKENS) return this.protocolSafeDropCount(arr, drop);
     while (drop < arr.length - 1 && total > Context.MAX_MESSAGE_TOKENS) {
       total -= arr[drop]?._estTokens ?? 0;
       drop++;
     }
-    return drop;
+    return this.protocolSafeDropCount(arr, drop);
+  }
+  /**
+   * Front eviction must not retain a `tool_result` after evicting the
+   * immediately preceding assistant `tool_use`. Long tool-heavy sessions sit
+   * at the retention cap, so an unsafe boundary would create a fresh orphan on
+   * nearly every append and make the request-time repair discard protocol
+   * history continuously.
+   *
+   * Move the boundary backward to retain the complete exchange for one more
+   * eviction cycle. Moving it forward would also drop non-protocol text/images
+   * that may share either message. The temporary one-message cap overshoot is
+   * the minimum lossless representation; once enough newer messages exist, the
+   * next eviction boundary naturally moves past both halves together.
+   */
+  protocolSafeDropCount(arr, drop) {
+    if (drop <= 0 || drop >= arr.length) return drop;
+    return hasToolResultBlock(arr[drop]) && hasToolUseBlock(arr[drop - 1]) ? drop - 1 : drop;
   }
   /**
    * Append a content block to the trailing user message's content array.
@@ -11847,6 +11909,28 @@ var Context = class _Context {
       return _Context.CONVERSATION_JOURNAL_MAX_BYTES + 1;
     }
   }
+  _journalDropCount = 0;
+  _journalDropWarnAt = 0;
+  /** Throttled notice that a conversation event never reached the journal. */
+  warnConversationJournalDrop(eventType) {
+    this._journalDropCount++;
+    const now = Date.now();
+    if (now - this._journalDropWarnAt < 5e3) return;
+    this._journalDropWarnAt = now;
+    const dropped = this._journalDropCount;
+    this._journalDropCount = 0;
+    console.warn(
+      JSON.stringify({
+        level: "error",
+        event: "session.conversation_journal_drop",
+        sessionId: this.session?.id,
+        eventType,
+        droppedEvents: dropped,
+        message: "Session writer is not draining; replay of this session will be incomplete.",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
   enqueueConversationJournal(event, writer) {
     const bytes = this.conversationJournalBytes(event);
     const shouldSnapshot = event.type === "messages_replaced" || this._conversationJournalQueue.length >= _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes + bytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES;
@@ -11864,18 +11948,21 @@ var Context = class _Context {
         this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - queued.bytes);
         this._conversationJournalQueue.splice(index, 1);
       }
-      if (snapshotBytes <= _Context.CONVERSATION_JOURNAL_MAX_BYTES) {
-        this._conversationJournalQueue.push({ event: snapshot, bytes: snapshotBytes, writer });
-        this._conversationJournalBytes += snapshotBytes;
-      }
+      this._conversationJournalQueue.push({ event: snapshot, bytes: snapshotBytes, writer });
+      this._conversationJournalBytes += snapshotBytes;
     } else {
       this._conversationJournalQueue.push({ event, bytes, writer });
       this._conversationJournalBytes += bytes;
     }
     while (this._conversationJournalQueue.length > _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES) {
-      const dropped = this._conversationJournalQueue.shift();
+      const index = this._conversationJournalQueue.findIndex(
+        (queued) => queued.event.type !== "messages_replaced"
+      );
+      if (index === -1) break;
+      const [dropped] = this._conversationJournalQueue.splice(index, 1);
       if (!dropped) break;
       this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - dropped.bytes);
+      this.warnConversationJournalDrop(dropped.event.type);
     }
     this.startConversationJournalDrain();
   }
@@ -13064,6 +13151,20 @@ function sessionScopedPath(dir, sessionId, suffix) {
   }
   return resolved;
 }
+var SESSION_SIDECAR_JSONL_SUFFIXES = [
+  ".replay.jsonl",
+  ".audit.jsonl",
+  ".annotations.jsonl"
+];
+var RESERVED_SESSION_JSONL_NAMES = /* @__PURE__ */ new Set([
+  "_index.jsonl",
+  "_mailbox.jsonl"
+]);
+function isSessionTranscriptFileName(name) {
+  if (!name.endsWith(".jsonl")) return false;
+  if (RESERVED_SESSION_JSONL_NAMES.has(name)) return false;
+  return !SESSION_SIDECAR_JSONL_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
 function invalid(sessionId) {
   return new FsError({
     message: `Invalid sessionId: ${sessionId}`,
@@ -15559,6 +15660,15 @@ async function validateResumeFileObservations(events, projectRoot) {
     staleFiles: results.filter((entry) => entry !== null)
   };
 }
+var RESUME_NOTICE_HEADERS = [
+  "[SESSION RESUME FILE VALIDATION]",
+  "[SESSION RESUME INTERRUPTED WORK]"
+];
+function isResumeNoticeMessage(message) {
+  if (message.role !== "system" || typeof message.content !== "string") return false;
+  return RESUME_NOTICE_HEADERS.some((header) => message.content === header || message.content.startsWith(`${header}
+`));
+}
 function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
   const root = path18.resolve(projectRoot);
@@ -15669,9 +15779,6 @@ async function assertSessionCanBeDeleted(sessionId, isSessionInUse) {
 function shouldSkipSessionDirectoryEntry(name) {
   return name.startsWith(".") && name !== ".wrongstack" || name === "shared" || name === "subagents" || name === "attachments";
 }
-function isSessionJsonlFileName(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl";
-}
 
 // src/storage/session-store/directory-session-files.ts
 import * as fsp11 from "node:fs/promises";
@@ -15696,7 +15803,7 @@ async function collectSessionFiles(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path21.join(dir, entry.name) });
     }
   }
@@ -15720,7 +15827,7 @@ async function collectSessionIds(dir, prefix = "", depth = 0) {
     if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
     if (entry.isDirectory()) {
       dirEntries.push(entry);
-    } else if (entry.isFile() && isSessionJsonlFileName(entry.name)) {
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
       fileIds.push(sessionIdForFile(prefix, entry.name));
     }
   }
@@ -15822,13 +15929,13 @@ function inheritsIntoFork(event) {
 
 // src/storage/session-store/fork-session.ts
 async function forkSession(host, id, opts = {}) {
-  const parent = await host.load(id);
-  let boundary = parent.events.length - 1;
+  const parentEvents = await host.readRawEvents(id);
+  let boundary = parentEvents.length - 1;
   let targetCheckpoint;
   if (opts.checkpointPromptIndex !== void 0) {
     boundary = -1;
-    for (let i = 0; i < parent.events.length; i++) {
-      const event = parent.events[i];
+    for (let i = 0; i < parentEvents.length; i++) {
+      const event = parentEvents[i];
       if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
         boundary = i;
         targetCheckpoint = event;
@@ -15838,15 +15945,18 @@ async function forkSession(host, id, opts = {}) {
       throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
     }
   }
-  const parentPrefix = parent.events.slice(0, boundary + 1);
+  const parentPrefix = parentEvents.slice(0, boundary + 1);
   const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
   const checkpointHash = createHash5("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
   const inherited = parentPrefix.filter(inheritsIntoFork);
+  const start = parentEvents.find(
+    (event) => event.type === "session_start"
+  );
   const writer = await host.create({
     id: "",
-    title: parent.metadata.title,
-    model: parent.metadata.model,
-    provider: parent.metadata.provider
+    title: "",
+    model: start?.model,
+    provider: start?.provider
   });
   try {
     await writer.append({
@@ -15952,6 +16062,17 @@ var SessionLoadCache = class {
     this.entries.clear();
     this.bytes = 0;
   }
+  /**
+   * A hit hands back fresh `messages` / `events` arrays over the cached
+   * contents.
+   *
+   * The entry outlives every caller, and callers treat what they get as their
+   * own: `resume()` passes `messages` straight into a live conversation, and
+   * anything walking `events` may splice it. Returning the cached arrays
+   * themselves let one caller's edit rewrite what the next one loads. The
+   * elements are still shared — copying them would defeat the cache — so
+   * entries remain read-only *contents* behind private containers.
+   */
   getFresh(id, stat15, full) {
     const cached = this.entries.get(id);
     if (!cached || cached.mtimeMs !== stat15.mtimeMs || cached.size !== stat15.size) {
@@ -15959,8 +16080,11 @@ var SessionLoadCache = class {
     }
     this.entries.delete(id);
     this.entries.set(id, cached);
-    if (full) return cached.data;
-    return { ...cached.data, messages: [] };
+    return {
+      ...cached.data,
+      messages: full ? [...cached.data.messages] : [],
+      events: [...cached.data.events]
+    };
   }
   set(id, stat15, data) {
     this.delete(id);
@@ -16149,6 +16273,9 @@ function stripSnapshotPayload(event) {
   event.messagesOmitted = event.messages.length;
   event.messages = [];
 }
+function isStrippedSnapshot(event) {
+  return event.messages.length === 0 && typeof event.messagesOmitted === "number" && event.messagesOmitted > 0;
+}
 function isSessionEventLike(value) {
   return value !== null && typeof value === "object" && typeof value.type === "string" && typeof value.ts === "string";
 }
@@ -16178,7 +16305,12 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed message_updated event at index ${ev.index}`);
     }
   } else if (ev.type === "messages_replaced" && ev.version === 1) {
-    if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored messages_replaced event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
       exactJournalActive = true;
     } else {
       emitDamaged(params, "Ignored malformed messages_replaced event");
@@ -16194,9 +16326,16 @@ function replaySessionEvent(params) {
       emitDamaged(params, `Ignored malformed messages_dropped event (count ${String(ev.count)})`);
     }
   } else if (ev.type === "context_snapshot") {
-    if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored context_snapshot event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
       emitDamaged(params, "Ignored malformed context_snapshot event");
     }
+  } else if (ev.type === "messages_replaced" || ev.type === "message_appended" || ev.type === "message_updated" || ev.type === "messages_dropped") {
+    emitDamaged(params, `Ignored ${ev.type} event with unsupported version`);
   } else if (!exactJournalActive && ev.type === "user_input") {
     openToolUses.clear();
     messages.push({ role: "user", content: ev.content, ts: ev.ts });
@@ -16249,7 +16388,7 @@ function emitDamaged(params, detail) {
 import * as fsp13 from "node:fs/promises";
 import * as path22 from "node:path";
 function isPrunableSessionJsonl(name) {
-  return name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
+  return isSessionTranscriptFileName(name);
 }
 async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
@@ -16772,6 +16911,21 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async fork(id, opts = {}) {
     return forkSession(this, id, opts);
   }
+  /**
+   * Implements {@link SessionForkHost.readRawEvents} — the parent stream a fork
+   * inherits, unmodified.
+   *
+   * Deliberately NOT `load()`: that loader empties superseded snapshot payloads
+   * in place and front-drops events past its retention budget, both of which
+   * are correct for reconstructing a conversation and wrong for copying a
+   * journal prefix into a child. Streaming with an accept-everything predicate
+   * keeps the scrubbing contract (`searchEvents` scrubs each line the same way
+   * `load()` does) without either transformation.
+   */
+  async readRawEvents(id) {
+    const hits = await this.searchEvents(id, () => true);
+    return hits.map((hit) => hit.event);
+  }
   /**
    * Capture the deterministic post-tool workspace identity through the store-owned CAS.
    */
@@ -16860,14 +17014,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         ts: (/* @__PURE__ */ new Date()).toISOString()
       });
     }
+    const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
     const resumedData = {
       ...data,
       ...resumeValidation ? { resumeValidation } : {},
-      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+      messages: [...carriedMessages, ...noticeMessages]
     };
     let handle;
     try {
-      handle = await fsp17.open(file, "a", 384);
+      handle = await openSessionForAppend(file);
     } catch (err) {
       emitSessionStoreError(this.events, canonicalId, file, "resume", toErrorMessage(err), false);
       throw new Error(
@@ -17046,10 +17201,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = criteria.limit ?? 100;
     if (this.catalogClient) {
       const records = await this.catalogClient.call("list_catalog", {
-        limit: Math.min(1e3, Math.max(limit, 100)),
-        ...criteria.titleContains ? { search: criteria.titleContains } : {}
+        limit,
+        ...criteria
       });
-      return this.scrubSummaries(records).filter((summary) => matchesSessionFilter(summary, criteria)).slice(0, limit);
+      return this.scrubSummaries(records);
     }
     try {
       const indexed = await this.readIndex();
@@ -17274,11 +17429,11 @@ var DefaultSessionStore = class _DefaultSessionStore {
     return shardKeys;
   }
   async readOrBuildShardManifest(shardKey) {
-    const cached = this.shardManifestCache.get(shardKey);
-    if (cached) return cached;
     const manifestPath = this.shardManifestPath(shardKey);
+    const cached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
+    if (cached) return cached;
     return withFileLock(manifestPath, async () => {
-      const lockedCached = this.shardManifestCache.get(shardKey);
+      const lockedCached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
       if (lockedCached) return lockedCached;
       const entry = await readOrBuildShardManifestEntry({
         shardKey,
@@ -17289,10 +17444,38 @@ var DefaultSessionStore = class _DefaultSessionStore {
         summaryHeaderFor: (ref) => this.summaryHeaderFor(ref),
         summaryFor: (id) => this.summaryFor(id)
       });
-      this.shardManifestCache.set(shardKey, entry);
+      try {
+        const stat15 = await fsp17.stat(manifestPath);
+        this.shardManifestCache.set(shardKey, {
+          entry,
+          mtimeMs: stat15.mtimeMs,
+          size: stat15.size,
+          ino: stat15.ino
+        });
+      } catch {
+        this.shardManifestCache.delete(shardKey);
+      }
       return entry;
     });
   }
+  /**
+   * Shard manifests are invalidated by other store processes via atomic
+   * delete/rebuild. Validate the in-memory projection against the persisted
+   * file so one long-lived process cannot retain another process's stale view.
+   */
+  async freshShardManifestCacheEntry(shardKey, manifestPath) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (!cached) return void 0;
+    try {
+      const stat15 = await fsp17.stat(manifestPath);
+      if (stat15.mtimeMs === cached.mtimeMs && stat15.size === cached.size && stat15.ino === cached.ino) {
+        return cached.entry;
+      }
+    } catch {
+    }
+    this.shardManifestCache.delete(shardKey);
+    return void 0;
+  }
   async collectSessionFilesInShard(shardKey) {
     const dir = shardKey ? path23.join(this.dir, shardKey) : this.dir;
     const entries = await this.collectSessionFiles(dir, shardKey);
@@ -17572,6 +17755,23 @@ var DefaultSessionStore = class _DefaultSessionStore {
     });
   }
 };
+async function openSessionForAppend(file) {
+  const handle = await fsp17.open(file, "a+", 384);
+  try {
+    const stat15 = await handle.stat();
+    if (stat15.size > 0) {
+      const tail = Buffer.allocUnsafe(1);
+      const { bytesRead } = await handle.read(tail, 0, 1, stat15.size - 1);
+      if (bytesRead === 1 && tail[0] !== 10) {
+        await handle.appendFile("\n", "utf8");
+      }
+    }
+    return handle;
+  } catch (err) {
+    await handle.close().catch(() => void 0);
+    throw err;
+  }
+}
 
 // src/coordination/director-session.ts
 function makeDirectorSessionFactory(opts) {
@@ -22148,6 +22348,9 @@ var DEFAULT_TOOLS_CONFIG = Object.freeze({
   disabledTools: Object.freeze([]),
   autoExtendLimit: true,
   restrictToProjectRoot: true,
+  // Off by default: the board is a record of the work, not a permit for it.
+  // See ToolsConfig.kanbanGovernance for what turning it on costs and gates.
+  kanbanGovernance: false,
   loopDetection: Object.freeze({
     mode: "steer-then-cut",
     steerThreshold: 3,
@@ -28051,7 +28254,7 @@ async function evaluateToolKanbanBoundary(tool, input, ctx, options = {}) {
     } : { decision: "allow" };
   }
   const task = identity.taskId ? board.tasks.find((candidate) => candidate.id === identity.taskId) : void 0;
-  if (governanceRequired) {
+  if (governanceRequired && board.lifecycle?.mode === "managed") {
     if (!identity.taskId) {
       return {
         decision: "block",
@@ -28077,9 +28280,11 @@ async function evaluateToolKanbanBoundary(tool, input, ctx, options = {}) {
       };
     }
     if (task.lifecycle?.currentStage !== "running" || task.assignment?.status !== "running") {
+      const lifecycleStage = task.lifecycle?.currentStage ?? "missing";
+      const assignmentStatus = task.assignment?.status ?? "missing";
       return {
         decision: "block",
-        reason: "Active card must be in Running with a live assignment before product mutation. Call kanban start_task after completing the required card details.",
+        reason: `Active card must be in Running with a live assignment before product mutation (lifecycle: ${lifecycleStage}; assignment: ${assignmentStatus}). Call kanban start_task after completing the required card details.`,
         boardId: board.id,
         taskId: task.id
       };
@@ -32974,23 +33179,21 @@ function unwrapDataKey(buf, keyFile) {
     });
   }
 }
-function checkKeyFilePermissions(keyFile, opts) {
-  if (process.platform === "win32") return;
+function keyFileNeedsHardening(keyFile, opts) {
+  if (process.platform === "win32") return false;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
     const stat15 = fs14.statSync(keyFile);
     const actualMode = stat15.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
-      void restrictFilePermissions(keyFile, {
-        label: "secret-vault",
-        warn
-      }).catch(() => void 0);
       warn(
         `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Hardening\u2026`
       );
+      return true;
     }
   } catch {
   }
+  return false;
 }
 function writeKeyFileAtomicSync(keyFile, content) {
   const tmp = `${keyFile}.${randomBytes3(4).toString("hex")}.tmp`;
@@ -33056,6 +33259,14 @@ var DefaultSecretVault = class {
     }).catch(() => void 0);
     this.pendingHardening.push(p);
   }
+  /** Detect and schedule repair of a pre-existing POSIX key with loose mode bits. */
+  checkKeyFilePermissions() {
+    if (keyFileNeedsHardening(this.keyFile, {
+      warn: (msg) => this.logWarn(msg)
+    })) {
+      this.scheduleKeyHardening();
+    }
+  }
   /** Flush all pending key-file hardening promises. */
   flushHardening() {
     if (this.pendingHardening.length === 0) return Promise.resolve();
@@ -33143,7 +33354,7 @@ var DefaultSecretVault = class {
       writeKeyFileAtomicSync(this.keyFile, keyFileBuf);
     }
     this.scheduleKeyHardening();
-    checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+    this.checkKeyFilePermissions();
     this.key = newKey;
     this._keyVersion = newVersion;
     return { oldVersion, newVersion };
@@ -33159,12 +33370,9 @@ var DefaultSecretVault = class {
     const passphrase = getVaultPassphrase();
     if (!passphrase || !this.key) return;
     try {
-      writeKeyFileAtomicSync(
-        this.keyFile,
-        wrapDataKey(this.key, this._keyVersion, passphrase)
-      );
+      writeKeyFileAtomicSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase));
       this.scheduleKeyHardening();
-      checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+      this.checkKeyFilePermissions();
     } catch {
     }
   }
@@ -33176,13 +33384,13 @@ var DefaultSecretVault = class {
         const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
         this.key = key2;
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         this.migrateToWrappedIfPassphrase();
         return this.key;
       }
@@ -33206,7 +33414,7 @@ var DefaultSecretVault = class {
         }
         this.key = Buffer.from(key2);
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         this.migrateToWrappedIfPassphrase();
         return this.key;
       }
@@ -33233,13 +33441,13 @@ var DefaultSecretVault = class {
         const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
         this.key = winnerKey;
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       if (buf.length === VERSIONED_KEY_FILE_SIZE) {
@@ -33255,7 +33463,7 @@ var DefaultSecretVault = class {
         const winnerKey = buf.subarray(KEY_FILE_MAGIC.length + 1);
         this.key = Buffer.from(winnerKey);
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
+        this.checkKeyFilePermissions();
         return this.key;
       }
       throw new ConfigError({
@@ -33506,6 +33714,7 @@ var CONFIG_BEHAVIOR_DEFAULTS = {
     disabledTools: DEFAULT_TOOLS_CONFIG.disabledTools,
     autoExtendLimit: DEFAULT_TOOLS_CONFIG.autoExtendLimit,
     restrictToProjectRoot: DEFAULT_TOOLS_CONFIG.restrictToProjectRoot,
+    kanbanGovernance: DEFAULT_TOOLS_CONFIG.kanbanGovernance,
     loopDetection: DEFAULT_TOOLS_CONFIG.loopDetection
   },
   log: { level: "info" },
@@ -33890,6 +34099,14 @@ var IN_PROJECT_DENIED_PATHS = [
   {
     path: "tools.restrictToProjectRoot",
     reason: "The other half of the filesystem confinement switch."
+  },
+  {
+    // Denied for the direction that loosens: the flag defaults to false, so a
+    // repo can only ever use it to turn OFF a gate the user deliberately
+    // enabled. Same class as `tools.restrictToProjectRoot` — a control the
+    // operator owns, not the checked-out repository.
+    path: "tools.kanbanGovernance",
+    reason: "Repo-committed config could disable a Kanban governance gate the operator switched on, letting product mutations run outside any managed card."
   }
 ];
 function deleteNestedPath(target, path45) {