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

package/dist/config/constants.d.ts

@@ -21,6 +21,9 @@ export declare const MAX_POLL_TIME_MS: number;
 export declare const FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
 export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
 export declare const PHASE_REMINDER_TEXT = "!IMPORTANT! Scheduler workflow: plan lanes/dependencies \u2192 dispatch background specialists \u2192 track task IDs \u2192 wait for hook-driven completion or use task_status only when needed \u2192 reconcile terminal results \u2192 verify. Do not consume running-job output or advance dependent work. !END!";
+export declare const WRITABLE_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- 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.\n- Use bash for execution and automation: git, package managers, tests, builds, scripts, diagnostics, and shell-native filesystem operations.\n- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.\n- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
+export declare const READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.\n- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.\n- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.";
+export declare const NO_SHELL_READONLY_FILE_OPERATIONS_RULES = "**File Operations Rules**:\n- READ-ONLY: inspect and report; do not modify files.\n- Use glob/grep/ast_grep_search for discovery and read for file contents.\n- Do not use bash or shell commands.";
 export declare const TMUX_SPAWN_DELAY_MS = 500;
 export declare const COUNCILLOR_STAGGER_MS = 250;
 export declare const STABLE_POLLS_THRESHOLD = 3;

package/dist/index.js

@@ -18309,6 +18309,21 @@ 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 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.
+- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.
+- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.
+- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.`;
+var READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- READ-ONLY: inspect and report; do not modify files.
+- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.
+- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.
+- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.`;
+var NO_SHELL_READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- READ-ONLY: inspect and report; do not modify files.
+- Use glob/grep/ast_grep_search for discovery and read for file contents.
+- Do not use bash or shell commands.`;
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
 var DEFAULT_DISABLED_AGENTS = ["observer"];
@@ -19093,12 +19108,7 @@ Review available agents and lane rules.
 - Do not immediately wait after spawning independent background tasks unless the next step truly depends on their result
 - Reconcile results, resolve conflicts, and gate dependent lanes
 
-**File operations rules:**
-- Always use dedicated file tools for file I/O.
-- Search files/code with \`glob\`, \`grep\`, or \`ast_grep_search\`.
-- Read files with \`read\`. Never use \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or bash commands to read file contents.
-- Edit files with \`apply_patch\`. Never use shell redirection, \`echo\`, \`printf\`, or heredocs for file content unless no file tool can do the job.
-- Use \`bash\` only for execution: git, package managers, tests, builds, scripts, or diagnostics.
+${WRITABLE_FILE_OPERATIONS_RULES}
 
 ## 4. Plan and Parallelize
 Build a short work graph before dispatching:
@@ -19120,12 +19130,15 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 - 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.
 - 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,
@@ -19255,11 +19268,7 @@ var COUNCIL_AGENT_PROMPT = `You are the Council agent — a multi-LLM orchestrat
 - Be transparent about trade-offs when different approaches have valid pros/cons
 - Don't just average responses — choose the best approach and improve upon it
 
-**File Operations Rules**:
-- Use dedicated tools for file I/O if local files must be inspected
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Use bash only for execution/diagnostics, never for file I/O
+${READONLY_FILE_OPERATIONS_RULES}
 
 **Required Output Format**:
 Always include these sections in your final response:
