oh-my-opencode 3.0.0-beta.10 → 3.0.0-beta.11

package/dist/index.js

@@ -19111,6 +19111,80 @@ ${ULTRAWORK_PLANNER_SECTION}
 
 [CODE RED] Maximum precision required. Ultrathink before acting.
 
+## **ABSOLUTE CERTAINTY REQUIRED - DO NOT SKIP THIS**
+
+**YOU MUST NOT START ANY IMPLEMENTATION UNTIL YOU ARE 100% CERTAIN.**
+
+| **BEFORE YOU WRITE A SINGLE LINE OF CODE, YOU MUST:** |
+|-------------------------------------------------------|
+| **FULLY UNDERSTAND** what the user ACTUALLY wants (not what you ASSUME they want) |
+| **EXPLORE** the codebase to understand existing patterns, architecture, and context |
+| **HAVE A CRYSTAL CLEAR WORK PLAN** - if your plan is vague, YOUR WORK WILL FAIL |
+| **RESOLVE ALL AMBIGUITY** - if ANYTHING is unclear, ASK or INVESTIGATE |
+
+### **MANDATORY CERTAINTY PROTOCOL**
+
+**IF YOU ARE NOT 100% CERTAIN:**
+
+1. **THINK DEEPLY** - What is the user's TRUE intent? What problem are they REALLY trying to solve?
+2. **EXPLORE THOROUGHLY** - Fire explore/librarian agents to gather ALL relevant context
+3. **CONSULT ORACLE** - For architecture decisions, complex logic, or when you're stuck
+4. **ASK THE USER** - If ambiguity remains after exploration, ASK. Don't guess.
+
+**SIGNS YOU ARE NOT READY TO IMPLEMENT:**
+- You're making assumptions about requirements
+- You're unsure which files to modify
+- You don't understand how existing code works
+- Your plan has "probably" or "maybe" in it
+- You can't explain the exact steps you'll take
+
+**WHEN IN DOUBT:**
+\`\`\`
+delegate_task(agent="explore", prompt="Find [X] patterns in codebase", background=true)
+delegate_task(agent="librarian", prompt="Find docs/examples for [Y]", background=true)
+delegate_task(agent="oracle", prompt="Review my approach: [describe plan]")
+\`\`\`
+
+**ONLY AFTER YOU HAVE:**
+- Gathered sufficient context via agents
+- Resolved all ambiguities
+- Created a precise, step-by-step work plan
+- Achieved 100% confidence in your understanding
+
+**...THEN AND ONLY THEN MAY YOU BEGIN IMPLEMENTATION.**
+
+---
+
+## **NO EXCUSES. NO COMPROMISES. DELIVER WHAT WAS ASKED.**
+
+**THE USER'S ORIGINAL REQUEST IS SACRED. YOU MUST FULFILL IT EXACTLY.**
+
+| VIOLATION | CONSEQUENCE |
+|-----------|-------------|
+| "I couldn't because..." | **UNACCEPTABLE.** Find a way or ask for help. |
+| "This is a simplified version..." | **UNACCEPTABLE.** Deliver the FULL implementation. |
+| "You can extend this later..." | **UNACCEPTABLE.** Finish it NOW. |
+| "Due to limitations..." | **UNACCEPTABLE.** Use agents, tools, whatever it takes. |
+| "I made some assumptions..." | **UNACCEPTABLE.** You should have asked FIRST. |
+
+**THERE ARE NO VALID EXCUSES FOR:**
+- Delivering partial work
+- Changing scope without explicit user approval
+- Making unauthorized simplifications
+- Stopping before the task is 100% complete
+- Compromising on any stated requirement
+
+**IF YOU ENCOUNTER A BLOCKER:**
+1. **DO NOT** give up
+2. **DO NOT** deliver a compromised version
+3. **DO** consult oracle for solutions
+4. **DO** ask the user for guidance
+5. **DO** explore alternative approaches
+
+**THE USER ASKED FOR X. DELIVER EXACTLY X. PERIOD.**
+
+---
+
 YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
 TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 
@@ -22298,7 +22372,7 @@ function createPrometheusMdOnlyHook(ctx) {
           filePath,
           agent: agentName
         });
-        throw new Error(`[${HOOK_NAME4}] Prometheus (Planner) can only write/edit .md files inside .sisyphus/ directory. ` + `Attempted to modify: ${filePath}. ` + `Prometheus is a READ-ONLY planner. Use /start-work to execute the plan.`);
+        throw new Error(`[${HOOK_NAME4}] Prometheus (Planner) can only write/edit .md files inside .sisyphus/ directory. ` + `Attempted to modify: ${filePath}. ` + `Prometheus is a READ-ONLY planner. Use /start-work to execute the plan. ` + `APOLOGIZE TO THE USER, REMIND OF YOUR PLAN WRITING PROCESSES, TELL USER WHAT YOU WILL GOING TO DO AS THE PROCESS, WRITE THE PLAN`);
       }
       log(`[${HOOK_NAME4}] Allowed: .sisyphus/*.md write permitted`, {
         sessionID: input.sessionID,
@@ -40050,7 +40124,14 @@ function truncateText(text, maxLength) {
   return text.slice(0, maxLength) + "...";
 }
 function formatTaskStatus(task) {
-  const duration3 = formatDuration(task.startedAt, task.completedAt);
+  let duration3;
+  if (task.status === "pending" && task.queuedAt) {
+    duration3 = formatDuration(task.queuedAt, undefined);
+  } else if (task.startedAt) {
+    duration3 = formatDuration(task.startedAt, task.completedAt);
+  } else {
+    duration3 = "N/A";
+  }
   const promptPreview = truncateText(task.prompt, 500);
   let progressSection = "";
   if (task.progress?.lastTool) {
@@ -40070,7 +40151,11 @@ ${truncated}
 \`\`\``;
   }
   let statusNote = "";
-  if (task.status === "running") {
+  if (task.status === "pending") {
+    statusNote = `
+
+> **Queued**: Task is waiting for a concurrency slot to become available.`;
+  } else if (task.status === "running") {
     statusNote = `
 
 > **Note**: No need to wait explicitly - the system will notify you when this task completes.`;
@@ -40079,6 +40164,7 @@ ${truncated}
 
 > **Failed**: The task encountered an error. Check the last message for details.`;
   }
+  const durationLabel = task.status === "pending" ? "Queued for" : "Duration";
   return `# Task Status
 
 | Field | Value |
@@ -40087,7 +40173,7 @@ ${truncated}
 | Description | ${task.description} |
 | Agent | ${task.agent} |
 | Status | **${task.status}** |
-| Duration | ${duration3} |
+| ${durationLabel} | ${duration3} |
 | Session ID | \`${task.sessionID}\` |${progressSection}
 ${statusNote}
 ## Original Prompt
@@ -40097,6 +40183,9 @@ ${promptPreview}
 \`\`\`${lastMessageSection}`;
 }
 async function formatTaskResult(task, client2) {
+  if (!task.sessionID) {
+    return `Error: Task has no sessionID`;
+  }
   const messagesResult = await client2.session.messages({
     path: { id: task.sessionID }
   });
@@ -40109,7 +40198,7 @@ async function formatTaskResult(task, client2) {
 
 Task ID: ${task.id}
 Description: ${task.description}
-Duration: ${formatDuration(task.startedAt, task.completedAt)}
+Duration: ${formatDuration(task.startedAt ?? new Date, task.completedAt)}
 Session ID: ${task.sessionID}
 
 ---
@@ -40122,7 +40211,7 @@ Session ID: ${task.sessionID}
 
 Task ID: ${task.id}
 Description: ${task.description}
-Duration: ${formatDuration(task.startedAt, task.completedAt)}
+Duration: ${formatDuration(task.startedAt ?? new Date, task.completedAt)}
 Session ID: ${task.sessionID}
 
 ---
@@ -40136,7 +40225,7 @@ Session ID: ${task.sessionID}
   });
   const newMessages = consumeNewMessages(task.sessionID, sortedMessages);
   if (newMessages.length === 0) {
-    const duration4 = formatDuration(task.startedAt, task.completedAt);
+    const duration4 = formatDuration(task.startedAt ?? new Date, task.completedAt);
     return `Task Result
 
 Task ID: ${task.id}
@@ -40170,7 +40259,7 @@ Session ID: ${task.sessionID}
   const textContent = extractedContent.filter((text) => text.length > 0).join(`
 
 `);
-  const duration3 = formatDuration(task.startedAt, task.completedAt);
+  const duration3 = formatDuration(task.startedAt ?? new Date, task.completedAt);
   return `Task Result
 
 Task ID: ${task.id}
@@ -40249,20 +40338,25 @@ function createBackgroundCancel(manager, client2) {
         }
         if (cancelAll) {
           const tasks = manager.getAllDescendantTasks(toolContext.sessionID);
-          const runningTasks = tasks.filter((t) => t.status === "running");
-          if (runningTasks.length === 0) {
-            return `\u2705 No running background tasks to cancel.`;
+          const cancellableTasks = tasks.filter((t) => t.status === "running" || t.status === "pending");
+          if (cancellableTasks.length === 0) {
+            return `\u2705 No running or pending background tasks to cancel.`;
           }
           const results = [];
-          for (const task2 of runningTasks) {
-            client2.session.abort({
-              path: { id: task2.sessionID }
-            }).catch(() => {});
-            task2.status = "cancelled";
-            task2.completedAt = new Date;
-            results.push(`- ${task2.id}: ${task2.description}`);
+          for (const task2 of cancellableTasks) {
+            if (task2.status === "pending") {
+              manager.cancelPendingTask(task2.id);
+              results.push(`- ${task2.id}: ${task2.description} (pending)`);
+            } else if (task2.sessionID) {
+              client2.session.abort({
+                path: { id: task2.sessionID }
+              }).catch(() => {});
+              task2.status = "cancelled";
+              task2.completedAt = new Date;
+              results.push(`- ${task2.id}: ${task2.description} (running)`);
+            }
           }
-          return `\u2705 Cancelled ${runningTasks.length} background task(s):
+          return `\u2705 Cancelled ${cancellableTasks.length} background task(s):
 
 ${results.join(`
 `)}`;
@@ -40271,13 +40365,26 @@ ${results.join(`
         if (!task) {
           return `\u274C Task not found: ${args.taskId}`;
         }
-        if (task.status !== "running") {
+        if (task.status !== "running" && task.status !== "pending") {
           return `\u274C Cannot cancel task: current status is "${task.status}".
-Only running tasks can be cancelled.`;
+Only running or pending tasks can be cancelled.`;
+        }
+        if (task.status === "pending") {
+          const cancelled = manager.cancelPendingTask(task.id);
+          if (!cancelled) {
+            return `\u274C Failed to cancel pending task: ${task.id}`;
+          }
+          return `\u2705 Pending task cancelled successfully
+
+Task ID: ${task.id}
+Description: ${task.description}
+Status: ${task.status}`;
+        }
+        if (task.sessionID) {
+          client2.session.abort({
+            path: { id: task.sessionID }
+          }).catch(() => {});
         }
-        client2.session.abort({
-          path: { id: task.sessionID }
-        }).catch(() => {});
         task.status = "cancelled";
         task.completedAt = new Date;
         return `\u2705 Task cancelled successfully
@@ -40817,7 +40924,8 @@ class TaskToastManager {
       for (const task of queued) {
         const bgIcon = task.isBackground ? "\u23F3" : "\u23F8\uFE0F";
         const skillsInfo = task.skills?.length ? ` [${task.skills.join(", ")}]` : "";
-        lines.push(`${bgIcon} ${task.description} (${task.agent})${skillsInfo}`);
+        const isNew = task.id === newTask.id ? " \u2190 NEW" : "";
+        lines.push(`${bgIcon} ${task.description} (${task.agent})${skillsInfo} - Queued${isNew}`);
       }
     }
     return lines.join(`
@@ -41616,6 +41724,8 @@ class BackgroundManager {
   concurrencyManager;
   shutdownTriggered = false;
   config;
+  queuesByKey = new Map;
+  processingKeys = new Set;
   constructor(ctx, config3) {
     this.tasks = new Map;
     this.notifications = new Map;
@@ -41636,8 +41746,78 @@ class BackgroundManager {
     if (!input.agent || input.agent.trim() === "") {
       throw new Error("Agent parameter is required");
     }
-    const concurrencyKey = input.agent;
-    await this.concurrencyManager.acquire(concurrencyKey);
+    const task = {
+      id: `bg_${crypto.randomUUID().slice(0, 8)}`,
+      status: "pending",
+      queuedAt: new Date,
+      description: input.description,
+      prompt: input.prompt,
+      agent: input.agent,
+      parentSessionID: input.parentSessionID,
+      parentMessageID: input.parentMessageID,
+      parentModel: input.parentModel,
+      parentAgent: input.parentAgent,
+      model: input.model
+    };
+    this.tasks.set(task.id, task);
+    if (input.parentSessionID) {
+      const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
+      pending.add(task.id);
+      this.pendingByParent.set(input.parentSessionID, pending);
+    }
+    const key = this.getConcurrencyKeyFromInput(input);
+    const queue = this.queuesByKey.get(key) ?? [];
+    queue.push({ task, input });
+    this.queuesByKey.set(key, queue);
+    log("[background-agent] Task queued:", { taskId: task.id, key, queueLength: queue.length });
+    const toastManager = getTaskToastManager();
+    if (toastManager) {
+      toastManager.addTask({
+        id: task.id,
+        description: input.description,
+        agent: input.agent,
+        isBackground: true,
+        status: "queued",
+        skills: input.skills
+      });
+    }
+    this.processKey(key);
+    return task;
+  }
+  async processKey(key) {
+    if (this.processingKeys.has(key)) {
+      return;
+    }
+    this.processingKeys.add(key);
+    try {
+      const queue = this.queuesByKey.get(key);
+      while (queue && queue.length > 0) {
+        const item = queue[0];
+        await this.concurrencyManager.acquire(key);
+        if (item.task.status === "cancelled") {
+          this.concurrencyManager.release(key);
+          queue.shift();
+          continue;
+        }
+        try {
+          await this.startTask(item);
+        } catch (error45) {
+          log("[background-agent] Error starting task:", error45);
+        }
+        queue.shift();
+      }
+    } finally {
+      this.processingKeys.delete(key);
+    }
+  }
+  async startTask(item) {
+    const { task, input } = item;
+    log("[background-agent] Starting task:", {
+      taskId: task.id,
+      agent: input.agent,
+      model: input.model
+    });
+    const concurrencyKey = this.getConcurrencyKeyFromInput(input);
     const parentSession = await this.client.session.get({
       path: { id: input.parentSessionID }
     }).catch((err) => {
@@ -41664,41 +41844,20 @@ class BackgroundManager {
     }
     const sessionID = createResult.data.id;
     subagentSessions.add(sessionID);
-    const task = {
-      id: `bg_${crypto.randomUUID().slice(0, 8)}`,
-      sessionID,
-      parentSessionID: input.parentSessionID,
-      parentMessageID: input.parentMessageID,
-      description: input.description,
-      prompt: input.prompt,
-      agent: input.agent,
-      status: "running",
-      startedAt: new Date,
-      progress: {
-        toolCalls: 0,
-        lastUpdate: new Date
-      },
-      parentModel: input.parentModel,
-      parentAgent: input.parentAgent,
-      model: input.model,
-      concurrencyKey,
-      concurrencyGroup: concurrencyKey
+    task.status = "running";
+    task.startedAt = new Date;
+    task.sessionID = sessionID;
+    task.progress = {
+      toolCalls: 0,
+      lastUpdate: new Date
     };
-    this.tasks.set(task.id, task);
+    task.concurrencyKey = concurrencyKey;
+    task.concurrencyGroup = concurrencyKey;
     this.startPolling();
-    const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
-    pending.add(task.id);
-    this.pendingByParent.set(input.parentSessionID, pending);
     log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent });
     const toastManager = getTaskToastManager();
     if (toastManager) {
-      toastManager.addTask({
-        id: task.id,
-        description: input.description,
-        agent: input.agent,
-        isBackground: true,
-        skills: input.skills
-      });
+      toastManager.updateTask(task.id, "running");
     }
     log("[background-agent] Calling prompt (fire-and-forget) for launch with:", {
       sessionID,
@@ -41743,7 +41902,6 @@ class BackgroundManager {
         });
       }
     });
-    return task;
   }
   getTask(id) {
     return this.tasks.get(id);
@@ -41762,8 +41920,10 @@ class BackgroundManager {
     const directChildren = this.getTasksByParentSession(sessionID);
     for (const child of directChildren) {
       result.push(child);
-      const descendants = this.getAllDescendantTasks(child.sessionID);
-      result.push(...descendants);
+      if (child.sessionID) {
+        const descendants = this.getAllDescendantTasks(child.sessionID);
+        result.push(...descendants);
+      }
     }
     return result;
   }
@@ -41775,6 +41935,12 @@ class BackgroundManager {
     }
     return;
   }
+  getConcurrencyKeyFromInput(input) {
+    if (input.model) {
+      return `${input.model.providerID}/${input.model.modelID}`;
+    }
+    return input.agent;
+  }
   async trackTask(input) {
     const existingTask = this.tasks.get(input.taskId);
     if (existingTask) {
@@ -41789,12 +41955,14 @@ class BackgroundManager {
       if (!existingTask.concurrencyGroup) {
         existingTask.concurrencyGroup = input.concurrencyKey ?? existingTask.agent;
       }
-      subagentSessions.add(existingTask.sessionID);
+      if (existingTask.sessionID) {
+        subagentSessions.add(existingTask.sessionID);
+      }
       this.startPolling();
-      if (existingTask.status === "running") {
-        const pending2 = this.pendingByParent.get(input.parentSessionID) ?? new Set;
-        pending2.add(existingTask.id);
-        this.pendingByParent.set(input.parentSessionID, pending2);
+      if (existingTask.status === "pending" || existingTask.status === "running") {
+        const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
+        pending.add(existingTask.id);
+        this.pendingByParent.set(input.parentSessionID, pending);
       } else if (!parentChanged) {
         this.cleanupPendingByParent(existingTask);
       }
@@ -41826,9 +41994,11 @@ class BackgroundManager {
     this.tasks.set(task.id, task);
     subagentSessions.add(input.sessionID);
     this.startPolling();
-    const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
-    pending.add(task.id);
-    this.pendingByParent.set(input.parentSessionID, pending);
+    if (input.parentSessionID) {
+      const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
+      pending.add(task.id);
+      this.pendingByParent.set(input.parentSessionID, pending);
+    }
     log("[background-agent] Registered external task:", { taskId: task.id, sessionID: input.sessionID });
     return task;
   }
@@ -41837,6 +42007,9 @@ class BackgroundManager {
     if (!existingTask) {
       throw new Error(`Task not found for session: ${input.sessionId}`);
     }
+    if (!existingTask.sessionID) {
+      throw new Error(`Task has no sessionID: ${existingTask.id}`);
+    }
     if (existingTask.status === "running") {
       log("[background-agent] Resume skipped - task already running:", {
         taskId: existingTask.id,
@@ -41861,10 +42034,14 @@ class BackgroundManager {
       lastUpdate: new Date
     };
     this.startPolling();
-    subagentSessions.add(existingTask.sessionID);
-    const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
-    pending.add(existingTask.id);
-    this.pendingByParent.set(input.parentSessionID, pending);
+    if (existingTask.sessionID) {
+      subagentSessions.add(existingTask.sessionID);
+    }
+    if (input.parentSessionID) {
+      const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set;
+      pending.add(existingTask.id);
+      this.pendingByParent.set(input.parentSessionID, pending);
+    }
     const toastManager = getTaskToastManager();
     if (toastManager) {
       toastManager.addTask({
@@ -41956,7 +42133,10 @@ class BackgroundManager {
       const task = this.findBySession(sessionID);
       if (!task || task.status !== "running")
         return;
-      const elapsedMs = Date.now() - task.startedAt.getTime();
+      const startedAt = task.startedAt;
+      if (!startedAt)
+        return;
+      const elapsedMs = Date.now() - startedAt.getTime();
       const MIN_IDLE_TIME_MS = 5000;
       if (elapsedMs < MIN_IDLE_TIME_MS) {
         log("[background-agent] Ignoring early session.idle, elapsed:", { elapsedMs, taskId: task.id });
@@ -42067,6 +42247,28 @@ class BackgroundManager {
       }
     }
   }
+  cancelPendingTask(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task || task.status !== "pending") {
+      return false;
+    }
+    const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
+    const queue = this.queuesByKey.get(key);
+    if (queue) {
+      const index = queue.findIndex((item) => item.task.id === taskId);
+      if (index !== -1) {
+        queue.splice(index, 1);
+        if (queue.length === 0) {
+          this.queuesByKey.delete(key);
+        }
+      }
+    }
+    task.status = "cancelled";
+    task.completedAt = new Date;
+    this.cleanupPendingByParent(task);
+    log("[background-agent] Cancelled pending task:", { taskId, key });
+    return true;
+  }
   startPolling() {
     if (this.pollingInterval)
       return;
@@ -42144,7 +42346,7 @@ class BackgroundManager {
     return true;
   }
   async notifyParentSession(task) {
-    const duration3 = this.formatDuration(task.startedAt, task.completedAt);
+    const duration3 = this.formatDuration(task.startedAt ?? new Date, task.completedAt);
     log("[background-agent] notifyParentSession called for task:", task.id);
     const toastManager = getTaskToastManager();
     if (toastManager) {
@@ -42163,12 +42365,12 @@ class BackgroundManager {
     }
     const allComplete = !pendingSet || pendingSet.size === 0;
     const remainingCount = pendingSet?.size ?? 0;
-    const statusText = task.status === "error" ? "FAILED" : "COMPLETED";
+    const statusText = task.status === "completed" ? "COMPLETED" : "CANCELLED";
     const errorInfo = task.error ? `
 **Error:** ${task.error}` : "";
     let notification;
     if (allComplete) {
-      const completedTasks = Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running").map((t) => `- \`${t.id}\`: ${t.description}`).join(`
+      const completedTasks = Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending").map((t) => `- \`${t.id}\`: ${t.description}`).join(`
 `);
       notification = `<system-reminder>
 [ALL BACKGROUND TASKS COMPLETE]
@@ -42264,11 +42466,16 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
   pruneStaleTasksAndNotifications() {
     const now = Date.now();
     for (const [taskId, task] of this.tasks.entries()) {
-      const age = now - task.startedAt.getTime();
+      const timestamp2 = task.status === "pending" ? task.queuedAt?.getTime() : task.startedAt?.getTime();
+      if (!timestamp2) {
+        continue;
+      }
+      const age = now - timestamp2;
       if (age > TASK_TTL_MS) {
-        log("[background-agent] Pruning stale task:", { taskId, age: Math.round(age / 1000) + "s" });
+        const errorMessage = task.status === "pending" ? "Task timed out while queued (30 minutes)" : "Task timed out after 30 minutes";
+        log("[background-agent] Pruning stale task:", { taskId, status: task.status, age: Math.round(age / 1000) + "s" });
         task.status = "error";
-        task.error = "Task timed out after 30 minutes";
+        task.error = errorMessage;
         task.completedAt = new Date;
         if (task.concurrencyKey) {
           this.concurrencyManager.release(task.concurrencyKey);
@@ -42277,7 +42484,9 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         this.cleanupPendingByParent(task);
         this.clearNotificationsForTask(taskId);
         this.tasks.delete(taskId);
-        subagentSessions.delete(task.sessionID);
+        if (task.sessionID) {
+          subagentSessions.delete(task.sessionID);
+        }
       }
     }
     for (const [sessionID, notifications] of this.notifications.entries()) {
@@ -42286,6 +42495,8 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         continue;
       }
       const validNotifications = notifications.filter((task) => {
+        if (!task.startedAt)
+          return false;
         const age = now - task.startedAt.getTime();
         return age <= TASK_TTL_MS;
       });
@@ -42304,7 +42515,11 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         continue;
       if (!task.progress?.lastUpdate)
         continue;
-      const runtime = now - task.startedAt.getTime();
+      const startedAt = task.startedAt;
+      const sessionID = task.sessionID;
+      if (!startedAt || !sessionID)
+        continue;
+      const runtime = now - startedAt.getTime();
       if (runtime < MIN_RUNTIME_BEFORE_STALE_MS)
         continue;
       const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime();
@@ -42321,7 +42536,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         task.concurrencyKey = undefined;
       }
       this.client.session.abort({
-        path: { id: task.sessionID }
+        path: { id: sessionID }
       }).catch(() => {});
       log(`[background-agent] Task ${task.id} interrupted: stale timeout`);
       try {
@@ -42339,17 +42554,20 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     for (const task of this.tasks.values()) {
       if (task.status !== "running")
         continue;
+      const sessionID = task.sessionID;
+      if (!sessionID)
+        continue;
       try {
-        const sessionStatus = allStatuses[task.sessionID];
+        const sessionStatus = allStatuses[sessionID];
         if (sessionStatus?.type === "idle") {
-          const hasValidOutput = await this.validateSessionHasOutput(task.sessionID);
+          const hasValidOutput = await this.validateSessionHasOutput(sessionID);
           if (!hasValidOutput) {
             log("[background-agent] Polling idle but no valid output yet, waiting:", task.id);
             continue;
           }
           if (task.status !== "running")
             continue;
-          const hasIncompleteTodos2 = await this.checkSessionTodos(task.sessionID);
+          const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
           if (hasIncompleteTodos2) {
             log("[background-agent] Task has incomplete todos via polling, waiting:", task.id);
             continue;
@@ -42358,7 +42576,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           continue;
         }
         const messagesResult = await this.client.session.messages({
-          path: { id: task.sessionID }
+          path: { id: sessionID }
         });
         if (!messagesResult.error && messagesResult.data) {
           const messages = messagesResult.data;
@@ -42389,19 +42607,33 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
             task.progress.lastMessageAt = new Date;
           }
           const currentMsgCount = messages.length;
-          const elapsedMs = Date.now() - task.startedAt.getTime();
+          const startedAt = task.startedAt;
+          if (!startedAt)
+            continue;
+          const elapsedMs = Date.now() - startedAt.getTime();
           if (elapsedMs >= MIN_STABILITY_TIME_MS) {
             if (task.lastMsgCount === currentMsgCount) {
               task.stablePolls = (task.stablePolls ?? 0) + 1;
               if (task.stablePolls >= 3) {
-                const hasValidOutput = await this.validateSessionHasOutput(task.sessionID);
+                const recheckStatus = await this.client.session.status();
+                const recheckData = recheckStatus.data ?? {};
+                const currentStatus = recheckData[sessionID];
+                if (currentStatus?.type !== "idle") {
+                  log("[background-agent] Stability reached but session not idle, resetting:", {
+                    taskId: task.id,
+                    sessionStatus: currentStatus?.type ?? "not_in_status"
+                  });
+                  task.stablePolls = 0;
+                  continue;
+                }
+                const hasValidOutput = await this.validateSessionHasOutput(sessionID);
                 if (!hasValidOutput) {
                   log("[background-agent] Stability reached but no valid output, waiting:", task.id);
                   continue;
                 }
                 if (task.status !== "running")
                   continue;
-                const hasIncompleteTodos2 = await this.checkSessionTodos(task.sessionID);
+                const hasIncompleteTodos2 = await this.checkSessionTodos(sessionID);
                 if (!hasIncompleteTodos2) {
                   await this.tryCompleteTask(task, "stability detection");
                   continue;
@@ -42437,6 +42669,8 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     this.tasks.clear();
     this.notifications.clear();
     this.pendingByParent.clear();
+    this.queuesByKey.clear();
+    this.processingKeys.clear();
     this.unregisterProcessCleanup();
     log("[background-agent] Shutdown complete");
   }