opencode-orchestrator 1.3.3 → 1.3.5

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();
   }
 });
 
@@ -216,7 +199,7 @@ var init_limits = __esm({
     "use strict";
     LIMITS = {
       /** Maximum mission loop iterations */
-      MAX_ITERATIONS: 1e4,
+      MAX_ITERATIONS: 1e9,
       /** Default scan limit for file listing */
       DEFAULT_SCAN_LIMIT: 20,
       /** Max message history to check for conclusion */
@@ -1494,6 +1477,9 @@ var init_session_events = __esm({
     "use strict";
     SESSION_EVENTS = {
       IDLE: "session.idle",
+      STATUS: "session.status",
+      UPDATED: "session.updated",
+      COMPACTED: "session.compacted",
       BUSY: "session.busy",
       ERROR: "session.error",
       DELETED: "session.deleted",
@@ -4737,9 +4723,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}`;
@@ -5514,6 +5501,9 @@ var ConcurrencyToken = class {
     }, autoReleaseMs);
     this.autoReleaseTimer.unref();
   }
+  controller;
+  key;
+  autoReleaseMs;
   released = false;
   autoReleaseTimer = null;
   /**
@@ -5857,6 +5847,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);
   }
@@ -7783,7 +7779,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.`);
@@ -17526,8 +17522,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();
@@ -18564,7 +18560,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();
@@ -18583,14 +18579,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;
@@ -21727,9 +21723,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()
@@ -21786,7 +21779,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}`);
           }
@@ -21812,6 +21805,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.
@@ -21981,6 +21981,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) {
@@ -22135,6 +22140,13 @@ var TaskPoller = class {
     this.pruneExpiredTasks = pruneExpiredTasks;
     this.onTaskComplete = onTaskComplete;
   }
+  client;
+  store;
+  concurrency;
+  notifyParentIfAllComplete;
+  scheduleCleanup;
+  pruneExpiredTasks;
+  onTaskComplete;
   pollingInterval;
   messageCache = /* @__PURE__ */ new Map();
   // Adaptive polling
@@ -22339,6 +22351,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])) {
@@ -22454,6 +22470,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.
@@ -22959,7 +22983,7 @@ var ParallelAgentManager = class _ParallelAgentManager {
   store = new TaskStore();
   client;
   directory;
-  concurrency = new ConcurrencyController();
+  concurrency;
   sessionPool;
   // Composed components
   launcher;
@@ -22967,9 +22991,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);
@@ -23021,12 +23046,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;
   }
@@ -23095,6 +23120,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);
   }
@@ -23723,7 +23751,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.`);
@@ -23868,7 +23896,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, {
@@ -32713,8 +32741,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();
@@ -33597,7 +33625,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();
@@ -33616,14 +33644,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;
@@ -34583,10 +34611,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 });
@@ -36413,8 +36441,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();
@@ -36522,19 +36550,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}`);
@@ -36543,12 +36751,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}`);
@@ -36557,7 +36765,7 @@ function writeLoopState(directory, state2) {
 }
 function clearLoopState(directory) {
   const filePath = getStateFilePath(directory);
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     return false;
   }
   try {
@@ -36578,17 +36786,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
@@ -36603,6 +36824,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;
@@ -36611,26 +36845,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) {
@@ -36643,6 +36899,9 @@ function ensureSessionInitialized(sessions, sessionID, directory) {
       startTime: now,
       lastStepTime: now,
       lastCompletedMessageID: void 0,
+      lastUserMessageAt: void 0,
+      lastAssistantCompletedAt: void 0,
+      lastAbortAt: void 0,
       tokens: { totalInput: 0, totalOutput: 0, estimatedCost: 0 }
     };
     if (directory) {
@@ -36697,6 +36956,14 @@ function isMissionActive(sessionID, directory) {
   }
   return false;
 }
+function deactivateMissionState(sessionID) {
+  const stateSession = state.sessions.get(sessionID);
+  if (stateSession) {
+    stateSession.enabled = false;
+  }
+  state.missionActive = false;
+  log(`[SessionManager] Mission Deactivated: ${sessionID}`);
+}
 var COST_PER_1K_INPUT = 3e-3;
 var COST_PER_1K_OUTPUT = 0.015;
 function updateSessionTokens(sessions, sessionID, inputLen, outputLen) {
@@ -36954,8 +37221,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();
@@ -37020,12 +37287,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}`);
@@ -37042,8 +37309,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;
@@ -37119,10 +37386,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;
@@ -37144,10 +37411,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(
@@ -37235,7 +37502,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 = {
@@ -37313,7 +37580,7 @@ async function notifyDarwin(title, message) {
 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;
@@ -37459,7 +37726,12 @@ var MissionControlHook = class {
   // -------------------------------------------------------------------------------
   async handleChatCommand(ctx, message) {
     const parsed = detectSlashCommand(message);
-    if (!parsed || parsed.command !== COMMAND_NAMES.TASK) return null;
+    if (!parsed) return null;
+    if (parsed.command === COMMAND_NAMES.CANCEL || parsed.command === COMMAND_NAMES.STOP) {
+      await this.cancelMission(ctx);
+      return { action: HOOK_ACTIONS.INTERCEPT };
+    }
+    if (parsed.command !== COMMAND_NAMES.TASK) return null;
     const command = COMMANDS[parsed.command];
     const { sessionID, sessions, directory } = ctx;
     log(MISSION_MESSAGES.START_LOG);
@@ -37477,6 +37749,17 @@ var MissionControlHook = class {
     }
     return { action: HOOK_ACTIONS.PROCESS };
   }
+  async cancelMission(ctx) {
+    const { sessionID, sessions, directory } = ctx;
+    log(MISSION_MESSAGES.CANCEL_LOG);
+    await cancelMissionLoop(directory, sessionID);
+    deactivateMissionState(sessionID);
+    clearSession2(sessionID);
+    const session = sessions.get(sessionID);
+    if (isRecord(session)) {
+      session.active = false;
+    }
+  }
   // -------------------------------------------------------------------------------
   // 2. Done Logic: Check Completion & Auto-Continue
   // -------------------------------------------------------------------------------
@@ -37529,6 +37812,9 @@ var MissionControlHook = class {
   // 4. Helper: Build Continuation Response
   // -------------------------------------------------------------------------------
   buildContinuationResponse(session, sessionID) {
+    if (!isMissionSessionState(session)) {
+      return { action: HOOK_ACTIONS.CONTINUE };
+    }
     const now = Date.now();
     const stepDuration = formatElapsedTime(session.lastStepTime, now);
     const totalElapsed = formatElapsedTime(session.startTime, now);
@@ -37586,6 +37872,12 @@ var MissionControlHook = class {
     }
   }
 };
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMissionSessionState(value) {
+  return isRecord(value) && typeof value.step === "number" && typeof value.startTime === "number" && typeof value.lastStepTime === "number";
+}
 
 // src/hooks/custom/strict-role-guard.ts
 init_shared();
@@ -38304,6 +38596,13 @@ function handleSessionError2(sessionID, error95) {
   }
   cancelCountdown(sessionID);
 }
+function handleAbort(sessionID) {
+  const state2 = getState3(sessionID);
+  state2.isAborting = true;
+  state2.abortDetectedAt = Date.now();
+  cancelCountdown(sessionID);
+  log("[todo-continuation] Marked as aborting", { sessionID });
+}
 function cleanupSession2(sessionID) {
   cancelCountdown(sessionID);
   sessionStates2.delete(sessionID);
@@ -38789,9 +39088,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 });
   }
 }
@@ -39293,15 +39592,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";
@@ -39313,30 +39612,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();
@@ -39350,10 +39649,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();
   }
   /**
@@ -39363,16 +39673,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);
@@ -39387,15 +39694,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 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() {
-    return new Promise((resolve) => {
+  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);
     });
@@ -39405,41 +39726,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);
     });
   }
   /**
@@ -39449,13 +39776,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");
@@ -39463,10 +39816,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 {
@@ -39474,6 +39825,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",
@@ -39482,11 +39835,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);
       }
     });
   }
@@ -39494,9 +39849,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
    */
@@ -39510,14 +39885,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`);
@@ -39534,11 +39902,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`);
@@ -39556,18 +39921,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();
@@ -39636,13 +40022,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
@@ -40788,6 +41176,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 isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readLimitMap(value) {
+  if (!isRecord2(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 (!isRecord2(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 (!isRecord2(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 = isRecord3(options) ? options : {};
+  return {
+    concurrency: extractConcurrencyConfig(source),
+    missionLoop: readMissionLoopOptions(source.missionLoop)
+  };
+}
+function readMissionLoopOptions(value) {
+  if (!isRecord3(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 isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/plugin-handlers/tool-execute-pre-handler.ts
 init_logger();
 function createToolExecuteBeforeHandler(ctx) {
@@ -40831,6 +41305,7 @@ function createChatMessageHandler(ctx) {
     const sessionID = msgInput.sessionID;
     const agentName = (msgInput.agent || "").toLowerCase();
     log("[chat-message-handler] hook triggered", { sessionID, agent: agentName, textLength: originalText.length });
+    markUserMessage(sessions, sessionID);
     if (sessionID && !sessions.has(sessionID)) {
     }
     const hooks = HookRegistry.getInstance();
@@ -40841,6 +41316,7 @@ function createChatMessageHandler(ctx) {
     };
     const hookResult = await hooks.executeChat(hookContext, originalText);
     if (hookResult.action === HOOK_ACTIONS.INTERCEPT) {
+      parts.splice(0, parts.length);
       return;
     }
     if (hookResult.modifiedMessage) {
@@ -40848,6 +41324,11 @@ function createChatMessageHandler(ctx) {
     }
   };
 }
+function markUserMessage(sessions, sessionID) {
+  const session = sessions.get(sessionID);
+  if (!session) return;
+  session.lastUserMessageAt = Date.now();
+}
 
 // src/plugin-handlers/config-handler.ts
 init_shared();
@@ -40899,8 +41380,41 @@ This plugin runs in "Claude Code Compatibility Mode".
 }
 
 // src/plugin-handlers/config-handler.ts
-function createConfigHandler() {
+function isRecord4(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 (isRecord4(globalPermission) && isRecord4(agentPermission)) {
+    return { ...globalPermission, ...agentPermission };
+  }
+  if (isPermissionAction(globalPermission) && isRecord4(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;
@@ -40912,8 +41426,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] = {
@@ -40924,39 +41439,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) {
@@ -40972,9 +41482,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;
   };
 }
 
@@ -41432,7 +41942,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}
 
@@ -41445,12 +41959,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);
@@ -41503,6 +42040,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;
   }
@@ -41517,8 +42068,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);
@@ -41526,9 +42098,11 @@ async function handleMissionIdle(client, directory, sessionID, mainSessionID) {
   }, MISSION_CONTROL.DEFAULT_COUNTDOWN_SECONDS * 1e3);
 }
 function handleUserMessage2(sessionID) {
+  const state2 = sessionStateStore.getState(sessionID);
+  state2.isAborting = false;
   sessionStateStore.cancelCountdown(sessionID);
 }
-function handleAbort(sessionID) {
+function handleAbort2(sessionID) {
   const state2 = sessionStateStore.getState(sessionID);
   state2.isAborting = true;
   sessionStateStore.cancelCountdown(sessionID);
@@ -41629,7 +42203,7 @@ function createEventHandler(ctx) {
       const error95 = event.properties?.error;
       if (sessionID) {
         handleSessionError2(sessionID, error95);
-        handleAbort(sessionID);
+        handleAbort2(sessionID);
       }
       if (sessionID && error95) {
         const recovered = await handleSessionError(
@@ -41656,6 +42230,7 @@ function createEventHandler(ctx) {
       if (sessionID && role === MESSAGE_ROLES.ASSISTANT) {
         markRecoveryComplete(sessionID);
         if (messageInfo?.id && messageInfo.time?.completed) {
+          markAssistantCompleted(sessions, sessionID);
           await handleCompletedAssistantMessage(ctx, sessionID, messageInfo.id);
         }
       }
@@ -41667,35 +42242,75 @@ function createEventHandler(ctx) {
     if (event.type === SESSION_EVENTS.IDLE) {
       const sessionID = event.properties?.sessionID || "";
       if (sessionID) {
-        const isMainSession = sessions.has(sessionID);
-        if (isMainSession) {
-          setTimeout(async () => {
-            const session = sessions.get(sessionID);
-            if (session?.active) {
-              if (isLoopActive(directory, sessionID)) {
-                await handleMissionIdle(
-                  client,
-                  directory,
-                  sessionID,
-                  sessionID
-                ).catch(() => {
-                });
-              } else {
-                await handleSessionIdle(
-                  client,
-                  directory,
-                  sessionID,
-                  sessionID
-                ).catch(() => {
-                });
-              }
-            }
-          }, 500);
-        }
+        scheduleIdleContinuation(ctx, sessionID);
+      }
+    }
+    if (event.type === SESSION_EVENTS.STATUS) {
+      const properties = event.properties;
+      const sessionID = properties?.sessionID ?? "";
+      if (sessionID && properties?.status?.type === "idle") {
+        scheduleIdleContinuation(ctx, sessionID);
       }
     }
   };
 }
+function markAssistantCompleted(sessions, sessionID) {
+  const session = sessions.get(sessionID);
+  if (!session) return;
+  session.lastAssistantCompletedAt = Date.now();
+}
+function shouldContinueAfterIdle(session) {
+  if (!session?.active || !session.lastAssistantCompletedAt) {
+    return false;
+  }
+  if (session.lastUserMessageAt && session.lastAssistantCompletedAt < session.lastUserMessageAt) {
+    return false;
+  }
+  if (session.lastAbortAt && session.lastAssistantCompletedAt < session.lastAbortAt) {
+    return false;
+  }
+  return true;
+}
+function markAbort(sessions, sessionID) {
+  const session = sessions.get(sessionID);
+  if (session) {
+    session.lastAbortAt = Date.now();
+  }
+  handleAbort(sessionID);
+  handleAbort2(sessionID);
+}
+function scheduleIdleContinuation(ctx, sessionID) {
+  const { client, directory, sessions } = ctx;
+  if (!sessions.has(sessionID)) return;
+  setTimeout(async () => {
+    const session = sessions.get(sessionID);
+    if (!shouldContinueAfterIdle(session)) {
+      markAbort(sessions, sessionID);
+      return;
+    }
+    if (isLoopActive(directory, sessionID)) {
+      try {
+        await handleMissionIdle(
+          client,
+          directory,
+          sessionID,
+          sessionID
+        );
+      } catch {
+      }
+      return;
+    }
+    try {
+      await handleSessionIdle(
+        client,
+        directory,
+        sessionID,
+        sessionID
+      );
+    } catch {
+    }
+  }, 500);
+}
 
 // src/plugin-handlers/tool-execute-handler.ts
 init_logger();
@@ -41777,6 +42392,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 ? "..." : ""}
 
@@ -41817,7 +42435,7 @@ Wait for these tasks to complete before concluding the mission.
 init_shared();
 
 // src/core/knowledge/context-provider.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6, readdirSync } from "node:fs";
 import path10 from "node:path";
 
 // src/core/knowledge/graph-parser.ts
@@ -42111,7 +42729,7 @@ var HybridSearch = class {
 };
 
 // src/core/knowledge/tag-indexer.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 var TagIndexer = class {
   tagMap = /* @__PURE__ */ new Map();
   fileCache = /* @__PURE__ */ new Map();
@@ -42185,7 +42803,7 @@ var TagIndexer = class {
    */
   indexFileFromDisk(filePath) {
     try {
-      const content = readFileSync4(filePath, "utf8");
+      const content = readFileSync5(filePath, "utf8");
       this.indexFile(filePath, content);
     } catch {
       this.clearIndexForFile(filePath);
@@ -42300,7 +42918,7 @@ var KnowledgeContextProvider = class {
     const files = [];
     for (const root of KNOWLEDGE_ROOTS) {
       const fullRoot = path10.join(directory, root);
-      if (!existsSync9(fullRoot)) continue;
+      if (!existsSync10(fullRoot)) continue;
       files.push(...this.walkDirectory(fullRoot));
     }
     return files.sort();
@@ -42328,7 +42946,7 @@ var KnowledgeContextProvider = class {
     const noteToSnippet = /* @__PURE__ */ new Map();
     for (const filePath of files) {
       try {
-        const content = readFileSync5(filePath, "utf8");
+        const content = readFileSync6(filePath, "utf8");
         const noteName = graphParser.getNoteName(filePath);
         const { body } = tagIndexer.parseFrontmatter(content);
         const normalizedBody = body.trim();
@@ -42388,7 +43006,7 @@ 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));
@@ -42420,18 +43038,25 @@ function buildKnowledgeContextPrompt(directory, missionPrompt, currentTask) {
   const queryParts = [missionPrompt ?? "", currentTask ?? ""].filter(Boolean);
   return knowledgeContextProvider.buildPrompt(directory, queryParts.join(" ").trim());
 }
-function buildMissionLoopSystemPrompt(iteration, maxIterations) {
+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) {
@@ -42456,13 +43081,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);
@@ -42500,10 +43128,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
     // -----------------------------------------------------------------
@@ -42539,9 +43169,9 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     [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();
     }
   };