@@ -19372,11 +19381,7 @@ var COUNCILLOR_PROMPT = `You are a councillor in a multi-model council.
 
 You CANNOT edit files, write files, run shell commands, or delegate to other agents. You are an advisor, not an implementer.
 
-**File Operations Rules**:
-- READ-ONLY: do not modify files
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Do not use bash or shell commands
+${NO_SHELL_READONLY_FILE_OPERATIONS_RULES}
 
 **Behavior**:
 - **Examine the codebase** before answering — your read access is what makes   council valuable. Don't guess at code you can see.
@@ -19466,12 +19471,7 @@ var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who crea
 - Prioritize visual excellence—code perfection comes second
 - Use grounded, normal, regular english - don't use jargon or overly technical language
 
-## File Operations Rules
-- Always use dedicated file tools for file I/O
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Edit/write files with write, edit, or apply_patch. Never use shell redirection, echo, printf, or heredocs for file content unless no file tool can do the job
-- Use bash only for execution: git, package managers, tests, builds, scripts, or diagnostics
+${WRITABLE_FILE_OPERATIONS_RULES}
 
 ## Review Responsibilities
 - Review existing UI for usability, responsiveness, visual consistency, and polish when asked
@@ -19510,11 +19510,7 @@ var EXPLORER_PROMPT = `You are Explorer - a fast codebase navigation specialist.
 - **Structural patterns** (function shapes, class structures): ast_grep_search
 - **File discovery** (find by name/extension): glob
 
-**File Operations Rules**:
-- READ-ONLY: Search and report, don't modify files
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Use bash only for execution/diagnostics, never for file I/O
+${READONLY_FILE_OPERATIONS_RULES}
 
 **Behavior**:
 - Be fast and thorough
@@ -19570,12 +19566,7 @@ var FIXER_PROMPT = `You are Fixer - a fast, focused implementation specialist.
 - Run relevant validation when requested or clearly applicable (otherwise note as skipped with reason)
 - Report completion with summary of changes
 
-**File Operations Rules**:
-- Always use dedicated file tools for file I/O
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Edit/write files with write, edit, or apply_patch. Never use shell redirection, echo, printf, or heredocs for file content unless no file tool can do the job
-- Use bash only for execution: git, package managers, tests, builds, scripts, or diagnostics
+${WRITABLE_FILE_OPERATIONS_RULES}
 
 **Constraints**:
 - NO external research (no websearch, context7, grep_app)
@@ -19642,11 +19633,7 @@ var LIBRARIAN_PROMPT = `You are Librarian - a research specialist for codebases
 - grep_app: Search GitHub repositories
 - websearch: General web search for docs
 
-**File Operations Rules**:
-- Use dedicated tools for file I/O when local files must be inspected
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Use bash only for execution/diagnostics, never for file I/O
+${READONLY_FILE_OPERATIONS_RULES}
 
 **Behavior**:
 - Provide evidence-based answers with sources
@@ -19693,10 +19680,7 @@ var OBSERVER_PROMPT = `You are Observer — a visual analysis specialist.
 - Match the language of the request
 - If info not found, state clearly what's missing
 
-**File Operations Rules**:
-- READ-ONLY: do not modify files
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Use bash only for execution/diagnostics, never for file I/O
+${READONLY_FILE_OPERATIONS_RULES}
 `;
 function createObserverAgent(model, customPrompt, customAppendPrompt) {
   let prompt = OBSERVER_PROMPT;
@@ -19742,11 +19726,7 @@ var ORACLE_PROMPT = `You are Oracle - a strategic technical advisor and code rev
 - Focus on strategy, not execution
 - Point to specific files/lines when relevant
 
-**File Operations Rules**:
-- READ-ONLY: do not modify files
-- Search files/code with glob, grep, or ast_grep_search
-- Read files with read. Never use cat, head, tail, sed, awk, or bash commands to read file contents
-- Use bash only for execution/diagnostics, never for file I/O
+${READONLY_FILE_OPERATIONS_RULES}
 `;
 function createOracleAgent(model, customPrompt, customAppendPrompt) {
   let prompt = ORACLE_PROMPT;
@@ -22662,6 +22642,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) {
@@ -22697,6 +22681,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());
@@ -22755,11 +22752,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
       };
@@ -22774,9 +22775,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),
@@ -22798,11 +22802,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);
@@ -22819,6 +22825,36 @@ class BackgroundJobBoard {
       resultSummary: status.result
     });
   }
