feat: dual-publish platform binaries for oh-my-openagent

After publishing oh-my-opencode-{platform}, rename package.json and
publish oh-my-openagent-{platform} from the same build artifact.
Download/extract steps now run if either package needs publishing.

.github/workflows/publish-platform.yml

@@ -193,10 +193,9 @@ jobs:
           if-no-files-found: error
 
   # =============================================================================
-  # Job 2: Publish all platforms using OIDC/Provenance
+  # Job 2: Publish all platforms (oh-my-opencode + oh-my-openagent)
   # - Runs on ubuntu-latest for ALL platforms (just downloading artifacts)
-  # - Uses npm Trusted Publishing (OIDC) - no NODE_AUTH_TOKEN needed
-  # - Fresh OIDC token at publish time avoids timeout issues
+  # - Uses NODE_AUTH_TOKEN for auth + OIDC for provenance attestation
   # =============================================================================
   publish:
     needs: build
@@ -208,7 +207,7 @@ jobs:
       matrix:
         platform: [darwin-arm64, darwin-x64, darwin-x64-baseline, linux-x64, linux-x64-baseline, linux-arm64, linux-x64-musl, linux-x64-musl-baseline, linux-arm64-musl, windows-x64, windows-x64-baseline]
     steps:
-      - name: Check if already published
+      - name: Check if oh-my-opencode already published
         id: check
         run: |
           PKG_NAME="oh-my-opencode-${{ matrix.platform }}"
@@ -222,9 +221,23 @@ jobs:
             echo "→ ${PKG_NAME}@${VERSION} will be published"
           fi
 
+      - name: Check if oh-my-openagent already published
+        id: check-openagent
+        run: |
+          PKG_NAME="oh-my-openagent-${{ matrix.platform }}"
+          VERSION="${{ inputs.version }}"
+          STATUS=$(curl -s -o /dev/null -w "%{http_code}" "https://registry.npmjs.org/${PKG_NAME}/${VERSION}")
+          if [ "$STATUS" = "200" ]; then
+            echo "skip=true" >> $GITHUB_OUTPUT
+            echo "✓ ${PKG_NAME}@${VERSION} already published, skipping"
+          else
+            echo "skip=false" >> $GITHUB_OUTPUT
+            echo "→ ${PKG_NAME}@${VERSION} will be published"
+          fi
+
       - name: Download artifact
         id: download
-        if: steps.check.outputs.skip != 'true'
+        if: steps.check.outputs.skip != 'true' || steps.check-openagent.outputs.skip != 'true'
         continue-on-error: true
         uses: actions/download-artifact@v4
         with:
@@ -232,7 +245,7 @@ jobs:
           path: .
 
       - name: Extract artifact
-        if: steps.check.outputs.skip != 'true' && steps.download.outcome == 'success'
+        if: (steps.check.outputs.skip != 'true' || steps.check-openagent.outputs.skip != 'true') && steps.download.outcome == 'success'
         run: |
           PLATFORM="${{ matrix.platform }}"
           mkdir -p packages/${PLATFORM}
@@ -248,7 +261,7 @@ jobs:
           ls -la packages/${PLATFORM}/bin/
 
       - uses: actions/setup-node@v4
-        if: steps.check.outputs.skip != 'true' && steps.download.outcome == 'success'
+        if: (steps.check.outputs.skip != 'true' || steps.check-openagent.outputs.skip != 'true') && steps.download.outcome == 'success'
         with:
           node-version: "24"
           registry-url: "https://registry.npmjs.org"
@@ -268,3 +281,25 @@ jobs:
           NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}
           NPM_CONFIG_PROVENANCE: true
         timeout-minutes: 15
+
+      - name: Publish oh-my-openagent-${{ matrix.platform }}
+        if: steps.check-openagent.outputs.skip != 'true' && steps.download.outcome == 'success'
+        run: |
+          cd packages/${{ matrix.platform }}
+          
+          # Rename package for oh-my-openagent
+          jq --arg name "oh-my-openagent-${{ matrix.platform }}" \
+             --arg desc "Platform-specific binary for oh-my-openagent (${{ matrix.platform }})" \
+             '.name = $name | .description = $desc | .bin = {"oh-my-openagent": (.bin | to_entries | .[0].value)}' \
+             package.json > tmp.json && mv tmp.json package.json
+          
+          TAG_ARG=""
+          if [ -n "${{ inputs.dist_tag }}" ]; then
+            TAG_ARG="--tag ${{ inputs.dist_tag }}"
+          fi
+          
+          npm publish --access public --provenance $TAG_ARG
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+        timeout-minutes: 15

.github/workflows/publish.yml

@@ -121,7 +121,7 @@ jobs:
   publish-main:
     runs-on: ubuntu-latest
     needs: [test, typecheck]
-    if: github.repository == 'code-yeongyu/oh-my-opencode'
+    if: github.repository == 'code-yeongyu/oh-my-openagent'
     outputs:
       version: ${{ steps.version.outputs.version }}
       dist_tag: ${{ steps.version.outputs.dist_tag }}
@@ -204,7 +204,7 @@ jobs:
           bunx tsc --emitDeclarationOnly
           bun run build:schema
 
-      - name: Publish main package
+      - name: Publish oh-my-opencode
         if: steps.check.outputs.skip != 'true'
         run: |
           TAG_ARG=""
@@ -213,20 +213,42 @@ jobs:
           fi
           npm publish --access public --provenance $TAG_ARG
         env:
+          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}
           NPM_CONFIG_PROVENANCE: true
