oh-my-opencode-slim 2.0.0-beta.12 → 2.0.0-beta.14

package/dist/index.js

@@ -18196,6 +18196,13 @@ function getCustomOpenCodeConfigDir() {
   const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   return configDir || undefined;
 }
+function getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
 function getConfigSearchDirs() {
   const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
   return dirs.filter((dir, index) => {
@@ -18203,7 +18210,7 @@ function getConfigSearchDirs() {
   });
 }
 function getOpenCodeConfigPaths() {
-  const configDir = getDefaultOpenCodeConfigDir();
+  const configDir = getConfigDir();
   return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
 }
 
@@ -18232,6 +18239,12 @@ var CUSTOM_SKILLS = [
     description: "Heavy/complex coding sessions and large modifications workflow",
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/deepwork"
+  },
+  {
+    name: "oh-my-opencode-slim",
+    description: "Configure, customize, and safely improve oh-my-opencode-slim setups",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/oh-my-opencode-slim"
   }
 ];
 
@@ -18597,12 +18610,6 @@ var DivoomConfigSchema = z2.object({
   posterizeBits: z2.number().int().min(1).max(8).default(3),
   gifs: z2.record(z2.string(), z2.string().min(1)).optional()
 });
-var TodoContinuationConfigSchema = z2.object({
-  maxContinuations: z2.number().int().min(1).max(50).default(5).describe("Maximum consecutive auto-continuations before stopping to ask user"),
-  cooldownMs: z2.number().int().min(0).max(30000).default(3000).describe("Delay in ms before auto-continuing (gives user time to abort)"),
-  autoEnable: z2.boolean().default(false).describe("Automatically enable auto-continue when the orchestrator session has enough todos"),
-  autoEnableThreshold: z2.number().int().min(1).max(50).default(4).describe("Number of todos that triggers auto-enable (only used when autoEnable is true)")
-});
 var FailoverConfigSchema = z2.object({
   enabled: z2.boolean().default(true),
   timeoutMs: z2.number().min(0).default(15000),
@@ -18649,7 +18656,6 @@ var PluginConfigSchema = z2.object({
   interview: InterviewConfigSchema.optional(),
   backgroundJobs: BackgroundJobsConfigSchema.optional(),
   divoom: DivoomConfigSchema.optional(),
-  todoContinuation: TodoContinuationConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
 }).superRefine((value, ctx) => {
@@ -18903,34 +18909,32 @@ function parseModelReference(model) {
 async function promptWithTimeout(client, args, timeoutMs, signal) {
   if (signal?.aborted)
     throw new Error("Prompt cancelled");
-  if (timeoutMs <= 0) {
-    await client.session.prompt(args);
-    return;
-  }
   const sessionId = args.path.id;
+  const hasTimeout = timeoutMs > 0;
   let timer;
   let onAbort;
   try {
     const promptPromise = client.session.prompt(args);
     promptPromise.catch(() => {});
-    await Promise.race([
-      promptPromise,
-      new Promise((_, reject) => {
+    const racers = [promptPromise];
+    if (hasTimeout) {
+      racers.push(new Promise((_, reject) => {
         timer = setTimeout(() => {
           reject(new OperationTimeoutError(`Prompt timed out after ${timeoutMs}ms`));
         }, timeoutMs);
-      }),
-      new Promise((_, reject) => {
-        if (!signal)
-          return;
+      }));
+    }
+    if (signal) {
+      racers.push(new Promise((_, reject) => {
         if (signal.aborted) {
           reject(new Error("Prompt cancelled"));
           return;
         }
         onAbort = () => reject(new Error("Prompt cancelled"));
         signal.addEventListener("abort", onAbort, { once: true });
-      })
-    ]);
+      }));
+    }
+    await Promise.race(racers);
   } catch (error) {
     if (error instanceof OperationTimeoutError) {
       try {
@@ -19161,13 +19165,6 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 - If multiple remembered sessions fit, prefer the most recently used matching session.
 - Prefer re-uses over creating new sessions all the time
 
-### Auto-Continue
-When working through multi-step tasks, consider enabling auto-continue to avoid stopping between batches:
-- **Enable when:** User requests autonomous/batch work, or you create 4+ todos in a session
-- **Don't enable when:** User is in an interactive/conversational flow, or each step needs explicit review
-- Use the \`auto_continue\` tool with \`enabled: true\` to activate. The system will automatically resume you when incomplete todos remain after you stop.
-- The user can toggle this anytime via the \`/auto-continue\` command.
-
 ### Validation routing
 - Validation is a workflow stage owned by the Orchestrator, not a separate specialist
 ${enabledValidationRouting}
@@ -20039,10 +20036,6 @@ function setActiveRuntimePresetWithPrevious(name) {
   previousRuntimePreset = activeRuntimePreset;
   activeRuntimePreset = name;
 }
-function rollbackRuntimePreset(previous) {
-  activeRuntimePreset = previous;
-  previousRuntimePreset = null;
-}
 
 // src/utils/logger.ts
 import * as fs2 from "node:fs";
@@ -20055,7 +20048,7 @@ var RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 var logFile = null;
 var writeChain = Promise.resolve();
 function getLogDir() {
-  return process.env.OPENCODE_LOG_DIR ?? path2.join(os.homedir(), ".local/share/opencode");
+  return process.env.OPENCODE_LOG_DIR ?? path2.join(os.homedir(), ".local/share/opencode/log");
 }
 function cleanupOldLogs(logDir) {
   try {
@@ -22642,6 +22635,10 @@ function createDisplayNameMentionRewriter(config) {
   };
 }
 // src/utils/task.ts
+var TRANSIENT_PROCESS_ERROR_TEXT = new Set([
+  "Task is not running in this process and has no final output.",
+  "Task is not running in this process and has not produced output."
+]);
 function parseTaskIdFromTaskOutput(output) {
   const lines = output.split(/\r?\n/);
   for (const line of lines) {
@@ -22677,6 +22674,19 @@ function parseTaskStatusOutput(output) {
     result: parseTaskResultFromOutput(output)
   };
 }
+function classifyTaskStatusOutput(status) {
+  if (status.timedOut)
+    return "timeout";
+  if (status.state === "running")
+    return "running";
+  if (status.state === "completed" || status.state === "cancelled") {
+    return "terminal";
+  }
+  if (TRANSIENT_PROCESS_ERROR_TEXT.has(status.result ?? "")) {
+    return "transient_process_error";
+  }
+  return "unknown_error";
+}
 function parseTaskStateFromOutput(output) {
   for (const line of getTaskHeader(output).split(/\r?\n/)) {
     const match = /^state:\s*(running|completed|error|cancelled)\s*$/i.exec(line.trim());
@@ -22735,11 +22745,15 @@ class BackgroundJobBoard {
         objective: input.objective ?? existing.objective,
         state: "running",
         timedOut: false,
+        statusUncertain: false,
+        cancellationRequested: false,
         terminalUnreconciled: false,
         completedAt: undefined,
         resultSummary: undefined,
+        lastStatusError: undefined,
         terminalState: undefined,
         lastLaunchedAt: now,
+        lastLiveBusyAt: now,
         lastUsedAt: now,
         updatedAt: now
       };
@@ -22754,9 +22768,12 @@ class BackgroundJobBoard {
       objective: input.objective,
       state: "running",
       timedOut: false,
+      statusUncertain: false,
+      cancellationRequested: false,
       terminalUnreconciled: false,
       launchedAt: now,
       lastLaunchedAt: now,
+      lastLiveBusyAt: now,
       lastUsedAt: now,
       updatedAt: now,
       alias: this.nextAlias(input.parentSessionID, input.agent),
@@ -22778,11 +22795,13 @@ class BackgroundJobBoard {
       ...existing,
       state: input.state,
       timedOut: input.timedOut ?? false,
+      statusUncertain: input.statusUncertain ?? false,
       terminalUnreconciled: terminal ? true : existing.terminalUnreconciled,
       updatedAt: now,
       completedAt: terminal ? existing.completedAt ?? now : existing.completedAt,
       terminalState: terminal ? input.state : existing.terminalState,
-      resultSummary: input.resultSummary ?? existing.resultSummary
+      resultSummary: input.resultSummary ?? existing.resultSummary,
+      lastStatusError: input.lastStatusError
     };
     this.jobs.set(input.taskID, updated);
     this.trimReusable(input.taskID);
@@ -22803,18 +22822,28 @@ class BackgroundJobBoard {
     const existing = this.jobs.get(taskID);
     if (!existing)
       return;
-    const isStaleCancellation = existing.state === "cancelled" || existing.state === "reconciled" && existing.terminalState === "cancelled";
-    if (!isStaleCancellation)
-      return existing;
+    const isStaleTerminal = TERMINAL_STATES.has(existing.state) || existing.state === "reconciled";
+    if (!isStaleTerminal || existing.cancellationRequested) {
+      const updated2 = {
+        ...existing,
+        lastLiveBusyAt: now
+      };
+      this.jobs.set(taskID, updated2);
+      return updated2;
+    }
     const updated = {
       ...existing,
       state: "running",
       timedOut: false,
+      statusUncertain: false,
+      cancellationRequested: false,
       terminalUnreconciled: false,
       updatedAt: now,
+      lastLiveBusyAt: now,
       completedAt: undefined,
       terminalState: undefined,
-      resultSummary: undefined
+      resultSummary: undefined,
+      lastStatusError: undefined
     };
     this.jobs.set(taskID, updated);
     return updated;
@@ -22830,6 +22859,7 @@ class BackgroundJobBoard {
       ...existing,
       state: "reconciled",
       terminalUnreconciled: false,
+      statusUncertain: false,
       updatedAt: now,
       lastUsedAt: now,
       terminalState: existing.terminalState ?? terminalStateOf(existing.state)
@@ -22838,24 +22868,29 @@ class BackgroundJobBoard {
     this.trimReusable(taskID);
     return updated;
   }
-  markCancelled(taskID, reason, now = Date.now()) {
+  markCancelled(taskID, reason, now = Date.now(), options = {}) {
     const existing = this.jobs.get(taskID);
     if (!existing)
       return;
-    if (existing.state === "reconciled")
-      return existing;
-    if (TERMINAL_STATES.has(existing.state))
-      return existing;
+    if (!options.force) {
+      if (existing.state === "reconciled")
+        return existing;
+      if (TERMINAL_STATES.has(existing.state))
+        return existing;
+    }
     const summary = normalizeCancelReason(reason);
     const updated = {
       ...existing,
       state: "cancelled",
       timedOut: false,
+      statusUncertain: false,
+      cancellationRequested: true,
       terminalUnreconciled: true,
       updatedAt: now,
       completedAt: existing.completedAt ?? now,
       terminalState: "cancelled",
-      resultSummary: summary
+      resultSummary: summary,
+      lastStatusError: undefined
     };
     this.jobs.set(taskID, updated);
     return updated;
@@ -22925,7 +22960,7 @@ class BackgroundJobBoard {
     return [
       "### Background Job Board",
       "SENTINEL: background-job-board-v2",
-      "Use task_status for running jobs. Reconcile terminal jobs before final response. Reuse any non-running session for the same specialist/context.",
+      "Use task_status for running jobs. Reconcile terminal jobs before final response. Reuse only completed sessions for the same specialist/context; never reuse cancelled or errored sessions.",
       "",
       "#### Active / Unreconciled",
       ...active.length > 0 ? active.map((job) => formatJob(job, now)) : ["- none"],
@@ -22981,7 +23016,8 @@ function deriveTaskSessionLabel(input) {
   return firstPromptLine ? firstPromptLine.slice(0, 48) : `recent ${input.agentType} task`;
 }
 function isReusable(job) {
-  return job.state !== "running";
+  const terminal = job.terminalState ?? terminalStateOf(job.state);
+  return terminal === "completed" && !job.terminalUnreconciled;
 }
 function terminalStateOf(state) {
   return state === "completed" || state === "error" || state === "cancelled" ? state : undefined;
@@ -23001,13 +23037,15 @@ function formatJob(job, now = Date.now()) {
   const ageMs = now - job.lastLaunchedAt;
   const isResume = job.lastLaunchedAt !== job.launchedAt;
   const ageLabel = job.state === "running" && ageMs < 30000 ? ` [${isResume ? "resumed" : "just launched"}, ${Math.floor(ageMs / 1000)}s ago]` : "";
-  const status = job.terminalUnreconciled ? `${job.state}, unreconciled` : job.timedOut ? `${job.state}, timed out` : `${job.state}${ageLabel}`;
+  const status = job.terminalUnreconciled ? `${job.state}, unreconciled` : job.statusUncertain ? `${job.state}, status uncertain` : job.timedOut ? `${job.state}, timed out` : `${job.state}${ageLabel}`;
   const lines = [
     `- ${job.alias} / ${job.taskID} / ${job.agent} / ${status}`,
     `  Objective: ${job.objective || job.description}`
   ];
   if (job.resultSummary && job.terminalUnreconciled) {
     lines.push(`  Result: ${singleLine(job.resultSummary)}`);
+  } else if (job.lastStatusError && job.statusUncertain) {
+    lines.push(`  Status: ${singleLine(job.lastStatusError)}`);
   }
   return lines.join(`
 `);
@@ -24094,6 +24132,17 @@ function createTaskSessionManagerHook(_ctx, options) {
       timedOut: status.timedOut,
       hasResult: Boolean(status.result)
     });
+    const existing = backgroundJobBoard.get(status.taskID);
+    if (isLateCancelledTaskError(existing, status.state)) {
+      log("[task-session-manager] suppressed late cancelled task error", {
+        taskID: status.taskID,
+        alias: existing?.alias,
+        state: existing?.state,
+        terminalState: existing?.terminalState,
+        result: status.result
+      });
+      return existing;
+    }
     const updated = backgroundJobBoard.updateStatus({
       taskID: status.taskID,
       state: status.state,
@@ -24122,6 +24171,61 @@ function createTaskSessionManagerHook(_ctx, options) {
     }
     return updated;
   }
+  async function handleTransientTaskStatusOutput(output) {
+    if (typeof output.output !== "string")
+      return false;
+    const status = parseTaskStatusOutput(output.output);
+    if (!status)
+      return false;
+    if (classifyTaskStatusOutput(status) !== "transient_process_error") {
+      return false;
+    }
+    const existing = backgroundJobBoard.get(status.taskID);
+    const liveStatus = existing && existing.state === "running" ? undefined : await getLiveSessionStatus(status.taskID);
+    const recentLiveBusy = !!existing?.lastLiveBusyAt && (!existing.completedAt || existing.lastLiveBusyAt >= existing.completedAt);
+    const isStillRunning = existing?.state === "running" || recentLiveBusy || liveStatus === "busy" || liveStatus === "retry";
+    if (!isStillRunning)
+      return false;
+    const updated = existing?.state === "running" ? backgroundJobBoard.updateStatus({
+      taskID: status.taskID,
+      state: "running",
+      statusUncertain: true,
+      lastStatusError: status.result
+    }) : undefined;
+    log("[task-session-manager] classified transient task_status error", {
+      taskID: status.taskID,
+      alias: existing?.alias,
+      parentSessionID: existing?.parentSessionID,
+      previousState: existing?.state,
+      updatedState: updated?.state,
+      liveStatus,
+      recentLiveBusy
+    });
+    return true;
+  }
+  async function getLiveSessionStatus(sessionID) {
+    try {
+      const response = await _ctx.client.session.status();
+      const data = response.data;
+      if (!isObjectRecord(data))
+        return;
+      const item = data[sessionID];
+      if (item === undefined)
+        return "idle";
+      if (isObjectRecord(item) && typeof item.type === "string") {
+        return item.type;
+      }
+      const directType = data.type;
+      if (typeof directType === "string")
+        return directType;
+      const nestedStatus = data.status;
+      if (!isObjectRecord(nestedStatus))
+        return;
+      return typeof nestedStatus.type === "string" ? nestedStatus.type : undefined;
+    } catch {
+      return;
+    }
+  }
   function updateFromInjectedCompletion(part, message, _messageIndex, partIndex) {
     if (part.type !== "text" || typeof part.text !== "string") {
       return;
@@ -24134,11 +24238,24 @@ function createTaskSessionManagerHook(_ctx, options) {
     const status = parseTaskStatusOutput(part.text);
     if (!status)
       return;
+    const occurrenceId = createOccurrenceId(part, message, partIndex);
+    const existing = backgroundJobBoard.get(status.taskID);
+    if (isFailed && isLateCancelledTaskError(existing, status.state)) {
+      part.text = formatCancelledTaskStatusOutput(status.taskID, existing?.resultSummary);
+      log("[task-session-manager] normalized late cancelled injected failure", {
+        taskID: status.taskID,
+        alias: existing?.alias,
+        state: existing?.state,
+        terminalState: existing?.terminalState,
+        result: status.result
+      });
+      rememberProcessedInjectedCompletion(occurrenceId);
+      return existing;
+    }
     if (isCompleted && status.state !== "completed")
       return;
     if (isFailed && status.state !== "error")
       return;
-    const occurrenceId = createOccurrenceId(part, message, partIndex);
     if (processedInjectedCompletions.has(occurrenceId))
       return;
     const updated = updateBackgroundJobFromOutput(part.text);
@@ -24298,6 +24415,10 @@ function createTaskSessionManagerHook(_ctx, options) {
         if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
           return;
         }
+        normalizeLateCancelledToolStatus(output);
+        if (await handleTransientTaskStatusOutput(output)) {
+          return;
+        }
         updateBackgroundJobFromOutput(output.output);
         return;
       }
@@ -24421,12 +24542,27 @@ function createTaskSessionManagerHook(_ctx, options) {
         const sessionId2 = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
         const before = sessionId2 ? backgroundJobBoard.get(sessionId2) : undefined;
         const updated = sessionId2 ? backgroundJobBoard.markRunningFromLiveSession(sessionId2) : undefined;
+        if (before?.cancellationRequested) {
+          log("[task-session-manager] busy observed after cancel request", {
+            sessionID: sessionId2,
+            previousState: before.state,
+            previousTerminalState: before.terminalState,
+            terminalUnreconciled: before.terminalUnreconciled,
+            resultSummary: before.resultSummary,
+            updatedState: updated?.state,
+            updatedCancellationRequested: updated?.cancellationRequested
+          });
+        }
         log("[task-session-manager] busy/status busy observed", {
           sessionID: sessionId2,
           managesSession: sessionId2 ? options.shouldManageSession(sessionId2) : false,
           previousState: before?.state,
           previousTerminalState: before?.terminalState,
-          updatedState: updated?.state
+          previousCancellationRequested: before?.cancellationRequested,
+          previousLastLiveBusyAt: before?.lastLiveBusyAt,
+          updatedState: updated?.state,
+          updatedCancellationRequested: updated?.cancellationRequested,
+          updatedLastLiveBusyAt: updated?.lastLiveBusyAt
         });
         return;
       }
@@ -24459,715 +24595,45 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
     }
   };
-}
-// src/hooks/todo-continuation/index.ts
-import { tool } from "@opencode-ai/plugin";
-
-// src/hooks/todo-continuation/todo-hygiene.ts
-var TODO_HYGIENE_REMINDER = "If the active task changed or finished, update the todo list to match the current work state.";
-var TODO_FINAL_ACTIVE_REMINDER = "If you are finishing now, do not leave the active todo in_progress. Mark it completed, or move unfinished work back to pending.";
-var RESET = new Set(["todowrite"]);
-var IGNORE = new Set(["auto_continue"]);
-function createTodoHygiene(options) {
-  const pending = new Map;
-  const active = new Set;
-  function clearCycle(sessionID) {
-    pending.delete(sessionID);
-  }
-  function clear(sessionID) {
-    clearCycle(sessionID);
-    active.delete(sessionID);
-  }
-  function isFinalActive(state) {
-    return state.inProgressCount === 1 && state.pendingCount === 0 && state.openCount === 1;
-  }
-  function mark(sessionID, reason) {
-    const reasons = pending.get(sessionID) ?? new Set;
-    reasons.add(reason);
-    pending.set(sessionID, reasons);
-  }
-  function pick(reasons) {
-    if (reasons.has("final_active")) {
-      return TODO_FINAL_ACTIVE_REMINDER;
-    }
-    return TODO_HYGIENE_REMINDER;
-  }
-  return {
-    handleRequestStart(input) {
-      clear(input.sessionID);
-    },
-    async handleToolExecuteAfter(input, _output) {
-      if (!input.sessionID) {
-        return;
-      }
-      const tool = input.tool.toLowerCase();
-      if (IGNORE.has(tool)) {
-        return;
-      }
-      try {
-        if (RESET.has(tool)) {
-          if (options.shouldInject && !options.shouldInject(input.sessionID)) {
-            clear(input.sessionID);
-            return;
-          }
-          active.add(input.sessionID);
-          clearCycle(input.sessionID);
-          const state2 = await options.getTodoState(input.sessionID);
-          if (!state2.hasOpenTodos) {
-            active.delete(input.sessionID);
-            options.log?.("Cleared todo hygiene cycle", {
-              sessionID: input.sessionID,
-              tool
-            });
-            return;
-          }
-          if (!isFinalActive(state2)) {
-            options.log?.("Reset todo hygiene cycle", {
-              sessionID: input.sessionID,
-              tool
-            });
-            return;
-          }
-          mark(input.sessionID, "final_active");
-          options.log?.("Armed final-active todo hygiene reminder", {
-            sessionID: input.sessionID,
-            tool
-          });
-          return;
-        }
-        if (!active.has(input.sessionID)) {
-          return;
-        }
-        if (pending.get(input.sessionID)?.has("final_active")) {
-          return;
-        }
-        if (options.shouldInject && !options.shouldInject(input.sessionID)) {
-          clear(input.sessionID);
-          return;
-        }
-        const state = await options.getTodoState(input.sessionID);
-        if (!state.hasOpenTodos) {
-          clear(input.sessionID);
-          return;
-        }
-        if (isFinalActive(state)) {
-          mark(input.sessionID, "final_active");
-        } else {
-          mark(input.sessionID, "general");
-        }
-        options.log?.("Armed todo hygiene reminder", {
-          sessionID: input.sessionID,
-          tool,
-          reasons: Array.from(pending.get(input.sessionID) ?? [])
-        });
-      } catch (error) {
-        options.log?.("Skipped todo hygiene reminder: failed to inspect todos", {
-          sessionID: input.sessionID,
-          tool,
-          error: error instanceof Error ? error.message : String(error)
-        });
-      }
-    },
-    getPendingReminder(sessionID) {
-      const reasons = pending.get(sessionID);
-      if (!reasons || reasons.size === 0) {
-        return null;
-      }
-      if (options.shouldInject && !options.shouldInject(sessionID)) {
-        clear(sessionID);
-        return null;
-      }
-      const reminder = pick(reasons);
-      options.log?.("Read todo hygiene reminder", {
-        sessionID,
-        reminder,
-        reasons: Array.from(reasons)
-      });
-      return reminder;
-    },
-    handleEvent(event) {
-      if (event.type !== "session.deleted") {
-        return;
-      }
-      const sessionID = event.properties?.sessionID ?? event.properties?.info?.id;
-      if (!sessionID) {
-        return;
-      }
-      clear(sessionID);
-    }
-  };
-}
-
-// src/hooks/todo-continuation/index.ts
-var HOOK_NAME = "todo-continuation";
-var COMMAND_NAME2 = "auto-continue";
-var TODO_STATE_TIMEOUT_MS = 500;
-var CONTINUATION_PROMPT = "[Auto-continue: enabled - there are incomplete todos remaining. Continue with the next uncompleted item. Press Esc to cancel. If you need user input or review for the next item, ask instead of proceeding.]";
-var TODO_HYGIENE_INSTRUCTION_OPEN = '<instruction name="todo_hygiene">';
-var TODO_HYGIENE_INSTRUCTION_CLOSE = "</instruction>";
-var SUPPRESS_AFTER_ABORT_MS = 5000;
-var NOTIFICATION_BUSY_GRACE_MS = 250;
-var QUESTION_PHRASES = [
-  "would you like",
-  "should i",
-  "do you want",
-  "please review",
-  "let me know",
-  "what do you think",
-  "can you confirm",
-  "would you prefer",
-  "shall i",
-  "any thoughts"
-];
-var TERMINAL_TODO_STATUSES = ["completed", "cancelled"];
-function isQuestion(text) {
-  const lowerText = text.toLowerCase().trim();
-  if (/\?\s*$/.test(lowerText)) {
-    return true;
-  }
-  return QUESTION_PHRASES.some((phrase) => lowerText.includes(phrase));
-}
-function cancelPendingTimer(state) {
-  if (state.pendingTimer) {
-    clearTimeout(state.pendingTimer);
-    state.pendingTimer = null;
-  }
-  state.pendingTimerSessionId = null;
-}
-function resetState(state) {
-  cancelPendingTimer(state);
-  state.consecutiveContinuations = 0;
-  state.suppressUntil = 0;
-  state.isAutoInjecting = false;
-  state.notifyingSessionIds.clear();
-  state.notificationBusyUntilBySession.clear();
-}
-function stripTodoHygieneInstruction(text) {
-  const trimmed = text.trimEnd();
-  if (!trimmed.endsWith(TODO_HYGIENE_INSTRUCTION_CLOSE)) {
-    return trimmed;
-  }
-  const start = trimmed.lastIndexOf(TODO_HYGIENE_INSTRUCTION_OPEN);
-  if (start === -1) {
-    return trimmed;
-  }
-  return trimmed.slice(0, start).trimEnd();
-}
-function appendTodoHygieneInstruction(message, reminder) {
-  const textPart = [...message.parts].reverse().find((part) => part.type === "text" && typeof part.text === "string");
-  if (!textPart)
-    return;
-  const baseText = stripTodoHygieneInstruction(textPart.text ?? "");
-  const instruction = `${TODO_HYGIENE_INSTRUCTION_OPEN}
-${reminder}
-${TODO_HYGIENE_INSTRUCTION_CLOSE}`;
-  textPart.text = baseText ? `${baseText}
-
-${instruction}` : instruction;
-}
-function stripTodoHygieneInstructionFromMessage(message) {
-  const textPart = [...message.parts].reverse().find((part) => part.type === "text" && typeof part.text === "string");
-  if (!textPart)
-    return;
-  textPart.text = stripTodoHygieneInstruction(textPart.text ?? "");
-}
-function createTodoContinuationHook(ctx, config) {
-  const maxContinuations = config?.maxContinuations ?? 5;
-  const cooldownMs = config?.cooldownMs ?? 3000;
-  const autoEnable = config?.autoEnable ?? false;
-  const autoEnableThreshold = config?.autoEnableThreshold ?? 4;
-  const backgroundJobBoard = config?.backgroundJobBoard;
-  const requestSignatureBySession = new Map;
-  const state = {
-    enabled: false,
-    consecutiveContinuations: 0,
-    pendingTimer: null,
-    pendingTimerSessionId: null,
-    suppressUntil: 0,
-    orchestratorSessionIds: new Set,
-    sawChatMessage: false,
-    isAutoInjecting: false,
-    notifyingSessionIds: new Set,
-    notificationBusyUntilBySession: new Map
-  };
-  async function fetchTodos(sessionID) {
-    const result = await withTimeout(ctx.client.session.todo({
-      path: { id: sessionID }
-    }), TODO_STATE_TIMEOUT_MS, `Todo state lookup timed out after ${TODO_STATE_TIMEOUT_MS}ms`);
-    return result.data;
-  }
-  const hygiene = createTodoHygiene({
-    getTodoState: async (sessionID) => {
-      const todos = await fetchTodos(sessionID);
-      const openTodos = todos.filter((todo) => !TERMINAL_TODO_STATUSES.includes(todo.status));
-      return {
-        hasOpenTodos: openTodos.length > 0,
-        openCount: openTodos.length,
-        inProgressCount: openTodos.filter((todo) => todo.status === "in_progress").length,
-        pendingCount: openTodos.filter((todo) => todo.status === "pending").length
-      };
-    },
-    shouldInject: (sessionID) => isOrchestratorSession(sessionID),
-    log: (message, meta) => log(`[${HOOK_NAME}] ${message}`, meta)
-  });
-  function inferSessionID(messages, index) {
-    const direct = messages[index]?.info.sessionID;
-    if (direct) {
-      return direct;
-    }
-    for (let i = index - 1;i >= 0; i--) {
-      const sessionID = messages[i]?.info.sessionID;
-      if (sessionID) {
-        return sessionID;
-      }
-    }
-    for (let i = index + 1;i < messages.length; i++) {
-      const sessionID = messages[i]?.info.sessionID;
-      if (sessionID) {
-        return sessionID;
-      }
-    }
-    if (state.orchestratorSessionIds.size === 1) {
-      return Array.from(state.orchestratorSessionIds)[0];
-    }
-    return;
-  }
-  function isExternalUserMessage(message) {
-    if (message.info.role !== "user") {
-      return false;
-    }
-    const visibleText = message.parts.filter((part) => part.type === "text" && typeof part.text === "string" && !part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER)).map((part) => part.text?.trim() ?? "").filter(Boolean).join(`
-`);
-    const hasNonTextPart = message.parts.some((part) => part.type !== "text");
-    return !(!visibleText && !hasNonTextPart && message.parts.some((part) => part.type === "text" && typeof part.text === "string" && part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER)));
-  }
-  function getLastExternalUserMessage(messages) {
-    for (let i = messages.length - 1;i >= 0; i--) {
-      const message = messages[i];
-      if (!isExternalUserMessage(message)) {
-        continue;
-      }
-      const sessionID = inferSessionID(messages, i);
-      const partSignature = message.parts.map((part) => {
-        if (part.type === "text" && typeof part.text === "string") {
-          const text = stripTodoHygieneInstruction(part.text);
-          return `${part.type}:${text.includes(SLIM_INTERNAL_INITIATOR_MARKER) ? "<internal>" : text.trim()}`;
-        }
-        return part.type ?? "unknown";
-      }).join("|");
-      const ordinal = messages.slice(0, i + 1).filter((item) => isExternalUserMessage(item)).length;
-      return {
-        sessionID,
-        agent: message.info.agent,
-        message,
-        signature: message.info.id ? `${message.info.id}:${partSignature}` : `${ordinal}:${partSignature}`
-      };
-    }
-    return null;
-  }
-  async function handleMessagesTransform(output) {
-    const lastUserMessage = getLastExternalUserMessage(output.messages);
-    if (!lastUserMessage) {
-      return;
-    }
-    if (lastUserMessage.agent && lastUserMessage.agent !== "orchestrator") {
-      return;
-    }
-    if (!lastUserMessage.sessionID) {
-      for (const sessionID of state.orchestratorSessionIds) {
-        requestSignatureBySession.delete(sessionID);
-        hygiene.handleRequestStart({ sessionID });
-      }
-      return;
-    }
-    const knownOrchestrator = isOrchestratorSession(lastUserMessage.sessionID);
-    if (lastUserMessage.agent === "orchestrator") {
-      registerOrchestratorSession(lastUserMessage.sessionID);
-    } else if (!knownOrchestrator) {
-      return;
-    }
-    if (requestSignatureBySession.get(lastUserMessage.sessionID) === lastUserMessage.signature) {
-      const reminder = hygiene.getPendingReminder(lastUserMessage.sessionID);
-      const guardrail = backgroundGuardrail(lastUserMessage.sessionID);
-      const combinedReminder = [reminder, guardrail].filter((item) => Boolean(item)).join(" ");
-      if (combinedReminder) {
-        appendTodoHygieneInstruction(lastUserMessage.message, combinedReminder);
-      } else {
-        stripTodoHygieneInstructionFromMessage(lastUserMessage.message);
-      }
-      return;
-    }
-    requestSignatureBySession.set(lastUserMessage.sessionID, lastUserMessage.signature);
-    stripTodoHygieneInstructionFromMessage(lastUserMessage.message);
-    hygiene.handleRequestStart({ sessionID: lastUserMessage.sessionID });
-  }
-  function markNotificationStarted(sessionID) {
-    state.notifyingSessionIds.add(sessionID);
-  }
-  function markNotificationFinished(sessionID) {
-    state.notifyingSessionIds.delete(sessionID);
-    state.notificationBusyUntilBySession.set(sessionID, Date.now() + NOTIFICATION_BUSY_GRACE_MS);
-  }
-  function clearNotificationState(sessionID) {
-    state.notifyingSessionIds.delete(sessionID);
-    state.notificationBusyUntilBySession.delete(sessionID);
-  }
-  function isNotificationBusy(sessionID) {
-    if (state.notifyingSessionIds.has(sessionID)) {
-      return true;
-    }
-    const until = state.notificationBusyUntilBySession.get(sessionID) ?? 0;
-    if (until <= Date.now()) {
-      state.notificationBusyUntilBySession.delete(sessionID);
-      return false;
-    }
-    return true;
-  }
-  function isOrchestratorSession(sessionID) {
-    return state.orchestratorSessionIds.has(sessionID);
-  }
-  function registerOrchestratorSession(sessionID) {
-    state.orchestratorSessionIds.add(sessionID);
-  }
-  function backgroundGuardrail(sessionID) {
-    if (!backgroundJobBoard)
-      return;
-    const hasRunning = backgroundJobBoard.hasRunning(sessionID);
-    const hasTerminal = backgroundJobBoard.hasTerminalUnreconciled(sessionID);
-    if (hasRunning && hasTerminal) {
-      return "Background jobs are still unresolved: call task_status for running jobs and reconcile terminal Background Job Board results before dependent work or finalizing.";
-    }
-    if (hasTerminal) {
-      return "Background jobs have terminal results: reconcile the Background Job Board results before finalizing.";
-    }
-    if (hasRunning) {
-      return "Background jobs are still running: call task_status before dependent work or finalizing.";
-    }
-    return;
-  }
-  function continuationPrompt(sessionID) {
-    const guardrail = backgroundGuardrail(sessionID);
-    if (!guardrail)
-      return CONTINUATION_PROMPT;
-    return `${CONTINUATION_PROMPT} ${guardrail}`;
-  }
-  function handleChatMessage(input) {
-    if (!input.agent) {
+  function normalizeLateCancelledToolStatus(output) {
+    if (typeof output.output !== "string")
       return;
-    }
-    state.sawChatMessage = true;
-    if (input.agent === "orchestrator") {
-      registerOrchestratorSession(input.sessionID);
-    }
-  }
-  const autoContinue = tool({
-    description: "Toggle auto-continuation for incomplete todos. When enabled, the orchestrator will automatically continue working through its todo list when it stops with incomplete items.",
-    args: { enabled: tool.schema.boolean() },
-    execute: async (args) => {
-      const enabled = args.enabled;
-      state.enabled = enabled;
-      state.consecutiveContinuations = 0;
-      if (enabled) {
-        state.suppressUntil = 0;
-        log(`[${HOOK_NAME}] Auto-continue enabled`, { maxContinuations });
-        return `Auto-continue enabled. Will auto-continue for up to ${maxContinuations} consecutive injections.`;
-      }
-      cancelPendingTimer(state);
-      log(`[${HOOK_NAME}] Auto-continue disabled`);
-      return "Auto-continue disabled.";
-    }
-  });
-  async function handleEvent(input) {
-    const { event } = input;
-    const properties = event.properties ?? {};
-    hygiene.handleEvent({
-      type: event.type,
-      properties: {
-        info: properties.info,
-        sessionID: properties.sessionID
-      }
-    });
-    if (event.type === "session.idle" || event.type === "session.status" && properties.status?.type === "idle") {
-      const sessionID = properties.sessionID;
-      if (!sessionID) {
-        return;
-      }
-      log(`[${HOOK_NAME}] Session idle`, { sessionID });
-      if (!state.sawChatMessage && state.orchestratorSessionIds.size === 0) {
-        registerOrchestratorSession(sessionID);
-        log(`[${HOOK_NAME}] Tracked orchestrator session`, {
-          sessionID
-        });
-      }
-      if (!isOrchestratorSession(sessionID)) {
-        log(`[${HOOK_NAME}] Skipped: not orchestrator session`, {
-          sessionID
-        });
-        return;
-      }
-      if (autoEnable && !state.enabled) {
-        try {
-          const todos = await fetchTodos(sessionID);
-          const incompleteCount2 = todos.filter((t) => !TERMINAL_TODO_STATUSES.includes(t.status)).length;
-          if (incompleteCount2 >= autoEnableThreshold) {
-            state.enabled = true;
-            state.consecutiveContinuations = 0;
-            state.suppressUntil = 0;
-            log(`[${HOOK_NAME}] Auto-enabled: ${incompleteCount2} incomplete todos >= threshold ${autoEnableThreshold}`, { sessionID });
-          } else {
-            log(`[${HOOK_NAME}] Auto-enable skipped: ${incompleteCount2} incomplete todos < threshold ${autoEnableThreshold}`, { sessionID });
-          }
-        } catch (error) {
-          log(`[${HOOK_NAME}] Warning: failed to fetch todos for auto-enable check`, {
-            sessionID,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        }
-      }
-      if (!state.enabled) {
-        log(`[${HOOK_NAME}] Skipped: auto-continue not enabled`, {
-          sessionID
-        });
-        return;
-      }
-      let hasIncompleteTodos = false;
-      let incompleteCount = 0;
-      try {
-        const todos = await fetchTodos(sessionID);
-        incompleteCount = todos.filter((t) => !TERMINAL_TODO_STATUSES.includes(t.status)).length;
-        hasIncompleteTodos = incompleteCount > 0;
-        log(`[${HOOK_NAME}] Fetched todos`, {
-          sessionID,
-          hasIncompleteTodos,
-          total: todos.length
-        });
-      } catch (error) {
-        log(`[${HOOK_NAME}] Warning: failed to fetch todos`, {
-          sessionID,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return;
-      }
-      if (!hasIncompleteTodos) {
-        log(`[${HOOK_NAME}] Skipped: no incomplete todos`, { sessionID });
-        return;
-      }
-      let lastAssistantIsQuestion = false;
-      try {
-        const messagesResult = await ctx.client.session.messages({
-          path: { id: sessionID }
-        });
-        const messages = messagesResult.data;
-        const lastAssistantMessage = messages.slice().reverse().find((m) => m.info?.role === "assistant");
-        if (lastAssistantMessage?.parts) {
-          const lastText = lastAssistantMessage.parts.map((p) => p.text ?? "").join(" ");
-          lastAssistantIsQuestion = isQuestion(lastText);
-        }
-        log(`[${HOOK_NAME}] Fetched messages`, {
-          sessionID,
-          lastAssistantIsQuestion
-        });
-      } catch (error) {
-        log(`[${HOOK_NAME}] Warning: failed to fetch messages`, {
-          sessionID,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return;
-      }
-      if (lastAssistantIsQuestion) {
-        log(`[${HOOK_NAME}] Skipped: last message is question`, {
-          sessionID
-        });
-        return;
-      }
-      if (state.consecutiveContinuations >= maxContinuations) {
-        log(`[${HOOK_NAME}] Skipped: max continuations reached`, {
-          sessionID,
-          consecutive: state.consecutiveContinuations,
-          max: maxContinuations
-        });
-        return;
-      }
-      const now = Date.now();
-      if (now < state.suppressUntil) {
-        log(`[${HOOK_NAME}] Skipped: in suppress window`, {
-          sessionID,
-          suppressUntil: state.suppressUntil
-        });
-        return;
-      }
-      if (state.pendingTimer !== null || state.isAutoInjecting) {
-        log(`[${HOOK_NAME}] Skipped: timer pending or injection in flight`, {
-          sessionID
-        });
-        return;
-      }
-      log(`[${HOOK_NAME}] Scheduling continuation`, {
-        sessionID,
-        delayMs: cooldownMs
-      });
-      markNotificationStarted(sessionID);
-      ctx.client.session.prompt({
-        path: { id: sessionID },
-        body: {
-          noReply: true,
-          parts: [
-            {
-              type: "text",
-              text: [
-                `⎔ Auto-continue: ${incompleteCount} incomplete todos remaining — resuming in ${cooldownMs / 1000}s — Esc×2 to cancel`,
-                "",
-                "[system status: continue without acknowledging this notification]"
-              ].join(`
-`)
-            }
-          ]
-        }
-      }).catch(() => {}).finally(() => {
-        markNotificationFinished(sessionID);
-      });
-      state.pendingTimerSessionId = sessionID;
-      state.pendingTimer = setTimeout(async () => {
-        state.pendingTimer = null;
-        state.pendingTimerSessionId = null;
-        clearNotificationState(sessionID);
-        if (!state.enabled) {
-          log(`[${HOOK_NAME}] Cancelled: disabled during cooldown`, {
-            sessionID
-          });
-          return;
-        }
-        state.isAutoInjecting = true;
-        try {
-          await ctx.client.session.prompt({
-            path: { id: sessionID },
-            body: {
-              parts: [
-                createInternalAgentTextPart(continuationPrompt(sessionID))
-              ]
-            }
-          });
-          state.consecutiveContinuations++;
-          log(`[${HOOK_NAME}] Continuation injected`, {
-            sessionID,
-            consecutive: state.consecutiveContinuations
-          });
-        } catch (error) {
-          log(`[${HOOK_NAME}] Error: failed to inject continuation`, {
-            sessionID,
-            error: error instanceof Error ? error.message : String(error)
-          });
-        } finally {
-          state.isAutoInjecting = false;
-        }
-      }, cooldownMs);
-    } else if (event.type === "session.status") {
-      const status = properties.status;
-      const sessionID = properties.sessionID;
-      if (status?.type === "busy") {
-        const isOrchestrator = isOrchestratorSession(sessionID);
-        const isNotification = isNotificationBusy(sessionID);
-        if (isOrchestrator && !isNotification && state.pendingTimerSessionId === sessionID) {
-          cancelPendingTimer(state);
-        }
-        if (!state.isAutoInjecting && !isNotification && isOrchestrator && state.consecutiveContinuations > 0) {
-          state.consecutiveContinuations = 0;
-          log(`[${HOOK_NAME}] Reset consecutive count on user activity`, {
-            sessionID
-          });
-        }
-      }
-    } else if (event.type === "session.error") {
-      const error = properties.error;
-      const sessionID = properties.sessionID;
-      const errorName = error?.name;
-      const isOrchestrator = isOrchestratorSession(sessionID);
-      if (isOrchestrator && (errorName === "MessageAbortedError" || errorName === "AbortError")) {
-        state.suppressUntil = Date.now() + SUPPRESS_AFTER_ABORT_MS;
-        log(`[${HOOK_NAME}] Suppressed continuation after abort`, {
-          sessionID,
-          errorName
-        });
-      }
-      if (isOrchestrator) {
-        cancelPendingTimer(state);
-        log(`[${HOOK_NAME}] Cancelled pending timer on error`, {
-          sessionID
-        });
-      }
-    } else if (event.type === "session.deleted") {
-      const deletedSessionId = properties.info?.id ?? properties.sessionID;
-      if (deletedSessionId && isOrchestratorSession(deletedSessionId)) {
-        requestSignatureBySession.delete(deletedSessionId);
-        if (state.pendingTimerSessionId === deletedSessionId) {
-          cancelPendingTimer(state);
-          log(`[${HOOK_NAME}] Cancelled pending timer on orchestrator delete`, {
-            sessionID: deletedSessionId
-          });
-        }
-        state.orchestratorSessionIds.delete(deletedSessionId);
-        clearNotificationState(deletedSessionId);
-        if (state.orchestratorSessionIds.size === 0) {
-          resetState(state);
-          state.sawChatMessage = false;
-        }
-        log(`[${HOOK_NAME}] Reset orchestrator session on delete`, {
-          sessionID: deletedSessionId
-        });
-      }
-    }
-  }
-  async function handleCommandExecuteBefore(input, output) {
-    if (input.command !== COMMAND_NAME2) {
+    const status = parseTaskStatusOutput(output.output);
+    if (!status)
       return;
-    }
-    registerOrchestratorSession(input.sessionID);
-    output.parts.length = 0;
-    const arg = input.arguments.trim().toLowerCase();
-    let newEnabled;
-    if (arg === "on") {
-      newEnabled = true;
-    } else if (arg === "off") {
-      newEnabled = false;
-    } else {
-      newEnabled = !state.enabled;
-    }
-    state.enabled = newEnabled;
-    state.consecutiveContinuations = 0;
-    if (!newEnabled) {
-      cancelPendingTimer(state);
-      output.parts.push(createInternalAgentTextPart("[Auto-continue: disabled by user command.]"));
-      log(`[${HOOK_NAME}] Disabled via /${COMMAND_NAME2} command`);
+    const existing = backgroundJobBoard.get(status.taskID);
+    if (!isLateCancelledTaskError(existing, status.state))
       return;
-    }
-    state.suppressUntil = 0;
-    log(`[${HOOK_NAME}] Enabled via /${COMMAND_NAME2} command`, {
-      maxContinuations
+    log("[task-session-manager] normalized late cancelled task_status output", {
+      taskID: status.taskID,
+      alias: existing?.alias,
+      state: existing?.state,
+      terminalState: existing?.terminalState,
+      result: status.result
     });
-    let hasIncompleteTodos = false;
-    try {
-      const todos = await fetchTodos(input.sessionID);
-      hasIncompleteTodos = todos.some((t) => !TERMINAL_TODO_STATUSES.includes(t.status));
-    } catch (error) {
-      log(`[${HOOK_NAME}] Warning: failed to fetch todos in command hook`, {
-        sessionID: input.sessionID,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-    if (hasIncompleteTodos) {
-      output.parts.push(createInternalAgentTextPart(`${continuationPrompt(input.sessionID)} [Auto-continue enabled: up to ${maxContinuations} continuations.]`));
-    } else {
-      output.parts.push(createInternalAgentTextPart(`[Auto-continue: enabled for up to ${maxContinuations} continuations. No incomplete todos right now.]`));
+    output.output = formatCancelledTaskStatusOutput(status.taskID, existing?.resultSummary);
+    if (isObjectRecord(output) && isObjectRecord(output.metadata)) {
+      output.metadata.state = "cancelled";
     }
   }
-  return {
-    tool: { auto_continue: autoContinue },
-    handleToolExecuteAfter: hygiene.handleToolExecuteAfter,
-    handleMessagesTransform,
-    handleEvent,
-    handleChatMessage,
-    handleCommandExecuteBefore
-  };
+}
+function isLateCancelledTaskError(job, state) {
+  if (state !== "error")
+    return false;
+  if (!job?.cancellationRequested)
+    return false;
+  return job.state === "cancelled" || job.terminalState === "cancelled";
+}
+function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
+  return [
+    `task_id: ${taskID}`,
+    "state: cancelled",
+    "",
+    "<task_error>",
+    summary,
+    "</task_error>"
+  ].join(`
+`);
 }
 // src/interview/manager.ts
 import path13 from "node:path";
@@ -28156,7 +27622,7 @@ function buildAnswerPrompt(answers, questions, maxQuestions) {
 }
 
 // src/interview/service.ts
-var COMMAND_NAME3 = "interview";
+var COMMAND_NAME2 = "interview";
 var DEFAULT_MAX_QUESTIONS = 2;
 function isTruthyEnvFlag(value) {
   if (!value) {
@@ -28403,11 +27869,11 @@ function createInterviewService(ctx, config, deps) {
   }
   function registerCommand(opencodeConfig) {
     const configCommand = opencodeConfig.command;
-    if (!configCommand?.[COMMAND_NAME3]) {
+    if (!configCommand?.[COMMAND_NAME2]) {
       if (!opencodeConfig.command) {
         opencodeConfig.command = {};
       }
-      opencodeConfig.command[COMMAND_NAME3] = {
+      opencodeConfig.command[COMMAND_NAME2] = {
         template: "Start an interview and write a live markdown spec",
         description: "Open a localhost interview UI linked to the current OpenCode session"
       };
@@ -28481,7 +27947,7 @@ function createInterviewService(ctx, config, deps) {
     }
   }
   async function handleCommandExecuteBefore(input, output) {
-    if (input.command !== COMMAND_NAME3) {
+    if (input.command !== COMMAND_NAME2) {
       return;
     }
     const idea = input.arguments.trim();
@@ -29951,7 +29417,7 @@ class MultiplexerSessionManager {
       });
       return;
     }
-    if (tracked.ownerInstanceId !== this.instanceId) {
+    if (reason !== "deleted" && tracked.ownerInstanceId !== this.instanceId) {
       log("[multiplexer-session-manager] close skipped; non-owner instance", {
         instanceId: this.instanceId,
         ownerInstanceId: tracked.ownerInstanceId,
@@ -29961,6 +29427,15 @@ class MultiplexerSessionManager {
       });
       return;
     }
+    if (reason === "deleted" && tracked.ownerInstanceId !== this.instanceId) {
+      log("[multiplexer-session-manager] closing deleted pane as non-owner", {
+        instanceId: this.instanceId,
+        ownerInstanceId: tracked.ownerInstanceId,
+        sessionId,
+        paneId: tracked.paneId,
+        reason
+      });
+    }
     if (reason === "idle" && this.isRunningBackgroundJob(sessionId)) {
       log("[multiplexer-session-manager] close skipped; background job running", {
         instanceId: this.instanceId,
@@ -30129,7 +29604,7 @@ async function isServerRunning(serverUrl, timeoutMs = 3000, maxAttempts = 2) {
   return false;
 }
 // src/tools/ast-grep/tools.ts
-import { tool as tool2 } from "@opencode-ai/plugin";
+import { tool } from "@opencode-ai/plugin";
 
 // src/tools/ast-grep/cli.ts
 import { existsSync as existsSync9 } from "node:fs";
@@ -30608,14 +30083,14 @@ function showOutputToUser(context, output) {
   const ctx = context;
   ctx.metadata?.({ metadata: { output } });
 }
-var ast_grep_search = tool2({
+var ast_grep_search = tool({
   description: "Search code patterns across filesystem using AST-aware matching. Supports 25 languages. " + "Use meta-variables: $VAR (single node), $$$ (multiple nodes). " + "IMPORTANT: Patterns must be complete AST nodes (valid code). " + "For functions, include params and body: 'export async function $NAME($$$) { $$$ }' not 'export async function $NAME'. " + "Examples: 'console.log($MSG)', 'def $FUNC($$$):', 'async function $NAME($$$)'",
   args: {
-    pattern: tool2.schema.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
-    lang: tool2.schema.enum(CLI_LANGUAGES).describe("Target language"),
-    paths: tool2.schema.array(tool2.schema.string()).optional().describe("Paths to search (default: ['.'])"),
-    globs: tool2.schema.array(tool2.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
-    context: tool2.schema.number().optional().describe("Context lines around match")
+    pattern: tool.schema.string().describe("AST pattern with meta-variables ($VAR, $$$). Must be complete AST node."),
+    lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
+    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search (default: ['.'])"),
+    globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs (prefix ! to exclude)"),
+    context: tool.schema.number().optional().describe("Context lines around match")
   },
   execute: async (args, context) => {
     try {
@@ -30644,15 +30119,15 @@ ${hint}`;
     }
   }
 });
-var ast_grep_replace = tool2({
+var ast_grep_replace = tool({
   description: "Replace code patterns across filesystem with AST-aware rewriting. " + "Dry-run by default. Use meta-variables in rewrite to preserve matched content. " + "Example: pattern='console.log($MSG)' rewrite='logger.info($MSG)'",
   args: {
-    pattern: tool2.schema.string().describe("AST pattern to match"),
-    rewrite: tool2.schema.string().describe("Replacement pattern (can use $VAR from pattern)"),
-    lang: tool2.schema.enum(CLI_LANGUAGES).describe("Target language"),
-    paths: tool2.schema.array(tool2.schema.string()).optional().describe("Paths to search"),
-    globs: tool2.schema.array(tool2.schema.string()).optional().describe("Include/exclude globs"),
-    dryRun: tool2.schema.boolean().optional().describe("Preview changes without applying (default: true)")
+    pattern: tool.schema.string().describe("AST pattern to match"),
+    rewrite: tool.schema.string().describe("Replacement pattern (can use $VAR from pattern)"),
+    lang: tool.schema.enum(CLI_LANGUAGES).describe("Target language"),
+    paths: tool.schema.array(tool.schema.string()).optional().describe("Paths to search"),
+    globs: tool.schema.array(tool.schema.string()).optional().describe("Include/exclude globs"),
+    dryRun: tool.schema.boolean().optional().describe("Preview changes without applying (default: true)")
   },
   execute: async (args, context) => {
     try {
@@ -30676,11 +30151,14 @@ var ast_grep_replace = tool2({
 });
 // src/tools/cancel-task.ts
 import {
-  tool as tool3
+  tool as tool2
 } from "@opencode-ai/plugin";
-var z4 = tool3.schema;
+var z4 = tool2.schema;
+
+class SessionStillRunningError extends Error {
+}
 function createCancelTaskTool(options) {
-  const cancel_task = tool3({
+  const cancel_task = tool2({
     description: `Cancel a tracked background specialist task.
 
 Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accepts either the native task_id/session ID or the parent-scoped alias shown in the Background Job Board. Cancellation is not rollback: if cancelling a writer, inspect and reconcile partial file changes before replacing the lane.`,
@@ -30702,43 +30180,68 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
       if (!requested)
         throw new Error("cancel_task requires task_id");
       const job = options.backgroundJobBoard.resolve(parentSessionID, requested);
+      log("[cancel-task] request received", {
+        parentSessionID,
+        requested,
+        resolvedTaskID: job?.taskID,
+        alias: job?.alias,
+        state: job?.state,
+        terminalState: job?.terminalState,
+        cancellationRequested: job?.cancellationRequested
+      });
       if (!job) {
-        return [
-          `task_id: ${requested}`,
-          "state: unknown",
-          "",
-          "<task_error>",
-          "unknown or unowned background task",
-          "</task_error>"
-        ].join(`
-`);
-      }
-      const shouldAbort = job.state === "running" || job.state === "cancelled" || job.state === "reconciled" && job.terminalState === "cancelled";
-      if (!shouldAbort) {
-        return [
-          `task_id: ${job.taskID}`,
-          `state: ${job.state}`,
-          "",
-          "<task_result>",
-          `not cancelled: task is already ${job.state}`,
-          "</task_result>"
-        ].join(`
-`);
+        if (isSessionID(requested)) {
+          if (requested === parentSessionID) {
+            log("[cancel-task] rejected parent session cancellation", {
+              parentSessionID,
+              taskID: requested
+            });
+            return unknownTaskOutput(requested, "cannot cancel parent session");
+          }
+          const knownJob = options.backgroundJobBoard.get(requested);
+          if (knownJob && knownJob.parentSessionID !== parentSessionID) {
+            log("[cancel-task] rejected unowned tracked raw session", {
+              parentSessionID,
+              taskID: requested,
+              ownerParentSessionID: knownJob.parentSessionID
+            });
+            return unknownTaskOutput(requested, "unknown or unowned background task");
+          }
+          const parentID = await getSessionParentID(options.client, requested);
+          if (parentID !== parentSessionID) {
+            log("[cancel-task] rejected raw session without parent ownership", {
+              parentSessionID,
+              taskID: requested,
+              actualParentID: parentID
+            });
+            return unknownTaskOutput(requested, "unknown or unowned background task");
+          }
+          log("[cancel-task] falling back to owned raw session abort", {
+            parentSessionID,
+            taskID: requested
+          });
+          return cancelSessionByID(options, requested, args.reason);
+        }
+        return unknownTaskOutput(requested, "unknown or unowned background task");
       }
       try {
-        await abortSessionWithTimeout(options.client, job.taskID, options.abortTimeoutMs ?? 1e4);
+        await abortAndVerifySession(options, job.taskID);
       } catch (error) {
-        const timedOut = error instanceof OperationTimeoutError;
-        if (timedOut) {
-          options.backgroundJobBoard.updateStatus({
-            taskID: job.taskID,
-            state: "error",
-            resultSummary: error instanceof Error ? error.message : "cancel request timed out"
-          });
-        }
+        const stillRunning = error instanceof SessionStillRunningError;
+        log("[cancel-task] abort failed", {
+          taskID: job.taskID,
+          stillRunning,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        options.backgroundJobBoard.updateStatus({
+          taskID: job.taskID,
+          state: "running",
+          statusUncertain: true,
+          lastStatusError: error instanceof Error ? error.message : String(error)
+        });
         return [
           `task_id: ${job.taskID}`,
-          `state: ${timedOut ? "error" : "cancel_error"}`,
+          "state: running",
           "",
           "<task_error>",
           error instanceof Error ? error.message : String(error),
@@ -30746,7 +30249,14 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
         ].join(`
 `);
       }
-      const cancelled = options.backgroundJobBoard.markCancelled(job.taskID, args.reason);
+      const cancelled = options.backgroundJobBoard.markCancelled(job.taskID, args.reason, Date.now(), { force: true });
+      log("[cancel-task] marked job cancelled after verified abort", {
+        taskID: job.taskID,
+        alias: job.alias,
+        previousState: job.state,
+        state: cancelled?.state,
+        cancellationRequested: cancelled?.cancellationRequested
+      });
       return [
         `task_id: ${job.taskID}`,
         `state: ${cancelled?.state ?? "cancelled"}`,
@@ -30760,11 +30270,287 @@ Use only for obsolete, wrong, conflicting, or user-requested cancellation. Accep
   });
   return { cancel_task };
 }
+async function cancelSessionByID(options, taskID, reason) {
+  try {
+    await abortAndVerifySession(options, taskID);
+  } catch (error) {
+    const stillRunning = error instanceof SessionStillRunningError;
+    log("[cancel-task] raw session abort failed", {
+      taskID,
+      stillRunning,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return [
+      `task_id: ${taskID}`,
+      `state: ${stillRunning ? "running" : "error"}`,
+      "",
+      "<task_error>",
+      error instanceof Error ? error.message : String(error),
+      "</task_error>"
+    ].join(`
+`);
+  }
+  return [
+    `task_id: ${taskID}`,
+    "state: cancelled",
+    "",
+    "<task_error>",
+    normalizeCancelReason2(reason),
+    "</task_error>"
+  ].join(`
+`);
+}
+async function abortAndVerifySession(options, taskID) {
+  log("[cancel-task] abort attempt starting", { taskID });
+  const abortStartedAt = Date.now();
+  try {
+    await abortSessionWithTimeout(options.client, taskID, options.abortTimeoutMs ?? 1e4);
+    log("[cancel-task] abort call returned", { taskID });
+  } catch (error) {
+    log("[cancel-task] abort call failed", {
+      taskID,
+      error: error instanceof Error ? error.message : String(error),
+      canDelete: canDeleteSession(options.client)
+    });
+    if (!canDeleteSession(options.client))
+      throw error;
+  }
+  if (canDeleteSession(options.client)) {
+    await deleteAndVerifySession(options, taskID, "cancel-task-after-abort");
+    return;
+  }
+  const verifyAbortMs = options.verifyAbortMs ?? 8000;
+  const stableStoppedMs = options.stableStoppedMs ?? 3000;
+  const retryIntervalMs = options.abortRetryIntervalMs ?? 150;
+  const deadline = Date.now() + verifyAbortMs;
+  log("[cancel-task] abort verification starting", {
+    taskID,
+    verifyAbortMs,
+    stableStoppedMs,
+    retryIntervalMs
+  });
+  let attempts = 0;
+  let stableStoppedSince;
+  let lastStatus;
+  while (Date.now() <= deadline) {
+    attempts += 1;
+    const statusSnapshot = await getSessionStatus(options.client, taskID);
+    lastStatus = statusSnapshot.status;
+    log("[cancel-task] abort verification status", {
+      taskID,
+      attempts,
+      status: statusSnapshot.status,
+      statusSource: statusSnapshot.source,
+      statusKeys: statusSnapshot.keys,
+      stableStoppedSince,
+      stableStoppedForMs: stableStoppedSince ? Date.now() - stableStoppedSince : 0,
+      boardState: options.backgroundJobBoard.get(taskID)?.state,
+      boardLastLiveBusyAt: options.backgroundJobBoard.get(taskID)?.lastLiveBusyAt
+    });
+    const boardLastLiveBusyAt = options.backgroundJobBoard.get(taskID)?.lastLiveBusyAt;
+    if (boardLastLiveBusyAt && boardLastLiveBusyAt >= abortStartedAt) {
+      log("[cancel-task] abort verification saw board busy after abort", {
+        taskID,
+        attempts,
+        abortStartedAt,
+        boardLastLiveBusyAt,
+        status: statusSnapshot.status,
+        statusSource: statusSnapshot.source
+      });
+      await deleteAndVerifySession(options, taskID, "board-busy-after-abort");
+      return;
+    }
+    if (statusSnapshot.status === "busy" || statusSnapshot.status === "retry") {
+      if (stableStoppedSince !== undefined) {
+        log("[cancel-task] abort verification saw busy after idle", {
+          taskID,
+          attempts,
+          stableStoppedForMs: Date.now() - stableStoppedSince
+        });
+        await deleteAndVerifySession(options, taskID, "busy-after-idle");
+        return;
+      }
+      stableStoppedSince = undefined;
+      await abortSessionWithTimeout(options.client, taskID, options.abortTimeoutMs ?? 1e4);
+      log("[cancel-task] abort retry returned", {
+        taskID,
+        attempts,
+        status: statusSnapshot.status
+      });
+      await delay(retryIntervalMs);
+      continue;
+    }
+    stableStoppedSince ??= Date.now();
+    if (Date.now() - stableStoppedSince >= stableStoppedMs) {
+      log("[cancel-task] abort verified stopped", {
+        taskID,
+        attempts,
+        status: statusSnapshot.status,
+        stableStoppedMs
+      });
+      return;
+    }
+    await delay(retryIntervalMs);
+  }
+  log("[cancel-task] abort verification timed out", {
+    taskID,
+    attempts,
+    lastStatus,
+    stableStoppedSince
+  });
+  if (lastStatus === "busy" || lastStatus === "retry") {
+    await deleteAndVerifySession(options, taskID, "still-busy-after-abort");
+    return;
+  }
+  throw new SessionStillRunningError(`Session abort returned but task did not stay stopped: ${taskID}`);
+}
+async function deleteAndVerifySession(options, taskID, reason) {
+  const session2 = options.client.session;
+  if (!session2.delete) {
+    log("[cancel-task] session delete unavailable", { taskID, reason });
+    throw new SessionStillRunningError(`Session resumed after abort and delete is unavailable: ${taskID}`);
+  }
+  log("[cancel-task] deleting session after unstable abort", {
+    taskID,
+    reason
+  });
+  try {
+    await withTimeout(session2.delete({ path: { id: taskID } }), options.deleteTimeoutMs ?? 1e4, `Session delete timed out after ${options.deleteTimeoutMs ?? 1e4}ms`);
+    log("[cancel-task] session delete returned", { taskID, reason });
+  } catch (error) {
+    log("[cancel-task] session delete failed; verifying live state", {
+      taskID,
+      reason,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    const status = await getSessionStatus(options.client, taskID);
+    log("[cancel-task] delete failure verification status", {
+      taskID,
+      reason,
+      status: status.status,
+      statusSource: status.source,
+      statusKeys: status.keys
+    });
+    if (status.status === "busy" || status.status === "retry") {
+      throw new SessionStillRunningError(`Session delete failed and task is still busy: ${taskID}`);
+    }
+    if (status.status !== "idle")
+      throw error;
+  }
+  const deadline = Date.now() + (options.deleteVerifyMs ?? 1500);
+  const stableStoppedMs = options.deleteStableStoppedMs ?? 300;
+  const retryIntervalMs = options.abortRetryIntervalMs ?? 150;
+  let stableStoppedSince;
+  let attempts = 0;
+  let lastStatus;
+  while (Date.now() <= deadline) {
+    attempts += 1;
+    const status = await getSessionStatus(options.client, taskID);
+    lastStatus = status.status;
+    log("[cancel-task] delete verification status", {
+      taskID,
+      reason,
+      attempts,
+      status: status.status,
+      statusSource: status.source,
+      statusKeys: status.keys,
+      stableStoppedSince
+    });
+    if (status.status === "busy" || status.status === "retry") {
+      stableStoppedSince = undefined;
+      await delay(retryIntervalMs);
+      continue;
+    }
+    stableStoppedSince ??= Date.now();
+    if (Date.now() - stableStoppedSince >= stableStoppedMs)
+      return;
+    await delay(retryIntervalMs);
+  }
+  throw new SessionStillRunningError(`Session delete returned but task did not stay stopped: ${taskID} (${lastStatus ?? "unknown"})`);
+}
+function canDeleteSession(client) {
+  const session2 = client.session;
+  return typeof session2.delete === "function";
+}
+async function getSessionStatus(client, taskID) {
+  try {
+    const result = await client.session.status();
+    const data = result.data;
+    if (!isObjectRecord2(data)) {
+      return { status: undefined, source: "invalid-data", keys: [] };
+    }
+    const keys = Object.keys(data).slice(0, 20);
+    const item = data[taskID];
+    if (item === undefined) {
+      return { status: "idle", source: "missing-from-map", keys };
+    }
+    if (isObjectRecord2(item) && typeof item.type === "string") {
+      return { status: item.type, source: "task-map-entry", keys };
+    }
+    if (typeof data.type === "string") {
+      return { status: data.type, source: "legacy-data-type", keys };
+    }
+    const nested = data.status;
+    if (isObjectRecord2(nested) && typeof nested.type === "string") {
+      return { status: nested.type, source: "legacy-data-status", keys };
+    }
+    return { status: undefined, source: "unknown-shape", keys };
+  } catch (error) {
+    log("[cancel-task] session status lookup failed", {
+      taskID,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return { status: undefined, source: "lookup-error", keys: [] };
+  }
+}
+function delay(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSessionID(value) {
+  return /^ses_[\w-]+$/.test(value);
+}
+function normalizeCancelReason2(reason) {
+  const normalized = reason?.replace(/\s+/g, " ").trim();
+  return normalized ? `cancelled: ${normalized}` : "cancelled";
+}
+async function getSessionParentID(client, taskID) {
+  const session2 = client.session;
+  if (!session2.get)
+    return;
+  try {
+    const response = await session2.get({ path: { id: taskID } });
+    const data = response.data;
+    if (!isObjectRecord2(data))
+      return;
+    const parentID = data.parentID;
+    return typeof parentID === "string" ? parentID : undefined;
+  } catch (error) {
+    log("[cancel-task] session metadata lookup failed", {
+      taskID,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return;
+  }
+}
+function unknownTaskOutput(taskID, message) {
+  return [
+    `task_id: ${taskID}`,
+    "state: unknown",
+    "",
+    "<task_error>",
+    message,
+    "</task_error>"
+  ].join(`
+`);
+}
 // src/tools/council.ts
 import {
-  tool as tool4
+  tool as tool3
 } from "@opencode-ai/plugin";
-var z5 = tool4.schema;
+var z5 = tool3.schema;
 function formatModelComposition(councillorResults) {
   return councillorResults.map((cr) => {
     const shortModel = shortModelLabel(cr.model);
@@ -30772,7 +30558,7 @@ function formatModelComposition(councillorResults) {
   }).join(", ");
 }
 function createCouncilTool(_ctx, councilManager) {
-  const council_session = tool4({
+  const council_session = tool3({
     description: `Launch a multi-LLM council session for consensus-based analysis.
 
 Sends the prompt to multiple models (councillors) in parallel and returns their formatted responses for you to synthesize.
@@ -30826,6 +30612,9 @@ Returns the councillor responses with a summary footer.`,
   });
   return { council_session };
 }
+// src/tools/preset-manager.ts
+import * as fs10 from "node:fs";
+
 // src/tui-state.ts
 import * as fs9 from "node:fs";
 import * as os5 from "node:os";
@@ -30895,11 +30684,11 @@ function recordTuiAgentModel(input) {
 }
 
 // src/tools/preset-manager.ts
-var COMMAND_NAME4 = "preset";
+var COMMAND_NAME3 = "preset";
 function createPresetManager(ctx, config) {
   let activePreset = getActiveRuntimePreset() ?? config.preset ?? null;
   async function handleCommandExecuteBefore(input, output) {
-    if (input.command !== COMMAND_NAME4) {
+    if (input.command !== COMMAND_NAME3) {
       return;
     }
     output.parts.length = 0;
@@ -30918,11 +30707,11 @@ function createPresetManager(ctx, config) {
   }
   function registerCommand(opencodeConfig) {
     const configCommand = opencodeConfig.command;
-    if (!configCommand?.[COMMAND_NAME4]) {
+    if (!configCommand?.[COMMAND_NAME3]) {
       if (!opencodeConfig.command) {
         opencodeConfig.command = {};
       }
-      opencodeConfig.command[COMMAND_NAME4] = {
+      opencodeConfig.command[COMMAND_NAME3] = {
         template: "List available presets and switch between them",
         description: "Switch agent presets at runtime (e.g., /preset cheap, /preset powerful)"
       };
@@ -30944,64 +30733,47 @@ function createPresetManager(ctx, config) {
         agentUpdates[resolvedName] = agentConfig;
       }
     }
-    const currentRuntimePreset = getActiveRuntimePreset();
-    const resetUpdates = {};
-    if (currentRuntimePreset && config.presets?.[currentRuntimePreset]) {
-      const oldPreset = config.presets[currentRuntimePreset];
-      for (const rawName of Object.keys(oldPreset)) {
-        const resolvedOld = AGENT_ALIASES[rawName] ?? rawName;
-        if (resolvedOld in agentUpdates)
-          continue;
-        const baseline = config.agents?.[resolvedOld];
-        if (baseline) {
-          resetUpdates[resolvedOld] = mapOverrideToAgentConfig(baseline);
-        }
-      }
-    }
     const hasAgentUpdates = Object.keys(agentUpdates).length > 0;
-    const allUpdates = { ...resetUpdates, ...agentUpdates };
     if (!hasAgentUpdates) {
       output.parts.push(createInternalAgentTextPart(`Preset "${presetName}" is empty (no agent overrides defined).`));
       return;
     }
-    const previousPreset = activePreset;
     setActiveRuntimePresetWithPrevious(presetName);
     try {
-      await ctx.client.config.update({
-        body: { agent: allUpdates }
-      });
-      const snapshot = readTuiSnapshot();
-      const agentModels = { ...snapshot.agentModels };
-      for (const [agentName, agentConfig] of Object.entries(allUpdates)) {
-        if (typeof agentConfig.model === "string") {
-          agentModels[agentName] = agentConfig.model;
-        }
-      }
-      recordTuiAgentModels({ agentModels });
-      activePreset = presetName;
-      const summaryParts = [];
-      for (const [name, cfg] of Object.entries(agentUpdates)) {
-        const parts = [name];
-        if (cfg.model)
-          parts.push(`model: ${cfg.model}`);
-        if (cfg.variant)
-          parts.push(`variant: ${cfg.variant}`);
-        if (cfg.temperature !== undefined)
-          parts.push(`temp: ${cfg.temperature}`);
-        if (cfg.options)
-          parts.push("options: yes");
-        summaryParts.push(parts.join(" → "));
-      }
-      if (Object.keys(resetUpdates).length > 0) {
-        summaryParts.push(`Reset to baseline: ${Object.keys(resetUpdates).join(", ")}`);
-      }
-      output.parts.push(createInternalAgentTextPart(`Switched to preset "${presetName}":
+      const { userConfigPath } = findPluginConfigPaths(ctx.directory);
+      if (userConfigPath) {
+        const raw = fs10.readFileSync(userConfigPath, "utf-8");
+        const persisted = JSON.parse(stripJsonComments(raw));
+        persisted.preset = presetName;
+        fs10.writeFileSync(userConfigPath, `${JSON.stringify(persisted, null, 2)}
+`);
+      }
+    } catch {}
+    const snapshot = readTuiSnapshot();
+    const agentModels = { ...snapshot.agentModels };
+    for (const [agentName, agentConfig] of Object.entries(agentUpdates)) {
+      if (typeof agentConfig.model === "string") {
+        agentModels[agentName] = agentConfig.model;
+      }
+    }
+    recordTuiAgentModels({ agentModels });
+    activePreset = presetName;
+    const summaryParts = [];
+    for (const [name, cfg] of Object.entries(agentUpdates)) {
+      const parts = [name];
+      if (cfg.model)
+        parts.push(`model: ${cfg.model}`);
+      if (cfg.variant)
+        parts.push(`variant: ${cfg.variant}`);
+      if (cfg.temperature !== undefined)
+        parts.push(`temp: ${cfg.temperature}`);
+      if (cfg.options)
+        parts.push("options: yes");
+      summaryParts.push(parts.join(" → "));
+    }
+    output.parts.push(createInternalAgentTextPart(`Saved preset "${presetName}". Restart or reload OpenCode to apply it to agent configuration. The current session was not reloaded to avoid interrupting the active conversation.
 ${summaryParts.join(`
 `)}`));
-    } catch (err) {
-      rollbackRuntimePreset(previousPreset);
-      output.parts.push(createInternalAgentTextPart(`Failed to switch preset "${presetName}": ${String(err)}`));
-    }
   }
   function mapOverrideToAgentConfig(override) {
     const agentConfig = {};
@@ -31091,7 +30863,7 @@ var WEBFETCH_DESCRIPTION = "Fetch a URL with better extraction for static/docs p
 import os6 from "node:os";
 import path18 from "node:path";
 import {
-  tool as tool5
+  tool as tool4
 } from "@opencode-ai/plugin";
 
 // src/tools/smartfetch/binary.ts
@@ -32873,10 +32645,10 @@ async function runSecondaryModelWithFallback(client, directory, models, prompt,
 }
 
 // src/tools/smartfetch/tool.ts
-var z6 = tool5.schema;
+var z6 = tool4.schema;
 function createWebfetchTool(pluginCtx, options = {}) {
   const binaryDir = options.binaryDir || path18.join(os6.tmpdir(), "opencode-smartfetch");
-  return tool5({
+  return tool4({
     description: WEBFETCH_DESCRIPTION,
     args: {
       url: z6.httpUrl(),
@@ -33467,7 +33239,6 @@ var OhMyOpenCodeLite = async (ctx) => {
   let applyPatchHook;
   let jsonErrorRecoveryHook;
   let foregroundFallback;
-  let todoContinuationHook;
   let deepworkCommandHook;
   let taskSessionManagerHook;
   let backgroundJobBoard;
@@ -33560,13 +33331,6 @@ var OhMyOpenCodeLite = async (ctx) => {
     applyPatchHook = createApplyPatchHook(ctx);
     jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
     foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
-    todoContinuationHook = createTodoContinuationHook(ctx, {
-      maxContinuations: config.todoContinuation?.maxContinuations ?? 5,
-      cooldownMs: config.todoContinuation?.cooldownMs ?? 3000,
-      autoEnable: config.todoContinuation?.autoEnable ?? false,
-      autoEnableThreshold: config.todoContinuation?.autoEnableThreshold ?? 4,
-      backgroundJobBoard
-    });
     deepworkCommandHook = createDeepworkCommandHook();
     taskSessionManagerHook = createTaskSessionManagerHook(ctx, {
       maxSessionsPerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? 2,
@@ -33583,7 +33347,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       backgroundJobBoard,
       shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator"
     });
-    toolCount = Object.keys(councilTools).length + Object.keys(cancelTaskTools).length + Object.keys(todoContinuationHook.tool).length + 1 + 2;
+    toolCount = Object.keys(councilTools).length + Object.keys(cancelTaskTools).length + 1 + 2;
   } catch (err) {
     log("[plugin] FATAL: init failed", String(err));
     await appLog(ctx, "error", `INIT FAILED: ${String(err)}. Report at github.com/alvinunreal/oh-my-opencode-slim/issues/310`);
@@ -33627,7 +33391,6 @@ var OhMyOpenCodeLite = async (ctx) => {
       ...councilTools,
       ...cancelTaskTools,
       webfetch,
-      ...todoContinuationHook.tool,
       ast_grep_search,
       ast_grep_replace
     },
@@ -33814,16 +33577,6 @@ var OhMyOpenCodeLite = async (ctx) => {
         }
         agentConfigEntry.permission = agentPermission;
       }
-      const configCommand = opencodeConfig.command;
-      if (!configCommand?.["auto-continue"]) {
-        if (!opencodeConfig.command) {
-          opencodeConfig.command = {};
-        }
-        opencodeConfig.command["auto-continue"] = {
-          template: "Call the auto_continue tool with enabled=true",
-          description: "Enable auto-continuation — orchestrator keeps working through incomplete todos"
-        };
-      }
       interviewManager.registerCommand(opencodeConfig);
       deepworkCommandHook.registerCommand(opencodeConfig);
       presetManager.registerCommand(opencodeConfig);
@@ -33850,7 +33603,6 @@ var OhMyOpenCodeLite = async (ctx) => {
       await multiplexerSessionManager.onSessionStatus(event);
       await multiplexerSessionManager.onSessionDeleted(event);
       await foregroundFallback.handleEvent(input.event);
-      await todoContinuationHook.handleEvent(input);
       await autoUpdateChecker.event(input);
       await interviewManager.handleEvent(input);
       await taskSessionManagerHook.event(input);
@@ -33908,7 +33660,6 @@ var OhMyOpenCodeLite = async (ctx) => {
       }
     },
     "command.execute.before": async (input, output) => {
-      await todoContinuationHook.handleCommandExecuteBefore(input, output);
       await interviewManager.handleCommandExecuteBefore(input, output);
       await presetManager.handleCommandExecuteBefore(input, output);
       await deepworkCommandHook.handleCommandExecuteBefore(input, output);
@@ -33923,10 +33674,6 @@ var OhMyOpenCodeLite = async (ctx) => {
       if (agent) {
         sessionAgentMap.set(input.sessionID, agent);
       }
-      todoContinuationHook.handleChatMessage({
-        sessionID: input.sessionID,
-        agent
-      });
     },
     "experimental.chat.system.transform": async (input, output) => {
       const agentName = input.sessionID ? sessionAgentMap.get(input.sessionID) : undefined;
@@ -33961,9 +33708,6 @@ ${output.system[0]}` : "");
         disabledAgents,
         log
       });
-      await todoContinuationHook.handleMessagesTransform({
-        messages: typedOutput.messages
-      });
       await taskSessionManagerHook["experimental.chat.messages.transform"](input, typedOutput);
       await phaseReminderHook["experimental.chat.messages.transform"](input, typedOutput);
       await filterAvailableSkillsHook["experimental.chat.messages.transform"](input, typedOutput);
@@ -33985,7 +33729,6 @@ ${output.system[0]}` : "");
       };
       await runPostToolHook("delegate-task-retry", () => delegateTaskRetryHook["tool.execute.after"](input, output));
       await runPostToolHook("json-error-recovery", () => jsonErrorRecoveryHook["tool.execute.after"](input, output));
-      await runPostToolHook("todo-continuation", () => todoContinuationHook.handleToolExecuteAfter(input, output));
       await runPostToolHook("post-file-tool-nudge", () => postFileToolNudgeHook["tool.execute.after"](input, output));
       await runPostToolHook("task-session-manager", () => taskSessionManagerHook["tool.execute.after"](input, output));
       if (input.tool.toLowerCase() === "task") {