opencode-orchestrator 1.2.71 → 1.3.4

package/dist/index.js

@@ -37,28 +37,11 @@ var init_names = __esm({
   }
 });
 
-// src/shared/agent/constants/agent-tokens.ts
-var AGENT_TOKENS;
-var init_agent_tokens = __esm({
-  "src/shared/agent/constants/agent-tokens.ts"() {
-    "use strict";
-    AGENT_TOKENS = {
-      /** Primary agent (Commander) max tokens */
-      PRIMARY_MAX_TOKENS: 64e3,
-      /** Primary agent thinking budget */
-      PRIMARY_THINKING_BUDGET: 32e3,
-      /** Subagent max tokens */
-      SUBAGENT_MAX_TOKENS: 32e3
-    };
-  }
-});
-
 // src/shared/agent/constants/index.ts
 var init_constants = __esm({
   "src/shared/agent/constants/index.ts"() {
     "use strict";
     init_names();
-    init_agent_tokens();
   }
 });
 
@@ -1903,10 +1886,14 @@ var init_plugin_hooks = __esm({
     PLUGIN_HOOKS = {
       /** Intercepts user messages before sending to LLM */
       CHAT_MESSAGE: "chat.message",
-      /** Runs after LLM finishes responding */
-      ASSISTANT_DONE: "assistant.done",
+      /** Runs before any tool call */
+      TOOL_EXECUTE_BEFORE: "tool.execute.before",
       /** Runs after any tool call completes */
-      TOOL_EXECUTE_AFTER: "tool.execute.after"
+      TOOL_EXECUTE_AFTER: "tool.execute.after",
+      /** Preserves custom compaction context */
+      EXPERIMENTAL_SESSION_COMPACTING: "experimental.session.compacting",
+      /** Injects dynamic system prompt additions */
+      EXPERIMENTAL_CHAT_SYSTEM_TRANSFORM: "experimental.chat.system.transform"
     };
   }
 });
@@ -4733,9 +4720,10 @@ You are ${AGENT_NAMES.COMMANDER}. Autonomous mission controller.
 - You ADAPT your approach to what the project requires
 
 ## \u{1F680} AUTONOMOUS EXECUTION MODE
-- Complete the ENTIRE mission without asking questions
+- Complete the ENTIRE mission without routine user hand-holding
 - Make decisions yourself - don't present options to user
 - If uncertain, make the BEST choice and proceed
+- Ask a concise clarification only when truly blocked and the OpenCode question permission allows it
 - Conclude ONLY after ${AGENT_NAMES.REVIEWER} verifies the full system
 - Only stop when everything is verified or truly blocked
 ${PROMPT_TAGS.ROLE.close}`;
@@ -5510,6 +5498,9 @@ var ConcurrencyToken = class {
     }, autoReleaseMs);
     this.autoReleaseTimer.unref();
   }
+  controller;
+  key;
+  autoReleaseMs;
   released = false;
   autoReleaseTimer = null;
   /**
@@ -5853,6 +5844,12 @@ var ConcurrencyController = class {
   constructor(config3) {
     this.config = config3 ?? {};
   }
+  configure(config3) {
+    this.config = config3;
+  }
+  getConfig() {
+    return this.config;
+  }
   setLimit(key, limit) {
     this.limits.set(key, limit);
   }
@@ -7779,7 +7776,7 @@ function $constructor(name, initializer5, params) {
   Object.defineProperty(_, "name", { value: name });
   return _;
 }
-var $brand = Symbol("zod_brand");
+var $brand = /* @__PURE__ */ Symbol("zod_brand");
 var $ZodAsyncError = class extends Error {
   constructor() {
     super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
@@ -7966,10 +7963,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path10) {
-  if (!path10)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8378,11 +8375,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path10, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -8529,16 +8526,16 @@ function flattenError(error95, mapper = (issue3) => issue3.message) {
 }
 function formatError(error95, mapper = (issue3) => issue3.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error96, path10 = []) => {
+  const processError = (error96, path11 = []) => {
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path10, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path11, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path11, ...issue3.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue3));
         } else {
@@ -8565,17 +8562,17 @@ function formatError(error95, mapper = (issue3) => issue3.message) {
 }
 function treeifyError(error95, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error96, path10 = []) => {
+  const processError = (error96, path11 = []) => {
     var _a3, _b;
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path10, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path11, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path11, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -8607,8 +8604,8 @@ function treeifyError(error95, mapper = (issue3) => issue3.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17522,8 +17519,8 @@ function yo_default() {
 
 // node_modules/zod/v4/core/registries.js
 var _a2;
-var $output = Symbol("ZodOutput");
-var $input = Symbol("ZodInput");
+var $output = /* @__PURE__ */ Symbol("ZodOutput");
+var $input = /* @__PURE__ */ Symbol("ZodInput");
 var $ZodRegistry = class {
   constructor() {
     this._map = /* @__PURE__ */ new WeakMap();
@@ -18560,7 +18557,7 @@ function _stringbool(Classes, _params) {
     type: "pipe",
     in: stringSchema,
     out: booleanSchema,
-    transform: (input, payload) => {
+    transform: ((input, payload) => {
       let data = input;
       if (params.case !== "sensitive")
         data = data.toLowerCase();
@@ -18579,14 +18576,14 @@ function _stringbool(Classes, _params) {
         });
         return {};
       }
-    },
-    reverseTransform: (input, _payload) => {
+    }),
+    reverseTransform: ((input, _payload) => {
       if (input === true) {
         return truthyArray[0] || "true";
       } else {
         return falsyArray[0] || "false";
       }
-    },
+    }),
     error: params.error
   });
   return codec3;
@@ -21300,13 +21297,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path10 = ref.slice(1).split("/").filter(Boolean);
-  if (path10.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path10[0] === defsKey) {
-    const key = path10[1];
+  if (path11[0] === defsKey) {
+    const key = path11[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -21723,9 +21720,6 @@ var AgentDefinitionSchema = external_exports.object({
   mode: external_exports.enum(["primary", "subagent"]).optional(),
   color: external_exports.string().optional(),
   hidden: external_exports.boolean().optional(),
-  thinking: external_exports.boolean().optional(),
-  maxTokens: external_exports.number().optional(),
-  budgetTokens: external_exports.number().optional(),
   canWrite: external_exports.boolean(),
   // Required per interface
   canBash: external_exports.boolean()
@@ -21782,7 +21776,7 @@ var AgentRegistry = class _AgentRegistry {
         for (const [name, def] of Object.entries(customAgents)) {
           const result = AgentDefinitionSchema.safeParse(def);
           if (result.success) {
-            this.registerAgent(name, def);
+            this.registerAgent(name, result.data);
           } else {
             log(`[AgentRegistry] Invalid custom agent definition for: ${name}. Errors: ${result.error.message}`);
           }
@@ -21808,6 +21802,13 @@ var TaskLauncher = class {
     this.onTaskError = onTaskError;
     this.startPolling = startPolling;
   }
+  client;
+  directory;
+  store;
+  concurrency;
+  sessionPool;
+  onTaskError;
+  startPolling;
   /**
    * Unified launch method - handles both single and multiple tasks efficiently.
    * All session creations happen in parallel immediately.
@@ -21977,6 +21978,11 @@ var TaskResumer = class {
     this.startPolling = startPolling;
     this.notifyParentIfAllComplete = notifyParentIfAllComplete;
   }
+  client;
+  store;
+  findBySession;
+  startPolling;
+  notifyParentIfAllComplete;
   async resume(input) {
     const existingTask = this.findBySession(input.sessionId);
     if (!existingTask) {
@@ -22131,6 +22137,13 @@ var TaskPoller = class {
     this.pruneExpiredTasks = pruneExpiredTasks;
     this.onTaskComplete = onTaskComplete;
   }
+  client;
+  store;
+  concurrency;
+  notifyParentIfAllComplete;
+  scheduleCleanup;
+  pruneExpiredTasks;
+  onTaskComplete;
   pollingInterval;
   messageCache = /* @__PURE__ */ new Map();
   // Adaptive polling
@@ -22335,6 +22348,10 @@ var TaskCleaner = class {
     this.concurrency = concurrency;
     this.sessionPool = sessionPool2;
   }
+  client;
+  store;
+  concurrency;
+  sessionPool;
   pruneExpiredTasks() {
     const now = Date.now();
     for (const [taskId, task] of this.store.getAll().map((t) => [t.id, t])) {
@@ -22450,6 +22467,14 @@ var EventHandler = class {
     this.validateSessionHasOutput = validateSessionHasOutput2;
     this.onTaskComplete = onTaskComplete;
   }
+  client;
+  store;
+  concurrency;
+  findBySession;
+  notifyParentIfAllComplete;
+  scheduleCleanup;
+  validateSessionHasOutput;
+  onTaskComplete;
   /**
    * Handle OpenCode session events for proper resource cleanup.
    * Call this from your plugin's event hook.
@@ -22955,7 +22980,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
   store = new TaskStore();
   client;
   directory;
-  concurrency = new ConcurrencyController();
+  concurrency;
   sessionPool;
   // Composed components
   launcher;
@@ -22963,9 +22988,10 @@ var ParallelAgentManager = class _ParallelAgentManager {
   poller;
   cleaner;
   eventHandler;
-  constructor(client, directory) {
+  constructor(client, directory, concurrencyConfig) {
     this.client = client;
     this.directory = directory;
+    this.concurrency = new ConcurrencyController(concurrencyConfig);
     const memory = MemoryManager.getInstance();
     memory.add("system" /* SYSTEM */, CORE_PHILOSOPHY, 1);
     memory.add("project" /* PROJECT */, `Working directory: ${directory}`, 0.9);
@@ -23017,12 +23043,12 @@ var ParallelAgentManager = class _ParallelAgentManager {
       log("Recovery error:", err);
     });
   }
-  static getInstance(client, directory) {
+  static getInstance(client, directory, concurrencyConfig) {
     if (!_ParallelAgentManager._instance) {
       if (!client || !directory) {
         throw new Error("ParallelAgentManager requires client and directory on first call");
       }
-      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory);
+      _ParallelAgentManager._instance = new _ParallelAgentManager(client, directory, concurrencyConfig);
     }
     return _ParallelAgentManager._instance;
   }
@@ -23091,6 +23117,9 @@ var ParallelAgentManager = class _ParallelAgentManager {
   setConcurrencyLimit(agentType, limit) {
     this.concurrency.setLimit(agentType, limit);
   }
+  configureConcurrency(config3) {
+    this.concurrency.configure(config3);
+  }
   getPendingCount(parentSessionID) {
     return this.store.getPendingCount(parentSessionID);
   }
@@ -23719,7 +23748,7 @@ function $constructor2(name, initializer5, params) {
   Object.defineProperty(_, "name", { value: name });
   return _;
 }
-var $brand2 = Symbol("zod_brand");
+var $brand2 = /* @__PURE__ */ Symbol("zod_brand");
 var $ZodAsyncError2 = class extends Error {
   constructor() {
     super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
@@ -23864,7 +23893,7 @@ function floatSafeRemainder2(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-var EVALUATING2 = Symbol("evaluating");
+var EVALUATING2 = /* @__PURE__ */ Symbol("evaluating");
 function defineLazy2(object3, key, getter) {
   let value = void 0;
   Object.defineProperty(object3, key, {
@@ -23909,10 +23938,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path10) {
-  if (!path10)
+function getElementAtPath2(obj, path11) {
+  if (!path11)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -24273,11 +24302,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path10, issues) {
+function prefixIssues2(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -24445,7 +24474,7 @@ function treeifyError2(error95, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error96, path10 = []) => {
+  const processError = (error96, path11 = []) => {
     var _a3, _b;
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -24455,7 +24484,7 @@ function treeifyError2(error95, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path11, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -24487,8 +24516,8 @@ function treeifyError2(error95, _mapper) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -32709,8 +32738,8 @@ function yo_default2() {
 }
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/core/registries.js
-var $output2 = Symbol("ZodOutput");
-var $input2 = Symbol("ZodInput");
+var $output2 = /* @__PURE__ */ Symbol("ZodOutput");
+var $input2 = /* @__PURE__ */ Symbol("ZodInput");
 var $ZodRegistry2 = class {
   constructor() {
     this._map = /* @__PURE__ */ new WeakMap();
@@ -33593,7 +33622,7 @@ function _stringbool2(Classes, _params) {
     type: "pipe",
     in: stringSchema,
     out: booleanSchema,
-    transform: (input, payload) => {
+    transform: ((input, payload) => {
       let data = input;
       if (params.case !== "sensitive")
         data = data.toLowerCase();
@@ -33612,14 +33641,14 @@ function _stringbool2(Classes, _params) {
         });
         return {};
       }
-    },
-    reverseTransform: (input, _payload) => {
+    }),
+    reverseTransform: ((input, _payload) => {
       if (input === true) {
         return truthyArray[0] || "true";
       } else {
         return falsyArray[0] || "false";
       }
-    },
+    }),
     error: params.error
   });
   return codec3;
@@ -34579,10 +34608,10 @@ var ZodType2 = /* @__PURE__ */ $constructor2("ZodType", (inst, def) => {
   };
   inst.clone = (def2, params) => clone2(inst, def2, params);
   inst.brand = () => inst;
-  inst.register = (reg, meta3) => {
+  inst.register = ((reg, meta3) => {
     reg.add(inst, meta3);
     return inst;
-  };
+  });
   inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse4(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync4(inst, data, params, { callee: inst.parseAsync });
@@ -36409,8 +36438,8 @@ init_logger();
 // src/core/loop/mission-loop.ts
 init_logger();
 init_shared();
-import { existsSync as existsSync2, readFileSync, writeFileSync, unlinkSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // src/shared/constants/system-messages.ts
 init_mission_control();
@@ -36518,19 +36547,199 @@ You must maintain a pristine workspace. **As part of your move**, perform these
 </system_maintenance>
 `;
 