+  markRunningFromLiveSession(taskID, now = Date.now()) {
+    const existing = this.jobs.get(taskID);
+    if (!existing)
+      return;
+    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,
+      lastStatusError: undefined
+    };
+    this.jobs.set(taskID, updated);
+    return updated;
+  }
   markReconciled(taskID, now = Date.now()) {
     const existing = this.jobs.get(taskID);
     if (!existing)
@@ -22830,6 +22866,7 @@ class BackgroundJobBoard {
       ...existing,
       state: "reconciled",
       terminalUnreconciled: false,
+      statusUncertain: false,
       updatedAt: now,
       lastUsedAt: now,
       terminalState: existing.terminalState ?? terminalStateOf(existing.state)
@@ -22838,24 +22875,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 +22967,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/reconciled sessions 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"],
@@ -22953,8 +22995,10 @@ class BackgroundJobBoard {
     }
   }
   formatReusableJob(job) {
+    const terminal = job.terminalState ?? terminalStateOf(job.state);
+    const reconciliation = job.terminalUnreconciled ? "unreconciled" : "reconciled";
     const lines = [
-      `- ${job.alias} / ${job.taskID} / ${job.agent} / completed, reconciled`,
+      `- ${job.alias} / ${job.taskID} / ${job.agent} / ${terminal ?? job.state}, ${reconciliation}`,
       `  Objective: ${job.objective || job.description}`
     ];
     const context = formatContextFiles(job.contextFiles, this.readContextMaxFiles);
@@ -22979,7 +23023,8 @@ function deriveTaskSessionLabel(input) {
   return firstPromptLine ? firstPromptLine.slice(0, 48) : `recent ${input.agentType} task`;
 }
 function isReusable(job) {
-  return job.state === "reconciled" && job.terminalState === "completed";
+  const terminal = job.terminalState ?? terminalStateOf(job.state);
+  return terminal === "completed" && !job.terminalUnreconciled;
 }
 function terminalStateOf(state) {
   return state === "completed" || state === "error" || state === "cancelled" ? state : undefined;
@@ -22999,13 +23044,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(`
 `);
@@ -24086,14 +24133,44 @@ function createTaskSessionManagerHook(_ctx, options) {
     const status = parseTaskStatusOutput(output);
     if (!status)
       return;
+    log("[task-session-manager] parsed task status output", {
+      taskID: status.taskID,
+      state: status.state,
+      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,
       timedOut: status.timedOut,
       resultSummary: status.result
     });
-    if (!updated)
+    if (!updated) {
+      log("[task-session-manager] ignored status for unknown background job", {
+        taskID: status.taskID,
+        state: status.state
+      });
       return;
+    }
+    log("[task-session-manager] background job status updated", {
+      taskID: updated.taskID,
+      alias: updated.alias,
+      parentSessionID: updated.parentSessionID,
+      state: updated.state,
+      terminalUnreconciled: updated.terminalUnreconciled,
+      timedOut: updated.timedOut
+    });
     if (updated.terminalUnreconciled) {
       pendingManagedTaskIds.delete(updated.taskID);
       backgroundJobBoard.addContext(updated.taskID, contextFilesForPrompt(contextByTask.get(updated.taskID)));
@@ -24101,6 +24178,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;
@@ -24113,16 +24245,36 @@ 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);
     if (!updated)
       return;
+    log("[task-session-manager] processed injected background completion", {
+      taskID: updated.taskID,
+      alias: updated.alias,
+      parentSessionID: updated.parentSessionID,
+      state: updated.state,
+      occurrenceId
+    });
     rememberProcessedInjectedCompletion(occurrenceId);
     return updated;
   }
@@ -24179,6 +24331,10 @@ function createTaskSessionManagerHook(_ctx, options) {
     const taskIDs = backgroundJobBoard.list(parentSessionID).filter((job) => job.terminalUnreconciled).map((job) => job.taskID);
     if (taskIDs.length === 0)
       return;
+    log("[task-session-manager] terminal jobs injected for reconciliation", {
+      parentSessionID,
+      taskIDs
+    });
     const existing = terminalJobsInjectedByParent.get(parentSessionID) ?? new Set;
     for (const taskID of taskIDs) {
       existing.add(taskID);
@@ -24189,6 +24345,10 @@ function createTaskSessionManagerHook(_ctx, options) {
     const taskIDs = terminalJobsInjectedByParent.get(parentSessionID);
     if (!taskIDs)
       return;
+    log("[task-session-manager] reconciling injected terminal jobs", {
+      parentSessionID,
+      taskIDs: [...taskIDs]
+    });
     for (const taskID of taskIDs) {
       backgroundJobBoard.markReconciled(taskID);
     }
@@ -24262,6 +24422,10 @@ function createTaskSessionManagerHook(_ctx, options) {
         if (!input.sessionID || !options.shouldManageSession(input.sessionID)) {
           return;
         }
+        normalizeLateCancelledToolStatus(output);
+        if (await handleTransientTaskStatusOutput(output)) {
+          return;
+        }
         updateBackgroundJobFromOutput(output.output);
         return;
       }
@@ -24272,13 +24436,21 @@ function createTaskSessionManagerHook(_ctx, options) {
         return;
       const launch = parseTaskLaunchOutput(output.output);
       if (launch) {
-        backgroundJobBoard.registerLaunch({
+        const record = backgroundJobBoard.registerLaunch({
           taskID: launch.taskID,
           parentSessionID: pending.parentSessionId,
           agent: pending.agentType,
           description: pending.label,
           objective: pending.label
         });
+        log("[task-session-manager] background task launch registered", {
+          taskID: record.taskID,
+          alias: record.alias,
+          parentSessionID: record.parentSessionID,
+          agent: record.agent,
+          description: record.description,
+          state: record.state
+        });
         backgroundJobBoard.addContext(launch.taskID, contextFilesForPrompt(contextByTask.get(launch.taskID)));
         pendingManagedTaskIds.add(launch.taskID);
         return;
@@ -24344,6 +24516,11 @@ function createTaskSessionManagerHook(_ctx, options) {
     event: async (input) => {
       if (input.event.type === "session.created") {
         const info = input.event.properties?.info;
+        log("[task-session-manager] session.created observed", {
+          sessionID: info?.id,
+          parentSessionID: info?.parentID,
+          managesParent: info?.parentID ? options.shouldManageSession(info.parentID) : false
+        });
         if (info?.id && info.parentID && options.shouldManageSession(info.parentID)) {
           pendingManagedTaskIds.add(info.id);
         }
@@ -24351,6 +24528,11 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
       if (input.event.type === "session.idle" || input.event.type === "session.status" && input.event.properties?.status?.type === "idle") {
         const sessionId2 = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
+        log("[task-session-manager] idle/status idle observed", {
+          sessionID: sessionId2,
+          managesSession: sessionId2 ? options.shouldManageSession(sessionId2) : false,
+          terminalJobsPending: sessionId2 ? terminalJobsInjectedByParent.get(sessionId2)?.size ?? 0 : 0
+        });
         if (sessionId2 && options.shouldManageSession(sessionId2)) {
           reconcileInjectedTerminalJobs(sessionId2);
         }
@@ -24363,11 +24545,49 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         return;
       }
+      if (input.event.type === "session.status" && input.event.properties?.status?.type === "busy") {
+        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,
+          previousCancellationRequested: before?.cancellationRequested,
+          previousLastLiveBusyAt: before?.lastLiveBusyAt,
+          updatedState: updated?.state,
+          updatedCancellationRequested: updated?.cancellationRequested,
+          updatedLastLiveBusyAt: updated?.lastLiveBusyAt
+        });
+        return;
+      }
       if (input.event.type !== "session.deleted")
         return;
       const sessionId = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
       if (!sessionId)
         return;
+      log("[task-session-manager] session.deleted observed; clearing job state", {
+        sessionID: sessionId,
+        deletedJob: backgroundJobBoard.get(sessionId) ? {
+          state: backgroundJobBoard.get(sessionId)?.state,
+          parentSessionID: backgroundJobBoard.get(sessionId)?.parentSessionID,
+          alias: backgroundJobBoard.get(sessionId)?.alias
+        } : undefined,
+        childJobCount: backgroundJobBoard.list(sessionId).length,
+        managesSession: options.shouldManageSession(sessionId)
+      });
       backgroundJobBoard.drop(sessionId);
       backgroundJobBoard.clearParent(sessionId);
       terminalJobsInjectedByParent.delete(sessionId);
@@ -24382,6 +24602,45 @@ function createTaskSessionManagerHook(_ctx, options) {
       }
     }
   };
+  function normalizeLateCancelledToolStatus(output) {
+    if (typeof output.output !== "string")
+      return;
+    const status = parseTaskStatusOutput(output.output);
+    if (!status)
+      return;
+    const existing = backgroundJobBoard.get(status.taskID);
+    if (!isLateCancelledTaskError(existing, status.state))
+      return;
+    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
+    });
+    output.output = formatCancelledTaskStatusOutput(status.taskID, existing?.resultSummary);
+    if (isObjectRecord(output) && isObjectRecord(output.metadata)) {
+      output.metadata.state = "cancelled";
+    }
+  }
+}
+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/hooks/todo-continuation/index.ts
 import { tool } from "@opencode-ai/plugin";
@@ -29690,6 +29949,7 @@ class MultiplexerSessionManager {
         parentId,
         title,
         directory,
+        ownerInstanceId: this.instanceId,
         createdAt: now,
         lastSeenAt: now,
         seenInStatus: false
@@ -29715,7 +29975,9 @@ class MultiplexerSessionManager {
         instanceId: this.instanceId,
         sessionId: sessionId2,
         tracked: this.sessions.has(sessionId2),
-        known: this.knownSessions.has(sessionId2)
+        known: this.knownSessions.has(sessionId2),
+        ownerInstanceId: this.sessions.get(sessionId2)?.ownerInstanceId,
+        backgroundJobState: this.backgroundJobBoard?.get(sessionId2)?.state
       });
       await this.closeSession(sessionId2, "idle");
       return;
@@ -29726,6 +29988,14 @@ class MultiplexerSessionManager {
     if (!sessionId)
       return;
     if (event.properties?.status?.type === "idle") {
+      log("[multiplexer-session-manager] session status idle received", {
+        instanceId: this.instanceId,
+        sessionId,
+        tracked: this.sessions.has(sessionId),
+        known: this.knownSessions.has(sessionId),
+        ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
+        backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
+      });
       await this.closeSession(sessionId, "idle");
       return;
     }
@@ -29734,7 +30004,9 @@ class MultiplexerSessionManager {
         instanceId: this.instanceId,
         sessionId,
         tracked: this.sessions.has(sessionId),
-        known: this.knownSessions.has(sessionId)
+        known: this.knownSessions.has(sessionId),
+        ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
+        backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
       });
       await this.respawnIfKnown(sessionId);
     }
@@ -29749,7 +30021,11 @@ class MultiplexerSessionManager {
       return;
     log("[multiplexer-session-manager] session deleted, closing pane", {
       instanceId: this.instanceId,
-      sessionId
+      sessionId,
+      tracked: this.sessions.has(sessionId),
+      known: this.knownSessions.has(sessionId),
+      ownerInstanceId: this.sessions.get(sessionId)?.ownerInstanceId,
+      backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
     });
     await this.closeSession(sessionId, "deleted");
   }
@@ -29780,6 +30056,15 @@ class MultiplexerSessionManager {
       const now = Date.now();
       const sessionsToClose = [];
       for (const [sessionId, tracked] of this.sessions.entries()) {
+        if (tracked.ownerInstanceId !== this.instanceId) {
+          log("[multiplexer-session-manager] skipping non-owner poll close", {
+            instanceId: this.instanceId,
+            ownerInstanceId: tracked.ownerInstanceId,
+            sessionId,
+            paneId: tracked.paneId
+          });
+          continue;
+        }
         const status = allStatuses[sessionId];
         const isIdle = status?.type === "idle";
         if (status) {
@@ -29790,7 +30075,7 @@ class MultiplexerSessionManager {
           tracked.missingSince = now;
         }
         const missingTooLong = !!tracked.missingSince && now - tracked.missingSince >= SESSION_MISSING_GRACE_MS;
-        const shouldKeepRunningBackgroundJob = missingTooLong && this.isRunningBackgroundJob(sessionId);
+        const shouldKeepRunningBackgroundJob = (isIdle || missingTooLong) && this.isRunningBackgroundJob(sessionId);
         if (isIdle || missingTooLong) {
           if (shouldKeepRunningBackgroundJob) {
             log("[multiplexer-session-manager] keeping running background pane", {
@@ -29848,12 +30133,44 @@ class MultiplexerSessionManager {
       });
       return;
     }
+    if (reason !== "deleted" && tracked.ownerInstanceId !== this.instanceId) {
+      log("[multiplexer-session-manager] close skipped; non-owner instance", {
+        instanceId: this.instanceId,
+        ownerInstanceId: tracked.ownerInstanceId,
+        sessionId,
+        paneId: tracked.paneId,
+        reason
+      });
+      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,
+        sessionId,
+        paneId: tracked.paneId,
+        reason,
+        backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state
+      });
+      return;
+    }
     this.sessions.delete(sessionId);
     log("[multiplexer-session-manager] closing session pane", {
       instanceId: this.instanceId,
       sessionId,
       paneId: tracked.paneId,
-      reason
+      reason,
+      backgroundJobState: this.backgroundJobBoard?.get(sessionId)?.state,
+      parentId: tracked.parentId,
+      title: tracked.title
     });
     const closePromise = this.multiplexer.closePane(tracked.paneId).then(() => {
       return;
@@ -29927,6 +30244,7 @@ class MultiplexerSessionManager {
         parentId: known.parentId,
         title: known.title,
         directory: known.directory,
+        ownerInstanceId: this.instanceId,
         createdAt: now,
         lastSeenAt: now,
         seenInStatus: false
@@ -30552,6 +30870,9 @@ import {
   tool as tool3
 } from "@opencode-ai/plugin";
 var z4 = tool3.schema;
+
+class SessionStillRunningError extends Error {
+}
 function createCancelTaskTool(options) {
   const cancel_task = tool3({
     description: `Cancel a tracked background specialist task.
@@ -30575,42 +30896,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(`
-`);
-      }
-      if (job.state !== "running") {
-        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),
@@ -30618,7 +30965,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"}`,
@@ -30632,6 +30986,282 @@ 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

package/dist/tools/cancel-task.d.ts

@@ -5,6 +5,12 @@ interface CancelTaskToolOptions {
     backgroundJobBoard: BackgroundJobBoard;
     shouldManageSession: (sessionID: string) => boolean;
     abortTimeoutMs?: number;
+    verifyAbortMs?: number;
+    abortRetryIntervalMs?: number;
+    stableStoppedMs?: number;
+    deleteTimeoutMs?: number;
+    deleteVerifyMs?: number;
+    deleteStableStoppedMs?: number;
 }
 export declare function createCancelTaskTool(options: CancelTaskToolOptions): Record<string, ToolDefinition>;
 export {};

package/dist/tui.js

@@ -69,6 +69,21 @@ 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 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.
+- Shell is acceptable for bulk or mechanical filesystem changes when it is clearer or safer than many individual edits (for example: truncate generated logs, remove build artifacts, batch rename/move files), especially when the user explicitly asks for that shell operation.
+- Before destructive or broad shell operations, verify the target set and quote paths. Prefer a dry-run/listing first when practical.
+- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.`;
+var READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- READ-ONLY: inspect and report; do not modify files.
+- Prefer dedicated file tools for codebase inspection: glob/grep/ast_grep_search for discovery and read for file contents.
+- Bash is allowed for non-mutating diagnostics and shell-native inspection when it is the clearest tool, but not for modifying files.
+- Do not use cat/head/tail/sed/awk only to read code into context; use read/grep unless a shell pipeline is genuinely the better diagnostic.`;
+var NO_SHELL_READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
+- READ-ONLY: inspect and report; do not modify files.
+- Use glob/grep/ast_grep_search for discovery and read for file contents.
+- Do not use bash or shell commands.`;
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
 var DEFAULT_DISABLED_AGENTS = ["observer"];

package/dist/utils/background-job-board.d.ts

@@ -14,12 +14,16 @@ export interface BackgroundJobRecord {
     objective?: string;
     state: BackgroundJobState;
     timedOut: boolean;
+    statusUncertain: boolean;
+    cancellationRequested: boolean;
     terminalUnreconciled: boolean;
     launchedAt: number;
     lastLaunchedAt: number;
     updatedAt: number;
+    lastLiveBusyAt?: number;
     completedAt?: number;
     resultSummary?: string;
+    lastStatusError?: string;
     alias: string;
     lastUsedAt: number;
     terminalState?: TaskOutputState;
@@ -42,7 +46,9 @@ export interface BackgroundJobStatusInput {
     taskID: string;
     state: TaskOutputState;
     timedOut?: boolean;
+    statusUncertain?: boolean;
     resultSummary?: string;
+    lastStatusError?: string;
     now?: number;
 }
 export declare class BackgroundJobBoard {
@@ -55,8 +61,11 @@ export declare class BackgroundJobBoard {
     registerLaunch(input: BackgroundJobLaunchInput): BackgroundJobRecord;
     updateStatus(input: BackgroundJobStatusInput): BackgroundJobRecord | undefined;
     updateFromStatusOutput(output: string): BackgroundJobRecord | undefined;
+    markRunningFromLiveSession(taskID: string, now?: number): BackgroundJobRecord | undefined;
     markReconciled(taskID: string, now?: number): BackgroundJobRecord | undefined;
-    markCancelled(taskID: string, reason?: string, now?: number): BackgroundJobRecord | undefined;
+    markCancelled(taskID: string, reason?: string, now?: number, options?: {
+        force?: boolean;
+    }): BackgroundJobRecord | undefined;
     get(taskID: string): BackgroundJobRecord | undefined;
     resolve(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;
     resolveForStatus(parentSessionID: string, taskIDOrAlias: string): BackgroundJobRecord | undefined;

package/dist/utils/task.d.ts

@@ -13,8 +13,10 @@ export interface TaskStatusOutput {
     timedOut: boolean;
     result?: string;
 }
+export type TaskStatusClassification = 'running' | 'terminal' | 'timeout' | 'transient_process_error' | 'unknown_error';
 export declare function parseTaskIdFromTaskOutput(output: string): string | undefined;
 export declare function parseTaskLaunchOutput(output: string): TaskLaunchOutput | undefined;
 export declare function parseTaskStatusOutput(output: string): TaskStatusOutput | undefined;
+export declare function classifyTaskStatusOutput(status: TaskStatusOutput): TaskStatusClassification;
 export declare function parseTaskStateFromOutput(output: string): TaskOutputState | undefined;
 export declare function parseTaskResultFromOutput(output: string): string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-slim",
-  "version": "2.0.0-beta.11",
+  "version": "2.0.0-beta.13",
   "description": "Lightweight agent orchestration plugin for OpenCode - a slimmed-down fork of oh-my-opencode",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",