oh-my-opencode-slim 2.0.0-beta.13 → 2.0.0-beta.15

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"
   }
 ];
 
@@ -18308,7 +18321,7 @@ var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion or use task_status only when needed → reconcile terminal results → verify. Do not consume running-job output or advance dependent work. !END!`;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
 var WRITABLE_FILE_OPERATIONS_RULES = `**File Operations Rules**:
 - Prefer dedicated file tools for normal code work: glob/grep/ast_grep_search for discovery, read for file contents, and edit/write/apply_patch for targeted source changes.
 - Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.
@@ -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 {
@@ -19122,31 +19126,15 @@ ${enabledParallelExamples}
 
 Balance: respect dependencies, avoid parallelizing what must be sequential, and avoid overlapping write ownership.
 
-### OpenCode scheduler model
-- Delegated specialists should be launched as background tasks whenever work can run independently: use \`task(..., background: true)\`.
-- A dispatch returns a task/session ID immediately; it does not mean completion.
-- Track each task ID with specialist, objective, state, and any advisory ownership/dependency labels from the dispatch plan.
-- Background completion is event/hook-driven: when a background task finishes, OpenCode injects a follow-up message with the terminal result.
-- Continue orchestration while tasks run only when useful: planning, scheduling independent lanes, preparing synthesis, or asking needed user questions.
-- If no useful independent work remains, stop after a brief status response; do not call \`task_status\` just to wait. OpenCode will resume you when the background completion event arrives.
-- Use \`task_status(wait: true, timeout_ms: ...)\` only when you actively need a result before a dependent step or final response and no completion event has arrived yet.
-- If \`task_status(wait: true)\` times out and reports the task still \`running\`, the delegated lane is still owned by that specialist. Do not treat the timeout as failure, cancellation, or permission to do the same work yourself.
-- For dependent work, either call \`task_status(wait: true)\` again with the same reasonable interval, or stop with a brief waiting status and let the completion event resume you.
+### Background Task Discipline
+- Prefer \`task(..., background: true)\` for delegated work that can run independently.
+- Track each task's specialist, objective, task/session ID, and file/topic ownership.
+- Continue orchestration only on non-overlapping work; otherwise briefly report what was launched and stop.
+- Before local edits or another writer task, compare against running task scopes.
 - Parallel background tasks are allowed only when their write scopes do not conflict.
-- Final response requires relevant tasks to be terminal and reconciled.
-
-### Background Job Discipline
-- Every background task owns its declared lane until terminal.
-- Do not duplicate, undermine, or race a running lane.
-- A polling timeout is not terminal. The lane remains running until a terminal completion/error/cancel event is observed or the user explicitly cancels it.
-- After dispatch, classify the next step:
-  1. independent: continue,
-  2. dependent: wait/poll,
-  3. no useful independent work: stop and let hook-driven completion resume.
-- Before editing files or spawning another writer, compare against running job scopes.
+- Before final response, reconcile any terminal jobs shown in the Background Job Board.
 - Use \`cancel_task\` only when the user asks, or when a running lane is obsolete, wrong, or conflicts with a safer replacement plan.
 - Cancellation is not rollback: if cancelling a writer, inspect and reconcile partial file changes before launching a replacement lane.
-- Never finalize work that depends on unresolved background jobs.
 
 ### Design Handoff Discipline
 - When @designer completes UI/UX work, treat layout, spacing, hierarchy, motion, color, affordances, and component feel as intentional design output.
@@ -19160,13 +19148,9 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 - When too much unrelated, and really needed, start a fresh session with the specialist
 - 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.
+- When reusing a specialist session, you MUST pass the existing session or alias in the task tool's \`task_id\` argument. Saying "reuse" in prose is not enough.
+- If the Background Job Board lists \`fix-1 / ses_abc / fixer\`, call task with \`subagent_type: "fixer"\` and \`task_id: "fix-1"\` or \`task_id: "ses_abc"\`.
+- Do not leave \`task_id\` empty when intending to reuse; omitted or empty \`task_id\` creates a new specialist session.
 
 ### Validation routing
 - Validation is a workflow stage owned by the Orchestrator, not a separate specialist
@@ -20039,10 +20023,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 +20035,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 {
@@ -22647,6 +22627,9 @@ var TRANSIENT_PROCESS_ERROR_TEXT = new Set([
   "Task is not running in this process and has not produced output."
 ]);
 function parseTaskIdFromTaskOutput(output) {
+  const xmlMatch = /<task\s+[^>]*\bid=["']([^"']+)["'][^>]*>/i.exec(output);
+  if (xmlMatch)
+    return xmlMatch[1];
   const lines = output.split(/\r?\n/);
   for (const line of lines) {
     const trimmed = line.trim();
@@ -22681,20 +22664,10 @@ 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) {
+  const xmlMatch = /<task\s+[^>]*\bstate=["'](running|completed|error|cancelled)["'][^>]*>/i.exec(output);
+  if (xmlMatch)
+    return xmlMatch[1].toLowerCase();
   for (const line of getTaskHeader(output).split(/\r?\n/)) {
     const match = /^state:\s*(running|completed|error|cancelled)\s*$/i.exec(line.trim());
     if (match)
@@ -22830,7 +22803,7 @@ class BackgroundJobBoard {
     if (!existing)
       return;
     const isStaleTerminal = TERMINAL_STATES.has(existing.state) || existing.state === "reconciled";
-    if (!isStaleTerminal || existing.cancellationRequested) {
+    if (isStaleTerminal) {
       const updated2 = {
         ...existing,
         lastLiveBusyAt: now
@@ -22840,17 +22813,8 @@ class BackgroundJobBoard {
     }
     const updated = {
       ...existing,
-      state: "running",
-      timedOut: false,
-      statusUncertain: false,
-      cancellationRequested: false,
-      terminalUnreconciled: false,
       updatedAt: now,
-      lastLiveBusyAt: now,
-      completedAt: undefined,
-      terminalState: undefined,
-      resultSummary: undefined,
-      lastStatusError: undefined
+      lastLiveBusyAt: now
     };
     this.jobs.set(taskID, updated);
     return updated;
@@ -22909,9 +22873,6 @@ class BackgroundJobBoard {
     const value = taskIDOrAlias.trim();
     return this.list(parentSessionID).find((job) => job.taskID === value || job.alias === value);
   }
-  resolveForStatus(parentSessionID, taskIDOrAlias) {
-    return this.resolve(parentSessionID, taskIDOrAlias);
-  }
   resolveReusable(parentSessionID, taskIDOrAlias, agent) {
     const job = this.resolve(parentSessionID, taskIDOrAlias);
     if (!job || !isReusable(job))
@@ -22967,7 +22928,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 only completed sessions for the same specialist/context; never reuse cancelled or errored sessions.",
+      "Do not poll running jobs. Wait for hook-driven completion, or use cancel_task only for explicit cancellation. 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"],
@@ -23230,7 +23191,7 @@ function activationPrompt(task2) {
     "- draft a plan and get `@oracle` review before implementation;",
     "- create and review a phased implementation/delegation plan;",
     "- execute phase by phase with background specialists where useful;",
-    "- poll `task_status`, reconcile results, validate, and ask `@oracle` to review each phase;",
+    "- wait for hook-driven background completion, reconcile results, validate, and ask `@oracle` to review each phase;",
     "- ask `@oracle` to include simplify/readability feedback in phase reviews;",
     "- fix actionable review issues before continuing.",
     "",
@@ -24008,6 +23969,7 @@ var BACKGROUND_JOB_BOARD_SENTINEL = "SENTINEL: background-job-board-v2";
 var BACKGROUND_COMPLETION_COMPLETED = /^Background task completed: /;
 var BACKGROUND_COMPLETION_FAILED = /^Background task failed: /;
 var MAX_PROCESSED_INJECTED_COMPLETIONS = 500;
+var RAW_SESSION_ID_PATTERN = /^ses_[A-Za-z0-9_-]+$/;
 function djb2Hash(str) {
   let hash = 5381;
   for (let i = 0;i < str.length; i++) {
@@ -24042,6 +24004,10 @@ function isObjectRecord(value) {
 function extractPath(output) {
   return /<path>([^<]+)<\/path>/.exec(output)?.[1];
 }
+function extractTaskSummary(output) {
+  const summary = /<summary>\s*([\s\S]*?)\s*<\/summary>/i.exec(output)?.[1];
+  return summary?.trim() || undefined;
+}
 function normalizePath(root, file) {
   const relative = path9.relative(root, file);
   if (!relative || relative.startsWith("..") || path9.isAbsolute(relative)) {
@@ -24133,7 +24099,7 @@ function createTaskSessionManagerHook(_ctx, options) {
     const status = parseTaskStatusOutput(output);
     if (!status)
       return;
-    log("[task-session-manager] parsed task status output", {
+    log("[task-session-manager] parsed task output status", {
       taskID: status.taskID,
       state: status.state,
       timedOut: status.timedOut,
@@ -24178,73 +24144,23 @@ 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;
     }
-    const isCompleted = BACKGROUND_COMPLETION_COMPLETED.test(part.text);
-    const isFailed = BACKGROUND_COMPLETION_FAILED.test(part.text);
-    if (part.synthetic !== true || !isCompleted && !isFailed) {
+    if (part.synthetic !== true)
       return;
-    }
     const status = parseTaskStatusOutput(part.text);
     if (!status)
       return;
+    if (status.state !== "completed" && status.state !== "error") {
+      return;
+    }
+    const summary = extractTaskSummary(part.text);
+    const isCompleted = summary ? BACKGROUND_COMPLETION_COMPLETED.test(summary) : status.state === "completed";
+    const isFailed = summary ? BACKGROUND_COMPLETION_FAILED.test(summary) : status.state === "error";
+    if (summary && !isCompleted && !isFailed)
+      return;
     const occurrenceId = createOccurrenceId(part, message, partIndex);
     const existing = backgroundJobBoard.get(status.taskID);
     if (isFailed && isLateCancelledTaskError(existing, status.state)) {
@@ -24357,23 +24273,13 @@ function createTaskSessionManagerHook(_ctx, options) {
   return {
     "tool.execute.before": async (input, output) => {
       const toolName = input.tool.toLowerCase();
-      if (toolName !== "task" && toolName !== "task_status")
+      if (toolName !== "task")
         return;
       if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
         return;
       }
       if (!isObjectRecord(output.args))
         return;
-      if (toolName === "task_status") {
-        const args2 = output.args;
-        if (typeof args2.task_id !== "string" || args2.task_id.trim() === "") {
-          return;
-        }
-        const resolved = backgroundJobBoard.resolveForStatus(input.sessionID, args2.task_id.trim());
-        if (resolved)
-          args2.task_id = resolved.taskID;
-        return;
-      }
       const args = output.args;
       if (!isAgentName(args.subagent_type)) {
         if (typeof args.task_id === "string" && args.task_id.trim() !== "") {
@@ -24402,6 +24308,11 @@ function createTaskSessionManagerHook(_ctx, options) {
       const requested = args.task_id.trim();
       const remembered = backgroundJobBoard.resolveReusable(input.sessionID, requested, args.subagent_type);
       if (!remembered) {
+        if (RAW_SESSION_ID_PATTERN.test(requested)) {
+          pendingCall.resumedTaskId = requested;
+          rememberPendingCall(pendingCall);
+          return;
+        }
         delete args.task_id;
         return;
       }
@@ -24418,24 +24329,13 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         return;
       }
-      if (input.tool.toLowerCase() === "task_status") {
-        if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
-          return;
-        }
-        normalizeLateCancelledToolStatus(output);
-        if (await handleTransientTaskStatusOutput(output)) {
-          return;
-        }
-        updateBackgroundJobFromOutput(output.output);
-        return;
-      }
       if (input.tool.toLowerCase() !== "task")
         return;
       const pending = takePendingCall(input.callID, input.sessionID);
       if (!pending || typeof output.output !== "string")
         return;
       const launch = parseTaskLaunchOutput(output.output);
-      if (launch) {
+      if (launch && !launch.result?.match(/Timed out after \d+ms/i)) {
         const record = backgroundJobBoard.registerLaunch({
           taskID: launch.taskID,
           parentSessionID: pending.parentSessionId,
@@ -24455,6 +24355,39 @@ function createTaskSessionManagerHook(_ctx, options) {
         pendingManagedTaskIds.add(launch.taskID);
         return;
       }
+      normalizeLateCancelledTaskOutput(output);
+      const status = parseTaskStatusOutput(output.output);
+      if (status) {
+        const existing = backgroundJobBoard.get(status.taskID);
+        const record = existing ?? backgroundJobBoard.registerLaunch({
+          taskID: status.taskID,
+          parentSessionID: pending.parentSessionId,
+          agent: pending.agentType,
+          description: pending.label,
+          objective: pending.label
+        });
+        const updated = backgroundJobBoard.updateStatus({
+          taskID: status.taskID,
+          state: status.state,
+          timedOut: status.timedOut,
+          resultSummary: status.result
+        });
+        log("[task-session-manager] foreground task status registered", {
+          taskID: status.taskID,
+          alias: updated?.alias ?? record.alias,
+          parentSessionID: pending.parentSessionId,
+          agent: pending.agentType,
+          state: updated?.state ?? record.state
+        });
+        if (pending.resumedTaskId && pending.resumedTaskId !== status.taskID) {
+          backgroundJobBoard.drop(pending.resumedTaskId);
+        }
+        pendingManagedTaskIds.delete(status.taskID);
+        const contextFiles2 = contextFilesForPrompt(contextByTask.get(status.taskID));
+        backgroundJobBoard.addContext(status.taskID, contextFiles2);
+        pruneContext();
+        return;
+      }
       const taskId = parseTaskIdFromTaskOutput(output.output);
       if (!taskId) {
         if (pending.resumedTaskId && isMissingRememberedSessionError(output.output)) {
@@ -24602,7 +24535,7 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
     }
   };
-  function normalizeLateCancelledToolStatus(output) {
+  function normalizeLateCancelledTaskOutput(output) {
     if (typeof output.output !== "string")
       return;
     const status = parseTaskStatusOutput(output.output);
@@ -24611,7 +24544,7 @@ function createTaskSessionManagerHook(_ctx, options) {
     const existing = backgroundJobBoard.get(status.taskID);
     if (!isLateCancelledTaskError(existing, status.state))
       return;
-    log("[task-session-manager] normalized late cancelled task_status output", {
+    log("[task-session-manager] normalized late cancelled task output", {
       taskID: status.taskID,
       alias: existing?.alias,
       state: existing?.state,
@@ -24642,715 +24575,6 @@ function formatCancelledTaskStatusOutput(taskID, summary = "cancelled") {
   ].join(`
 `);
 }
-// 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) {
-      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) {
-      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`);
-      return;
-    }
-    state.suppressUntil = 0;
-    log(`[${HOOK_NAME}] Enabled via /${COMMAND_NAME2} command`, {
-      maxContinuations
-    });
-    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.]`));
-    }
-  }
-  return {
-    tool: { auto_continue: autoContinue },
-    handleToolExecuteAfter: hygiene.handleToolExecuteAfter,
-    handleMessagesTransform,
-    handleEvent,
-    handleChatMessage,
-    handleCommandExecuteBefore
-  };
-}
 // src/interview/manager.ts
 import path13 from "node:path";
 
@@ -28338,7 +27562,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) {
@@ -28585,11 +27809,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"
       };
@@ -28663,7 +27887,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();
@@ -30320,7 +29544,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";
@@ -30799,14 +30023,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 {
@@ -30835,15 +30059,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 {
@@ -30867,14 +30091,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.`,
@@ -31264,9 +30488,9 @@ function unknownTaskOutput(taskID, message) {
 }
 // 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);
@@ -31274,7 +30498,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.
@@ -31328,6 +30552,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";
@@ -31397,11 +30624,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;
@@ -31420,11 +30647,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)"
       };
@@ -31446,64 +30673,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 = {};
@@ -31593,7 +30803,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
@@ -33375,10 +32585,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(),
@@ -33969,7 +33179,6 @@ var OhMyOpenCodeLite = async (ctx) => {
   let applyPatchHook;
   let jsonErrorRecoveryHook;
   let foregroundFallback;
-  let todoContinuationHook;
   let deepworkCommandHook;
   let taskSessionManagerHook;
   let backgroundJobBoard;
@@ -34062,13 +33271,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,
@@ -34085,7 +33287,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`);
@@ -34129,7 +33331,6 @@ var OhMyOpenCodeLite = async (ctx) => {
       ...councilTools,
       ...cancelTaskTools,
       webfetch,
-      ...todoContinuationHook.tool,
       ast_grep_search,
       ast_grep_replace
     },
@@ -34316,16 +33517,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);
@@ -34352,7 +33543,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);
@@ -34410,7 +33600,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);
@@ -34425,10 +33614,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;
@@ -34463,9 +33648,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);
@@ -34487,7 +33669,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") {