+// src/core/knowledge/mission-memory.ts
+init_shared();
+import { mkdirSync as mkdirSync3, renameSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
+
+// src/core/loop/mission-ledger.ts
+init_shared();
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync } from "node:fs";
+import { join as join4 } from "node:path";
+import { randomUUID } from "node:crypto";
+
+// src/core/loop/mission-runtime-options.ts
+var DEFAULT_MISSION_RUNTIME_OPTIONS = {
+  ledger: true,
+  markdownMemory: true,
+  maxEvidenceEvents: 20
+};
+var runtimeOptions = { ...DEFAULT_MISSION_RUNTIME_OPTIONS };
+function configureMissionRuntimeOptions(options) {
+  runtimeOptions = { ...DEFAULT_MISSION_RUNTIME_OPTIONS, ...options };
+}
+function getMissionRuntimeOptions() {
+  return runtimeOptions;
+}
+
+// src/core/loop/mission-ledger.ts
+var LEDGER_FILE = "mission-ledger.jsonl";
+function getMissionLedgerPath(directory) {
+  return join4(directory, PATHS.OPENCODE, LEDGER_FILE);
+}
+function appendMissionLedgerEvent(directory, input) {
+  if (!getMissionRuntimeOptions().ledger) return null;
+  const event = {
+    id: randomUUID(),
+    timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    type: input.type,
+    sessionID: input.sessionID,
+    iteration: input.iteration,
+    objective: input.objective,
+    summary: input.summary,
+    reason: input.reason
+  };
+  try {
+    const ledgerPath = getMissionLedgerPath(directory);
+    mkdirSync2(join4(directory, PATHS.OPENCODE), { recursive: true });
+    appendFileSync(ledgerPath, `${JSON.stringify(event)}
+`, "utf8");
+    return event;
+  } catch {
+    return null;
+  }
+}
+function readMissionLedger(directory, limit = 20) {
+  const options = getMissionRuntimeOptions();
+  if (!options.ledger) return [];
+  const ledgerPath = getMissionLedgerPath(directory);
+  if (!existsSync2(ledgerPath)) return [];
+  try {
+    const lines = readFileSync(ledgerPath, "utf8").split(/\r?\n/).filter(Boolean);
+    const maxEvents = Math.max(1, Math.min(limit, options.maxEvidenceEvents));
+    return lines.slice(Math.max(0, lines.length - maxEvents)).map(parseLedgerLine).filter((event) => event !== null);
+  } catch {
+    return [];
+  }
+}
+function parseLedgerLine(line) {
+  try {
+    const value = JSON.parse(line);
+    if (!value.id || !value.type || !value.timestamp || !value.sessionID) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/knowledge/mission-memory.ts
+var BRAIN_DIR = join5(PATHS.DOCS, "brain");
+var SCRATCHPAD_FILE = "scratchpad.md";
+var CANVAS_FILE = "knowledge-map.canvas";
+var MAX_CANVAS_EVENTS = 3;
+var MAX_SCRATCHPAD_EVENTS = 6;
+function syncMissionMemory(directory, state2) {
+  const options = getMissionRuntimeOptions();
+  if (!options.markdownMemory) return false;
+  const events = readMissionLedger(
+    directory,
+    Math.min(MAX_SCRATCHPAD_EVENTS, options.maxEvidenceEvents)
+  );
+  try {
+    writeScratchpad(directory, state2, events);
+    writeCanvas(directory, state2, events);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getMissionScratchpadPath(directory) {
+  return join5(directory, BRAIN_DIR, SCRATCHPAD_FILE);
+}
+function getMissionCanvasPath(directory) {
+  return join5(directory, BRAIN_DIR, CANVAS_FILE);
+}
+function writeScratchpad(directory, state2, events) {
+  const content = [
+    "---",
+    "tags: [scratchpad, mission, orchestrator]",
+    "keep: true",
+    `title: "${escapeYaml(state2.objective ?? "Active Mission")}"`,
+    "---",
+    "# Orchestrator Mission Scratchpad",
+    "",
+    "## Focus",
+    `- Objective: ${state2.objective ?? state2.prompt}`,
+    `- Session: ${state2.sessionID}`,
+    `- Status: ${state2.active ? "active" : "inactive"}`,
+    `- Iteration: ${state2.iteration}/${state2.maxIterations}`,
+    "",
+    "## Runtime State",
+    `- Last progress: ${state2.lastProgress ?? "unknown"}`,
+    `- Last verification: ${state2.lastVerificationSummary ?? "unknown"}`,
+    `- Last continuation reason: ${state2.lastContinuationReason ?? "unknown"}`,
+    "",
+    "## Recent Evidence",
+    ...formatEventLines(events),
+    "",
+    "## Open Questions",
+    "- Keep this section short; unresolved blockers should be reflected in TODO or sync issues.",
+    ""
+  ].join("\n");
+  atomicWrite(getMissionScratchpadPath(directory), content);
+}
+function writeCanvas(directory, state2, events) {
+  const nodes = buildCanvasNodes(state2, events);
+  const edges = buildCanvasEdges(nodes);
+  atomicWrite(getMissionCanvasPath(directory), JSON.stringify({ nodes, edges }, null, 2));
+}
+function buildCanvasNodes(state2, events) {
+  const nodes = [
+    textNode("objective", `Objective
+${state2.objective ?? state2.prompt}`, 0, 0),
+    textNode("runtime", `Runtime
+Iteration ${state2.iteration}/${state2.maxIterations}
+Progress ${state2.lastProgress ?? "unknown"}`, 420, 0),
+    textNode("verification", `Verification
+${state2.lastVerificationSummary ?? "unknown"}`, 840, 0)
+  ];
+  events.slice(-MAX_CANVAS_EVENTS).forEach((event, index) => {
+    nodes.push(textNode(`event-${index}`, `${event.type}
+${event.summary ?? event.reason ?? event.timestamp}`, 420 * index, 260));
+  });
+  return nodes;
+}
+function buildCanvasEdges(nodes) {
+  const edges = [
+    { id: "objective-runtime", fromNode: "objective", toNode: "runtime", label: "drives" },
+    { id: "runtime-verification", fromNode: "runtime", toNode: "verification", label: "checks" }
+  ];
+  for (const node of nodes.filter((item) => item.id.startsWith("event-"))) {
+    edges.push({ id: `verification-${node.id}`, fromNode: "verification", toNode: node.id, label: "evidence" });
+  }
+  return edges;
+}
+function textNode(id, text, x, y) {
+  return { id, type: "text", text, x, y, width: 360, height: 180 };
+}
+function formatEventLines(events) {
+  if (events.length === 0) return ["- No runtime evidence recorded yet."];
+  return events.map((event) => `- ${event.timestamp} ${event.type}: ${event.summary ?? event.reason ?? "recorded"}`);
+}
+function atomicWrite(path11, content) {
+  mkdirSync3(dirname2(path11), { recursive: true });
+  const tempPath = `${path11}.tmp`;
+  writeFileSync(tempPath, content, "utf8");
+  renameSync(tempPath, path11);
+}
+function escapeYaml(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
 // src/core/loop/mission-loop.ts
 var STATE_FILE = MISSION_CONTROL.STATE_FILE;
 var DEFAULT_MAX_ITERATIONS = MISSION_CONTROL.DEFAULT_MAX_ITERATIONS;
+var UNKNOWN_STATUS = "unknown";
 function getStateFilePath(directory) {
-  return join4(directory, PATHS.OPENCODE, STATE_FILE);
+  return join6(directory, PATHS.OPENCODE, STATE_FILE);
 }
 function readLoopState(directory) {
   const filePath = getStateFilePath(directory);
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync2(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error95) {
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Failed to read state: ${error95}`);
@@ -36539,12 +36748,12 @@ function readLoopState(directory) {
 }
 function writeLoopState(directory, state2) {
   const filePath = getStateFilePath(directory);
-  const dirPath = join4(directory, PATHS.OPENCODE);
+  const dirPath = join6(directory, PATHS.OPENCODE);
   try {
-    if (!existsSync2(dirPath)) {
-      mkdirSync2(dirPath, { recursive: true });
+    if (!existsSync3(dirPath)) {
+      mkdirSync4(dirPath, { recursive: true });
     }
-    writeFileSync(filePath, JSON.stringify(state2, null, 2), "utf-8");
+    writeFileSync2(filePath, JSON.stringify(state2, null, 2), "utf-8");
     return true;
   } catch (error95) {
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Failed to write state: ${error95}`);
@@ -36553,7 +36762,7 @@ function writeLoopState(directory, state2) {
 }
 function clearLoopState(directory) {
   const filePath = getStateFilePath(directory);
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     return false;
   }
   try {
@@ -36574,17 +36783,30 @@ function incrementIteration(directory) {
   }
   return null;
 }
+function deriveObjective(prompt) {
+  const firstLine = prompt.split(/\r?\n/).find((line) => line.trim().length > 0);
+  return firstLine?.trim() || prompt.trim() || "Continue the active mission";
+}
 function startMissionLoop(directory, sessionID, prompt, options = {}) {
   const state2 = {
     active: true,
     iteration: 1,
     maxIterations: options.maxIterations ?? DEFAULT_MAX_ITERATIONS,
     prompt,
+    objective: deriveObjective(prompt),
     sessionID,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const success3 = writeLoopState(directory, state2);
   if (success3) {
+    appendMissionLedgerEvent(directory, {
+      type: "mission_started",
+      sessionID,
+      iteration: state2.iteration,
+      objective: state2.objective,
+      summary: "Mission loop started"
+    });
+    syncMissionMemory(directory, state2);
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Loop started`, {
       sessionID,
       maxIterations: state2.maxIterations
@@ -36599,6 +36821,19 @@ function cancelMissionLoop(directory, sessionID) {
   }
   const success3 = clearLoopState(directory);
   if (success3) {
+    const cancelledState = {
+      ...state2,
+      active: false,
+      lastContinuationReason: "cancelled"
+    };
+    appendMissionLedgerEvent(directory, {
+      type: "mission_cancelled",
+      sessionID,
+      iteration: state2.iteration,
+      objective: state2.objective,
+      reason: "cancelled"
+    });
+    syncMissionMemory(directory, cancelledState);
     log(`[${MISSION_CONTROL.LOG_SOURCE}] Loop cancelled`, { sessionID, iteration: state2.iteration });
   }
   return success3;
@@ -36607,26 +36842,48 @@ function isLoopActive(directory, sessionID) {
   const state2 = readLoopState(directory);
   return state2?.active === true && state2?.sessionID === sessionID;
 }
-function generateMissionContinuationPrompt(state2, verificationSummary) {
-  const summaryHeader = verificationSummary ? `
-[Verification Status]: ${verificationSummary}
-` : "";
+function generateMissionContinuationPrompt(state2, input) {
+  const context = normalizeContinuationContext(state2, input);
   let prompt = `${CONTINUE_INSTRUCTION}
 
 <mission_loop iteration="${state2.iteration}" max="${state2.maxIterations}">
-\u26A0\uFE0F **MISSION NOT COMPLETE** - Iteration ${state2.iteration}/${state2.maxIterations}
-${summaryHeader}
+MISSION NOT COMPLETE
+
+Objective:
+${context.objective}
 
-**Your Original Task**:
-${state2.prompt}
+Runtime status:
+- todo progress: ${context.progress}
+- verification: ${context.verification}
+- stagnation: ${context.stagnation}
+- continuation reason: ${context.reason}
 
-**NOW**: Continue executing!
+Next action:
+1. Read the current TODO, checklist, and sync issue state.
+2. Execute or delegate only the next unblocked work.
+3. Verify the result with real file reads, build commands, tests, or tool output.
+4. Finish only when mission verification passes.
+
+Completion rule:
+Do not declare success while TODO/checklist/sync verification is still failing.
 </mission_loop>`;
   if (state2.iteration > 1) {
     prompt += "\n" + CLEANUP_INSTRUCTION.replace("%ITER%", state2.iteration.toString());
   }
   return prompt;
 }
+function normalizeContinuationContext(state2, input) {
+  const verificationSummary = typeof input === "string" ? input : input?.verificationSummary;
+  const continuationReason = typeof input === "string" ? void 0 : input?.continuationReason;
+  const stagnationCount = state2.stagnationCount ?? 0;
+  return {
+    objective: state2.objective || deriveObjective(state2.prompt),
+    progress: state2.lastProgress ?? UNKNOWN_STATUS,
+    verification: verificationSummary ?? state2.lastVerificationSummary ?? UNKNOWN_STATUS,
+    reason: continuationReason ?? state2.lastContinuationReason ?? "verification_failed",
+    stagnation: stagnationCount > 0 ? `${stagnationCount} unchanged check(s)` : "not detected"
+  };
+}
 
 // src/core/orchestrator/session-manager.ts
 function ensureSessionInitialized(sessions, sessionID, directory) {
@@ -36638,6 +36895,7 @@ function ensureSessionInitialized(sessions, sessionID, directory) {
       timestamp: now,
       startTime: now,
       lastStepTime: now,
+      lastCompletedMessageID: void 0,
       tokens: { totalInput: 0, totalOutput: 0, estimatedCost: 0 }
     };
     if (directory) {
@@ -36949,8 +37207,8 @@ ${commandList}`;
 // src/core/loop/verification.ts
 init_shared();
 init_logger();
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 var CHECKLIST_FILE = CHECKLIST.FILE;
 function parseChecklistLine(line, currentCategory) {
   const trimmedLine = line.trim();
@@ -37015,12 +37273,12 @@ function parseChecklist(content) {
   return items;
 }
 function readChecklist(directory) {
-  const filePath = join5(directory, CHECKLIST_FILE);
-  if (!existsSync3(filePath)) {
+  const filePath = join7(directory, CHECKLIST_FILE);
+  if (!existsSync4(filePath)) {
     return [];
   }
   try {
-    const content = readFileSync2(filePath, "utf-8");
+    const content = readFileSync3(filePath, "utf-8");
     return parseChecklist(content);
   } catch (error95) {
     log(`[checklist] Failed to read checklist: ${error95}`);
@@ -37037,8 +37295,8 @@ function verifyChecklist(directory) {
     incompleteList: [],
     errors: []
   };
-  const filePath = join5(directory, CHECKLIST_FILE);
-  if (!existsSync3(filePath)) {
+  const filePath = join7(directory, CHECKLIST_FILE);
+  if (!existsSync4(filePath)) {
     result.errors.push(`Verification checklist not found at ${CHECKLIST_FILE}`);
     result.errors.push("Create checklist with at least: build, tests, and any environment-specific checks");
     return result;
@@ -37114,10 +37372,10 @@ function verifyMissionCompletion(directory) {
       result.errors.push(`  ... and ${checklistResult.incompleteList.length - 5} more`);
     }
   }
-  const todoPath = join5(directory, PATHS.TODO);
-  if (existsSync3(todoPath)) {
+  const todoPath = join7(directory, PATHS.TODO);
+  if (existsSync4(todoPath)) {
     try {
-      const content = readFileSync2(todoPath, "utf-8");
+      const content = readFileSync3(todoPath, "utf-8");
       const incompleteCount = countMatches(content, TODO_INCOMPLETE_PATTERN);
       const completeCount = countMatches(content, TODO_COMPLETE_PATTERN);
       const total = incompleteCount + completeCount;
@@ -37139,10 +37397,10 @@ function verifyMissionCompletion(directory) {
   } else if (!hasChecklist) {
     result.errors.push(`TODO file not found at ${PATHS.TODO}`);
   }
-  const syncPath = join5(directory, PATHS.SYNC_ISSUES);
-  if (existsSync3(syncPath)) {
+  const syncPath = join7(directory, PATHS.SYNC_ISSUES);
+  if (existsSync4(syncPath)) {
     try {
-      const content = readFileSync2(syncPath, "utf-8");
+      const content = readFileSync3(syncPath, "utf-8");
       result.syncIssuesEmpty = !hasRealSyncIssues(content);
       if (!result.syncIssuesEmpty) {
         const issueLines = content.split("\n").filter(
@@ -37230,7 +37488,7 @@ function buildVerificationSummary(result) {
 init_logger();
 import { exec as exec2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 
 // src/shared/notification/os-notify/constants/notification-commands.ts
 var NOTIFICATION_COMMANDS = {
@@ -37284,10 +37542,10 @@ async function resolveCommandPath(key, commandName) {
   const currentPending = pending.get(key);
   if (currentPending) return currentPending;
   const promise3 = (async () => {
-    const path10 = await findCommand(commandName);
-    cache[key] = path10;
+    const path11 = await findCommand(commandName);
+    cache[key] = path11;
     pending.delete(key);
-    return path10;
+    return path11;
   })();
   pending.set(key, promise3);
   return promise3;
@@ -37296,19 +37554,19 @@ async function resolveCommandPath(key, commandName) {
 // src/core/notification/os-notify/notifier.ts
 var execAsync2 = promisify2(exec2);
 async function notifyDarwin(title, message) {
-  const path10 = await resolveCommandPath(
+  const path11 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.OSASCRIPT,
     NOTIFICATION_COMMANDS.OSASCRIPT
   );
-  if (!path10) return;
+  if (!path11) return;
   const escT = title.replace(/"/g, '\\"');
   const escM = message.replace(/"/g, '\\"');
-  await execAsync2(`${path10} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"' >/dev/null 2>/dev/null`);
+  await execAsync2(`${path11} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"' >/dev/null 2>/dev/null`);
 }
 function isWSL() {
   try {
     if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) return true;
-    const procVersion = readFileSync3("/proc/version", "utf-8");
+    const procVersion = readFileSync4("/proc/version", "utf-8");
     return /microsoft|WSL/i.test(procVersion);
   } catch {
     return false;
@@ -37316,11 +37574,11 @@ function isWSL() {
 }
 async function notifyLinux(title, message) {
   if (isWSL()) return;
-  const path10 = await resolveCommandPath(
+  const path11 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.NOTIFY_SEND,
     NOTIFICATION_COMMANDS.NOTIFY_SEND
   );
-  if (path10) await execAsync2(`${path10} "${title}" "${message}" >/dev/null 2>/dev/null`);
+  if (path11) await execAsync2(`${path11} "${title}" "${message}" >/dev/null 2>/dev/null`);
 }
 async function notifyWindows(title, message) {
   const ps = await resolveCommandPath(
@@ -37368,11 +37626,11 @@ init_os();
 async function playDarwin(soundPath) {
   if (!soundPath) return;
   try {
-    const path10 = await resolveCommandPath(
+    const path11 = await resolveCommandPath(
       NOTIFICATION_COMMAND_KEYS.AFPLAY,
       NOTIFICATION_COMMANDS.AFPLAY
     );
-    if (path10) exec3(`"${path10}" "${soundPath}" >/dev/null 2>/dev/null`);
+    if (path11) exec3(`"${path11}" "${soundPath}" >/dev/null 2>/dev/null`);
   } catch (err) {
     log(`[session-notify] Error playing sound (Darwin): ${err}`);
   }
@@ -38784,9 +39042,9 @@ import * as path6 from "node:path";
 
 // src/core/cache/utils.ts
 import * as fs6 from "node:fs/promises";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 async function ensureCacheDir() {
-  if (!existsSync5(CACHE_DIR)) {
+  if (!existsSync6(CACHE_DIR)) {
     await fs6.mkdir(CACHE_DIR, { recursive: true });
   }
 }
@@ -39288,15 +39546,15 @@ var backgroundTaskManager = BackgroundTaskManager.instance;
 
 // src/tools/rust-pool.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 
 // src/utils/binary.ts
 init_shared();
-import { join as join10, dirname as dirname4 } from "path";
+import { join as join12, dirname as dirname5 } from "path";
 import { fileURLToPath } from "url";
 import { platform, arch } from "os";
-import { existsSync as existsSync7 } from "fs";
-var __dirname = dirname4(fileURLToPath(import.meta.url));
+import { existsSync as existsSync8 } from "fs";
+var __dirname = dirname5(fileURLToPath(import.meta.url));
 function getPlatformBinaryName(os = platform(), cpu = arch()) {
   if (os === PLATFORM.WIN32) {
     return "orchestrator-windows-x64.exe";
@@ -39308,30 +39566,30 @@ function getPlatformBinaryName(os = platform(), cpu = arch()) {
 }
 function getCandidateBinDirs(moduleDir = __dirname) {
   return [
-    join10(moduleDir, "..", "bin"),
-    join10(moduleDir, "..", "..", "bin")
+    join12(moduleDir, "..", "bin"),
+    join12(moduleDir, "..", "..", "bin")
   ];
 }
 function resolveBinaryPath(options = {}) {
   const moduleDir = options.moduleDir ?? __dirname;
   const os = options.os ?? platform();
   const cpu = options.cpu ?? arch();
-  const exists = options.exists ?? existsSync7;
+  const exists = options.exists ?? existsSync8;
   const binaryName = getPlatformBinaryName(os, cpu);
   for (const binDir of getCandidateBinDirs(moduleDir)) {
-    const binaryPath = join10(binDir, binaryName);
+    const binaryPath = join12(binDir, binaryName);
     if (exists(binaryPath)) {
       return binaryPath;
     }
   }
   const fallbackName = os === PLATFORM.WIN32 ? "orchestrator.exe" : "orchestrator";
   for (const binDir of getCandidateBinDirs(moduleDir)) {
-    const fallbackPath = join10(binDir, fallbackName);
+    const fallbackPath = join12(binDir, fallbackName);
     if (exists(fallbackPath)) {
       return fallbackPath;
     }
   }
-  return join10(getCandidateBinDirs(moduleDir)[0], binaryName);
+  return join12(getCandidateBinDirs(moduleDir)[0], binaryName);
 }
 function getBinaryPath() {
   return resolveBinaryPath();
@@ -39345,10 +39603,21 @@ var RustToolPool = class {
   maxSize = 4;
   idleTimeout = 3e4;
   // 30 seconds
+  processReadyDelay = 100;
+  requestTimeout = 6e4;
   cleanupInterval = null;
+  binaryPath;
+  exists;
+  spawnProcess;
   shuttingDown = false;
-  constructor(maxSize = 4) {
+  constructor(maxSize = 4, options = {}) {
     this.maxSize = maxSize;
+    this.binaryPath = options.binaryPath ?? getBinaryPath;
+    this.exists = options.exists ?? existsSync9;
+    this.idleTimeout = options.idleTimeoutMs ?? this.idleTimeout;
+    this.processReadyDelay = options.processReadyDelayMs ?? this.processReadyDelay;
+    this.requestTimeout = options.requestTimeoutMs ?? this.requestTimeout;
+    this.spawnProcess = options.spawnProcess ?? spawn2;
     this.startCleanupTimer();
   }
   /**
@@ -39358,16 +39627,13 @@ var RustToolPool = class {
     if (this.shuttingDown) {
       throw new Error("Pool is shutting down");
     }
-    const binary = getBinaryPath();
-    if (!existsSync8(binary)) {
+    const binary = this.binaryPath();
+    if (!this.exists(binary)) {
       return JSON.stringify({ error: `Binary not found: ${binary}` });
     }
     let pooled = this.getAvailable();
-    if (!pooled && this.processes.length < this.maxSize) {
-      pooled = await this.createProcess(binary);
-    }
     if (!pooled) {
-      pooled = await this.waitForAvailable();
+      pooled = await this.createOrWaitForProcess(binary);
     }
     try {
       return await this.sendRequest(pooled, name, args);
@@ -39382,15 +39648,29 @@ var RustToolPool = class {
     return this.processes.find((p) => !p.busy) || null;
   }
   /**
-   * Wait for a process to become available
+   * Create a process immediately, or wait until one is available/capacity opens.
    */
-  async waitForAvailable() {
-    return new Promise((resolve) => {
+  async createOrWaitForProcess(binary) {
+    if (this.processes.length < this.maxSize) {
+      return this.createProcess(binary);
+    }
+    return this.waitForAvailable(binary);
+  }
+  /**
+   * Wait for a process to become available, or create one if capacity opens.
+   */
+  async waitForAvailable(binary) {
+    return new Promise((resolve, reject) => {
       const interval = setInterval(() => {
         const available = this.getAvailable();
         if (available) {
           clearInterval(interval);
           resolve(available);
+          return;
+        }
+        if (this.processes.length < this.maxSize) {
+          clearInterval(interval);
+          this.createProcess(binary).then(resolve, reject);
         }
       }, 10);
     });
@@ -39400,41 +39680,47 @@ var RustToolPool = class {
    */
   async createProcess(binary) {
     return new Promise((resolve, reject) => {
-      const proc = spawn2(binary, ["serve"], {
+      const proc = this.spawnProcess(binary, ["serve"], {
         stdio: ["pipe", "pipe", "pipe"],
         detached: false
       });
-      let started = false;
+      let startupSettled = false;
+      let readyTimer = null;
       const pooled = {
         proc,
-        busy: false,
+        busy: true,
+        destroyed: false,
         lastUsed: Date.now(),
         requestId: 0,
         stdout: ""
       };
-      proc.stderr?.on("data", (data) => {
-        const msg = data.toString().trim();
-        if (msg && msg.includes("Listening")) {
-          started = true;
+      const settleStartup = (callback) => {
+        if (startupSettled) {
+          return;
         }
-      });
-      proc.on("close", () => {
-        const index = this.processes.indexOf(pooled);
-        if (index !== -1) {
-          this.processes.splice(index, 1);
+        startupSettled = true;
+        if (readyTimer) {
+          clearTimeout(readyTimer);
+          readyTimer = null;
         }
+        callback();
+      };
+      proc.on("close", () => {
+        const error95 = new Error("Rust tool process closed before completing request");
+        settleStartup(() => reject(error95));
+        pooled.pendingReject?.(error95);
+        this.removeProcess(pooled, false);
       });
       proc.on("error", (err) => {
-        const index = this.processes.indexOf(pooled);
-        if (index !== -1) {
-          this.processes.splice(index, 1);
-        }
-        if (!started) {
-          reject(err);
-        }
+        const error95 = err instanceof Error ? err : new Error(String(err));
+        settleStartup(() => reject(error95));
+        pooled.pendingReject?.(error95);
+        this.removeProcess(pooled, false);
       });
       this.processes.push(pooled);
-      setTimeout(() => resolve(pooled), 100);
+      readyTimer = setTimeout(() => {
+        settleStartup(() => resolve(pooled));
+      }, this.processReadyDelay);
     });
   }
   /**
@@ -39444,13 +39730,39 @@ var RustToolPool = class {
     pooled.busy = true;
     pooled.lastUsed = Date.now();
     pooled.stdout = "";
+    if (pooled.destroyed || !this.processes.includes(pooled)) {
+      throw new Error("Rust tool process is unavailable");
+    }
     return new Promise((resolve, reject) => {
       const requestId = ++pooled.requestId;
+      let settled = false;
+      const fail = (error95, kill) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        this.removeProcess(pooled, kill);
+        reject(error95);
+      };
+      const succeed = (text) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(text);
+      };
       const timeout = setTimeout(() => {
+        fail(new Error("Request timeout"), true);
+      }, this.requestTimeout);
+      const cleanup = () => {
+        clearTimeout(timeout);
         pooled.pendingResolve = void 0;
         pooled.pendingReject = void 0;
-        reject(new Error("Request timeout"));
-      }, 6e4);
+        pooled.pendingCleanup = void 0;
+        pooled.proc.stdout?.removeListener("data", onData);
+      };
       const onData = (data) => {
         pooled.stdout += data.toString();
         const lines = pooled.stdout.trim().split("\n");
@@ -39458,10 +39770,8 @@ var RustToolPool = class {
           try {
             const response = JSON.parse(lines[i]);
             if (response.id === requestId && (response.result || response.error)) {
-              clearTimeout(timeout);
-              pooled.proc.stdout?.removeListener("data", onData);
               const text = response?.result?.content?.[0]?.text;
-              resolve(text || JSON.stringify(response.result));
+              succeed(text || JSON.stringify(response.result));
               return;
             }
           } catch {
@@ -39469,6 +39779,8 @@ var RustToolPool = class {
           }
         }
       };
+      pooled.pendingReject = (error95) => fail(error95, false);
+      pooled.pendingCleanup = cleanup;
       pooled.proc.stdout?.on("data", onData);
       const request = JSON.stringify({
         jsonrpc: "2.0",
@@ -39477,11 +39789,13 @@ var RustToolPool = class {
         params: { name, arguments: args }
       });
       try {
-        pooled.proc.stdin?.write(request + "\n");
+        const written = pooled.proc.stdin?.write(request + "\n");
+        if (written === false || written === void 0) {
+          fail(new Error("Failed to write request to Rust tool process"), true);
+        }
       } catch (err) {
-        clearTimeout(timeout);
-        pooled.proc.stdout?.removeListener("data", onData);
-        reject(err);
+        const error95 = err instanceof Error ? err : new Error(String(err));
+        fail(error95, true);
       }
     });
   }
@@ -39489,9 +39803,29 @@ var RustToolPool = class {
    * Release a process back to the pool
    */
   release(pooled) {
+    if (pooled.destroyed || !this.processes.includes(pooled)) {
+      return;
+    }
     pooled.busy = false;
     pooled.lastUsed = Date.now();
   }
+  /**
+   * Remove a process from the pool, optionally terminating it first.
+   */
+  removeProcess(pooled, kill) {
+    pooled.destroyed = true;
+    pooled.pendingCleanup?.();
+    if (kill) {
+      try {
+        pooled.proc.kill();
+      } catch {
+      }
+    }
+    const index = this.processes.indexOf(pooled);
+    if (index !== -1) {
+      this.processes.splice(index, 1);
+    }
+  }
   /**
    * Start cleanup timer for idle processes
    */
@@ -39505,14 +39839,7 @@ var RustToolPool = class {
         }
       }
       for (const pooled of toRemove) {
-        try {
-          pooled.proc.kill();
-        } catch {
-        }
-        const index = this.processes.indexOf(pooled);
-        if (index !== -1) {
-          this.processes.splice(index, 1);
-        }
+        this.removeProcess(pooled, true);
       }
       if (toRemove.length > 0) {
         log(`[${LOG_PREFIX.RUST_POOL}] Cleaned up ${toRemove.length} idle processes`);
@@ -39529,11 +39856,8 @@ var RustToolPool = class {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
-    for (const pooled of this.processes) {
-      try {
-        pooled.proc.kill();
-      } catch {
-      }
+    for (const pooled of [...this.processes]) {
+      this.removeProcess(pooled, true);
     }
     this.processes = [];
     log(`[${LOG_PREFIX.RUST_POOL}] Shutdown complete`);
@@ -39551,18 +39875,39 @@ var RustToolPool = class {
   }
 };
 var globalPool = null;
+var resetInFlight = null;
 function getRustToolPool() {
   if (!globalPool) {
     globalPool = new RustToolPool();
   }
   return globalPool;
 }
-async function shutdownRustToolPool() {
-  if (globalPool) {
-    await globalPool.shutdown();
+async function resetRustToolPool(reason = "manual reset", expectedPool) {
+  while (resetInFlight) {
+    await resetInFlight;
+  }
+  const poolToReset = globalPool;
+  if (!poolToReset) {
+    return;
+  }
+  if (expectedPool && poolToReset !== expectedPool) {
+    log(`[${LOG_PREFIX.RUST_POOL}] Skipped reset for stale pool: ${reason}`);
+    return;
+  }
+  resetInFlight = (async () => {
     globalPool = null;
+    log(`[${LOG_PREFIX.RUST_POOL}] Resetting global pool: ${reason}`);
+    await poolToReset.shutdown();
+  })();
+  try {
+    await resetInFlight;
+  } finally {
+    resetInFlight = null;
   }
 }
+async function shutdownRustToolPool() {
+  await resetRustToolPool("shutdown");
+}
 
 // src/tools/callAgent.ts
 init_shared();
@@ -39631,13 +39976,15 @@ ${PROMPT_TAGS.EXECUTION.close}
 init_logger();
 init_shared();
 async function callRustTool(name, args) {
+  const pool = getRustToolPool();
   try {
-    const pool = getRustToolPool();
     return await pool.call(name, args);
   } catch (err) {
-    log(`[${LOG_PREFIX.RUST_TOOL}] Pool error: ${err}`);
-    throw err;
+    log(`[${LOG_PREFIX.RUST_TOOL}] Pool error, resetting and retrying once: ${err}`);
+    await resetRustToolPool(`transport error while calling ${name}`, pool);
   }
+  const retryPool = getRustToolPool();
+  return retryPool.call(name, args);
 }
 
 // src/tools/search.ts
@@ -40783,6 +41130,92 @@ function registerAllTools(directory, asyncAgentTools, dynamicTools) {
 // src/index.ts
 init_shared();
 
+// src/core/agents/concurrency-config.ts
+var CONCURRENCY_KEYS = [
+  "defaultConcurrency",
+  "agentConcurrency",
+  "providerConcurrency",
+  "modelConcurrency"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readLimitMap(value) {
+  if (!isRecord(value)) return void 0;
+  const result = {};
+  for (const [key, limit] of Object.entries(value)) {
+    if (typeof limit === "number" && Number.isFinite(limit) && limit >= 0) {
+      result[key] = limit;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function extractConcurrencyConfig(source) {
+  if (!isRecord(source)) return {};
+  const config3 = {};
+  if (typeof source.defaultConcurrency === "number" && source.defaultConcurrency >= 0) {
+    config3.defaultConcurrency = source.defaultConcurrency;
+  }
+  const agentConcurrency = readLimitMap(source.agentConcurrency);
+  if (agentConcurrency) config3.agentConcurrency = agentConcurrency;
+  const providerConcurrency = readLimitMap(source.providerConcurrency);
+  if (providerConcurrency) config3.providerConcurrency = providerConcurrency;
+  const modelConcurrency = readLimitMap(source.modelConcurrency);
+  if (modelConcurrency) config3.modelConcurrency = modelConcurrency;
+  return config3;
+}
+function hasConcurrencyConfig(source) {
+  if (!isRecord(source)) return false;
+  return CONCURRENCY_KEYS.some((key) => source[key] !== void 0);
+}
+function mergeConcurrencyConfig(base, override) {
+  return {
+    ...base,
+    ...override,
+    agentConcurrency: {
+      ...base.agentConcurrency,
+      ...override.agentConcurrency
+    },
+    providerConcurrency: {
+      ...base.providerConcurrency,
+      ...override.providerConcurrency
+    },
+    modelConcurrency: {
+      ...base.modelConcurrency,
+      ...override.modelConcurrency
+    }
+  };
+}
+
+// src/core/config/plugin-options.ts
+function parseOrchestratorPluginOptions(options) {
+  const source = isRecord2(options) ? options : {};
+  return {
+    concurrency: extractConcurrencyConfig(source),
+    missionLoop: readMissionLoopOptions(source.missionLoop)
+  };
+}
+function readMissionLoopOptions(value) {
+  if (!isRecord2(value)) return DEFAULT_MISSION_RUNTIME_OPTIONS;
+  return {
+    ledger: readBoolean(value.ledger, DEFAULT_MISSION_RUNTIME_OPTIONS.ledger),
+    markdownMemory: readBoolean(value.markdownMemory, DEFAULT_MISSION_RUNTIME_OPTIONS.markdownMemory),
+    maxEvidenceEvents: readPositiveInteger(
+      value.maxEvidenceEvents,
+      DEFAULT_MISSION_RUNTIME_OPTIONS.maxEvidenceEvents
+    )
+  };
+}
+function readBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function readPositiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/plugin-handlers/tool-execute-pre-handler.ts
 init_logger();
 function createToolExecuteBeforeHandler(ctx) {
@@ -40894,8 +41327,41 @@ This plugin runs in "Claude Code Compatibility Mode".
 }
 
 // src/plugin-handlers/config-handler.ts
-function createConfigHandler() {
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPermissionAction(value) {
+  return value === "ask" || value === "allow" || value === "deny";
+}
+function mergePermission(globalPermission, agentPermission) {
+  if (agentPermission === void 0) {
+    return globalPermission;
+  }
+  if (isRecord3(globalPermission) && isRecord3(agentPermission)) {
+    return { ...globalPermission, ...agentPermission };
+  }
+  if (isPermissionAction(globalPermission) && isRecord3(agentPermission)) {
+    return { "*": globalPermission, ...agentPermission };
+  }
+  return agentPermission;
+}
+function defineAgent(existing, defaults, globalPermission) {
+  const permission = mergePermission(globalPermission, existing?.permission);
+  const agent = {
+    ...existing,
+    ...defaults
+  };
+  if (permission !== void 0) {
+    agent.permission = permission;
+  }
+  return agent;
+}
+function createConfigHandler(options = {}) {
   return async (config3) => {
+    const mutableConfig = config3;
+    if (hasConcurrencyConfig(config3)) {
+      options.onConcurrencyConfig?.(extractConcurrencyConfig(config3));
+    }
     const claudeRules = findClaudeRules();
     const injectRules = (prompt) => {
       if (!claudeRules) return prompt;
@@ -40907,8 +41373,9 @@ ${claudeRules}`;
     const plannerPrompt = injectRules(AGENTS[AGENT_NAMES.PLANNER]?.systemPrompt || "");
     const workerPrompt = injectRules(AGENTS[AGENT_NAMES.WORKER]?.systemPrompt || "");
     const reviewerPrompt = injectRules(AGENTS[AGENT_NAMES.REVIEWER]?.systemPrompt || "");
-    const existingCommands = config3.command ?? {};
-    const existingAgents = config3.agent ?? {};
+    const existingCommands = mutableConfig.command ?? {};
+    const existingAgents = mutableConfig.agent ?? {};
+    const globalPermission = mutableConfig.permission;
     const orchestratorCommands = {};
     for (const [name, cmd] of Object.entries(COMMANDS)) {
       orchestratorCommands[name] = {
@@ -40919,39 +41386,34 @@ ${claudeRules}`;
     }
     const orchestratorAgents = {
       // Primary agent - the main orchestrator
-      [AGENT_NAMES.COMMANDER]: {
+      [AGENT_NAMES.COMMANDER]: defineAgent(existingAgents[AGENT_NAMES.COMMANDER], {
         description: "Autonomous orchestrator - executes until mission complete",
         mode: "primary",
         prompt: commanderPrompt,
-        maxTokens: AGENT_TOKENS.PRIMARY_MAX_TOKENS,
-        thinking: { type: "enabled", budgetTokens: AGENT_TOKENS.PRIMARY_THINKING_BUDGET },
         color: "#ffea98"
-      },
-      // Subagents (5 total)
-      [AGENT_NAMES.PLANNER]: {
+      }, globalPermission),
+      // Subagents
+      [AGENT_NAMES.PLANNER]: defineAgent(existingAgents[AGENT_NAMES.PLANNER], {
         description: "Strategic planning and research specialist",
         mode: "subagent",
         hidden: true,
         prompt: plannerPrompt,
-        maxTokens: AGENT_TOKENS.SUBAGENT_MAX_TOKENS,
         color: "#9B59B6"
-      },
-      [AGENT_NAMES.WORKER]: {
+      }, globalPermission),
+      [AGENT_NAMES.WORKER]: defineAgent(existingAgents[AGENT_NAMES.WORKER], {
         description: "Implementation and documentation specialist",
         mode: "subagent",
         hidden: true,
         prompt: workerPrompt,
-        maxTokens: AGENT_TOKENS.SUBAGENT_MAX_TOKENS,
         color: "#E67E22"
-      },
-      [AGENT_NAMES.REVIEWER]: {
+      }, globalPermission),
+      [AGENT_NAMES.REVIEWER]: defineAgent(existingAgents[AGENT_NAMES.REVIEWER], {
         description: "Module-level verification specialist",
         mode: "subagent",
         hidden: true,
         prompt: reviewerPrompt,
-        maxTokens: AGENT_TOKENS.SUBAGENT_MAX_TOKENS,
         color: "#27AE60"
-      }
+      }, globalPermission)
     };
     const processedExistingAgents = { ...existingAgents };
     if (processedExistingAgents.build) {
@@ -40967,9 +41429,9 @@ ${claudeRules}`;
         mode: "subagent"
       };
     }
-    config3.command = { ...existingCommands, ...orchestratorCommands };
-    config3.agent = { ...processedExistingAgents, ...orchestratorAgents };
-    config3.default_agent = AGENT_NAMES.COMMANDER;
+    mutableConfig.command = { ...existingCommands, ...orchestratorCommands };
+    mutableConfig.agent = { ...processedExistingAgents, ...orchestratorAgents };
+    mutableConfig.default_agent = AGENT_NAMES.COMMANDER;
   };
 }
 
@@ -41427,7 +41889,11 @@ async function injectContinuation2(client, directory, sessionID, loopState, cust
     return;
   }
   const summary = buildVerificationSummary(verification);
-  let prompt = generateMissionContinuationPrompt(loopState, summary);
+  const continuationReason = customPrompt ? "stagnation_intervention" : loopState.lastContinuationReason;
+  let prompt = generateMissionContinuationPrompt(loopState, {
+    verificationSummary: summary,
+    continuationReason
+  });
   if (customPrompt) {
     prompt = `${customPrompt}
 
@@ -41440,12 +41906,35 @@ ${prompt}`;
         parts: [{ type: PART_TYPES.TEXT, text: prompt }]
       }
     });
+    appendMissionLedgerEvent(directory, {
+      type: "prompt_injected",
+      sessionID,
+      iteration: loopState.iteration,
+      objective: loopState.objective,
+      summary,
+      reason: continuationReason
+    });
+    syncMissionMemory(directory, loopState);
     markInjectionPerformed(sessionID);
   } catch (err) {
     log("[mission-loop-handler] Failed to inject continuation prompt", { sessionID, error: err });
   }
 }
 async function handleMissionComplete(client, directory, loopState) {
+  const completedState = {
+    ...loopState,
+    active: false,
+    lastVerificationSummary: "Mission verification passed",
+    lastContinuationReason: "mission_completed"
+  };
+  appendMissionLedgerEvent(directory, {
+    type: "mission_completed",
+    sessionID: loopState.sessionID,
+    iteration: loopState.iteration,
+    objective: loopState.objective,
+    summary: "Mission verification passed"
+  });
+  syncMissionMemory(directory, completedState);
   const cleared = clearLoopState(directory);
   if (cleared) {
     await showCompletedToast(client, loopState);
@@ -41498,6 +41987,20 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
     return;
   }
   if (shouldTripCircuit(sessionID)) {
+    const verificationSummary2 = buildVerificationSummary(verification);
+    appendMissionLedgerEvent(directory, {
+      type: "circuit_open",
+      sessionID,
+      iteration: loopState.iteration,
+      objective: loopState.objective,
+      summary: verificationSummary2,
+      reason: "stagnation_threshold"
+    });
+    syncMissionMemory(directory, {
+      ...loopState,
+      lastVerificationSummary: verificationSummary2,
+      lastContinuationReason: "circuit_open"
+    });
     log(`[${MISSION_CONTROL.LOG_SOURCE}-handler] Circuit breaker tripped for ${sessionID}`);
     return;
   }
@@ -41512,8 +42015,29 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
   const stagnant = isStagnant(sessionID, DEFAULT_STAGNATION_THRESHOLD);
   const newState = incrementIteration(directory);
   if (!newState) return;
+  const verificationSummary = buildVerificationSummary(verification);
   newState.lastProgress = currentProgress;
+  newState.stagnationCount = stagnant ? (newState.stagnationCount ?? 0) + 1 : 0;
+  newState.lastVerificationSummary = verificationSummary;
+  newState.lastContinuationReason = stagnant ? "stagnation_intervention" : "verification_failed";
+  newState.lastContinuationAt = (/* @__PURE__ */ new Date()).toISOString();
   writeLoopState(directory, newState);
+  appendMissionLedgerEvent(directory, {
+    type: "verification_failed",
+    sessionID,
+    iteration: newState.iteration,
+    objective: newState.objective,
+    summary: verificationSummary
+  });
+  appendMissionLedgerEvent(directory, {
+    type: "continuation_scheduled",
+    sessionID,
+    iteration: newState.iteration,
+    objective: newState.objective,
+    summary: verificationSummary,
+    reason: newState.lastContinuationReason
+  });
+  syncMissionMemory(directory, newState);
   await showCountdownToast2(client, MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS, newState.iteration, newState.maxIterations);
   state2.countdownTimer = setTimeout(async () => {
     sessionStateStore.cancelCountdown(sessionID);
@@ -41541,6 +42065,55 @@ function handleSessionCompacted(sessionID) {
 
 // src/plugin-handlers/event-handler.ts
 init_shared();
+
+// src/plugin-handlers/assistant-done-handler.ts
+init_logger();
+init_shared();
+async function handleCompletedAssistantMessage(ctx, sessionID, messageID) {
+  const { client, directory, sessions } = ctx;
+  const hooks = HookRegistry.getInstance();
+  const session = sessions.get(sessionID);
+  if (!session?.active || session.lastCompletedMessageID === messageID) {
+    return;
+  }
+  const textContent = await readAssistantText(client, sessionID, messageID);
+  session.lastCompletedMessageID = messageID;
+  const result = await hooks.executeDone(
+    { sessionID, directory, sessions },
+    textContent
+  );
+  if (result.action !== "inject" || result.prompts.length === 0) {
+    return;
+  }
+  const now = Date.now();
+  session.step++;
+  session.timestamp = now;
+  session.lastStepTime = now;
+  try {
+    const parts = result.prompts.map((text) => ({ type: PART_TYPES.TEXT, text }));
+    client.session.prompt({
+      path: { id: sessionID },
+      body: { parts }
+    }).catch((error95) => {
+      log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
+    });
+  } catch (error95) {
+    log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
+  }
+}
+async function readAssistantText(client, sessionID, messageID) {
+  try {
+    const response = await client.session.message({
+      path: { id: sessionID, messageID }
+    });
+    return (response.parts ?? []).filter((part) => part.type === PART_TYPES.TEXT || part.type === PART_TYPES.REASONING).map((part) => part.text ?? "").join("\n");
+  } catch (error95) {
+    log("[assistant-done-handler] Failed to read assistant message", { sessionID, messageID, error: error95 });
+    return "";
+  }
+}
+
+// src/plugin-handlers/event-handler.ts
 function createEventHandler(ctx) {
   const { client, directory, sessions, state: state2 } = ctx;
   return async (input) => {
@@ -41591,7 +42164,7 @@ function createEventHandler(ctx) {
     if (event.type === MESSAGE_EVENTS.UPDATED) {
       const messageProperties = event.properties;
       const messageInfo = messageProperties?.info;
-      const sessionID = messageInfo?.sessionID;
+      const sessionID = messageProperties.sessionID || messageInfo?.sessionID;
       const role = messageInfo?.role;
       if (sessionID && messageProperties?.usage) {
         const totalTokens = messageProperties.usage.totalTokens ?? (messageProperties.usage.inputTokens ?? 0) + (messageProperties.usage.outputTokens ?? 0);
@@ -41601,6 +42174,9 @@ function createEventHandler(ctx) {
       }
       if (sessionID && role === MESSAGE_ROLES.ASSISTANT) {
         markRecoveryComplete(sessionID);
+        if (messageInfo?.id && messageInfo.time?.completed) {
+          await handleCompletedAssistantMessage(ctx, sessionID, messageInfo.id);
+        }
       }
       if (sessionID && role === MESSAGE_ROLES.USER) {
         handleUserMessage(sessionID);
@@ -41682,53 +42258,6 @@ function createToolExecuteAfterHandler(ctx) {
   };
 }
 
-// src/plugin-handlers/assistant-done-handler.ts
-init_logger();
-init_shared();
-function createAssistantDoneHandler(ctx) {
-  const { client, directory, sessions } = ctx;
-  const hooks = HookRegistry.getInstance();
-  return async (assistantInput, assistantOutput) => {
-    const sessionID = assistantInput.sessionID;
-    const session = sessions.get(sessionID);
-    if (!session?.active) return;
-    const parts = assistantOutput.parts;
-    const textContent = parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text || "").join("\n") || "";
-    const hookContext = {
-      sessionID,
-      directory,
-      sessions
-      // Cast because types might slightly differ in strict mode, but it's the same object
-    };
-    const result = await hooks.executeDone(hookContext, textContent);
-    if (result.action === "stop") {
-      return;
-    }
-    if (result.action === "inject" && result.prompts) {
-      const now = Date.now();
-      session.step++;
-      session.timestamp = now;
-      session.lastStepTime = now;
-      try {
-        if (client?.session?.prompt) {
-          const parts2 = result.prompts.map((p) => ({
-            type: PART_TYPES.TEXT,
-            text: p
-          }));
-          client.session.prompt({
-            path: { id: sessionID },
-            body: { parts: parts2 }
-          }).catch((error95) => {
-            log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
-          });
-        }
-      } catch (error95) {
-        log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
-      }
-    }
-  };
-}
-
 // src/plugin-handlers/session-compacting-handler.ts
 init_shared();
 function createSessionCompactingHandler(ctx) {
@@ -41767,6 +42296,9 @@ function buildMissionContext(loopState) {
   return `<mission_context>
 ACTIVE MISSION LOOP:
 - Status: Active (Iteration ${loopState.iteration}/${loopState.maxIterations})
+- Objective: ${loopState.objective ?? "Continue the active mission"}
+- Last Progress: ${loopState.lastProgress ?? "unknown"}
+- Last Verification: ${loopState.lastVerificationSummary ?? "unknown"}
 - Started: ${loopState.startedAt}
 - Original Task: ${loopState.prompt.slice(0, 500)}${loopState.prompt.length > 500 ? "..." : ""}
 
@@ -41805,6 +42337,564 @@ Wait for these tasks to complete before concluding the mission.
 
 // src/plugin-handlers/system-transform-handler.ts
 init_shared();
+
+// src/core/knowledge/context-provider.ts
+import { existsSync as existsSync10, readFileSync as readFileSync6, readdirSync } from "node:fs";
+import path10 from "node:path";
+
+// src/core/knowledge/graph-parser.ts
+var GraphParser = class _GraphParser {
+  /** Heading marker used for the auto-generated backlinks section */
+  static BACKLINKS_HEADING = "## \u{1F517} Backlinks";
+  // Maps note name -> set of target note names it links to
+  forwardLinks = /* @__PURE__ */ new Map();
+  // Maps note name -> set of source note names that link to it
+  backlinks = /* @__PURE__ */ new Map();
+  // Maps note name -> file path
+  noteToPath = /* @__PURE__ */ new Map();
+  // Maps file path -> note name
+  pathToNote = /* @__PURE__ */ new Map();
+  /**
+   * Resolve file path or relative link to a note name (basename without extension).
+   */
+  getNoteName(filePath) {
+    const basename = filePath.split(/[/\\]/).pop() || "";
+    const dotIdx = basename.lastIndexOf(".");
+    return dotIdx !== -1 ? basename.slice(0, dotIdx) : basename;
+  }
+  /**
+   * Parse content and extract all unique referenced target note names.
+   */
+  parseLinks(content) {
+    const targets = [];
+    const wikiRegex = /\[\[([^[\]|#]+)(?:\|[^[\]]+)?(?:#[^[\]]+)?\]\]/g;
+    let match;
+    while ((match = wikiRegex.exec(content)) !== null) {
+      const target = match[1].trim();
+      if (target && !targets.includes(target)) {
+        targets.push(target);
+      }
+    }
+    const mdLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    while ((match = mdLinkRegex.exec(content)) !== null) {
+      const url3 = match[2].trim();
+      if (!url3.includes("://") && (url3.endsWith(".md") || url3.startsWith(".") || url3.startsWith("/"))) {
+        const targetName = this.getNoteName(url3);
+        if (targetName && !targets.includes(targetName)) {
+          targets.push(targetName);
+        }
+      }
+    }
+    return targets;
+  }
+  /**
+   * Index file and register its bi-directional links.
+   */
+  indexFile(filePath, content) {
+    const sourceNote = this.getNoteName(filePath);
+    this.noteToPath.set(sourceNote, filePath);
+    this.pathToNote.set(filePath, sourceNote);
+    this.clearIndexForNote(sourceNote);
+    const targets = this.parseLinks(content);
+    if (targets.length > 0) {
+      const forwardSet = new Set(targets);
+      this.forwardLinks.set(sourceNote, forwardSet);
+      for (const target of targets) {
+        let backSet = this.backlinks.get(target);
+        if (!backSet) {
+          backSet = /* @__PURE__ */ new Set();
+          this.backlinks.set(target, backSet);
+        }
+        backSet.add(sourceNote);
+      }
+    }
+  }
+  /**
+   * Retrieve backlinks for a note name or file path.
+   */
+  getBacklinks(noteOrPath) {
+    const note = noteOrPath.includes("/") || noteOrPath.endsWith(".md") ? this.getNoteName(noteOrPath) : noteOrPath;
+    const sources = this.backlinks.get(note);
+    return sources ? Array.from(sources).sort() : [];
+  }
+  /**
+   * Retrieve forward links for a note name or file path.
+   */
+  getForwardLinks(noteOrPath) {
+    const note = noteOrPath.includes("/") || noteOrPath.endsWith(".md") ? this.getNoteName(noteOrPath) : noteOrPath;
+    const targets = this.forwardLinks.get(note);
+    return targets ? Array.from(targets).sort() : [];
+  }
+  /**
+   * Synchronize the ## 🔗 Backlinks section in a file's content.
+   */
+  syncBacklinksSection(content, backlinksList) {
+    const backlinksHeading = _GraphParser.BACKLINKS_HEADING;
+    const headingRegex = new RegExp(`(?:\\r?\\n|^)${backlinksHeading}\\b[\\s\\S]*$`);
+    let backlinksSectionContent = `
+
+${backlinksHeading}
+
+`;
+    if (backlinksList.length > 0) {
+      backlinksSectionContent += backlinksList.map((b) => `- [[${b}]]`).join("\n");
+    } else {
+      backlinksSectionContent += "*(No backlinks found)*";
+    }
+    if (content.includes(backlinksHeading)) {
+      return content.replace(headingRegex, backlinksSectionContent);
+    } else {
+      return content.trimEnd() + backlinksSectionContent;
+    }
+  }
+  /**
+   * Clear all indexes for a note.
+   */
+  clearIndexForNote(sourceNote) {
+    const targets = this.forwardLinks.get(sourceNote);
+    if (targets) {
+      for (const target of targets) {
+        const backSet = this.backlinks.get(target);
+        if (backSet) {
+          backSet.delete(sourceNote);
+          if (backSet.size === 0) {
+            this.backlinks.delete(target);
+          }
+        }
+      }
+      this.forwardLinks.delete(sourceNote);
+    }
+  }
+};
+
+// src/core/knowledge/hybrid-search.ts
+var RRF_K = 60;
+var DEFAULT_MAX_RESULTS = 20;
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+var GRAPH_HOP_DEPTH = 2;
+var HybridSearch = class {
+  tagIndexer;
+  graphParser;
+  /** Stores indexed note content keyed by note name. */
+  contentMap = /* @__PURE__ */ new Map();
+  constructor(tagIndexer, graphParser) {
+    this.tagIndexer = tagIndexer;
+    this.graphParser = graphParser;
+  }
+  /**
+   * Register note content for lexical search.
+   * Must be called after TagIndexer.indexFile / GraphParser.indexFile.
+   */
+  indexContent(noteName, content) {
+    this.contentMap.set(noteName, content.toLowerCase());
+  }
+  /**
+   * Fuse lexical, tag, and graph rankings via RRF to produce a single list.
+   */
+  search(query, maxResults) {
+    const limit = maxResults ?? DEFAULT_MAX_RESULTS;
+    const terms = this.tokenize(query);
+    if (terms.length === 0) return [];
+    const lexicalRanked = this.lexicalSearch(terms);
+    const tagRanked = this.tagSearch(terms);
+    const graphRanked = this.graphSearch(terms);
+    return this.fuseResults(lexicalRanked, tagRanked, graphRanked, limit);
+  }
+  /**
+   * BM25-inspired term-frequency scoring across all indexed documents.
+   * Approximates IDF via corpus size and document frequency.
+   */
+  lexicalSearch(terms) {
+    const scores = /* @__PURE__ */ new Map();
+    const corpusSize = this.contentMap.size;
+    if (corpusSize === 0) return [];
+    const avgLen = this.computeAverageLength();
+    for (const term of terms) {
+      const df = this.documentFrequency(term);
+      const idf = Math.log((corpusSize - df + 0.5) / (df + 0.5) + 1);
+      for (const [name, content] of this.contentMap) {
+        const tf = this.countOccurrences(content, term);
+        if (tf === 0) continue;
+        const docLen = content.length;
+        const tfNorm = tf * (BM25_K1 + 1) / (tf + BM25_K1 * (1 - BM25_B + BM25_B * (docLen / avgLen)));
+        const prev = scores.get(name) ?? 0;
+        scores.set(name, prev + idf * tfNorm);
+      }
+    }
+    return this.sortByScore(scores);
+  }
+  /**
+   * Match query terms against the tag index to find tagged notes.
+   */
+  tagSearch(terms) {
+    const scores = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      const files = this.tagIndexer.getFilesWithTag(term);
+      for (const file3 of files) {
+        const noteName = this.graphParser.getNoteName(file3);
+        const prev = scores.get(noteName) ?? 0;
+        scores.set(noteName, prev + 1);
+      }
+    }
+    return this.sortByScore(scores);
+  }
+  /**
+   * 2-hop graph traversal from tag-matched seed notes to discover related notes.
+   */
+  graphSearch(terms) {
+    const seeds = new Set(this.tagSearch(terms));
+    const visited = /* @__PURE__ */ new Set();
+    const scores = /* @__PURE__ */ new Map();
+    for (const seed of seeds) {
+      this.traverseGraph(seed, GRAPH_HOP_DEPTH, visited, scores);
+    }
+    return this.sortByScore(scores);
+  }
+  /**
+   * Depth-limited BFS from a seed note, scoring neighbors by proximity.
+   */
+  traverseGraph(note, depth, visited, scores) {
+    if (depth <= 0 || visited.has(note)) return;
+    visited.add(note);
+    const neighbors = [
+      ...this.graphParser.getForwardLinks(note),
+      ...this.graphParser.getBacklinks(note)
+    ];
+    for (const neighbor of neighbors) {
+      const prev = scores.get(neighbor) ?? 0;
+      scores.set(neighbor, prev + depth);
+      this.traverseGraph(neighbor, depth - 1, visited, scores);
+    }
+  }
+  /**
+   * Reciprocal Rank Fusion: combine three ranked lists into a single ranking.
+   * Formula: score(d) = Σ 1/(k + rank_i) for each list where d appears.
+   */
+  fuseResults(lexical, tags, graph, limit) {
+    const fused = /* @__PURE__ */ new Map();
+    this.addRrfScores(fused, lexical, "lexical");
+    this.addRrfScores(fused, tags, "tag");
+    this.addRrfScores(fused, graph, "graph");
+    return Array.from(fused.entries()).map(([noteName, { score, matchType }]) => ({ noteName, score, matchType })).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /**
+   * Accumulate RRF scores from a single ranked list into the fused map.
+   * The matchType is set to the source with the highest individual contribution.
+   */
+  addRrfScores(fused, ranked, matchType) {
+    for (let i = 0; i < ranked.length; i++) {
+      const rrfScore = 1 / (RRF_K + i + 1);
+      const existing = fused.get(ranked[i]);
+      if (existing) {
+        existing.score += rrfScore;
+        if (rrfScore > 1 / (RRF_K + 1)) {
+          existing.matchType = matchType;
+        }
+      } else {
+        fused.set(ranked[i], { score: rrfScore, matchType });
+      }
+    }
+  }
+  /** Split query into lowercase tokens for matching. */
+  tokenize(query) {
+    return query.toLowerCase().split(/\s+/).filter(Boolean);
+  }
+  /** Count non-overlapping occurrences of a term in text. */
+  countOccurrences(text, term) {
+    let count = 0;
+    let pos = 0;
+    while ((pos = text.indexOf(term, pos)) !== -1) {
+      count++;
+      pos += term.length;
+    }
+    return count;
+  }
+  /** Average document length across the corpus (character-based). */
+  computeAverageLength() {
+    let total = 0;
+    for (const content of this.contentMap.values()) {
+      total += content.length;
+    }
+    return total / Math.max(this.contentMap.size, 1);
+  }
+  /** Number of documents containing the given term. */
+  documentFrequency(term) {
+    let count = 0;
+    for (const content of this.contentMap.values()) {
+      if (content.includes(term)) count++;
+    }
+    return count;
+  }
+  /** Sort entries by descending score and return the keys in order. */
+  sortByScore(scores) {
+    return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).map(([name]) => name);
+  }
+};
+
+// src/core/knowledge/tag-indexer.ts
+import { readFileSync as readFileSync5 } from "node:fs";
+var TagIndexer = class {
+  tagMap = /* @__PURE__ */ new Map();
+  fileCache = /* @__PURE__ */ new Map();
+  /**
+   * Parse frontmatter using regular expressions as a primary safe parser.
+   * This avoids library dependencies and provides deterministic error recovery.
+   */
+  parseFrontmatter(content) {
+    const data = {};
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { data, body: content };
+    }
+    const rawYaml = match[1];
+    const body = content.replace(frontmatterRegex, "").trim();
+    const lines = rawYaml.split(/\r?\n/);
+    let activeKey = null;
+    for (const line of lines) {
+      activeKey = this.parseYamlLine(line, data, activeKey);
+    }
+    return { data, body };
+  }
+  /**
+   * Parse a single YAML line and update data object in-place.
+   * Returns the currently active key for block list continuation.
+   */
+  parseYamlLine(line, data, activeKey) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return activeKey;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx !== -1) {
+      const key = trimmed.slice(0, colonIdx).trim();
+      const val = trimmed.slice(colonIdx + 1).trim();
+      if (val.startsWith("[") && val.endsWith("]")) {
+        data[key] = val.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+      } else if (val) {
+        data[key] = this.parseScalar(val);
+      } else {
+        data[key] = [];
+      }
+      return key;
+    }
+    if (trimmed.startsWith("-") && activeKey) {
+      const listVal = trimmed.slice(1).trim();
+      if (listVal) {
+        const currentList = Array.isArray(data[activeKey]) ? data[activeKey] : [];
+        currentList.push(listVal);
+        data[activeKey] = currentList;
+      }
+    }
+    return activeKey;
+  }
+  /**
+   * Index a single markdown file content dynamically.
+   */
+  indexFile(filePath, fileContent) {
+    this.clearIndexForFile(filePath);
+    const { data } = this.parseFrontmatter(fileContent);
+    this.fileCache.set(filePath, data);
+    if (data.tags && Array.isArray(data.tags)) {
+      for (const tag of data.tags) {
+        if (typeof tag === "string") {
+          this.addTagEntry(tag.toLowerCase(), filePath);
+        }
+      }
+    }
+  }
+  /**
+   * Index a file directly from the filesystem.
+   */
+  indexFileFromDisk(filePath) {
+    try {
+      const content = readFileSync5(filePath, "utf8");
+      this.indexFile(filePath, content);
+    } catch {
+      this.clearIndexForFile(filePath);
+    }
+  }
+  /**
+   * Get all files associated with a specific tag O(1).
+   */
+  getFilesWithTag(tag) {
+    return this.tagMap.get(tag.toLowerCase()) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get intersection of files containing all specified tags.
+   */
+  getFilesWithAllTags(tags) {
+    if (tags.length === 0) return /* @__PURE__ */ new Set();
+    let result = new Set(this.getFilesWithTag(tags[0]));
+    for (let i = 1; i < tags.length; i++) {
+      const currentSet = this.getFilesWithTag(tags[i]);
+      result = new Set([...result].filter((x) => currentSet.has(x)));
+    }
+    return result;
+  }
+  /**
+   * Get union of files containing any of the specified tags.
+   */
+  getFilesWithAnyTags(tags) {
+    const result = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      const files = this.getFilesWithTag(tag);
+      for (const file3 of files) {
+        result.add(file3);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get the cached frontmatter metadata of a file.
+   */
+  getMetadata(filePath) {
+    return this.fileCache.get(filePath);
+  }
+  /**
+   * Return all file paths that have been indexed.
+   */
+  getIndexedFiles() {
+    return Array.from(this.fileCache.keys());
+  }
+  /**
+   * Return all distinct tags currently present across all indexed files.
+   */
+  getAllTags() {
+    return Array.from(this.tagMap.keys());
+  }
+  /**
+   * Remove file references cleanly from tag mappings and metadata cache.
+   */
+  clearIndexForFile(filePath) {
+    this.fileCache.delete(filePath);
+    for (const [tag, files] of this.tagMap.entries()) {
+      if (files.has(filePath)) {
+        files.delete(filePath);
+        if (files.size === 0) {
+          this.tagMap.delete(tag);
+        }
+      }
+    }
+  }
+  /**
+   * Helper to insert tags atomically.
+   */
+  addTagEntry(tag, filePath) {
+    let files = this.tagMap.get(tag);
+    if (!files) {
+      files = /* @__PURE__ */ new Set();
+      this.tagMap.set(tag, files);
+    }
+    files.add(filePath);
+  }
+  /**
+   * Basic scalar value parser for YAML frontmatter fields.
+   */
+  parseScalar(val) {
+    if (val === "true") return true;
+    if (val === "false") return false;
+    const num = Number(val);
+    if (!isNaN(num)) return num;
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      return val.slice(1, -1);
+    }
+    return val;
+  }
+};
+
+// src/core/knowledge/context-provider.ts
+var MAX_RESULTS = 3;
+var MAX_SNIPPET_CHARS = 220;
+var KNOWLEDGE_ROOTS = ["docs", path10.join(".opencode", "docs")];
+var SKIP_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", "bin", ".git", "archive"]);
+var KnowledgeContextProvider = class {
+  buildPrompt(directory, query) {
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery) return null;
+    const markdownFiles = this.collectMarkdownFiles(directory);
+    if (markdownFiles.length === 0) return null;
+    const indexed = this.indexKnowledge(directory, markdownFiles);
+    const results = indexed.search.search(normalizedQuery, MAX_RESULTS);
+    if (results.length === 0) return null;
+    return this.formatPrompt(normalizedQuery, results, indexed);
+  }
+  collectMarkdownFiles(directory) {
+    const files = [];
+    for (const root of KNOWLEDGE_ROOTS) {
+      const fullRoot = path10.join(directory, root);
+      if (!existsSync10(fullRoot)) continue;
+      files.push(...this.walkDirectory(fullRoot));
+    }
+    return files.sort();
+  }
+  walkDirectory(directory) {
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const fullPath = path10.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_SEGMENTS.has(entry.name)) continue;
+        files.push(...this.walkDirectory(fullPath));
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  indexKnowledge(directory, files) {
+    const tagIndexer = new TagIndexer();
+    const graphParser = new GraphParser();
+    const search = new HybridSearch(tagIndexer, graphParser);
+    const noteToPath = /* @__PURE__ */ new Map();
+    const noteToSnippet = /* @__PURE__ */ new Map();
+    for (const filePath of files) {
+      try {
+        const content = readFileSync6(filePath, "utf8");
+        const noteName = graphParser.getNoteName(filePath);
+        const { body } = tagIndexer.parseFrontmatter(content);
+        const normalizedBody = body.trim();
+        tagIndexer.indexFile(filePath, content);
+        graphParser.indexFile(filePath, content);
+        search.indexContent(noteName, normalizedBody);
+        noteToPath.set(noteName, path10.relative(directory, filePath) || filePath);
+        noteToSnippet.set(noteName, this.buildSnippet(normalizedBody));
+      } catch {
+        continue;
+      }
+    }
+    return { search, noteToPath, noteToSnippet };
+  }
+  buildSnippet(content) {
+    const normalized = content.replace(/\s+/g, " ").trim();
+    if (normalized.length <= MAX_SNIPPET_CHARS) return normalized;
+    return `${normalized.slice(0, MAX_SNIPPET_CHARS)}...`;
+  }
+  formatPrompt(query, results, indexed) {
+    const lines = [
+      "<knowledge_rag_context>",
+      `Query: ${query}`,
+      "Repository knowledge matches:",
+      ""
+    ];
+    for (const [index, result] of results.entries()) {
+      const filePath = indexed.noteToPath.get(result.noteName) ?? result.noteName;
+      const snippet = indexed.noteToSnippet.get(result.noteName) ?? "";
+      lines.push(`${index + 1}. ${result.noteName} [${result.matchType}]`);
+      lines.push(`   Source: ${filePath}`);
+      if (snippet) {
+        lines.push(`   Snippet: ${snippet}`);
+      }
+    }
+    lines.push("");
+    lines.push("Use this as supplemental repository memory. Verify against source files before making claims.");
+    lines.push("</knowledge_rag_context>");
+    return lines.join("\n");
+  }
+};
+
+// src/plugin-handlers/system-transform-handler.ts
+var knowledgeContextProvider = new KnowledgeContextProvider();
 function createSystemTransformHandler(ctx) {
   const { directory, sessions, state: state2 } = ctx;
   return async (input, output) => {
@@ -41820,11 +42910,19 @@ function createSystemTransformHandler(ctx) {
     if (isActiveLoop && loopState) {
       const { commander: commander2 } = await Promise.resolve().then(() => (init_commander(), commander_exports));
       systemAdditions.push(commander2.systemPrompt);
-      systemAdditions.push(buildMissionLoopSystemPrompt(loopState.iteration, loopState.maxIterations));
+      systemAdditions.push(buildMissionLoopSystemPrompt(loopState));
     }
     if (session?.active) {
       systemAdditions.push(buildActiveSessionPrompt(session.step));
     }
+    const knowledgePrompt = buildKnowledgeContextPrompt(
+      directory,
+      loopState?.prompt,
+      state2.sessions.get(sessionID)?.currentTask
+    );
+    if (knowledgePrompt) {
+      systemAdditions.push(knowledgePrompt);
+    }
     try {
       const manager = ParallelAgentManager.getInstance();
       const tasks = manager.getTasksByParent(sessionID);
@@ -41840,18 +42938,29 @@ function createSystemTransformHandler(ctx) {
     }
   };
 }
-function buildMissionLoopSystemPrompt(iteration, maxIterations) {
+function buildKnowledgeContextPrompt(directory, missionPrompt, currentTask) {
+  const queryParts = [missionPrompt ?? "", currentTask ?? ""].filter(Boolean);
+  return knowledgeContextProvider.buildPrompt(directory, queryParts.join(" ").trim());
+}
+function buildMissionLoopSystemPrompt(loopState) {
   return `<orchestrator_mission_loop>
-\u{1F3AF} MISSION LOOP ACTIVE: Iteration ${iteration}/${maxIterations}
+\u{1F3AF} MISSION LOOP ACTIVE: Iteration ${loopState.iteration}/${loopState.maxIterations}
 
 You are in an autonomous mission loop. Continue working until ALL tasks are verified and 100% complete.
 
+ACTIVE OBJECTIVE:
+${loopState.objective ?? "Continue the active mission"}
+
+RUNTIME MEMORY:
+- Last progress: ${loopState.lastProgress ?? "unknown"}
+- Last verification: ${loopState.lastVerificationSummary ?? "unknown"}
+
 COMPLETION CRITERIA:
 - All hierarchical items in .opencode/todo.md are marked [x]
 - .opencode/verification-checklist.md is fully checked off [x]
 - All tests pass and builds succeed
 
-DO NOT stop or ask for permission. Execute autonomously.
+Do not stop for routine permission or preference checks. Execute autonomously, and ask a concise clarification only when truly blocked and the OpenCode question permission allows it.
 </orchestrator_mission_loop>`;
 }
 function buildActiveSessionPrompt(stepCount) {
@@ -41876,13 +42985,16 @@ Use \`delegate_task\` with background=true for parallel work.
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version: PLUGIN_VERSION } = require2("../package.json");
-var OrchestratorPlugin = async (input) => {
+var OrchestratorPlugin = async (input, options) => {
   const { directory, client } = input;
+  const orchestratorOptions = parseOrchestratorPluginOptions(options);
+  let concurrencyConfig = orchestratorOptions.concurrency;
+  configureMissionRuntimeOptions(orchestratorOptions.missionLoop);
   initializeHooks();
   initToastClient(client);
   const taskToastManager = initTaskToastManager(client);
   const sessions = /* @__PURE__ */ new Map();
-  const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory);
+  const parallelAgentManager2 = ParallelAgentManager.getInstance(client, directory, concurrencyConfig);
   const asyncAgentTools = createAsyncAgentTools(parallelAgentManager2, client);
   const pluginManager = PluginManager.getInstance();
   await pluginManager.initialize(directory);
@@ -41920,10 +43032,12 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     // Config hook - registers our commands and agents with OpenCode
     // -----------------------------------------------------------------
-    config: createConfigHandler(),
-    // -----------------------------------------------------------------
-    // Event hook - handles OpenCode events
-    // -----------------------------------------------------------------
+    config: createConfigHandler({
+      onConcurrencyConfig: (config3) => {
+        concurrencyConfig = mergeConcurrencyConfig(concurrencyConfig, config3);
+        parallelAgentManager2.configureConcurrency(concurrencyConfig);
+      }
+    }),
     // -----------------------------------------------------------------
     // Event hook - handles OpenCode events
     // -----------------------------------------------------------------
@@ -41945,27 +43059,23 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     // tool.execute.before hook - runs before any tool call
     // -----------------------------------------------------------------
-    "tool.execute.before": createToolExecuteBeforeHandler(handlerContext),
+    [PLUGIN_HOOKS.TOOL_EXECUTE_BEFORE]: createToolExecuteBeforeHandler(handlerContext),
     // -----------------------------------------------------------------
     // tool.execute.after hook - runs after any tool call completes
     // -----------------------------------------------------------------
     [PLUGIN_HOOKS.TOOL_EXECUTE_AFTER]: createToolExecuteAfterHandler(handlerContext),
     // -----------------------------------------------------------------
-    // assistant.done hook - runs when the LLM finishes responding
-    // -----------------------------------------------------------------
-    [PLUGIN_HOOKS.ASSISTANT_DONE]: createAssistantDoneHandler(handlerContext),
-    // -----------------------------------------------------------------
     // experimental.session.compacting hook - preserves mission context during compaction
     // -----------------------------------------------------------------
-    "experimental.session.compacting": createSessionCompactingHandler(handlerContext),
+    [PLUGIN_HOOKS.EXPERIMENTAL_SESSION_COMPACTING]: createSessionCompactingHandler(handlerContext),
     // -----------------------------------------------------------------
     // experimental.chat.system.transform hook - dynamic system prompt injection
     // -----------------------------------------------------------------
-    "experimental.chat.system.transform": createSystemTransformHandler(handlerContext),
+    [PLUGIN_HOOKS.EXPERIMENTAL_CHAT_SYSTEM_TRANSFORM]: createSystemTransformHandler(handlerContext),
     // -----------------------------------------------------------------
-    // shutdown hook - cleanup resources on plugin unload
+    // dispose hook - cleanup resources on plugin unload
     // -----------------------------------------------------------------
-    shutdown: async () => {
+    dispose: async () => {
       await shutdownManager.shutdown();
     }
   };