@wrongstack/core 0.285.0 → 0.286.0

package/dist/defaults/index.js

@@ -528,9 +528,17 @@ function globToRegex(pat) {
   return new RegExp(re + "$");
 }
 function baseDir(pat) {
-  let i = pat.length - 1;
-  while (i >= 0 && !GLOB_CHARS.has(expectDefined(pat[i])) && pat[i] !== SEP && pat[i] !== "/") i--;
-  const cut = i >= 0 ? pat.lastIndexOf(SEP, i) : pat.lastIndexOf("/", i);
+  let firstGlob = pat.length;
+  for (let i = 0; i < pat.length; i++) {
+    if (GLOB_CHARS.has(expectDefined(pat[i]))) {
+      firstGlob = i;
+      break;
+    }
+  }
+  const cut = Math.max(
+    pat.lastIndexOf(SEP, firstGlob - 1),
+    pat.lastIndexOf("/", firstGlob - 1)
+  );
   return cut < 0 ? "." : pat.slice(0, cut);
 }
 async function expandGlob(pattern) {
@@ -3187,9 +3195,11 @@ function normalizeSubagentStructuredReport(value) {
   const filesExamined = stringArray(value["files_examined"]);
   const nextSteps = stringArray(value["suggested_next_steps"]);
   const confidence = value["confidence"];
+  const completion = value["completion"];
+  const remainingWork = optionalString(value["remaining_work"]);
   if (!summary || summary.length > MAX_SUMMARY_CHARS || !findings || findings.length > MAX_FINDINGS || !filesExamined || filesExamined.length > MAX_FILES || !nextSteps || nextSteps.length > MAX_NEXT_STEPS || [...findings, ...filesExamined, ...nextSteps].some(
     (item) => item.trim().length > MAX_ITEM_CHARS
-  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1 || completion !== void 0 && completion !== "complete" && completion !== "partial" || completion === "partial" && !remainingWork || remainingWork !== void 0 && remainingWork.length > MAX_SUMMARY_CHARS) {
     return void 0;
   }
   const report = {
@@ -3197,7 +3207,9 @@ function normalizeSubagentStructuredReport(value) {
     findings: findings.map((item) => item.trim()).filter(Boolean),
     files_examined: filesExamined.map((item) => item.trim()).filter(Boolean),
     confidence,
-    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean)
+    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean),
+    ...completion === "complete" || completion === "partial" ? { completion } : {},
+    ...remainingWork ? { remaining_work: remainingWork } : {}
   };
   return JSON.stringify(report).length <= MAX_SUBAGENT_STRUCTURED_REPORT_CHARS ? report : void 0;
 }
@@ -3210,6 +3222,8 @@ function formatSubagentStructuredReport(report) {
   const next = report.suggested_next_steps.length ? report.suggested_next_steps.map((item) => `- ${item}`).join("\n") : "- (none)";
   return [
     report.summary,
+    report.completion ? `Completion: ${report.completion}` : void 0,
+    report.remaining_work ? `Remaining work: ${report.remaining_work}` : void 0,
     `
 Findings:
 ${findings}`,
@@ -3219,7 +3233,7 @@ Files examined: ${files}`,
     `
 Suggested next steps:
 ${next}`
-  ].join("\n");
+  ].filter((line) => typeof line === "string").join("\n");
 }
 function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3227,6 +3241,9 @@ function isRecord3(value) {
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
+function optionalString(value) {
+  return value === void 0 ? void 0 : nonEmptyString(value);
+}
 function stringArray(value) {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
@@ -5119,58 +5136,27 @@ import * as path5 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/coordination/fleet.ts
-var AUDIT_LOG_AGENT = {
-  id: "audit-log",
-  name: "Audit Log",
-  role: "audit-log",
-  prompt: agentPrompt("audit-log")
-  // No hardcoded budgets — the orchestrator (delegate tool or
-  // spawn_subagent) decides per-task how much room a subagent gets.
-  // A monorepo audit needs hours; a single-file lint check needs
-  // seconds. Pinning a number here forces the orchestrator to fight
-  // the role's default instead of just asking for what it needs.
-};
-var BUG_HUNTER_AGENT = {
-  id: "bug-hunter",
-  name: "Bug Hunter",
-  role: "bug-hunter",
-  prompt: agentPrompt("bug-hunter")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var REFACTOR_PLANNER_AGENT = {
-  id: "refactor-planner",
-  name: "Refactor Planner",
-  role: "refactor-planner",
-  prompt: agentPrompt("refactor-planner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SECURITY_SCANNER_AGENT = {
-  id: "security-scanner",
-  name: "Security Scanner",
-  role: "security-scanner",
-  prompt: agentPrompt("security-scanner")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var SHADOW_AGENT = {
-  id: "shadow-agent",
-  name: "Shadow",
-  role: "shadow-agent",
-  prompt: agentPrompt("shadow-agent")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
-var CRITIC_AGENT = {
-  id: "critic",
-  name: "Critic",
-  role: "critic",
-  prompt: agentPrompt("critic")
-  // Budgets are set by the orchestrator per task — see fleet.ts header.
-};
+function defineAgent(id, name, promptRole = id, provider) {
+  return {
+    id,
+    name,
+    role: id,
+    prompt: agentPrompt(promptRole),
+    ...provider === void 0 ? {} : { provider }
+  };
+}
+var AUDIT_LOG_AGENT = defineAgent("audit-log", "Audit Log");
+var BUG_HUNTER_AGENT = defineAgent("bug-hunter", "Bug Hunter");
+var REFACTOR_PLANNER_AGENT = defineAgent("refactor-planner", "Refactor Planner");
+var SECURITY_SCANNER_AGENT = defineAgent("security-scanner", "Security Scanner");
+var SHADOW_AGENT = defineAgent("shadow-agent", "Shadow");
+var CRITIC_AGENT = defineAgent("critic", "Critic");
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
   "bug-hunter": BUG_HUNTER_AGENT,
   "refactor-planner": REFACTOR_PLANNER_AGENT,
   "security-scanner": SECURITY_SCANNER_AGENT,
-  "critic": CRITIC_AGENT,
+  critic: CRITIC_AGENT,
   "shadow-agent": SHADOW_AGENT,
   ...Object.fromEntries(
     ALL_AGENT_DEFINITIONS.map((d) => [d.config.role, d.config])
@@ -5182,7 +5168,7 @@ var FLEET_ROSTER_BUDGETS = {
   "bug-hunter": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
   "refactor-planner": { timeoutMs: 7.5 * 60 * 60 * 1e3, maxIterations: 6e3, maxToolCalls: 18e3 },
   "security-scanner": { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 },
-  "critic": { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
+  critic: { timeoutMs: 5 * 60 * 60 * 1e3, maxIterations: 4e3, maxToolCalls: 12e3 },
   "shadow-agent": {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: 2e3,
@@ -5219,41 +5205,11 @@ function applyRosterBudget(cfg) {
   };
 }
 var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
-var CLINE_AGENT = {
-  id: "cline",
-  name: "Cline",
-  role: "cline",
-  prompt: agentPrompt("acp-cline"),
-  provider: "acp"
-};
-var GEMINI_CLI_AGENT = {
-  id: "gemini-cli",
-  name: "Gemini CLI",
-  role: "gemini-cli",
-  prompt: agentPrompt("acp-gemini-cli"),
-  provider: "acp"
-};
-var COPILOT_AGENT = {
-  id: "copilot",
-  name: "GitHub Copilot",
-  role: "copilot",
-  prompt: agentPrompt("acp-copilot"),
-  provider: "acp"
-};
-var OPENHANDS_AGENT = {
-  id: "openhands",
-  name: "OpenHands",
-  role: "openhands",
-  prompt: agentPrompt("acp-openhands"),
-  provider: "acp"
-};
-var GOOSE_AGENT = {
-  id: "goose",
-  name: "Goose",
-  role: "goose",
-  prompt: agentPrompt("acp-goose"),
-  provider: "acp"
-};
+var CLINE_AGENT = defineAgent("cline", "Cline", "acp-cline", "acp");
+var GEMINI_CLI_AGENT = defineAgent("gemini-cli", "Gemini CLI", "acp-gemini-cli", "acp");
+var COPILOT_AGENT = defineAgent("copilot", "GitHub Copilot", "acp-copilot", "acp");
+var OPENHANDS_AGENT = defineAgent("openhands", "OpenHands", "acp-openhands", "acp");
+var GOOSE_AGENT = defineAgent("goose", "Goose", "acp-goose", "acp");
 var ACP_AGENTS = [
   CLINE_AGENT,
   GEMINI_CLI_AGENT,
@@ -5261,11 +5217,14 @@ var ACP_AGENTS = [
   OPENHANDS_AGENT,
   GOOSE_AGENT
 ];
-FLEET_ROSTER_BUDGETS["cline"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["gemini-cli"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["copilot"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["openhands"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
-FLEET_ROSTER_BUDGETS["goose"] = { timeoutMs: 10 * 60 * 60 * 1e3, maxIterations: 8e3, maxToolCalls: 2e4 };
+var ACP_AGENT_BUDGET = {
+  timeoutMs: 10 * 60 * 60 * 1e3,
+  maxIterations: 8e3,
+  maxToolCalls: 2e4
+};
+for (const agent of ACP_AGENTS) {
+  FLEET_ROSTER_BUDGETS[agent.role] = { ...ACP_AGENT_BUDGET };
+}
 var FLEET_ROSTER_WITHACP = {
   ...FLEET_ROSTER,
   ...Object.fromEntries(ACP_AGENTS.map((a) => [a.role, a]))
@@ -5273,7 +5232,7 @@ var FLEET_ROSTER_WITHACP = {
 
 // src/coordination/delegate-tool.ts
 function createDelegateTool(opts) {
-  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 30 * 60 * 1e3;
+  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
   const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
   const inputSchema = {
     type: "object",
@@ -5332,16 +5291,23 @@ function createDelegateTool(opts) {
         type: "number",
         minimum: 0,
         description: "Maximum estimated USD cost the subagent may incur. Unset = use the role/coordinator default."
+      },
+      maxHandoffs: {
+        type: "number",
+        minimum: 0,
+        maximum: 8,
+        description: "Maximum fresh-worker continuations after partial completion or budget exhaustion. Default 1; set 0 to disable. Each successor receives the prior structured/partial report and is told to continue only the remaining work."
       }
     },
     required: ["task"]
   };
   return {
     name: "delegate",
-    description: "Hand a discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and its own budget \u2014 use this when a task is self-contained, would otherwise blow up your context, or benefits from a specialized role (bug-hunter, security-scanner, refactor-planner, audit-log). For free-form coding tasks (not tied to a pre-defined role), pass `name` + `task` \u2014 the subagent runs as a general-purpose coding agent with a large default budget. YOU decide how big the budget is: pass `timeoutMs`, `maxIterations`, and `maxToolCalls` sized to the actual work. There is no hidden cap forcing a 3-minute / 80-iteration limit \u2014 if a monorepo audit needs 2 hours and 500 tool calls, ask for that. Call multiple delegates in parallel through the provider's parallel-tool-call surface to fan work out across roles.",
-    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster (audit-log, bug-hunter, refactor-planner, security-scanner) or pass `name` to run a free-form coding agent. For non-trivial work, also pass `timeoutMs`, `maxIterations`, and `maxToolCalls`. Returns the subagent's `TaskResult` \u2014 including the textual `result`, iteration count, tool count, and duration. Requires Director mode to be active in normal CLI sessions.",
+    description: "Hand a discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and a generous, auto-extending budget. If it reports explicit partial completion or still exhausts a recoverable budget, delegate can continue the remaining work with a fresh subagent (bounded by `maxHandoffs`, default 1). Workers may ask the leader to spawn a parallel helper through the mailbox, but cannot recursively spawn agents themselves. Use specialized roster roles when possible; otherwise pass `name` + `task`. Call multiple delegates in parallel through the provider's parallel-tool-call surface for independent work.",
+    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster or pass `name` for a free-form coding agent. Defaults are intentionally generous; override `timeoutMs`, `maxIterations`, `maxToolCalls`, or `maxHandoffs` only when the task warrants it. Returns the final TaskResult plus a `handoffs` history when fresh workers continued partial work. Requires Director mode in normal CLI sessions.",
     permission: "auto",
     mutating: false,
+    managesOwnTimeout: true,
     capabilities: [ToolCapabilities.SUBAGENT_SPAWN],
     inputSchema,
     async execute(input, _ctx, execOpts) {
@@ -5381,7 +5347,7 @@ function createDelegateTool(opts) {
               error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
             };
           }
-          cfg = instantiateRosterConfig(i.role, base);
+          cfg = instantiateRosterConfig(i.role, base, i.timeoutMs, defaultTimeoutMs);
           if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
           if (i.provider) cfg.provider = i.provider;
           if (i.model) cfg.model = i.model;
@@ -5420,172 +5386,175 @@ function createDelegateTool(opts) {
           cfg.timeoutMs = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         }
         opts.events?.emit("delegate.started", { sessionId, target, task: i.task });
-        const subagentId = await director.spawn(cfg);
-        const taskId = await director.assign({
-          id: `${randomUUID2()}`,
-          description: i.task,
-          subagentId
-        });
         const dir = director;
-        const result = await new Promise((resolve12) => {
-          let settled = false;
-          let timer;
-          let offAbort = () => {
-          };
-          const finish = (value) => {
-            if (settled) return;
-            settled = true;
-            if (timer) clearTimeout(timer);
-            offTool();
-            offIter();
-            offProgress();
-            offAbort();
-            resolve12(value);
-          };
-          const arm = () => {
-            if (timer) clearTimeout(timer);
-            timer = setTimeout(() => finish({ __timeout: true }), timeoutMs);
-          };
-          const bump = (e) => {
-            if (e.subagentId === subagentId) arm();
-          };
-          const offTool = dir.fleet.filter("tool.executed", bump);
-          const offIter = dir.fleet.filter("iteration.started", bump);
-          const offProgress = dir.fleet.filter("tool.progress", bump);
-          if (abortSignal) {
-            const onAbortSignal = () => finish({ __aborted: true });
-            abortSignal.addEventListener("abort", onAbortSignal, { once: true });
-            offAbort = () => abortSignal.removeEventListener("abort", onAbortSignal);
-            if (abortSignal.aborted) onAbortSignal();
-          }
-          arm();
-          dir.awaitTasks([taskId]).then((r) => finish(r[0] ?? { __emptyResult: true })).catch(() => finish({ __timeout: true }));
-        });
-        if ("__aborted" in result) {
-          try {
-            await dir.terminate(subagentId);
-          } catch {
-          }
-          const partial2 = await readSubagentPartial(opts, subagentId);
-          opts.events?.emit("delegate.completed", {
-            sessionId,
-            target,
-            task: i.task,
-            ok: false,
-            status: "aborted",
-            summary: `[${target}] aborted \u2014 the run was interrupted`,
-            durationMs: 0,
-            iterations: partial2?.events ?? 0,
-            toolCalls: partial2?.toolUsesObserved ?? 0,
+        const maxHandoffs = Math.min(8, Math.max(0, Math.floor(i.maxHandoffs ?? 1)));
+        const handoffs = [];
+        let delegatedTask = i.task;
+        let handoffCount = 0;
+        for (; ; ) {
+          const attemptConfig = handoffCount === 0 ? cfg : freshHandoffConfig(cfg, i.role, handoffCount);
+          const subagentId = await dir.spawn(attemptConfig);
+          const taskId = await dir.assign({
+            id: randomUUID2(),
+            description: delegatedTask,
             subagentId
           });
-          return {
-            ok: false,
-            stopReason: "aborted",
-            error: "Delegated task aborted \u2014 the run was interrupted.",
+          const result = await awaitDelegateAttempt(
+            dir,
             subagentId,
             taskId,
-            partial: partial2
-          };
-        }
-        if ("__timeout" in result) {
-          const partial2 = await readSubagentPartial(opts, subagentId);
-          opts.events?.emit("delegate.completed", {
-            sessionId,
-            target,
-            task: i.task,
-            ok: false,
-            status: "host_timeout",
-            summary: `[${target}] timed out \u2014 no result within ${Math.round(timeoutMs / 1e3)}s`,
-            durationMs: timeoutMs,
-            iterations: partial2?.events ?? 0,
-            toolCalls: partial2?.toolUsesObserved ?? 0,
-            subagentId
-          });
-          return {
-            ok: false,
-            stopReason: "host_timeout",
-            error: `Subagent did not finish within ${timeoutMs}ms.`,
-            hint: "Reduce scope of the next delegate, raise timeoutMs, or use spawn_subagent + await_tasks for long-running work.",
-            subagentId,
-            taskId,
-            partial: partial2
-          };
-        }
-        if ("__emptyResult" in result) {
-          const partial2 = await readSubagentPartial(opts, subagentId);
+            timeoutMs,
+            abortSignal
+          );
+          if ("__aborted" in result) {
+            try {
+              await dir.terminate(subagentId);
+            } catch {
+            }
+            const partial2 = await readSubagentPartial(opts, subagentId);
+            opts.events?.emit("delegate.completed", {
+              sessionId,
+              target,
+              task: i.task,
+              ok: false,
+              status: "aborted",
+              summary: `[${target}] aborted \u2014 the run was interrupted`,
+              durationMs: 0,
+              iterations: partial2?.events ?? 0,
+              toolCalls: partial2?.toolUsesObserved ?? 0,
+              subagentId
+            });
+            return {
+              ok: false,
+              stopReason: "aborted",
+              error: "Delegated task aborted \u2014 the run was interrupted.",
+              subagentId,
+              taskId,
+              partial: partial2,
+              ...handoffs.length > 0 ? { handoffs } : {}
+            };
+          }
+          if ("__timeout" in result) {
+            try {
+              await dir.terminate(subagentId);
+            } catch {
+            }
+            const partial2 = await readSubagentPartial(opts, subagentId);
+            opts.events?.emit("delegate.completed", {
+              sessionId,
+              target,
+              task: i.task,
+              ok: false,
+              status: "host_timeout",
+              summary: `[${target}] timed out \u2014 no progress within ${Math.round(timeoutMs / 1e3)}s`,
+              durationMs: timeoutMs,
+              iterations: partial2?.events ?? 0,
+              toolCalls: partial2?.toolUsesObserved ?? 0,
+              subagentId
+            });
+            return {
+              ok: false,
+              stopReason: "host_timeout",
+              error: `Subagent timed out: it did not finish or report progress within ${timeoutMs}ms.`,
+              hint: "Raise timeoutMs for unusually long single operations, or split the remaining work.",
+              subagentId,
+              taskId,
+              partial: partial2,
+              ...handoffs.length > 0 ? { handoffs } : {}
+            };
+          }
+          if ("__emptyResult" in result) {
+            const partial2 = await readSubagentPartial(opts, subagentId);
+            opts.events?.emit("delegate.completed", {
+              sessionId,
+              target,
+              task: i.task,
+              ok: false,
+              status: "empty_result",
+              summary: `[${target}] completed without a task result`,
+              durationMs: 0,
+              iterations: partial2?.events ?? 0,
+              toolCalls: partial2?.toolUsesObserved ?? 0,
+              subagentId
+            });
+            return {
+              ok: false,
+              stopReason: "error",
+              error: "Director returned no task result for the delegated task.",
+              hint: "Check fleet state, then retry or reassign the task.",
+              subagentId,
+              taskId,
+              partial: partial2,
+              ...handoffs.length > 0 ? { handoffs } : {}
+            };
+          }
+          const partial = result.status === "success" ? void 0 : result.partial ? {
+            lastAssistantText: result.partial.text,
+            toolUsesObserved: result.toolCalls,
+            events: result.iterations
+          } : await readSubagentPartial(opts, subagentId);
+          const continuation = continuationFor(result, partial, attemptConfig);
+          if (continuation && handoffCount < maxHandoffs) {
+            handoffs.push({
+              fromSubagentId: result.subagentId,
+              fromTaskId: result.taskId,
+              status: result.status,
+              errorKind: result.error?.kind,
+              summary: continuation.summary,
+              remainingWork: continuation.remainingWork
+            });
+            handoffCount += 1;
+            delegatedTask = buildHandoffTask(i.task, continuation, handoffCount, maxHandoffs);
+            continue;
+          }
+          const incomplete = result.report?.completion === "partial";
+          const baseStopReason = incomplete ? "handoff_limit" : result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
+          const errorKind = result.error?.kind;
+          const retryable = result.error?.retryable;
+          const backoffMs = result.error?.backoffMs;
+          const summary = incomplete ? `[${target}] partial checkpoint \u2014 handoff limit reached after ${handoffCount} continuation(s)` : buildDelegateSummary(i.role, result);
+          let costUsd;
+          try {
+            costUsd = dir.snapshot().perSubagent[result.subagentId]?.cost;
+          } catch {
+            costUsd = void 0;
+          }
           opts.events?.emit("delegate.completed", {
             sessionId,
             target,
             task: i.task,
-            ok: false,
-            status: "empty_result",
-            summary: `[${target}] completed without a task result`,
-            durationMs: 0,
-            iterations: partial2?.events ?? 0,
-            toolCalls: partial2?.toolUsesObserved ?? 0,
-            subagentId
+            ok: result.status === "success" && !incomplete,
+            status: incomplete ? "partial" : result.status,
+            summary,
+            durationMs: result.durationMs,
+            iterations: result.iterations,
+            toolCalls: result.toolCalls,
+            costUsd,
+            subagentId: result.subagentId
           });
           return {
-            ok: false,
-            stopReason: "error",
-            error: "Director returned no task result for the delegated task.",
-            hint: "Check fleet state with /fleet status, then retry or reassign the task.",
-            subagentId,
-            taskId,
-            partial: partial2
+            ok: result.status === "success" && !incomplete,
+            status: incomplete ? "partial" : result.status,
+            stopReason: baseStopReason,
+            errorKind,
+            retryable,
+            backoffMs,
+            subagentId: result.subagentId,
+            taskId: result.taskId,
+            result: result.result,
+            report: result.report,
+            error: result.error,
+            iterations: result.iterations,
+            toolCalls: result.toolCalls,
+            durationMs: result.durationMs,
+            ...partial ? { partial } : {},
+            ...handoffs.length > 0 ? { handoffs } : {},
+            ...incomplete ? {
+              hint: "A clean partial checkpoint remains. Reinvoke delegate with a larger maxHandoffs or assign report.remaining_work explicitly."
+            } : hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {},
+            summary
           };
         }
-        const baseStopReason = result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
-        const partial = result.status === "success" ? void 0 : result.partial ? {
-          lastAssistantText: result.partial.text,
-          toolUsesObserved: result.toolCalls,
-          events: result.iterations
-        } : await readSubagentPartial(opts, subagentId);
-        const errorKind = result.error?.kind;
-        const retryable = result.error?.retryable;
-        const backoffMs = result.error?.backoffMs;
-        const summary = buildDelegateSummary(i.role, result);
-        let costUsd;
-        try {
-          costUsd = dir.snapshot().perSubagent[result.subagentId]?.cost;
-        } catch {
-          costUsd = void 0;
-        }
-        opts.events?.emit("delegate.completed", {
-          sessionId,
-          target,
-          task: i.task,
-          ok: result.status === "success",
-          status: result.status,
-          summary,
-          durationMs: result.durationMs,
-          iterations: result.iterations,
-          toolCalls: result.toolCalls,
-          costUsd,
-          subagentId: result.subagentId
-        });
-        return {
-          ok: result.status === "success",
-          status: result.status,
-          stopReason: baseStopReason,
-          errorKind,
-          retryable,
-          backoffMs,
-          subagentId: result.subagentId,
-          taskId: result.taskId,
-          result: result.result,
-          report: result.report,
-          error: result.error,
-          iterations: result.iterations,
-          toolCalls: result.toolCalls,
-          durationMs: result.durationMs,
-          ...partial ? { partial } : {},
-          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {},
-          // Summary is included so callers (TUI, CLI renderer) can surface
-          // it as a chat history line — the LLM also sees it for continuity.
-          summary
-        };
       } catch (err) {
         const message = toErrorMessage(err);
         opts.events?.emit("delegate.completed", {
@@ -5608,10 +5577,103 @@ function createDelegateTool(opts) {
     }
   };
 }
-function instantiateRosterConfig(role, base) {
+async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
+  return new Promise((resolve12) => {
+    let settled = false;
+    let timer;
+    let offAbort = () => {
+    };
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      offTool();
+      offIter();
+      offProgress();
+      offAbort();
+      resolve12(value);
+    };
+    const arm = () => {
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => finish({ __timeout: true }), timeoutMs);
+    };
+    const bump = (event) => {
+      if (event.subagentId === subagentId) arm();
+    };
+    const offTool = director.fleet.filter("tool.executed", bump);
+    const offIter = director.fleet.filter("iteration.started", bump);
+    const offProgress = director.fleet.filter("tool.progress", bump);
+    if (abortSignal) {
+      const onAbort = () => finish({ __aborted: true });
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+      offAbort = () => abortSignal.removeEventListener("abort", onAbort);
+      if (abortSignal.aborted) onAbort();
+    }
+    arm();
+    director.awaitTasks([taskId]).then((results) => finish(results[0] ?? { __emptyResult: true })).catch(() => finish({ __timeout: true }));
+  });
+}
+function freshHandoffConfig(cfg, role, handoffCount) {
+  return {
+    ...cfg,
+    id: role ? `${role}-${randomUUID2().slice(0, 8)}` : `${cfg.name.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "subagent"}-handoff-${handoffCount}-${randomUUID2().slice(0, 6)}`
+  };
+}
+function continuationFor(result, partial, config) {
+  if (result.report?.completion === "partial" && result.report.remaining_work) {
+    return {
+      summary: result.report.summary,
+      remainingWork: result.report.remaining_work,
+      partialText: typeof result.result === "string" ? result.result : partial?.lastAssistantText
+    };
+  }
+  const budgetKinds = /* @__PURE__ */ new Set([
+    "budget_iterations",
+    "budget_tool_calls",
+    "budget_tokens",
+    "budget_cost",
+    "budget_timeout"
+  ]);
+  const partialText = result.partial?.text ?? partial?.lastAssistantText;
+  const mayHaveIsolatedWrites = config.worktree !== false && config.worktree !== "off" && (!config.tools || config.tools.some(
+    (tool) => ["write", "edit", "replace", "patch", "bash", "exec", "install", "format"].includes(tool)
+  ));
+  if (!mayHaveIsolatedWrites && result.status !== "success" && result.error?.kind && budgetKinds.has(result.error.kind) && partialText) {
+    return {
+      summary: `Prior worker stopped at ${result.error.kind} after ${result.iterations} iterations and ${result.toolCalls} tool calls.`,
+      remainingWork: "Inspect the existing workspace and finish only the work that remains from the original task.",
+      partialText
+    };
+  }
+  return void 0;
+}
+function buildHandoffTask(originalTask, continuation, handoffCount, maxHandoffs) {
+  const partial = continuation.partialText?.trim().slice(-6e3);
+  return [
+    `Continue an oversized delegated task as fresh worker ${handoffCount} of ${maxHandoffs}.`,
+    "Do not blindly repeat completed actions. Inspect the current workspace, git diff, tests, and any files named below before changing anything.",
+    'If the remaining work is still too large, stop at a clean checkpoint and call submit_result with completion="partial" plus concrete remaining_work.',
+    "If parallel help would materially improve the outcome and mail_send is available, send the leader an `ask` that names the exact helper task; do not spawn agents yourself.",
+    `Original task:
+${originalTask}`,
+    `Prior checkpoint summary:
+${continuation.summary}`,
+    `Remaining work:
+${continuation.remainingWork}`,
+    partial ? `Prior worker's last useful output:
+${partial}` : ""
+  ].filter(Boolean).join("\n\n");
+}
+function instantiateRosterConfig(role, base, requestedTimeoutMs, defaultTimeoutMs) {
   const withBudget = applyRosterBudget({ ...base, role });
+  const rosterTimeoutMs = FLEET_ROSTER_BUDGETS[role]?.timeoutMs;
   return {
     ...withBudget,
+    // Without an explicit host wait, apply the role's tuned multi-hour
+    // wall-clock budget. With an explicit wait, leave this unset so the buffer
+    // logic above derives a slightly shorter child budget without clamping the
+    // role defaults used by ordinary calls.
+    timeoutMs: requestedTimeoutMs === void 0 ? rosterTimeoutMs ?? defaultTimeoutMs : void 0,
     // Give each spawn a fresh id so parallel or repeated delegates
     // can use the same role safely.
     id: `${role}-${randomUUID2().slice(0, 8)}`
@@ -6253,9 +6315,9 @@ var CollabSession = class extends EventEmitter {
         this._timeoutTimer = void 0;
       }
       this.cleanup();
-      const error = err instanceof Error ? err : new Error(String(err));
-      this.emit("session.error", error);
-      throw error;
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      this.emit("session.error", error2);
+      throw error2;
     }
     for (const result of results?.flat() ?? []) {
       await this.parseAndEmit(result);
@@ -7392,13 +7454,13 @@ ${a.reports.map((r) => `- ${r.role}: ${r.verdict}${r.error ? ` (${r.error})` : "
 }
 function summarizeTaskResult(result) {
   const text = typeof result.result === "string" ? result.result : result.result !== void 0 ? JSON.stringify(result.result, null, 2) : "";
-  const error = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
+  const error2 = result.error ? `${result.error.kind}: ${result.error.message}` : void 0;
   return {
     taskId: result.taskId,
     subagentId: result.subagentId,
     status: result.status,
-    summary: excerpt(text || error || "(no output)", 4e3),
-    error
+    summary: excerpt(text || error2 || "(no output)", 4e3),
+    error: error2
   };
 }
 function assessRoleResult(role, result) {
@@ -10146,7 +10208,7 @@ var Director = class _Director {
     this.subagentBaseline = opts.subagentBaseline ?? DEFAULT_SUBAGENT_BASELINE;
     this.taskResultNotifier = opts.taskResultNotifier;
     this.subagentIdleTimeoutMs = typeof opts.subagentIdleTimeoutMs === "number" && Number.isFinite(opts.subagentIdleTimeoutMs) && opts.subagentIdleTimeoutMs >= 0 ? opts.subagentIdleTimeoutMs : void 0;
-    this.retireSubagentOnTaskComplete = opts.retireSubagentOnTaskComplete ?? false;
+    this.retireSubagentOnTaskComplete = opts.retireSubagentOnTaskComplete ?? true;
     this.sharedScratchpadPath = opts.sharedScratchpadPath ?? null;
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.fleetManager?.maxSpawnDepth ?? resolveMaxSpawnDepth(opts.maxSpawnDepth);
@@ -10157,7 +10219,7 @@ var Director = class _Director {
     this.dispatchClassifier = opts.dispatchClassifier;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
     this.maxFleetTokens = opts.directorBudget?.maxTokens ?? Number.POSITIVE_INFINITY;
-    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 12;
     this.maxLeaderContextLoad = opts.maxLeaderContextLoad ?? 0.85;
     this.maxContext = opts.maxContext ?? 128e3;
     this.modelMatrix = opts.modelMatrix;
@@ -10406,7 +10468,7 @@ var Director = class _Director {
             payload.deny();
             return;
           }
-          if (decision.optionId === "stop" || /\bstop\b/i.test(decision.text)) {
+          if (decision.optionId === "stop") {
             payload.deny();
             return;
           }
@@ -10934,6 +10996,7 @@ var Director = class _Director {
       await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
       await this.stateCheckpoint.releaseLock().catch((err) => this.logShutdownError("state_checkpoint_lock_release", err));
     }
+    this.largeAnswerStore.clear();
   }
   /**
    * Funnel for shutdown-phase errors. We can't throw — `shutdown()` is
@@ -11135,9 +11198,18 @@ var Director = class _Director {
   }
   async terminate(subagentId) {
     await this.coordinator.stop(subagentId);
+    void this.remove(subagentId).catch(
+      (err) => this.logShutdownError("terminate_remove", err)
+    );
   }
   async terminateAll() {
+    const ids = this.status().subagents.map((s) => s.id);
     await this.coordinator.stopAll();
+    for (const id of ids) {
+      void this.remove(id).catch(
+        (err) => this.logShutdownError("terminate_all_remove", err)
+      );
+    }
   }
   async remove(subagentId) {
     this.clearSubagentIdleRetirement(subagentId);
@@ -11177,7 +11249,7 @@ var Director = class _Director {
     const timer = setTimeout(() => {
       this.subagentIdleTimers.delete(subagentId);
       const entry = this.coordinator.getStatus().subagents.find((a) => a.id === subagentId);
-      if (!entry || entry.status !== "idle") return;
+      if (entry?.status !== "idle") return;
       if (this.coordinator.listPendingTasks().some((task) => task.subagentId === subagentId)) {
         this.armSubagentIdleRetirement(subagentId, this.subagentIdleTimeoutMs);
         return;
@@ -12769,6 +12841,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
   projectRoot;
   checkpointCas;
   isSessionInUse;
+  logger;
   /**
    * In-memory cache for load() results, keyed by session ID. The cache is
    * invalidated when the file's mtimeMs or size changes (indicating the
@@ -12794,6 +12867,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
     this.events = opts.events;
     this.secretScrubber = opts.secretScrubber;
     this.isSessionInUse = opts.isSessionInUse;
+    this.logger = opts.logger;
+  }
+  /**
+   * Emit a structured warning. Uses the configured Logger when available;
+   * falls back to console.warn(JSON) so warnings are never silently dropped.
+   */
+  logWarn(msg, ctx) {
+    if (this.logger) {
+      this.logger.warn(msg, ctx);
+    } else {
+      console.warn(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
   }
   /**
    * Clear the load() cache. Useful for testing or when the caller knows
@@ -12807,7 +12892,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     }
   }
   // ── Storage event helpers ───────────────────────────────────────────────────
-  emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
+  emitRead(sessionId, filePath, operation, outcome, durationMs, error2) {
     this.events?.emit("storage.read", {
       sessionId,
       store: "session",
@@ -12815,10 +12900,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       operation,
       outcome,
       durationMs,
-      ...error !== void 0 ? { error } : {}
+      ...error2 !== void 0 ? { error: error2 } : {}
     });
   }
-  emitWrite(sessionId, filePath, operation, outcome, durationMs, eventCount, error) {
+  emitWrite(sessionId, filePath, operation, outcome, durationMs, eventCount, error2) {
     this.events?.emit("storage.write", {
       sessionId,
       store: "session",
@@ -12827,16 +12912,16 @@ var DefaultSessionStore = class _DefaultSessionStore {
       outcome,
       durationMs,
       ...eventCount !== void 0 ? { eventCount } : {},
-      ...error !== void 0 ? { error } : {}
+      ...error2 !== void 0 ? { error: error2 } : {}
     });
   }
-  emitError(sessionId, filePath, operation, error, recoverable) {
+  emitError(sessionId, filePath, operation, error2, recoverable) {
     this.events?.emit("storage.error", {
       sessionId,
       store: "session",
       filePath,
       operation,
-      error,
+      error: error2,
       recoverable
     });
   }
@@ -12895,12 +12980,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
-      await handle.close().catch((e) => console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.handle_close_failed",
-        message: e instanceof Error ? e.message : String(e),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })));
+      await handle.close().catch((e) => this.logWarn(
+        "Session handle close failed",
+        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
+      ));
       this.emitError(id, file, "create", toErrorMessage(err), true);
       throw err;
     }
@@ -13031,12 +13114,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
       return { writer, data: resumedData };
     } catch (err) {
-      await handle.close().catch((e) => console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.handle_close_failed",
-        message: e instanceof Error ? e.message : String(e),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })));
+      await handle.close().catch((e) => this.logWarn(
+        "Session handle close failed",
+        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
+      ));
       this.emitError(id, file, "resume", toErrorMessage(err), true);
       throw err;
     }
@@ -13657,13 +13738,10 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
-        console.warn(JSON.stringify({
-          level: "warn",
-          event: "session_store.manifest_write_failed",
-          sessionId: id,
-          message: msg,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        this.logWarn(
+          "Session manifest write failed",
+          { event: "session_store.manifest_write_failed", sessionId: id, message: msg }
+        );
       });
       outcome = "failure";
       errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
@@ -14280,12 +14358,12 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
       const stillHard = afterLoad >= pressure.hardThreshold;
       const fatal = stillHard && (this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard");
       if (stillHard) {
-        const error = new Error(
+        const error2 = new Error(
           `Auto-compaction left context above the hard threshold after ${pressure.level} compaction`
         );
         this.events?.emit("compaction.failed", {
           sessionId: ctx.session.id,
-          err: error,
+          err: error2,
           aggressive,
           level: pressure.level,
           tokens: afterTokens,
@@ -14309,11 +14387,11 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         }
       }
     } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
+      const error2 = err instanceof Error ? err : new Error(String(err));
       const fatal = this.failureMode === "throw" || this.failureMode === "throw_on_hard" && pressure.level === "hard";
       this.events?.emit("compaction.failed", {
         sessionId: ctx.session.id,
-        err: error,
+        err: error2,
         aggressive,
         level: pressure.level,
         tokens: pressure.tokens,
@@ -14374,19 +14452,27 @@ function adaptThresholdsForSignals(thresholds, signals) {
 
 // src/execution/autonomous-runner.ts
 var DoneConditionChecker = class {
-  constructor(condition) {
+  constructor(condition, opts) {
     this.condition = condition;
+    this.logger = opts?.logger;
     if (condition.type === "output_match" && condition.pattern) {
       const result = compileUserRegex(condition.pattern, "");
       this.compiledRegex = result.ok ? result.regex : null;
       if (!result.ok) {
-        console.warn(JSON.stringify({
-          level: "warn",
-          event: "autonomous.done_condition_invalid_regex",
-          pattern: condition.pattern,
-          reason: result.reason,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        if (this.logger) {
+          this.logger.warn(
+            "Done condition has invalid regex \u2014 will never match",
+            { event: "autonomous.done_condition_invalid_regex", pattern: condition.pattern, reason: result.reason }
+          );
+        } else {
+          console.warn(JSON.stringify({
+            level: "warn",
+            event: "autonomous.done_condition_invalid_regex",
+            pattern: condition.pattern,
+            reason: result.reason,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+        }
       }
     } else {
       this.compiledRegex = null;
@@ -14394,6 +14480,7 @@ var DoneConditionChecker = class {
   }
   condition;
   compiledRegex;
+  logger;
   check(state) {
     switch (this.condition.type) {
       case "iterations":
@@ -14444,7 +14531,7 @@ var DoneConditionChecker = class {
 var AutonomousRunner = class {
   constructor(opts) {
     this.opts = opts;
-    this.doneChecker = new DoneConditionChecker(opts.doneCondition);
+    this.doneChecker = new DoneConditionChecker(opts.doneCondition, { logger: opts.logger });
   }
   opts;
   iterations = 0;
@@ -14555,7 +14642,7 @@ var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
   return resolveWstackPaths({ projectRoot }).projectGoal;
 }
-async function loadGoal(filePath, events) {
+async function loadGoal(filePath, events, warn) {
   const t0 = Date.now();
   let raw;
   try {
@@ -14586,13 +14673,9 @@ async function loadGoal(filePath, events) {
   try {
     const parsed = JSON.parse(raw);
     if (parsed?.version !== 1 || typeof parsed.goal !== "string" || !Array.isArray(parsed.journal)) {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "goal_store.invalid_schema",
-        path: filePath,
-        message: "invalid schema \u2014 consider deleting and re-creating",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.invalid_schema", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
+        "invalid schema \u2014 consider deleting and re-creating"
+      );
       events?.emit("storage.read", {
         sessionId: "~boot~",
         store: "goal",
@@ -14614,13 +14697,9 @@ async function loadGoal(filePath, events) {
     });
     return parsed;
   } catch {
-    console.warn(JSON.stringify({
-      level: "warn",
-      event: "goal_store.parse_failed",
-      path: filePath,
-      message: "JSON parse failed \u2014 consider deleting and re-creating",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }));
+    (warn ?? ((msg) => console.warn(JSON.stringify({ level: "warn", event: "goal_store.parse_failed", path: filePath, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(
+      "JSON parse failed \u2014 consider deleting and re-creating"
+    );
     events?.emit("storage.read", {
       sessionId: "~boot~",
       store: "goal",
@@ -14993,8 +15072,8 @@ function summarizeToolResultElision(block, tokens) {
   if (block.name) parts.push(`tool=${block.name}`);
   const files = extractPathHints(block.content).slice(0, 5);
   if (files.length > 0) parts.push(`files=${files.join(", ")}`);
-  const error = firstErrorLine(block.content);
-  if (error) parts.push(`error=${error}`);
+  const error2 = firstErrorLine(block.content);
+  if (error2) parts.push(`error=${error2}`);
   return `[${parts.join("; ")}]`;
 }
 function extractPathHints(content) {
@@ -16530,22 +16609,40 @@ var EternalAutonomyEngine = class {
   currentCtrl = null;
   iterationsSinceCompact = 0;
   goalPath;
+  /**
+   * Emit a structured error. Uses the configured Logger when available;
+   * falls back to console.error(JSON) so events are never silently dropped.
+   */
+  logError(msg, ctx) {
+    if (this.opts.logger) {
+      this.opts.logger.error(msg, ctx);
+    } else {
+      console.error(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
+  }
   /** Current engine state — readable for UIs. */
   get currentState() {
     return this.state;
   }
+  /**
+   * Load the goal file with structured logging for parse/schema warnings.
+   */
+  loadGoal() {
+    return loadGoal(
+      this.goalPath,
+      this.opts.events,
+      this.opts.logger ? (msg) => this.opts.logger.warn(msg) : void 0
+    );
+  }
   /** Synchronously request stop. Resolves once the running iteration aborts. */
   stop() {
     this.stopRequested = true;
     this.currentCtrl?.abort();
     void this.persistEngineState("stopped").catch((err) => {
-      console.error(JSON.stringify({
-        level: "error",
-        event: "engine.persist_state_failed",
-        message: toErrorMessage(err),
-        context: { expectedState: "stopped" },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Engine persist state failed",
+        { event: "engine.persist_state_failed", message: toErrorMessage(err), context: { expectedState: "stopped" } }
+      );
     });
     this.state = "stopped";
   }
@@ -16601,7 +16698,7 @@ var EternalAutonomyEngine = class {
     const emit = (stage) => {
       this.opts.onStage?.(stage);
     };
-    const goal = await loadGoal(this.goalPath, this.opts.events);
+    const goal = await this.loadGoal();
     if (!goal) {
       emit({ phase: "stopped" });
       this.stopRequested = true;
@@ -16705,16 +16802,13 @@ var EternalAutonomyEngine = class {
     emit({ phase: "reflect", status, note });
     let iterationIndex = 0;
     try {
-      const reloaded = await loadGoal(this.goalPath, this.opts.events);
+      const reloaded = await this.loadGoal();
       iterationIndex = reloaded?.iterations ?? 0;
     } catch (err) {
-      console.error(JSON.stringify({
-        level: "warn",
-        event: "autonomy.goal_reload_failed",
-        message: toErrorMessage(err),
-        context: { goalPath: this.goalPath },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Goal reload failed",
+        { event: "autonomy.goal_reload_failed", message: toErrorMessage(err), context: { goalPath: this.goalPath } }
+      );
     }
     this.opts.onIteration?.({
       at: (this.opts.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
@@ -16950,13 +17044,10 @@ ${lastFew}` : "No prior iterations yet.",
         clearTimeout(timer);
       }
     } catch (err) {
-      console.error(JSON.stringify({
-        level: "warn",
-        event: "autonomy.brainstorm_failed",
-        message: toErrorMessage(err),
-        context: { goal: goal.goal.slice(0, 100) },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Brainstorm failed",
+        { event: "autonomy.brainstorm_failed", message: toErrorMessage(err), context: { goal: goal.goal.slice(0, 100) } }
+      );
       return null;
     }
   }
@@ -17039,7 +17130,7 @@ ${recentJournal}` : "No prior iterations.",
     }
   }
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) {
       return;
     }
@@ -17053,7 +17144,7 @@ ${recentJournal}` : "No prior iterations.",
    * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
    */
   async bumpTodoAttempt(todoId) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     const attempts = { ...current.todoAttempts ?? {} };
     attempts[todoId] = (attempts[todoId] ?? 0) + 1;
@@ -17067,7 +17158,7 @@ ${recentJournal}` : "No prior iterations.",
    * goal is already `completed`.
    */
   async markGoalCompleted(action, note) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     if (current.goalState === "completed") return;
     const withFlag = { ...current, goalState: "completed" };
@@ -17078,6 +17169,11 @@ ${recentJournal}` : "No prior iterations.",
       note: note.slice(0, 240)
     });
     await saveGoal(this.goalPath, withEntry, this.opts.events);
+    try {
+      const { unlink: unlink12 } = await import("node:fs/promises");
+      await unlink12(this.goalPath);
+    } catch {
+    }
     this.opts.onEternalStop?.();
   }
   /**
@@ -17086,7 +17182,7 @@ ${recentJournal}` : "No prior iterations.",
    * `onEternalStop` so the REPL returns to normal mode.
    */
   async clearGoalManually(note) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (current) {
       const abandoned = { ...current, goalState: "abandoned" };
       await saveGoal(this.goalPath, abandoned, this.opts.events);
@@ -17134,7 +17230,23 @@ Recent work:
 ${recentJournal}` : ""
         ].join("\n"),
         risk: "high",
-        fallback: "continue"
+        fallback: "continue",
+        // Structured verdict — completion is control-plane input, decided by
+        // exact option id rather than sniffing prose for "done"/"complete".
+        options: [
+          {
+            id: "goal_complete",
+            label: "The goal is complete \u2014 stop the eternal run",
+            consequence: "The engine stops and the goal file is archived.",
+            risk: "high"
+          },
+          {
+            id: "keep_working",
+            label: "Not complete yet \u2014 keep working",
+            consequence: "The engine continues iterating on the goal.",
+            risk: "low"
+          }
+        ]
       });
       const summary = formatDecisionSummary(decision, {
         id: `goal-done-${goal.iterations}`,
@@ -17154,8 +17266,7 @@ ${recentJournal}` : ""
         return false;
       }
       if (decision.type === "answer") {
-        const text = decision.text.toLowerCase();
-        return text.includes("complete") || text.includes("done") || text.includes("yes");
+        return decision.optionId === "goal_complete";
       }
       return true;
     } catch {
@@ -17166,13 +17277,13 @@ ${recentJournal}` : ""
    * Persist a progress update from the agent's [PROGRESS: N%] output.
    */
   async updateProgress(progress, note) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     const updated = recordProgress(current, progress, note);
     await saveGoal(this.goalPath, updated, this.opts.events);
   }
   async persistEngineState(state) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     if (current.engineState === state) return;
     await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
@@ -17361,6 +17472,27 @@ var ParallelEternalEngine = class {
   agentFactory;
   dispatchEnabled;
   dispatchClassifier;
+  /**
+   * Emit a structured error. Uses the configured Logger when available;
+   * falls back to console.error(JSON) so events are never silently dropped.
+   */
+  logError(msg, ctx) {
+    if (this.opts.logger) {
+      this.opts.logger.error(msg, ctx);
+    } else {
+      console.error(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
+  }
+  /**
+   * Load the goal file with structured logging for parse/schema warnings.
+   */
+  loadGoal() {
+    return loadGoal(
+      this.goalPath,
+      this.opts.events,
+      this.opts.logger ? (msg) => this.opts.logger.warn(msg) : void 0
+    );
+  }
   get currentState() {
     return this.state;
   }
@@ -17373,13 +17505,10 @@ var ParallelEternalEngine = class {
   stop() {
     this.stopRequested = true;
     void this.persistState("stopped").catch((err) => {
-      console.error(JSON.stringify({
-        level: "error",
-        event: "engine.persist_state_failed",
-        message: toErrorMessage(err),
-        context: { expectedState: "stopped" },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Engine persist state failed",
+        { event: "engine.persist_state_failed", message: toErrorMessage(err), context: { expectedState: "stopped" } }
+      );
     });
     this.state = "stopped";
   }
@@ -17433,7 +17562,7 @@ var ParallelEternalEngine = class {
       this.opts.onStage?.(stage);
     };
     this.iterations++;
-    const goal = await loadGoal(this.goalPath, this.opts.events);
+    const goal = await this.loadGoal();
     if (!goal) {
       this.stopRequested = true;
       emit({ phase: "stopped" });
@@ -17577,13 +17706,10 @@ ${personaLine}Task: ${task}
             taskIds.push(taskId);
             await coordinator.assign(spec);
           } catch (err) {
-            console.error(JSON.stringify({
-              level: "warn",
-              event: "parallel_engine.spawn_failed",
-              message: toErrorMessage(err),
-              context: { slot: i, task, subagentId },
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            }));
+            this.logError(
+              "Parallel spawn failed",
+              { event: "parallel_engine.spawn_failed", message: toErrorMessage(err), context: { slot: i, task, subagentId } }
+            );
           }
         })()
       );
@@ -17609,13 +17735,10 @@ ${personaLine}Task: ${task}
         clearTimeout(timer);
       }
     } catch (err) {
-      console.error(JSON.stringify({
-        level: "warn",
-        event: "parallel_engine.brainstorm_results_failed",
-        message: toErrorMessage(err),
-        context: { slotCount, taskIds },
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logError(
+        "Brainstorm results failed",
+        { event: "parallel_engine.brainstorm_results_failed", message: toErrorMessage(err), context: { slotCount, taskIds } }
+      );
       results = coordinator.results().slice(-taskIds.length);
     }
     await Promise.allSettled(subagentIds.map((id) => coordinator.remove(id)));
@@ -17650,13 +17773,10 @@ ${personaLine}Task: ${task}
           }
         }
       } catch (err) {
-        console.error(JSON.stringify({
-          level: "warn",
-          event: "parallel_engine.git_status_failed",
-          message: toErrorMessage(err),
-          context: { projectRoot: this.opts.projectRoot },
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
+        this.logError(
+          "Git status failed",
+          { event: "parallel_engine.git_status_failed", message: toErrorMessage(err), context: { projectRoot: this.opts.projectRoot } }
+        );
       }
     }
     if (tasks.length < this.slots) {
@@ -17737,7 +17857,7 @@ ${lastFew}` : "No prior iterations.",
   // Helpers
   // -------------------------------------------------------------------------
   async appendIterationEntry(entry) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     const updated = appendJournal(current, entry);
     await saveGoal(this.goalPath, updated, this.opts.events);
@@ -17752,7 +17872,7 @@ ${lastFew}` : "No prior iterations.",
     await this.appendIterationEntry({ source: "manual", task, status: "failure", note });
   }
   async persistState(state) {
-    const current = await loadGoal(this.goalPath, this.opts.events);
+    const current = await this.loadGoal();
     if (!current) return;
     if (current.engineState === state) return;
     await saveGoal(this.goalPath, { ...current, engineState: state }, this.opts.events);
@@ -19991,12 +20111,12 @@ ${post.additionalContext}`;
       if (parentSignal.reason instanceof Error) throw parentSignal.reason;
       throw new Error(typeof parentSignal.reason === "string" ? parentSignal.reason : "aborted");
     }
-    const timeoutMs = clampTimeoutMs(
-      tool.timeoutMs ?? this.iterationTimeoutMs,
-      this.maxToolTimeoutMs
-    );
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    const combined = AbortSignal.any([parentSignal, timeoutSignal]);
+    const combined = tool.managesOwnTimeout ? parentSignal : AbortSignal.any([
+      parentSignal,
+      AbortSignal.timeout(
+        clampTimeoutMs(tool.timeoutMs ?? this.iterationTimeoutMs, this.maxToolTimeoutMs)
+      )
+    ]);
     let output;
     const toolPromise = typeof tool.executeStream === "function" ? this.runStreamedTool(tool, input, ctx, combined, toolUseId) : (async () => tool.execute(input, ctx, { signal: combined }))();
     toolPromise.catch(() => {
@@ -21960,34 +22080,35 @@ function wireMetricsToEvents(events, sink) {
         retryable: String(e.retryable)
       })
     ),
-    events.on("tool.started", (e) => sink.counter("tool.starts.total", 1, { tool: e.name })),
+    events.on(
+      "tool.started",
+      (e) => sink.counter("tool.starts.total", 1, { tool: metricToolName(e.name) })
+    ),
     events.on("tool.executed", (e) => {
-      sink.counter("tool.executions.total", 1, { tool: e.name, ok: String(e.ok) });
-      sink.histogram("tool.duration_ms", e.durationMs, { tool: e.name });
+      const tool = metricToolName(e.name);
+      sink.counter("tool.executions.total", 1, { tool, ok: String(e.ok) });
+      sink.histogram("tool.duration_ms", e.durationMs, { tool });
     }),
     events.on("token.threshold", (e) => sink.gauge("agent.tokens.used", e.used)),
     events.on("compaction.fired", (e) => {
       sink.counter("compaction.fired.total");
       sink.histogram("compaction.reduction_tokens", e.report.before - e.report.after);
     }),
-    events.on(
-      "mcp.server.connected",
-      (e) => sink.counter("mcp.connects.total", 1, { server: e.name })
-    ),
-    events.on(
-      "mcp.server.reconnected",
-      (e) => sink.counter("mcp.reconnects.total", 1, { server: e.name })
-    ),
-    events.on(
-      "mcp.server.disconnected",
-      (e) => sink.counter("mcp.disconnects.total", 1, { server: e.name })
-    ),
+    // MCP server names are user-controlled and may contain tenant/project
+    // identifiers. Keep them out of metric labels to bound cardinality and
+    // prevent operational metadata leaks.
+    events.on("mcp.server.connected", () => sink.counter("mcp.connects.total")),
+    events.on("mcp.server.reconnected", () => sink.counter("mcp.reconnects.total")),
+    events.on("mcp.server.disconnected", () => sink.counter("mcp.disconnects.total")),
     events.on("error", (e) => sink.counter("agent.errors.total", 1, { phase: e.phase }))
   );
   return () => {
     for (const u of unsubs) u();
   };
 }
+function metricToolName(name) {
+  return name.startsWith("mcp__") ? "mcp_proxy" : name;
+}
 
 // src/observability/prometheus.ts
 var NUMBER_FORMAT_INFINITY = "NaN";
@@ -22398,6 +22519,172 @@ function startOtlpTraceExporter(opts) {
 // src/security/permission-policy.ts
 import * as fs10 from "node:fs/promises";
 
+// src/security/permission-policy-schema.ts
+var TRUST_POLICY_LIMITS = Object.freeze({
+  maxTools: 1e3,
+  maxPatternsPerRule: 1e3,
+  maxToolNameChars: 256,
+  maxPatternChars: 4096
+});
+var TRUST_POLICY_JSON_SCHEMA = Object.freeze({
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://wrongstack.dev/schemas/trust-policy-v1.json",
+  title: "WrongStack Trust Policy",
+  type: "object",
+  maxProperties: TRUST_POLICY_LIMITS.maxTools,
+  propertyNames: {
+    minLength: 1,
+    maxLength: TRUST_POLICY_LIMITS.maxToolNameChars,
+    not: { enum: ["__proto__", "prototype", "constructor"] }
+  },
+  additionalProperties: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      allow: {
+        type: "array",
+        maxItems: TRUST_POLICY_LIMITS.maxPatternsPerRule,
+        items: { type: "string", minLength: 1, maxLength: TRUST_POLICY_LIMITS.maxPatternChars }
+      },
+      deny: {
+        type: "array",
+        maxItems: TRUST_POLICY_LIMITS.maxPatternsPerRule,
+        items: { type: "string", minLength: 1, maxLength: TRUST_POLICY_LIMITS.maxPatternChars }
+      },
+      auto: { type: "boolean" },
+      trustWorkdir: { type: "boolean" },
+      denyPrivate: { type: "boolean" }
+    }
+  }
+});
+var RULE_FIELDS = /* @__PURE__ */ new Set(["allow", "deny", "auto", "trustWorkdir", "denyPrivate"]);
+var UNSAFE_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function error(diagnostics, code, path29, message) {
+  diagnostics.push({ severity: "error", code, path: path29, message });
+}
+function validatePatterns(value, path29, diagnostics) {
+  if (!Array.isArray(value)) {
+    error(diagnostics, "invalid_pattern_list", path29, "must be an array of strings");
+    return void 0;
+  }
+  if (value.length > TRUST_POLICY_LIMITS.maxPatternsPerRule) {
+    error(
+      diagnostics,
+      "too_many_patterns",
+      path29,
+      `must contain at most ${TRUST_POLICY_LIMITS.maxPatternsPerRule} patterns`
+    );
+    return void 0;
+  }
+  const patterns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, pattern] of value.entries()) {
+    const itemPath = `${path29}[${index}]`;
+    if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > TRUST_POLICY_LIMITS.maxPatternChars) {
+      error(
+        diagnostics,
+        "invalid_pattern",
+        itemPath,
+        `must be a non-empty string up to ${TRUST_POLICY_LIMITS.maxPatternChars} characters`
+      );
+      continue;
+    }
+    if (seen.has(pattern)) {
+      diagnostics.push({
+        severity: "warning",
+        code: "duplicate_pattern",
+        path: itemPath,
+        message: "duplicates an earlier pattern and was normalized away"
+      });
+      continue;
+    }
+    seen.add(pattern);
+    patterns.push(pattern);
+  }
+  return patterns;
+}
+function validateTrustPolicy(value) {
+  const diagnostics = [];
+  if (!isRecord5(value)) {
+    return {
+      ok: false,
+      diagnostics: [
+        {
+          severity: "error",
+          code: "invalid_root",
+          path: "$",
+          message: "trust policy must be an object"
+        }
+      ]
+    };
+  }
+  const entries = Object.entries(value);
+  if (entries.length > TRUST_POLICY_LIMITS.maxTools) {
+    error(
+      diagnostics,
+      "too_many_tools",
+      "$",
+      `must contain at most ${TRUST_POLICY_LIMITS.maxTools} tool rules`
+    );
+  }
+  const policy = {};
+  for (const [toolName, rawRule] of entries.slice(0, TRUST_POLICY_LIMITS.maxTools)) {
+    const toolPath = `$[${JSON.stringify(toolName)}]`;
+    if (toolName.length === 0 || toolName.length > TRUST_POLICY_LIMITS.maxToolNameChars) {
+      error(
+        diagnostics,
+        "invalid_tool_name",
+        toolPath,
+        `tool name must be 1-${TRUST_POLICY_LIMITS.maxToolNameChars} characters`
+      );
+      continue;
+    }
+    if (UNSAFE_PROPERTY_NAMES.has(toolName)) {
+      error(
+        diagnostics,
+        "unsafe_tool_name",
+        toolPath,
+        "reserved object property names are not valid tool rules"
+      );
+      continue;
+    }
+    if (!isRecord5(rawRule)) {
+      error(diagnostics, "invalid_rule", toolPath, "tool rule must be an object");
+      continue;
+    }
+    for (const field of Object.keys(rawRule)) {
+      if (!RULE_FIELDS.has(field)) {
+        error(
+          diagnostics,
+          "unknown_field",
+          `${toolPath}.${field}`,
+          `unknown policy field "${field}"`
+        );
+      }
+    }
+    const rule = {};
+    for (const field of ["allow", "deny"]) {
+      if (rawRule[field] === void 0) continue;
+      const patterns = validatePatterns(rawRule[field], `${toolPath}.${field}`, diagnostics);
+      if (patterns) rule[field] = patterns;
+    }
+    for (const field of ["auto", "trustWorkdir", "denyPrivate"]) {
+      const setting = rawRule[field];
+      if (setting === void 0) continue;
+      if (typeof setting !== "boolean") {
+        error(diagnostics, "invalid_boolean", `${toolPath}.${field}`, "must be a boolean");
+      } else {
+        rule[field] = setting;
+      }
+    }
+    policy[toolName] = rule;
+  }
+  return diagnostics.some((diagnostic) => diagnostic.severity === "error") ? { ok: false, diagnostics } : { ok: true, policy, diagnostics };
+}
+
 // src/utils/lru-cache.ts
 var LruCache = class {
   store = /* @__PURE__ */ new Map();
@@ -22566,6 +22853,8 @@ var DefaultPermissionPolicy = class {
    * the LRU evicts the least-recently-used entries first.
    */
   _evalCache = new LruCache(500);
+  policyDiagnostics = [];
+  policyInvalid = false;
   constructor(opts) {
     this.trustFile = opts.trustFile;
     this.yolo = opts.yolo ?? false;
@@ -22609,13 +22898,50 @@ var DefaultPermissionPolicy = class {
   getConfirmDestructive() {
     return this.confirmDestructive;
   }
+  /** Read-only diagnostics for policy inspector/editor surfaces. */
+  getPolicyDiagnostics() {
+    return this.policyDiagnostics.map((diagnostic) => ({ ...diagnostic }));
+  }
   async reload() {
+    this.policyDiagnostics = [];
+    this.policyInvalid = false;
     try {
       const raw = await fs10.readFile(this.trustFile, "utf8");
       const parsed = safeParse(raw);
-      if (parsed.ok && parsed.value) this.policy = parsed.value;
-    } catch {
+      if (!parsed.ok) {
+        this.policy = {};
+        this.policyInvalid = true;
+        this.policyDiagnostics = [
+          {
+            severity: "error",
+            code: "invalid_json",
+            path: "$",
+            message: parsed.error ?? "trust policy is not valid JSON"
+          }
+        ];
+      } else {
+        const validation = validateTrustPolicy(parsed.value);
+        this.policyDiagnostics = validation.diagnostics;
+        if (validation.ok) {
+          this.policy = validation.policy;
+        } else {
+          this.policy = {};
+          this.policyInvalid = true;
+        }
+      }
+    } catch (err) {
       this.policy = {};
+      if (err.code !== "ENOENT") {
+        this.policyInvalid = true;
+        this.policyDiagnostics = [
+          {
+            severity: "error",
+            code: "read_error",
+            path: "$",
+            message: err instanceof Error ? err.message : String(err)
+          }
+        ];
+      }
     }
     this.wildcardEntries = [];
     for (const [key, val] of Object.entries(this.policy)) {
@@ -22628,6 +22954,13 @@ var DefaultPermissionPolicy = class {
   }
   async evaluate(tool, input, ctx) {
     if (!this.loaded) await this.reload();
+    if (this.policyInvalid) {
+      return {
+        permission: "deny",
+        source: "deny",
+        reason: "trust policy is invalid; refusing tool execution until it is repaired"
+      };
+    }
     const namespaceEntry = this.findNamespaceEntry(tool.name);
     const entry = this.policy[tool.name] ?? namespaceEntry;
     const subject = subjectForToolInput(tool.name, input, tool.subjectKey);
@@ -22757,6 +23090,9 @@ var DefaultPermissionPolicy = class {
   }
   async trust(rule) {
     if (!this.loaded) await this.reload();
+    if (this.policyInvalid) {
+      throw new Error("Cannot update trust rules while trust.json is invalid; repair it first.");
+    }
     const entry = this.policy[rule.tool] ?? {};
     entry.allow = Array.from(/* @__PURE__ */ new Set([...entry.allow ?? [], rule.pattern]));
     this.policy[rule.tool] = entry;
@@ -22775,6 +23111,9 @@ var DefaultPermissionPolicy = class {
   /** Persist a deny rule — this tool+pattern pair is permanently blocked. */
   async deny(rule) {
     if (!this.loaded) await this.reload();
+    if (this.policyInvalid) {
+      throw new Error("Cannot update deny rules while trust.json is invalid; repair it first.");
+    }
     const entry = this.policy[rule.tool] ?? {};
     entry.deny = Array.from(/* @__PURE__ */ new Set([...entry.deny ?? [], rule.pattern]));
     this.policy[rule.tool] = entry;
@@ -23178,31 +23517,40 @@ function unwrapDataKey(buf, keyFile) {
     });
   }
 }
-function checkKeyFilePermissions(keyFile) {
+function checkKeyFilePermissions(keyFile, opts) {
   if (process.platform === "win32") return;
+  const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
     const stat13 = fs11.statSync(keyFile);
     const actualMode = stat13.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "vault.key_file_wrong_permissions",
-        message: `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Run: chmod ${KEY_FILE_MODE.toString(8)} ${keyFile}`,
-        keyFile,
-        expectedMode: KEY_FILE_MODE,
-        actualMode,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      warn(
+        `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Run: chmod ${KEY_FILE_MODE.toString(8)} ${keyFile}`
+      );
     }
   } catch {
   }
 }
 var DefaultSecretVault = class {
   keyFile;
+  logger;
   key;
   _keyVersion = 1;
   constructor(opts) {
     this.keyFile = opts.keyFile;
+    this.logger = opts.logger;
+  }
+  /**
+   * Emit a structured warning. Uses the configured Logger when available;
+   * falls back to console.warn(JSON) so warnings are never silently dropped
+   * during early boot.
+   */
+  logWarn(msg, ctx) {
+    if (this.logger) {
+      this.logger.warn(msg, ctx);
+    } else {
+      console.warn(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
   }
   /** Current key version. Starts at 1; incremented by rotateKey(). */
   get keyVersion() {
@@ -23281,7 +23629,7 @@ var DefaultSecretVault = class {
       newKey.copy(keyFileBuf, KEY_FILE_MAGIC.length + 1);
       fs11.writeFileSync(this.keyFile, keyFileBuf, { mode: 384 });
     }
-    checkKeyFilePermissions(this.keyFile);
+    checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
     this.key = newKey;
     this._keyVersion = newVersion;
     return { oldVersion, newVersion };
@@ -23300,7 +23648,7 @@ var DefaultSecretVault = class {
       fs11.writeFileSync(this.keyFile, wrapDataKey(this.key, this._keyVersion, passphrase), {
         mode: 384
       });
-      checkKeyFilePermissions(this.keyFile);
+      checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
     } catch {
     }
   }
@@ -23312,13 +23660,13 @@ var DefaultSecretVault = class {
         const { key: key2, version } = unwrapDataKey(buf, this.keyFile);
         this.key = key2;
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile);
+        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
         return this.key;
       }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
-        checkKeyFilePermissions(this.keyFile);
+        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
         this.migrateToWrappedIfPassphrase();
         return this.key;
       }
@@ -23342,7 +23690,7 @@ var DefaultSecretVault = class {
         }
         this.key = Buffer.from(key2);
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile);
+        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
         this.migrateToWrappedIfPassphrase();
         return this.key;
       }
@@ -23367,13 +23715,13 @@ var DefaultSecretVault = class {
         const { key: winnerKey, version } = unwrapDataKey(buf, this.keyFile);
         this.key = winnerKey;
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile);
+        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
         return this.key;
       }
       if (buf.length === KEY_BYTES) {
         this.key = buf;
         this._keyVersion = 1;
-        checkKeyFilePermissions(this.keyFile);
+        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
         return this.key;
       }
       if (buf.length === VERSIONED_KEY_FILE_SIZE) {
@@ -23389,7 +23737,7 @@ var DefaultSecretVault = class {
         const winnerKey = buf.subarray(KEY_FILE_MAGIC.length + 1);
         this.key = Buffer.from(winnerKey);
         this._keyVersion = version;
-        checkKeyFilePermissions(this.keyFile);
+        checkKeyFilePermissions(this.keyFile, { warn: (msg) => this.logWarn(msg) });
         return this.key;
       }
       throw new ConfigError({
@@ -23944,6 +24292,10 @@ var KNOWN_DENIED_IN_PROJECT = [
     key: "fleet",
     reason: "Fleet supervision knobs: a repo-committed config could enable autonomous subagent spawning/steering/termination and mailbox traffic on the victim machine."
   },
+  {
+    key: "brain",
+    reason: "Brain decision-layer knobs: a repo-committed config could raise the autonomy risk ceiling, switch the Brain to headless (removing the human tier), or reroute Brain decisions to an attacker-chosen provider/model."
+  },
   {
     key: "git",
     reason: "Carries git.identity (GIT_AUTHOR_*/GIT_COMMITTER_* injection): a repo-committed config could spoof the author identity written into the victim's commit history (impersonation)."
@@ -23992,6 +24344,7 @@ var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "extensions",
   "acp",
   "fleet",
+  "brain",
   "git"
 ]);
 function assertInProjectAllowListComplete() {
@@ -24143,6 +24496,7 @@ var DefaultConfigLoader = class {
   extraSources;
   events;
   traceId;
+  logger;
   jsonCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.paths = opts.paths;
@@ -24151,6 +24505,19 @@ var DefaultConfigLoader = class {
     this.extraSources = opts.sources ?? [];
     this.events = opts.events;
     this.traceId = opts.traceId;
+    this.logger = opts.logger;
+  }
+  /**
+   * Emit a structured warning. Uses the configured Logger when available;
+   * falls back to console.warn(JSON) so warnings are never silently dropped
+   * during early boot (before a Logger is constructed).
+   */
+  logWarn(msg, ctx) {
+    if (this.logger) {
+      this.logger.warn(msg, ctx);
+    } else {
+      console.warn(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
   }
   async load(opts = {}) {
     let cfg = { ...BEHAVIOR_DEFAULTS };
@@ -24163,7 +24530,14 @@ var DefaultConfigLoader = class {
     ]);
     cfg = deepMerge2(cfg, global);
     cfg = deepMerge2(cfg, local);
-    cfg = deepMerge2(cfg, stripUnsafeInProjectFields(inProject, this.paths.inProjectConfig));
+    cfg = deepMerge2(
+      cfg,
+      stripUnsafeInProjectFields(
+        inProject,
+        this.paths.inProjectConfig,
+        this.logger ? (msg) => this.logger.warn(msg) : void 0
+      )
+    );
     for (const [key, fn] of Object.entries(ENV_MAP)) {
       const v = process.env[key];
       if (v) fn(cfg, v);
@@ -24180,14 +24554,9 @@ var DefaultConfigLoader = class {
           cfg = deepMerge2(cfg, patch);
         }
       } catch (err) {
-        console.warn(
-          JSON.stringify({
-            level: "warn",
-            event: "config.source_load_failed",
-            source: src.name,
-            message: toErrorMessage(err),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          })
+        this.logWarn(
+          "Config source load failed",
+          { event: "config.source_load_failed", source: src.name, message: toErrorMessage(err) }
         );
       }
     }
@@ -24247,14 +24616,9 @@ var DefaultConfigLoader = class {
               durationMs: Date.now() - t0,
               ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
             });
-            console.warn(
-              JSON.stringify({
-                level: "warn",
-                event: "config.defaults_read_failed",
-                path: fp,
-                message: toErrorMessage(err),
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              })
+            this.logWarn(
+              "Config defaults read failed",
+              { event: "config.defaults_read_failed", path: fp, message: toErrorMessage(err) }
             );
             return;
           }
@@ -24288,14 +24652,9 @@ var DefaultConfigLoader = class {
         durationMs: Date.now() - t0,
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "config.defaults_write_failed",
-          path: fp,
-          message: toErrorMessage(err),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
+      this.logWarn(
+        "Config defaults write failed",
+        { event: "config.defaults_write_failed", path: fp, message: toErrorMessage(err) }
       );
     }
   }
@@ -24398,13 +24757,9 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "config.sync_load_failed",
-          message: toErrorMessage(err),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
+      this.logWarn(
+        "Config sync load failed",
+        { event: "config.sync_load_failed", message: toErrorMessage(err) }
       );
       return null;
     }
@@ -24434,14 +24789,9 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "config.read_failed",
-          path: file,
-          message: toErrorMessage(err),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
+      this.logWarn(
+        "Config read failed (stat)",
+        { event: "config.read_failed", path: file, message: toErrorMessage(err) }
       );
       return {};
     }
@@ -24460,14 +24810,9 @@ var DefaultConfigLoader = class {
           error: storageErrorString(err),
           ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
         });
-        console.warn(
-          JSON.stringify({
-            level: "warn",
-            event: "config.read_failed",
-            path: file,
-            message: toErrorMessage(err),
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          })
+        this.logWarn(
+          "Config read failed (read)",
+          { event: "config.read_failed", path: file, message: toErrorMessage(err) }
         );
       }
       this.jsonCache.set(file, { mtimeMs: null, value: {} });
@@ -24485,14 +24830,9 @@ var DefaultConfigLoader = class {
         error: "parse error or empty file",
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      console.warn(
-        JSON.stringify({
-          level: "warn",
-          event: "config.parse_failed",
-          path: file,
-          message: "invalid JSON \u2014 falling back to defaults for this layer",
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        })
+      this.logWarn(
+        "Config parse failed \u2014 falling back to defaults",
+        { event: "config.parse_failed", path: file }
       );
       return {};
     }
@@ -24539,8 +24879,9 @@ var DefaultConfigLoader = class {
     }
     if (c.mode !== void 0 && !isContextWindowModeId(c.mode)) {
       const known = listContextWindowModes().map((m) => m.id).join(", ");
-      console.warn(
-        `[config] Ignoring unknown context.mode "${c.mode}" (expected one of: ${known}); falling back to "${DEFAULT_CONTEXT_WINDOW_MODE_ID}".`
+      this.logWarn(
+        `Ignoring unknown context.mode "${c.mode}" \u2014 falling back to "${DEFAULT_CONTEXT_WINDOW_MODE_ID}"`,
+        { event: "config.unknown_context_mode", mode: c.mode, known }
       );
       c.mode = DEFAULT_CONTEXT_WINDOW_MODE_ID;
     }
@@ -25670,7 +26011,7 @@ async function loadPlan(filePath, events) {
     return null;
   }
 }
-async function savePlan(filePath, plan, events) {
+async function savePlan(filePath, plan, events, warn) {
   const t0 = Date.now();
   try {
     await atomicWrite(filePath, JSON.stringify(plan, null, 2), { mode: 384 });
@@ -25692,10 +26033,14 @@ async function savePlan(filePath, plan, events) {
       error: toErrorMessage(err),
       recoverable: false
     });
-    console.warn(
-      "[plan-store] save failed:",
-      toErrorMessage(err)
-    );
+    (warn ?? ((m) => console.warn(
+      JSON.stringify({
+        level: "warn",
+        event: "plan_store.save_failed",
+        message: m,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    )))(toErrorMessage(err));
     return false;
   }
 }
@@ -25736,9 +26081,7 @@ function setPlanItemStatus(plan, idOrIndex, status) {
   const idx = matchIndex(plan, idOrIndex);
   if (idx === -1) return plan;
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const items = plan.items.map(
-    (it, i) => i === idx ? { ...it, status, updatedAt: now } : it
-  );
+  const items = plan.items.map((it, i) => i === idx ? { ...it, status, updatedAt: now } : it);
   return { ...plan, items, updatedAt: now };
 }
 function clearPlan(plan) {
@@ -25920,10 +26263,19 @@ var QueueStore = class {
   // reject assigning an optional constructor parameter to these fields.
   events;
   traceId;
+  logger;
   constructor(opts) {
     this.file = path27.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
+    this.logger = opts.logger;
+  }
+  logWarn(msg, ctx) {
+    if (this.logger) {
+      this.logger.warn(msg, ctx);
+    } else {
+      console.warn(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
   }
   async write(items) {
     const t0 = Date.now();
@@ -25953,13 +26305,7 @@ var QueueStore = class {
         recoverable: false,
         ...this.traceId !== void 0 && { traceId: this.traceId }
       });
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "queue_store.write_failed",
-        path: this.file,
-        message: toErrorMessage(err),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logWarn("Queue store write failed", { event: "queue_store.write_failed", path: this.file, message: toErrorMessage(err) });
     }
   }
   async read() {
@@ -25991,13 +26337,7 @@ var QueueStore = class {
         recoverable: true,
         ...this.traceId !== void 0 && { traceId: this.traceId }
       });
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "queue_store.read_failed",
-        path: this.file,
-        message: toErrorMessage(err),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logWarn("Queue store read failed", { event: "queue_store.read_failed", path: this.file, message: toErrorMessage(err) });
       return [];
     }
     let parsed;
@@ -26070,13 +26410,7 @@ var QueueStore = class {
         recoverable: true,
         ...this.traceId !== void 0 && { traceId: this.traceId }
       });
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "queue_store.clear_failed",
-        path: this.file,
-        message: err.message,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      this.logWarn("Queue store clear failed", { event: "queue_store.clear_failed", path: this.file, message: err.message });
     }
   }
 };
@@ -26888,7 +27222,7 @@ async function loadTodosCheckpoint(filePath, events, traceId) {
     return null;
   }
 }
-async function saveTodosCheckpoint(filePath, sessionId, todos, events, traceId) {
+async function saveTodosCheckpoint(filePath, sessionId, todos, events, traceId, warn) {
   const t0 = Date.now();
   const payload = {
     version: 1,
@@ -26917,28 +27251,17 @@ async function saveTodosCheckpoint(filePath, sessionId, todos, events, traceId)
       error: toErrorMessage(err),
       recoverable: false
     });
-    console.warn(JSON.stringify({
-      level: "warn",
-      event: "todos_checkpoint.save_failed",
-      message: toErrorMessage(err),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }));
+    (warn ?? ((m) => console.warn(JSON.stringify({ level: "warn", event: "todos_checkpoint.save_failed", message: m, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(toErrorMessage(err));
   }
 }
-function attachTodosCheckpoint(state, filePath, sessionId, events, traceId) {
+function attachTodosCheckpoint(state, filePath, sessionId, events, traceId, warn) {
   let timer = null;
   let pending = null;
   let writeChain = Promise.resolve();
   const enqueueWrite = (todos) => {
     writeChain = writeChain.then(() => saveTodosCheckpoint(filePath, sessionId, todos, events, traceId)).catch((err) => {
       const msg = toErrorMessage(err);
-      console.error(JSON.stringify({
-        level: "error",
-        event: "todos_checkpoint.write_chain_failed",
-        sessionId,
-        message: msg,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      (warn ?? ((m) => console.error(JSON.stringify({ level: "error", event: "todos_checkpoint.write_chain_failed", sessionId, message: m, timestamp: (/* @__PURE__ */ new Date()).toISOString() }))))(msg);
     });
     return writeChain;
   };