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

package/dist/index.js

@@ -22642,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) {
@@ -22677,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());
@@ -22735,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
       };
@@ -22754,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),
@@ -22778,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);
@@ -22803,18 +22829,28 @@ class BackgroundJobBoard {
     const existing = this.jobs.get(taskID);
     if (!existing)
       return;
-    const isStaleCancellation = existing.state === "cancelled" || existing.state === "reconciled" && existing.terminalState === "cancelled";
-    if (!isStaleCancellation)
-      return existing;
+    const isStaleTerminal = TERMINAL_STATES.has(existing.state) || existing.state === "reconciled";
+    if (!isStaleTerminal || existing.cancellationRequested) {
+      const updated2 = {
+        ...existing,
+        lastLiveBusyAt: now
+      };
+      this.jobs.set(taskID, updated2);
+      return updated2;
+    }
     const updated = {
       ...existing,
       state: "running",
       timedOut: false,
+      statusUncertain: false,
+      cancellationRequested: false,
       terminalUnreconciled: false,
       updatedAt: now,
+      lastLiveBusyAt: now,
       completedAt: undefined,
       terminalState: undefined,
-      resultSummary: undefined
+      resultSummary: undefined,
+      lastStatusError: undefined
     };
     this.jobs.set(taskID, updated);
     return updated;
@@ -22830,6 +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 any non-running session for the same specialist/context.",
+      "Use task_status for running jobs. Reconcile terminal jobs before final response. Reuse only completed sessions for the same specialist/context; never reuse cancelled or errored sessions.",
       "",
       "#### Active / Unreconciled",
       ...active.length > 0 ? active.map((job) => formatJob(job, now)) : ["- none"],
@@ -22981,7 +23023,8 @@ function deriveTaskSessionLabel(input) {
   return firstPromptLine ? firstPromptLine.slice(0, 48) : `recent ${input.agentType} task`;
 }
 function isReusable(job) {
-  return job.state !== "running";
+  const terminal = job.terminalState ?? terminalStateOf(job.state);
+  return terminal === "completed" && !job.terminalUnreconciled;
 }
 function terminalStateOf(state) {
   return state === "completed" || state === "error" || state === "cancelled" ? state : undefined;
@@ -23001,13 +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(`
 `);
@@ -24094,6 +24139,17 @@ function createTaskSessionManagerHook(_ctx, options) {
       timedOut: status.timedOut,
       hasResult: Boolean(status.result)
     });
+    const existing = backgroundJobBoard.get(status.taskID);
+    if (isLateCancelledTaskError(existing, status.state)) {
+      log("[task-session-manager] suppressed late cancelled task error", {
+        taskID: status.taskID,
+        alias: existing?.alias,
+        state: existing?.state,
+        terminalState: existing?.terminalState,
+        result: status.result
+      });
+      return existing;
+    }
     const updated = backgroundJobBoard.updateStatus({
       taskID: status.taskID,
       state: status.state,
@@ -24122,6 +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;
@@ -24134,11 +24245,24 @@ function createTaskSessionManagerHook(_ctx, options) {
     const status = parseTaskStatusOutput(part.text);
     if (!status)
       return;
+    const occurrenceId = createOccurrenceId(part, message, partIndex);
+    const existing = backgroundJobBoard.get(status.taskID);
+    if (isFailed && isLateCancelledTaskError(existing, status.state)) {
+      part.text = formatCancelledTaskStatusOutput(status.taskID, existing?.resultSummary);
+      log("[task-session-manager] normalized late cancelled injected failure", {
+        taskID: status.taskID,
+        alias: existing?.alias,
+        state: existing?.state,
+        terminalState: existing?.terminalState,
+        result: status.result
+      });
+      rememberProcessedInjectedCompletion(occurrenceId);
+      return existing;
+    }
     if (isCompleted && status.state !== "completed")
       return;
     if (isFailed && status.state !== "error")
       return;
-    const occurrenceId = createOccurrenceId(part, message, partIndex);
     if (processedInjectedCompletions.has(occurrenceId))
       return;
     const updated = updateBackgroundJobFromOutput(part.text);
@@ -24298,6 +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;
       }
@@ -24421,12 +24549,27 @@ function createTaskSessionManagerHook(_ctx, options) {
         const sessionId2 = input.event.properties?.info?.id ?? input.event.properties?.sessionID;
         const before = sessionId2 ? backgroundJobBoard.get(sessionId2) : undefined;
         const updated = sessionId2 ? backgroundJobBoard.markRunningFromLiveSession(sessionId2) : undefined;
+        if (before?.cancellationRequested) {
+          log("[task-session-manager] busy observed after cancel request", {
+            sessionID: sessionId2,
+            previousState: before.state,
+            previousTerminalState: before.terminalState,
+            terminalUnreconciled: before.terminalUnreconciled,
+            resultSummary: before.resultSummary,
+            updatedState: updated?.state,
+            updatedCancellationRequested: updated?.cancellationRequested
+          });
+        }
         log("[task-session-manager] busy/status busy observed", {
           sessionID: sessionId2,
           managesSession: sessionId2 ? options.shouldManageSession(sessionId2) : false,
           previousState: before?.state,
           previousTerminalState: before?.terminalState,
-          updatedState: updated?.state
+          previousCancellationRequested: before?.cancellationRequested,
+          previousLastLiveBusyAt: before?.lastLiveBusyAt,
+          updatedState: updated?.state,
+          updatedCancellationRequested: updated?.cancellationRequested,
+          updatedLastLiveBusyAt: updated?.lastLiveBusyAt
         });
         return;
       }
@@ -24459,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";
@@ -29951,7 +30133,7 @@ class MultiplexerSessionManager {
       });
       return;
     }
-    if (tracked.ownerInstanceId !== this.instanceId) {
+    if (reason !== "deleted" && tracked.ownerInstanceId !== this.instanceId) {
       log("[multiplexer-session-manager] close skipped; non-owner instance", {
         instanceId: this.instanceId,
         ownerInstanceId: tracked.ownerInstanceId,
@@ -29961,6 +30143,15 @@ class MultiplexerSessionManager {
       });
       return;
     }
+    if (reason === "deleted" && tracked.ownerInstanceId !== this.instanceId) {
+      log("[multiplexer-session-manager] closing deleted pane as non-owner", {
+        instanceId: this.instanceId,
+        ownerInstanceId: tracked.ownerInstanceId,
+        sessionId,
+        paneId: tracked.paneId,
+        reason
+      });
+    }
     if (reason === "idle" && this.isRunningBackgroundJob(sessionId)) {
       log("[multiplexer-session-manager] close skipped; background job running", {
         instanceId: this.instanceId,
@@ -30679,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.
@@ -30702,43 +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(`
-`);
-      }
-      const shouldAbort = job.state === "running" || job.state === "cancelled" || job.state === "reconciled" && job.terminalState === "cancelled";
-      if (!shouldAbort) {
-        return [
-          `task_id: ${job.taskID}`,
-          `state: ${job.state}`,
-          "",
-          "<task_result>",
-          `not cancelled: task is already ${job.state}`,
-          "</task_result>"
-        ].join(`
-`);
+        if (isSessionID(requested)) {
+          if (requested === parentSessionID) {
+            log("[cancel-task] rejected parent session cancellation", {
+              parentSessionID,
+              taskID: requested
+            });
+            return unknownTaskOutput(requested, "cannot cancel parent session");
+          }
+          const knownJob = options.backgroundJobBoard.get(requested);
+          if (knownJob && knownJob.parentSessionID !== parentSessionID) {
+            log("[cancel-task] rejected unowned tracked raw session", {
+              parentSessionID,
+              taskID: requested,
+              ownerParentSessionID: knownJob.parentSessionID
+            });
+            return unknownTaskOutput(requested, "unknown or unowned background task");
+          }
+          const parentID = await getSessionParentID(options.client, requested);
+          if (parentID !== parentSessionID) {
+            log("[cancel-task] rejected raw session without parent ownership", {
+              parentSessionID,
+              taskID: requested,
+              actualParentID: parentID
+            });
+            return unknownTaskOutput(requested, "unknown or unowned background task");
+          }
+          log("[cancel-task] falling back to owned raw session abort", {
+            parentSessionID,
+            taskID: requested
+          });
+          return cancelSessionByID(options, requested, args.reason);
+        }
+        return unknownTaskOutput(requested, "unknown or unowned background task");
       }
       try {
-        await abortSessionWithTimeout(options.client, job.taskID, options.abortTimeoutMs ?? 1e4);
+        await abortAndVerifySession(options, job.taskID);
       } catch (error) {
-        const timedOut = error instanceof OperationTimeoutError;
-        if (timedOut) {
-          options.backgroundJobBoard.updateStatus({
-            taskID: job.taskID,
-            state: "error",
-            resultSummary: error instanceof Error ? error.message : "cancel request timed out"
-          });
-        }
+        const stillRunning = error instanceof SessionStillRunningError;
+        log("[cancel-task] abort failed", {
+          taskID: job.taskID,
+          stillRunning,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        options.backgroundJobBoard.updateStatus({
+          taskID: job.taskID,
+          state: "running",
+          statusUncertain: true,
+          lastStatusError: error instanceof Error ? error.message : String(error)
+        });
         return [
           `task_id: ${job.taskID}`,
-          `state: ${timedOut ? "error" : "cancel_error"}`,
+          "state: running",
           "",
           "<task_error>",
           error instanceof Error ? error.message : String(error),
@@ -30746,7 +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"}`,
@@ -30760,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/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 {
@@ -57,7 +63,9 @@ export declare class BackgroundJobBoard {
     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.12",
+  "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",