-
-      - name: Git commit and tag
+      - name: Publish oh-my-openagent
         if: steps.check.outputs.skip != 'true'
         run: |
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git config user.name "github-actions[bot]"
-          git add package.json assets/oh-my-opencode.schema.json packages/*/package.json || true
-          git diff --cached --quiet || git commit -m "release: v${{ steps.version.outputs.version }}"
-          git tag -f "v${{ steps.version.outputs.version }}"
-          git push origin --tags --force
-          git push origin HEAD || echo "Branch push failed (non-critical)"
+          # Update package name to oh-my-openagent
+          jq '.name = "oh-my-openagent"' package.json > tmp.json && mv tmp.json package.json
+          
+          # Update optionalDependencies to use oh-my-openagent naming
+          jq '.optionalDependencies = {
+            "oh-my-openagent-darwin-arm64": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-darwin-x64": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-darwin-x64-baseline": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-linux-arm64": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-linux-arm64-musl": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-linux-x64": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-linux-x64-baseline": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-linux-x64-musl": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-linux-x64-musl-baseline": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-windows-x64": "${{ steps.version.outputs.version }}",
+            "oh-my-openagent-windows-x64-baseline": "${{ steps.version.outputs.version }}"
+          }' package.json > tmp.json && mv tmp.json package.json
+          
+          TAG_ARG=""
+          if [ -n "${{ steps.version.outputs.dist_tag }}" ]; then
+            TAG_ARG="--tag ${{ steps.version.outputs.dist_tag }}"
+          fi
+          npm publish --access public --provenance $TAG_ARG || echo "oh-my-openagent publish may have failed (package may already exist)"
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NODE_AUTH_TOKEN: ${{ secrets.NODE_AUTH_TOKEN }}
+          NPM_CONFIG_PROVENANCE: true
+      - name: Restore package.json
+        if: steps.check.outputs.skip != 'true'
+        run: |
+          # Restore original package name
+          jq '.name = "oh-my-opencode"' package.json > tmp.json && mv tmp.json package.json
 
   trigger-platform:
     runs-on: ubuntu-latest

package.json

@@ -45,12 +45,12 @@
   "license": "SUL-1.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/code-yeongyu/oh-my-opencode.git"
+    "url": "git+https://github.com/code-yeongyu/oh-my-openagent.git"
   },
   "bugs": {
-    "url": "https://github.com/code-yeongyu/oh-my-opencode/issues"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent/issues"
   },
-  "homepage": "https://github.com/code-yeongyu/oh-my-opencode#readme",
+  "homepage": "https://github.com/code-yeongyu/oh-my-openagent#readme",
   "dependencies": {
     "@ast-grep/cli": "^0.40.0",
     "@ast-grep/napi": "^0.40.0",

packages/darwin-arm64/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "darwin"

packages/darwin-x64-baseline/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "darwin"

packages/darwin-x64/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "darwin"

packages/linux-arm64-musl/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "linux"

packages/linux-arm64/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "linux"

packages/linux-x64-baseline/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "linux"

packages/linux-x64-musl-baseline/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "linux"

packages/linux-x64-musl/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "linux"

packages/linux-x64/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "linux"

packages/windows-x64-baseline/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "win32"

packages/windows-x64/package.json

@@ -5,7 +5,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/code-yeongyu/oh-my-opencode"
+    "url": "https://github.com/code-yeongyu/oh-my-openagent"
   },
   "os": [
     "win32"

signatures/cla.json

@@ -2015,6 +2015,22 @@
       "created_at": "2026-03-07T13:53:56Z",
       "repoId": 1108837393,
       "pullRequestNo": 2360
+    },
+    {
+      "name": "crazyrabbit0",
+      "id": 5244848,
+      "comment_id": 3936744393,
+      "created_at": "2026-02-20T19:40:05Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 2012
+    },
+    {
+      "name": "vaur94",
+      "id": 100377859,
+      "comment_id": 4019104338,
+      "created_at": "2026-03-08T14:01:19Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 2385
     }
   ]
 }

src/features/background-agent/manager.polling.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from "bun:test"
 import { tmpdir } from "node:os"
 import type { PluginInput } from "@opencode-ai/plugin"
 import { BackgroundManager } from "./manager"
+import type { BackgroundTask } from "./types"
 
 function createManagerWithStatus(statusImpl: () => Promise<{ data: Record<string, { type: string }> }>): BackgroundManager {
   const client = {
@@ -51,3 +52,105 @@ describe("BackgroundManager polling overlap", () => {
     expect(statusCallCount).toBe(1)
   })
 })
+
+
+function createRunningTask(sessionID: string): BackgroundTask {
+  return {
+    id: `bg_test_${sessionID}`,
+    sessionID,
+    parentSessionID: "parent-session",
+    parentMessageID: "parent-msg",
+    description: "test task",
+    prompt: "test",
+    agent: "explore",
+    status: "running",
+    startedAt: new Date(),
+    progress: { toolCalls: 0, lastUpdate: new Date() },
+  }
+}
+
+function injectTask(manager: BackgroundManager, task: BackgroundTask): void {
+  const tasks = (manager as unknown as { tasks: Map<string, BackgroundTask> }).tasks
+  tasks.set(task.id, task)
+}
+
+function createManagerWithClient(clientOverrides: Record<string, unknown> = {}): BackgroundManager {
+  const client = {
+    session: {
+      status: async () => ({ data: {} }),
+      prompt: async () => ({}),
+      promptAsync: async () => ({}),
+      abort: async () => ({}),
+      todo: async () => ({ data: [] }),
+      messages: async () => ({
+        data: [{
+          info: { role: "assistant", finish: "end_turn", id: "msg-2" },
+          parts: [{ type: "text", text: "done" }],
+        }, {
+          info: { role: "user", id: "msg-1" },
+          parts: [{ type: "text", text: "go" }],
+        }],
+      }),
+      ...clientOverrides,
+    },
+  }
+  return new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
+}
+
+describe("BackgroundManager pollRunningTasks", () => {
+  describe("#given a running task whose session is no longer in status response", () => {
+    test("#when pollRunningTasks runs #then completes the task instead of leaving it running", async () => {
+      //#given
+      const manager = createManagerWithClient()
+      const task = createRunningTask("ses-gone")
+      injectTask(manager, task)
+
+      //#when
+      const poll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks
+      await poll.call(manager)
+      manager.shutdown()
+
+      //#then
+      expect(task.status).toBe("completed")
+      expect(task.completedAt).toBeDefined()
+    })
+  })
+
+  describe("#given a running task whose session status is idle", () => {
+    test("#when pollRunningTasks runs #then completes the task", async () => {
+      //#given
+      const manager = createManagerWithClient({
+        status: async () => ({ data: { "ses-idle": { type: "idle" } } }),
+      })
+      const task = createRunningTask("ses-idle")
+      injectTask(manager, task)
+
+      //#when
+      const poll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks
+      await poll.call(manager)
+      manager.shutdown()
+
+      //#then
+      expect(task.status).toBe("completed")
+    })
+  })
+
+  describe("#given a running task whose session status is busy", () => {
+    test("#when pollRunningTasks runs #then keeps the task running", async () => {
+      //#given
+      const manager = createManagerWithClient({
+        status: async () => ({ data: { "ses-busy": { type: "busy" } } }),
+      })
+      const task = createRunningTask("ses-busy")
+      injectTask(manager, task)
+
+      //#when
+      const poll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks
+      await poll.call(manager)
+      manager.shutdown()
+
+      //#then
+      expect(task.status).toBe("running")
+    })
+  })
+})

src/features/background-agent/manager.test.ts

@@ -224,12 +224,6 @@ function stubNotifyParentSession(manager: BackgroundManager): void {
   ;(manager as unknown as { notifyParentSession: () => Promise<void> }).notifyParentSession = async () => {}
 }
 
-async function flushBackgroundNotifications(): Promise<void> {
-  for (let i = 0; i < 6; i++) {
-    await Promise.resolve()
-  }
-}
-
 function createToastRemoveTaskTracker(): { removeTaskCalls: string[]; resetToastManager: () => void } {
   _resetTaskToastManagerForTesting()
   const toastManager = initTaskToastManager({
@@ -1312,20 +1306,11 @@ describe("BackgroundManager.tryCompleteTask", () => {
     expect(abortedSessionIDs).toEqual(["session-1"])
   })
 
-  test("should clean pendingByParent even when promptAsync notification fails", async () => {
+  test("should clean pendingByParent even when notifyParentSession throws", async () => {
     // given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => {
-          throw new Error("notify failed")
-        },
-        abort: async () => ({}),
-        messages: async () => ({ data: [] }),
-      },
+    ;(manager as unknown as { notifyParentSession: () => Promise<void> }).notifyParentSession = async () => {
+      throw new Error("notify failed")
     }
-    manager.shutdown()
-    manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
 
     const task: BackgroundTask = {
       id: "task-pending-cleanup",
@@ -1439,7 +1424,7 @@ describe("BackgroundManager.tryCompleteTask", () => {
     // then
     expect(rejectedCount).toBe(0)
     expect(promptBodies.length).toBe(2)
-    expect(promptBodies.filter((body) => body.noReply === false)).toHaveLength(1)
+    expect(promptBodies.some((b) => b.noReply === false)).toBe(true)
   })
 })
 
@@ -1947,6 +1932,7 @@ describe("BackgroundManager - Non-blocking Queue Integration", () => {
     test("should cancel running task and release concurrency", async () => {
       // given
       const manager = createBackgroundManager()
+      stubNotifyParentSession(manager)
 
       const concurrencyManager = getConcurrencyManager(manager)
       const concurrencyKey = "test-provider/test-model"
@@ -2904,7 +2890,7 @@ describe("BackgroundManager.shutdown session abort", () => {
 })
 
 describe("BackgroundManager.handleEvent - session.deleted cascade", () => {
-  test("should cancel descendant tasks and keep them until delayed cleanup", async () => {
+  test("should cancel descendant tasks when parent session is deleted", () => {
     // given
     const manager = createBackgroundManager()
     const parentSessionID = "session-parent"
@@ -2951,26 +2937,21 @@ describe("BackgroundManager.handleEvent - session.deleted cascade", () => {
       properties: { info: { id: parentSessionID } },
     })
 
-    await flushBackgroundNotifications()
-
     // then
-    expect(taskMap.has(childTask.id)).toBe(true)
-    expect(taskMap.has(siblingTask.id)).toBe(true)
-    expect(taskMap.has(grandchildTask.id)).toBe(true)
+    expect(taskMap.has(childTask.id)).toBe(false)
+    expect(taskMap.has(siblingTask.id)).toBe(false)
+    expect(taskMap.has(grandchildTask.id)).toBe(false)
     expect(taskMap.has(unrelatedTask.id)).toBe(true)
     expect(childTask.status).toBe("cancelled")
     expect(siblingTask.status).toBe("cancelled")
     expect(grandchildTask.status).toBe("cancelled")
     expect(pendingByParent.get(parentSessionID)).toBeUndefined()
     expect(pendingByParent.get("session-child")).toBeUndefined()
-    expect(getCompletionTimers(manager).has(childTask.id)).toBe(true)
-    expect(getCompletionTimers(manager).has(siblingTask.id)).toBe(true)
-    expect(getCompletionTimers(manager).has(grandchildTask.id)).toBe(true)
 
     manager.shutdown()
   })
 
-  test("should remove cancelled tasks from toast manager while preserving delayed cleanup", async () => {
+  test("should remove tasks from toast manager when session is deleted", () => {
     //#given
     const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
     const manager = createBackgroundManager()
@@ -2999,13 +2980,9 @@ describe("BackgroundManager.handleEvent - session.deleted cascade", () => {
       properties: { info: { id: parentSessionID } },
     })
 
-    await flushBackgroundNotifications()
-
     //#then
     expect(removeTaskCalls).toContain(childTask.id)
     expect(removeTaskCalls).toContain(grandchildTask.id)
-    expect(getCompletionTimers(manager).has(childTask.id)).toBe(true)
-    expect(getCompletionTimers(manager).has(grandchildTask.id)).toBe(true)
 
     manager.shutdown()
     resetToastManager()
@@ -3068,7 +3045,7 @@ describe("BackgroundManager.handleEvent - session.error", () => {
     return task
   }
 
-  test("sets task to error, releases concurrency, and keeps it until delayed cleanup", async () => {
+  test("sets task to error, releases concurrency, and cleans up", async () => {
     //#given
     const manager = createBackgroundManager()
     const concurrencyManager = getConcurrencyManager(manager)
@@ -3101,21 +3078,18 @@ describe("BackgroundManager.handleEvent - session.error", () => {
       },
     })
 
-    await flushBackgroundNotifications()
-
     //#then
     expect(task.status).toBe("error")
     expect(task.error).toBe("Model not found: kimi-for-coding/k2p5.")
     expect(task.completedAt).toBeInstanceOf(Date)
     expect(concurrencyManager.getCount(concurrencyKey)).toBe(0)
-    expect(getTaskMap(manager).has(task.id)).toBe(true)
+    expect(getTaskMap(manager).has(task.id)).toBe(false)
     expect(getPendingByParent(manager).get(task.parentSessionID)).toBeUndefined()
-    expect(getCompletionTimers(manager).has(task.id)).toBe(true)
 
     manager.shutdown()
   })
 
-  test("should remove errored task from toast manager while preserving delayed cleanup", async () => {
+  test("removes errored task from toast manager", () => {
     //#given
     const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
     const manager = createBackgroundManager()
@@ -3137,11 +3111,8 @@ describe("BackgroundManager.handleEvent - session.error", () => {
       },
     })
 
-    await flushBackgroundNotifications()
-
     //#then
     expect(removeTaskCalls).toContain(task.id)
-    expect(getCompletionTimers(manager).has(task.id)).toBe(true)
 
     manager.shutdown()
     resetToastManager()
@@ -3422,7 +3393,7 @@ describe("BackgroundManager.pruneStaleTasksAndNotifications - removes pruned tas
     manager.shutdown()
   })
 
-  test("removes stale task from toast manager", async () => {
+  test("removes stale task from toast manager", () => {
     //#given
     const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
     const manager = createBackgroundManager()
@@ -3437,7 +3408,6 @@ describe("BackgroundManager.pruneStaleTasksAndNotifications - removes pruned tas
 
     //#when
     pruneStaleTasksAndNotificationsForTest(manager)
-    await flushBackgroundNotifications()
 
     //#then
     expect(removeTaskCalls).toContain(staleTask.id)
@@ -3445,53 +3415,6 @@ describe("BackgroundManager.pruneStaleTasksAndNotifications - removes pruned tas
     manager.shutdown()
     resetToastManager()
   })
-
-  test("keeps stale task until notification cleanup after notifying parent", async () => {
-    //#given
-    const notifications: string[] = []
-    const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async (args: { path: { id: string }; body: Record<string, unknown> & { noReply?: boolean; parts?: unknown[] } }) => {
-          const firstPart = args.body.parts?.[0]
-          if (firstPart && typeof firstPart === "object" && "text" in firstPart && typeof firstPart.text === "string") {
-            notifications.push(firstPart.text)
-          }
-          return {}
-        },
-        abort: async () => ({}),
-        messages: async () => ({ data: [] }),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
-    const staleTask = createMockTask({
-      id: "task-stale-notify-cleanup",
-      sessionID: "session-stale-notify-cleanup",
-      parentSessionID: "parent-stale-notify-cleanup",
-      status: "running",
-      startedAt: new Date(Date.now() - 31 * 60 * 1000),
-    })
-    getTaskMap(manager).set(staleTask.id, staleTask)
-    getPendingByParent(manager).set(staleTask.parentSessionID, new Set([staleTask.id]))
-
-    //#when
-    pruneStaleTasksAndNotificationsForTest(manager)
-    await flushBackgroundNotifications()
-
-    //#then
-    const retainedTask = getTaskMap(manager).get(staleTask.id)
-    expect(retainedTask?.status).toBe("error")
-    expect(getTaskMap(manager).has(staleTask.id)).toBe(true)
-    expect(notifications).toHaveLength(1)
-    expect(notifications[0]).toContain("[ALL BACKGROUND TASKS COMPLETE]")
-    expect(notifications[0]).toContain(staleTask.description)
-    expect(getCompletionTimers(manager).has(staleTask.id)).toBe(true)
-    expect(removeTaskCalls).toContain(staleTask.id)
-
-    manager.shutdown()
-    resetToastManager()
-  })
 })
 
 describe("BackgroundManager.completionTimers - Memory Leak Fix", () => {
@@ -3595,7 +3518,7 @@ describe("BackgroundManager.completionTimers - Memory Leak Fix", () => {
     expect(completionTimers.size).toBe(0)
   })
 
-  test("should preserve cleanup timer when terminal task session is deleted", () => {
+  test("should cancel timer when task is deleted via session.deleted", () => {
     // given
     const manager = createBackgroundManager()
     const task: BackgroundTask = {
@@ -3624,7 +3547,7 @@ describe("BackgroundManager.completionTimers - Memory Leak Fix", () => {
     })
 
     // then
-    expect(completionTimers.has(task.id)).toBe(true)
+    expect(completionTimers.has(task.id)).toBe(false)
 
     manager.shutdown()
   })

src/features/background-agent/manager.ts

@@ -390,6 +390,7 @@ export class BackgroundManager {
         }).catch(() => {})
 
         this.markForNotification(existingTask)
+        this.cleanupPendingByParent(existingTask)
         this.enqueueNotificationForParent(existingTask.parentSessionID, () => this.notifyParentSession(existingTask)).catch(err => {
           log("[background-agent] Failed to notify on error:", err)
         })
@@ -660,6 +661,7 @@ export class BackgroundManager {
       }
 
       this.markForNotification(existingTask)
+      this.cleanupPendingByParent(existingTask)
       this.enqueueNotificationForParent(existingTask.parentSessionID, () => this.notifyParentSession(existingTask)).catch(err => {
         log("[background-agent] Failed to notify on resume error:", err)
       })
@@ -802,14 +804,16 @@ export class BackgroundManager {
         this.idleDeferralTimers.delete(task.id)
       }
 
-      if (task.sessionID) {
-        SessionCategoryRegistry.remove(task.sessionID)
+      this.cleanupPendingByParent(task)
+      this.tasks.delete(task.id)
+      this.clearNotificationsForTask(task.id)
+      const toastManager = getTaskToastManager()
+      if (toastManager) {
+        toastManager.removeTask(task.id)
+      }
+      if (task.sessionID) {
+        subagentSessions.delete(task.sessionID)
       }
-
-      this.markForNotification(task)
-      this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task)).catch(err => {
-        log("[background-agent] Error in notifyParentSession for errored task:", { taskId: task.id, error: err })
-      })
     }
 
     if (event.type === "session.deleted") {
@@ -830,30 +834,47 @@ export class BackgroundManager {
 
       if (tasksToCancel.size === 0) return
 
-      const deletedSessionIDs = new Set<string>([sessionID])
-      for (const task of tasksToCancel.values()) {
-        if (task.sessionID) {
-          deletedSessionIDs.add(task.sessionID)
-        }
-      }
-
       for (const task of tasksToCancel.values()) {
         if (task.status === "running" || task.status === "pending") {
           void this.cancelTask(task.id, {
             source: "session.deleted",
             reason: "Session deleted",
-          }).then(() => {
-            if (deletedSessionIDs.has(task.parentSessionID)) {
-              this.pendingNotifications.delete(task.parentSessionID)
-            }
+            skipNotification: true,
           }).catch(err => {
-            if (deletedSessionIDs.has(task.parentSessionID)) {
-              this.pendingNotifications.delete(task.parentSessionID)
-            }
             log("[background-agent] Failed to cancel task on session.deleted:", { taskId: task.id, error: err })
           })
         }
+
+        const existingTimer = this.completionTimers.get(task.id)
+        if (existingTimer) {
+          clearTimeout(existingTimer)
+          this.completionTimers.delete(task.id)
+        }
+
+        const idleTimer = this.idleDeferralTimers.get(task.id)
+        if (idleTimer) {
+          clearTimeout(idleTimer)
+          this.idleDeferralTimers.delete(task.id)
+        }
+
+        this.cleanupPendingByParent(task)
+        this.tasks.delete(task.id)
+        this.clearNotificationsForTask(task.id)
+        const toastManager = getTaskToastManager()
+        if (toastManager) {
+          toastManager.removeTask(task.id)
+        }
+        if (task.sessionID) {
+          subagentSessions.delete(task.sessionID)
+        }
       }
+
+      for (const task of tasksToCancel.values()) {
+        if (task.parentSessionID) {
+          this.pendingNotifications.delete(task.parentSessionID)
+        }
+      }
+
       SessionCategoryRegistry.remove(sessionID)
     }
 
@@ -1073,6 +1094,8 @@ export class BackgroundManager {
       this.idleDeferralTimers.delete(task.id)
     }
 
+    this.cleanupPendingByParent(task)
+
     if (abortSession && task.sessionID) {
       this.client.session.abort({
         path: { id: task.sessionID },
@@ -1179,6 +1202,9 @@ export class BackgroundManager {
 
     this.markForNotification(task)
 
+    // Ensure pending tracking is cleaned up even if notification fails
+    this.cleanupPendingByParent(task)
+
     const idleTimer = this.idleDeferralTimers.get(task.id)
     if (idleTimer) {
       clearTimeout(idleTimer)
@@ -1234,10 +1260,7 @@ export class BackgroundManager {
         this.pendingByParent.delete(task.parentSessionID)
       }
     } else {
-      remainingCount = Array.from(this.tasks.values())
-        .filter(t => t.parentSessionID === task.parentSessionID && t.id !== task.id && (t.status === "running" || t.status === "pending"))
-        .length
-      allComplete = remainingCount === 0
+      allComplete = true
     }
 
     const completedTasks = allComplete
@@ -1245,13 +1268,7 @@ export class BackgroundManager {
         .filter(t => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending")
       : []
 
-    const statusText = task.status === "completed"
-      ? "COMPLETED"
-      : task.status === "interrupt"
-        ? "INTERRUPTED"
-        : task.status === "error"
-          ? "ERROR"
-          : "CANCELLED"
+    const statusText = task.status === "completed" ? "COMPLETED" : task.status === "interrupt" ? "INTERRUPTED" : "CANCELLED"
     const errorInfo = task.error ? `\n**Error:** ${task.error}` : ""
 
     let notification: string
@@ -1382,13 +1399,8 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         }
         const timer = setTimeout(() => {
           this.completionTimers.delete(taskId)
-          const taskToRemove = this.tasks.get(taskId)
-          if (taskToRemove) {
+          if (this.tasks.has(taskId)) {
             this.clearNotificationsForTask(taskId)
-            if (taskToRemove.sessionID) {
-              subagentSessions.delete(taskToRemove.sessionID)
-              SessionCategoryRegistry.remove(taskToRemove.sessionID)
-            }
             this.tasks.delete(taskId)
             log("[background-agent] Removed completed task from memory:", taskId)
           }
@@ -1423,21 +1435,11 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         task.status = "error"
         task.error = errorMessage
         task.completedAt = new Date()
-        this.taskHistory.record(task.parentSessionID, { id: task.id, sessionID: task.sessionID, agent: task.agent, description: task.description, status: "error", category: task.category, startedAt: task.startedAt, completedAt: task.completedAt })
         if (task.concurrencyKey) {
           this.concurrencyManager.release(task.concurrencyKey)
           task.concurrencyKey = undefined
         }
-        const existingTimer = this.completionTimers.get(taskId)
-        if (existingTimer) {
-          clearTimeout(existingTimer)
-          this.completionTimers.delete(taskId)
-        }
-        const idleTimer = this.idleDeferralTimers.get(taskId)
-        if (idleTimer) {
-          clearTimeout(idleTimer)
-          this.idleDeferralTimers.delete(taskId)
-        }
+        this.cleanupPendingByParent(task)
         if (wasPending) {
           const key = task.model
             ? `${task.model.providerID}/${task.model.modelID}`
@@ -1453,10 +1455,16 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
             }
           }
         }
-        this.markForNotification(task)
-        this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task)).catch(err => {
-          log("[background-agent] Error in notifyParentSession for stale-pruned task:", { taskId: task.id, error: err })
-        })
+        this.clearNotificationsForTask(taskId)
+        const toastManager = getTaskToastManager()
+        if (toastManager) {
+          toastManager.removeTask(taskId)
+        }
+        this.tasks.delete(taskId)
+        if (task.sessionID) {
+          subagentSessions.delete(task.sessionID)
+          SessionCategoryRegistry.remove(task.sessionID)
+        }
       },
     })
   }
@@ -1493,32 +1501,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 
       try {
         const sessionStatus = allStatuses[sessionID]
-        
-        if (sessionStatus?.type === "idle") {
-          // Edge guard: Validate session has actual output before completing
-          const hasValidOutput = await this.validateSessionHasOutput(sessionID)
-          if (!hasValidOutput) {
-            log("[background-agent] Polling idle but no valid output yet, waiting:", task.id)
-            continue
-          }
-
-          // Re-check status after async operation
-          if (task.status !== "running") continue
-
-          const hasIncompleteTodos = await this.checkSessionTodos(sessionID)
-          if (hasIncompleteTodos) {
-            log("[background-agent] Task has incomplete todos via polling, waiting:", task.id)
-            continue
-          }
-
-          await this.tryCompleteTask(task, "polling (idle status)")
-          continue
-        }
-
-        // Session is still actively running (not idle).
-        // Progress is already tracked via handleEvent(message.part.updated),
-        // so we skip the expensive session.messages() fetch here.
-        // Completion will be detected when session transitions to idle.
+        // Handle retry before checking running state
         if (sessionStatus?.type === "retry") {
           const retryMessage = typeof (sessionStatus as { message?: string }).message === "string"
             ? (sessionStatus as { message?: string }).message
@@ -1529,12 +1512,40 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           }
         }
 
-        log("[background-agent] Session still running, relying on event-based progress:", {
-          taskId: task.id,
-          sessionID,
-          sessionStatus: sessionStatus?.type ?? "not_in_status",
-          toolCalls: task.progress?.toolCalls ?? 0,
-        })
+        // Match sync-session-poller pattern: only skip completion check when
+        // status EXISTS and is not idle (i.e., session is actively running).
+        // When sessionStatus is undefined, the session has completed and dropped
+        // from the status response — fall through to completion detection.
+        if (sessionStatus && sessionStatus.type !== "idle") {
+          log("[background-agent] Session still running, relying on event-based progress:", {
+            taskId: task.id,
+            sessionID,
+            sessionStatus: sessionStatus.type,
+            toolCalls: task.progress?.toolCalls ?? 0,
+          })
+          continue
+        }
+
+        // Session is idle or no longer in status response (completed/disappeared)
+        const completionSource = sessionStatus?.type === "idle"
+          ? "polling (idle status)"
+          : "polling (session gone from status)"
+        const hasValidOutput = await this.validateSessionHasOutput(sessionID)
+        if (!hasValidOutput) {
+          log("[background-agent] Polling idle/gone but no valid output yet, waiting:", task.id)
+          continue
+        }
+
+        // Re-check status after async operation
+        if (task.status !== "running") continue
+
+        const hasIncompleteTodos = await this.checkSessionTodos(sessionID)
+        if (hasIncompleteTodos) {
+          log("[background-agent] Task has incomplete todos via polling, waiting:", task.id)
+          continue
+        }
+
+        await this.tryCompleteTask(task, completionSource)
       } catch (error) {
         log("[background-agent] Poll error for task:", { taskId: task.id, error })
       }

src/features/background-agent/task-poller.test.ts

@@ -422,38 +422,4 @@ describe("pruneStaleTasksAndNotifications", () => {
     //#then
     expect(pruned).toContain("old-task")
   })
-
-  it("should skip terminal tasks even when they exceeded TTL", () => {
-    //#given
-    const tasks = new Map<string, BackgroundTask>()
-    const oldStartedAt = new Date(Date.now() - 31 * 60 * 1000)
-    const terminalStatuses: BackgroundTask["status"][] = ["completed", "error", "cancelled", "interrupt"]
-
-    for (const status of terminalStatuses) {
-      tasks.set(status, {
-        id: status,
-        parentSessionID: "parent",
-        parentMessageID: "msg",
-        description: status,
-        prompt: status,
-        agent: "explore",
-        status,
-        startedAt: oldStartedAt,
-        completedAt: new Date(),
-      })
-    }
-
-    const pruned: string[] = []
-
-    //#when
-    pruneStaleTasksAndNotifications({
-      tasks,
-      notifications: new Map<string, BackgroundTask[]>(),
-      onTaskPruned: (taskId) => pruned.push(taskId),
-    })
-
-    //#then
-    expect(pruned).toEqual([])
-    expect(Array.from(tasks.keys())).toEqual(terminalStatuses)
-  })
 })

src/features/background-agent/task-poller.ts

@@ -12,13 +12,6 @@ import {
   TASK_TTL_MS,
 } from "./constants"
 
-const TERMINAL_TASK_STATUSES = new Set<BackgroundTask["status"]>([
-  "completed",
-  "error",
-  "cancelled",
-  "interrupt",
-])
-
 export function pruneStaleTasksAndNotifications(args: {
   tasks: Map<string, BackgroundTask>
   notifications: Map<string, BackgroundTask[]>
@@ -28,8 +21,6 @@ export function pruneStaleTasksAndNotifications(args: {
   const now = Date.now()
 
   for (const [taskId, task] of tasks.entries()) {
-    if (TERMINAL_TASK_STATUSES.has(task.status)) continue
-
     const timestamp = task.status === "pending"
       ? task.queuedAt?.getTime()
       : task.startedAt?.getTime()

src/hooks/auto-update-checker/cache.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs"
 import * as path from "node:path"
-import { PACKAGE_NAME, USER_CONFIG_DIR } from "./constants"
+import { CACHE_DIR, PACKAGE_NAME, USER_CONFIG_DIR } from "./constants"
 import { log } from "../../shared/logger"
 
 interface BunLockfile {
@@ -48,17 +48,22 @@ function removeFromBunLock(packageName: string): boolean {
 
 export function invalidatePackage(packageName: string = PACKAGE_NAME): boolean {
   try {
-    const pkgDir = path.join(USER_CONFIG_DIR, "node_modules", packageName)
+    const pkgDirs = [
+      path.join(USER_CONFIG_DIR, "node_modules", packageName),
+      path.join(CACHE_DIR, "node_modules", packageName),
+    ]
     const pkgJsonPath = path.join(USER_CONFIG_DIR, "package.json")
 
     let packageRemoved = false
     let dependencyRemoved = false
     let lockRemoved = false
 
-    if (fs.existsSync(pkgDir)) {
-      fs.rmSync(pkgDir, { recursive: true, force: true })
-      log(`[auto-update-checker] Package removed: ${pkgDir}`)
-      packageRemoved = true
+    for (const pkgDir of pkgDirs) {
+      if (fs.existsSync(pkgDir)) {
+        fs.rmSync(pkgDir, { recursive: true, force: true })
+        log(`[auto-update-checker] Package removed: ${pkgDir}`)
+        packageRemoved = true
+      }
     }
 
     if (fs.existsSync(pkgJsonPath)) {

src/hooks/session-notification-scheduler.ts

@@ -9,6 +9,8 @@ type SessionNotificationConfig = {
   idleConfirmationDelay: number
   skipIfIncompleteTodos: boolean
   maxTrackedSessions: number
+  /** Grace period in ms to ignore late-arriving activity events after scheduling (default: 100) */
+  activityGracePeriodMs?: number
 }
 
 export function createIdleNotificationScheduler(options: {
@@ -24,6 +26,9 @@ export function createIdleNotificationScheduler(options: {
   const sessionActivitySinceIdle = new Set<string>()
   const notificationVersions = new Map<string, number>()
   const executingNotifications = new Set<string>()
+  const scheduledAt = new Map<string, number>()
+
+  const activityGracePeriodMs = options.config.activityGracePeriodMs ?? 100
 
   function cleanupOldSessions(): void {
     const maxSessions = options.config.maxTrackedSessions
@@ -43,6 +48,10 @@ export function createIdleNotificationScheduler(options: {
       const sessionsToRemove = Array.from(executingNotifications).slice(0, executingNotifications.size - maxSessions)
       sessionsToRemove.forEach((id) => executingNotifications.delete(id))
     }
+    if (scheduledAt.size > maxSessions) {
+      const sessionsToRemove = Array.from(scheduledAt.keys()).slice(0, scheduledAt.size - maxSessions)
+      sessionsToRemove.forEach((id) => scheduledAt.delete(id))
+    }
   }
 
   function cancelPendingNotification(sessionID: string): void {
@@ -51,11 +60,17 @@ export function createIdleNotificationScheduler(options: {
       clearTimeout(timer)
       pendingTimers.delete(sessionID)
     }
+    scheduledAt.delete(sessionID)
     sessionActivitySinceIdle.add(sessionID)
     notificationVersions.set(sessionID, (notificationVersions.get(sessionID) ?? 0) + 1)
   }
 
   function markSessionActivity(sessionID: string): void {
+    const scheduledTime = scheduledAt.get(sessionID)
+    if (scheduledTime && Date.now() - scheduledTime < activityGracePeriodMs) {
+      return
+    }
+
     cancelPendingNotification(sessionID)
     if (!executingNotifications.has(sessionID)) {
       notifiedSessions.delete(sessionID)
@@ -65,22 +80,26 @@ export function createIdleNotificationScheduler(options: {
   async function executeNotification(sessionID: string, version: number): Promise<void> {
     if (executingNotifications.has(sessionID)) {
       pendingTimers.delete(sessionID)
+      scheduledAt.delete(sessionID)
       return
     }
 
     if (notificationVersions.get(sessionID) !== version) {
       pendingTimers.delete(sessionID)
+      scheduledAt.delete(sessionID)
       return
     }
 
     if (sessionActivitySinceIdle.has(sessionID)) {
       sessionActivitySinceIdle.delete(sessionID)
       pendingTimers.delete(sessionID)
+      scheduledAt.delete(sessionID)
       return
     }
 
     if (notifiedSessions.has(sessionID)) {
       pendingTimers.delete(sessionID)
+      scheduledAt.delete(sessionID)
       return
     }
 
@@ -113,6 +132,7 @@ export function createIdleNotificationScheduler(options: {
     } finally {
       executingNotifications.delete(sessionID)
       pendingTimers.delete(sessionID)
+      scheduledAt.delete(sessionID)
       if (sessionActivitySinceIdle.has(sessionID)) {
         notifiedSessions.delete(sessionID)
         sessionActivitySinceIdle.delete(sessionID)
@@ -126,6 +146,7 @@ export function createIdleNotificationScheduler(options: {
     if (executingNotifications.has(sessionID)) return
 
     sessionActivitySinceIdle.delete(sessionID)
+    scheduledAt.set(sessionID, Date.now())
 
     const currentVersion = (notificationVersions.get(sessionID) ?? 0) + 1
     notificationVersions.set(sessionID, currentVersion)
@@ -144,6 +165,7 @@ export function createIdleNotificationScheduler(options: {
     sessionActivitySinceIdle.delete(sessionID)
     notificationVersions.delete(sessionID)
     executingNotifications.delete(sessionID)
+    scheduledAt.delete(sessionID)
   }
 
   return {

src/hooks/session-notification.test.ts

@@ -195,8 +195,9 @@ describe("session-notification", () => {
     setMainSession(mainSessionID)
 
     const hook = createSessionNotification(createMockPluginInput(), {
-      idleConfirmationDelay: 100, // Long delay
+      idleConfirmationDelay: 100,
       skipIfIncompleteTodos: false,
+      activityGracePeriodMs: 0,
     })
 
     // when - session goes idle
@@ -272,6 +273,7 @@ describe("session-notification", () => {
     const hook = createSessionNotification(createMockPluginInput(), {
       idleConfirmationDelay: 50,
       skipIfIncompleteTodos: false,
+      activityGracePeriodMs: 0,
     })
 
     // when - session goes idle, then message.updated fires
@@ -306,6 +308,7 @@ describe("session-notification", () => {
     const hook = createSessionNotification(createMockPluginInput(), {
       idleConfirmationDelay: 50,
       skipIfIncompleteTodos: false,
+      activityGracePeriodMs: 0,
     })
 
     // when - session goes idle, then tool.execute.before fires
@@ -509,4 +512,75 @@ describe("session-notification", () => {
       }
     }
   })
+
+  test("should ignore activity events within grace period", async () => {
+    // given - main session is set
+    const mainSessionID = "main-grace"
+    setMainSession(mainSessionID)
+
+    const hook = createSessionNotification(createMockPluginInput(), {
+      idleConfirmationDelay: 50,
+      skipIfIncompleteTodos: false,
+      activityGracePeriodMs: 100,
+    })
+
+    // when - session goes idle
+    await hook({
+      event: {
+        type: "session.idle",
+        properties: { sessionID: mainSessionID },
+      },
+    })
+
+    // when - activity happens immediately (within grace period)
+    await hook({
+      event: {
+        type: "tool.execute.before",
+        properties: { sessionID: mainSessionID },
+      },
+    })
+
+    // Wait for idle delay to pass
+    await new Promise((resolve) => setTimeout(resolve, 100))
+
+    // then - notification SHOULD be sent (activity was within grace period, ignored)
+    expect(notificationCalls.length).toBeGreaterThanOrEqual(1)
+  })
+
+  test("should cancel notification for activity after grace period", async () => {
+    // given - main session is set
+    const mainSessionID = "main-grace-cancel"
+    setMainSession(mainSessionID)
+
+    const hook = createSessionNotification(createMockPluginInput(), {
+      idleConfirmationDelay: 200,
+      skipIfIncompleteTodos: false,
+      activityGracePeriodMs: 50,
+    })
+
+    // when - session goes idle
+    await hook({
+      event: {
+        type: "session.idle",
+        properties: { sessionID: mainSessionID },
+      },
+    })
+
+    // when - wait for grace period to pass
+    await new Promise((resolve) => setTimeout(resolve, 60))
+
+    // when - activity happens after grace period
+    await hook({
+      event: {
+        type: "tool.execute.before",
+        properties: { sessionID: mainSessionID },
+      },
+    })
+
+    // Wait for original delay to pass
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    // then - notification should NOT be sent (activity cancelled it after grace period)
+    expect(notificationCalls).toHaveLength(0)
+  })
 })

src/hooks/session-notification.ts

@@ -24,6 +24,8 @@ interface SessionNotificationConfig {
   /** Maximum number of sessions to track before cleanup (default: 100) */
   maxTrackedSessions?: number
   enforceMainSessionFilter?: boolean
+  /** Grace period in ms to ignore late-arriving activity events after scheduling (default: 100) */
+  activityGracePeriodMs?: number
 }
 export function createSessionNotification(
   ctx: PluginInput,

src/plugin-handlers/tool-config-handler.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "bun:test"
+import { describe, it, expect, beforeEach, afterEach } from "bun:test"
 import { applyToolConfig } from "./tool-config-handler"
 import type { OhMyOpenCodeConfig } from "../config"
 
@@ -56,6 +56,109 @@ describe("applyToolConfig", () => {
     })
   })
 
+  describe("#given OPENCODE_CONFIG_CONTENT has question set to deny", () => {
+    let originalConfigContent: string | undefined
+    let originalCliRunMode: string | undefined
+
+    beforeEach(() => {
+      originalConfigContent = process.env.OPENCODE_CONFIG_CONTENT
+      originalCliRunMode = process.env.OPENCODE_CLI_RUN_MODE
+    })
+
+    afterEach(() => {
+      if (originalConfigContent === undefined) {
+        delete process.env.OPENCODE_CONFIG_CONTENT
+      } else {
+        process.env.OPENCODE_CONFIG_CONTENT = originalConfigContent
+      }
+      if (originalCliRunMode === undefined) {
+        delete process.env.OPENCODE_CLI_RUN_MODE
+      } else {
+        process.env.OPENCODE_CLI_RUN_MODE = originalCliRunMode
+      }
+    })
+
+    describe("#when config explicitly denies question permission", () => {
+      it.each(["sisyphus", "hephaestus", "prometheus"])(
+        "#then should deny question for %s even without CLI_RUN_MODE",
+        (agentName) => {
+          process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+            permission: { question: "deny" },
+          })
+          delete process.env.OPENCODE_CLI_RUN_MODE
+          const params = createParams({ agents: [agentName] })
+
+          applyToolConfig(params)
+
+          const agent = params.agentResult[agentName] as {
+            permission: Record<string, unknown>
+          }
+          expect(agent.permission.question).toBe("deny")
+        },
+      )
+    })
+
+    describe("#when config does not deny question permission", () => {
+      it.each(["sisyphus", "hephaestus", "prometheus"])(
+        "#then should allow question for %s in interactive mode",
+        (agentName) => {
+          process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+            permission: { question: "allow" },
+          })
+          delete process.env.OPENCODE_CLI_RUN_MODE
+          const params = createParams({ agents: [agentName] })
+
+          applyToolConfig(params)
+
+          const agent = params.agentResult[agentName] as {
+            permission: Record<string, unknown>
+          }
+          expect(agent.permission.question).toBe("allow")
+        },
+      )
+    })
+
+    describe("#when CLI_RUN_MODE is true and config does not deny", () => {
+      it.each(["sisyphus", "hephaestus", "prometheus"])(
+        "#then should deny question for %s via CLI_RUN_MODE",
+        (agentName) => {
+          process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+            permission: {},
+          })
+          process.env.OPENCODE_CLI_RUN_MODE = "true"
+          const params = createParams({ agents: [agentName] })
+
+          applyToolConfig(params)
+
+          const agent = params.agentResult[agentName] as {
+            permission: Record<string, unknown>
+          }
+          expect(agent.permission.question).toBe("deny")
+        },
+      )
+    })
+
+    describe("#when config deny overrides CLI_RUN_MODE allow", () => {
+      it.each(["sisyphus", "hephaestus", "prometheus"])(
+        "#then should deny question for %s when config says deny regardless of CLI_RUN_MODE",
+        (agentName) => {
+          process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+            permission: { question: "deny" },
+          })
+          process.env.OPENCODE_CLI_RUN_MODE = "false"
+          const params = createParams({ agents: [agentName] })
+
+          applyToolConfig(params)
+
+          const agent = params.agentResult[agentName] as {
+            permission: Record<string, unknown>
+          }
+          expect(agent.permission.question).toBe("deny")
+        },
+      )
+    })
+  })
+
   describe("#given task_system is disabled", () => {
     describe("#when applying tool config", () => {
       it.each([

src/plugin-handlers/tool-config-handler.ts

@@ -3,6 +3,17 @@ import { getAgentDisplayName } from "../shared/agent-display-names";
 
 type AgentWithPermission = { permission?: Record<string, unknown> };
 
+function getConfigQuestionPermission(): string | null {
+  const configContent = process.env.OPENCODE_CONFIG_CONTENT;
+  if (!configContent) return null;
+  try {
+    const parsed = JSON.parse(configContent);
+    return parsed?.permission?.question ?? null;
+  } catch {
+    return null;
+  }
+}
+
 function agentByKey(agentResult: Record<string, unknown>, key: string): AgentWithPermission | undefined {
   return (agentResult[key] ?? agentResult[getAgentDisplayName(key)]) as
     | AgentWithPermission
@@ -32,7 +43,11 @@ export function applyToolConfig(params: {
   };
 
   const isCliRunMode = process.env.OPENCODE_CLI_RUN_MODE === "true";
-  const questionPermission = isCliRunMode ? "deny" : "allow";
+  const configQuestionPermission = getConfigQuestionPermission();
+  const questionPermission =
+    configQuestionPermission === "deny" ? "deny" :
+    isCliRunMode ? "deny" :
+    "allow";
 
   const librarian = agentByKey(params.agentResult, "librarian");
   if (librarian) {