release: v3.5.4

The stale detection was checking lastUpdate timestamps BEFORE
consulting session.status(), causing tasks to be unfairly killed
after 3 minutes even when the session was actively running
(e.g., during long tool executions or extended thinking).

Changes:
- Reorder pollRunningTasks to fetch session.status() before stale check
- Skip stale-kill entirely when session status is 'running'
- Port no-lastUpdate handling from task-poller.ts into manager.ts
  (previously manager silently skipped tasks without lastUpdate)
- Add sessionStatuses parameter to checkAndInterruptStaleTasks
- Add 7 new test cases covering session-status-aware stale detection

.github/workflows/publish.yml

@@ -51,13 +51,33 @@ jobs:
           # Run them in separate processes to prevent cross-file contamination
           bun test src/plugin-handlers
           bun test src/hooks/atlas
+          bun test src/hooks/compaction-context-injector
           bun test src/features/tmux-subagent
+          bun test src/cli/doctor/formatter.test.ts
+          bun test src/cli/doctor/format-default.test.ts
+          bun test src/tools/call-omo-agent/sync-executor.test.ts
+          bun test src/tools/call-omo-agent/session-creator.test.ts
+          bun test src/features/opencode-skill-loader/loader.test.ts
 
       - name: Run remaining tests
         run: |
-          # Run all other tests (mock-heavy ones are re-run but that's acceptable)
-          bun test bin script src/cli src/config src/mcp src/index.test.ts \
-            src/agents src/tools src/shared \
+          # Enumerate subdirectories/files explicitly to EXCLUDE mock-heavy files
+          # that were already run in isolation above.
+          # Excluded from src/cli: doctor/formatter.test.ts, doctor/format-default.test.ts
+          # Excluded from src/tools: call-omo-agent/sync-executor.test.ts, call-omo-agent/session-creator.test.ts
+          bun test bin script src/config src/mcp src/index.test.ts \
+            src/agents src/shared \
+            src/cli/run src/cli/config-manager src/cli/mcp-oauth \
+            src/cli/index.test.ts src/cli/install.test.ts src/cli/model-fallback.test.ts \
+            src/cli/config-manager.test.ts \
+            src/cli/doctor/runner.test.ts src/cli/doctor/checks \
+            src/tools/ast-grep src/tools/background-task src/tools/delegate-task \
+            src/tools/glob src/tools/grep src/tools/interactive-bash \
+            src/tools/look-at src/tools/lsp src/tools/session-manager \
+            src/tools/skill src/tools/skill-mcp src/tools/slashcommand src/tools/task \
+            src/tools/call-omo-agent/background-agent-executor.test.ts \
+            src/tools/call-omo-agent/background-executor.test.ts \
+            src/tools/call-omo-agent/subagent-session-creator.test.ts \
             src/hooks/anthropic-context-window-limit-recovery \
             src/hooks/claude-code-compatibility \
             src/hooks/context-injection \
@@ -70,7 +90,11 @@ jobs:
             src/features/builtin-skills \
             src/features/claude-code-session-state \
             src/features/hook-message-injector \
-            src/features/opencode-skill-loader \
+            src/features/opencode-skill-loader/config-source-discovery.test.ts \
+            src/features/opencode-skill-loader/merger.test.ts \
+            src/features/opencode-skill-loader/skill-content.test.ts \
+            src/features/opencode-skill-loader/blocking.test.ts \
+            src/features/opencode-skill-loader/async-loader.test.ts \
             src/features/skill-mcp-manager
 
   typecheck:

assets/oh-my-opencode.schema.json

@@ -162,9 +162,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -210,9 +207,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -300,9 +294,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -344,9 +335,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -392,9 +380,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -482,9 +467,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -526,9 +508,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -574,9 +553,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -664,9 +640,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -708,9 +681,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -756,9 +726,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -846,9 +813,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -890,9 +854,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -938,9 +899,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1028,9 +986,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1072,9 +1027,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1120,9 +1072,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1210,9 +1159,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1254,9 +1200,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1302,9 +1245,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1392,9 +1332,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1436,9 +1373,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1484,9 +1418,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1574,9 +1505,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1618,9 +1546,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1666,9 +1591,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1756,9 +1678,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1800,9 +1719,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1848,9 +1764,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1938,9 +1851,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1982,9 +1892,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2030,9 +1937,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2120,9 +2024,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2164,9 +2065,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2212,9 +2110,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2302,9 +2197,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2346,9 +2238,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2394,9 +2283,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2484,9 +2370,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2528,9 +2411,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2576,9 +2456,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2666,9 +2543,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2679,9 +2553,6 @@
     },
     "categories": {
       "type": "object",
-      "propertyNames": {
-        "type": "string"
-      },
       "additionalProperties": {
         "type": "object",
         "properties": {
@@ -2745,9 +2616,6 @@
           },
           "tools": {
             "type": "object",
-            "propertyNames": {
-              "type": "string"
-            },
             "additionalProperties": {
               "type": "boolean"
             }
@@ -2788,9 +2656,6 @@
         },
         "plugins_override": {
           "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
           "additionalProperties": {
             "type": "boolean"
           }
@@ -3061,9 +2926,6 @@
                   },
                   "metadata": {
                     "type": "object",
-                    "propertyNames": {
-                      "type": "string"
-                    },
                     "additionalProperties": {}
                   },
                   "allowed-tools": {
@@ -3115,9 +2977,6 @@
         },
         "providerConcurrency": {
           "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
           "additionalProperties": {
             "type": "number",
             "minimum": 0
@@ -3125,9 +2984,6 @@
         },
         "modelConcurrency": {
           "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
           "additionalProperties": {
             "type": "number",
             "minimum": 0
@@ -3136,6 +2992,10 @@
         "staleTimeoutMs": {
           "type": "number",
           "minimum": 60000
+        },
+        "messageStalenessTimeoutMs": {
+          "type": "number",
+          "minimum": 60000
         }
       },
       "additionalProperties": false

bun.lock

@@ -28,13 +28,13 @@
         "typescript": "^5.7.3",
       },
       "optionalDependencies": {
-        "oh-my-opencode-darwin-arm64": "3.5.2",
-        "oh-my-opencode-darwin-x64": "3.5.2",
-        "oh-my-opencode-linux-arm64": "3.5.2",
-        "oh-my-opencode-linux-arm64-musl": "3.5.2",
-        "oh-my-opencode-linux-x64": "3.5.2",
-        "oh-my-opencode-linux-x64-musl": "3.5.2",
-        "oh-my-opencode-windows-x64": "3.5.2",
+        "oh-my-opencode-darwin-arm64": "3.5.3",
+        "oh-my-opencode-darwin-x64": "3.5.3",
+        "oh-my-opencode-linux-arm64": "3.5.3",
+        "oh-my-opencode-linux-arm64-musl": "3.5.3",
+        "oh-my-opencode-linux-x64": "3.5.3",
+        "oh-my-opencode-linux-x64-musl": "3.5.3",
+        "oh-my-opencode-windows-x64": "3.5.3",
       },
     },
   },
@@ -226,19 +226,19 @@
 
     "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
 
-    "oh-my-opencode-darwin-arm64": ["oh-my-opencode-darwin-arm64@3.5.2", "", { "os": "darwin", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-oIS3lB2F9/N+3mF5wCKk6/EPVSz516XWN+mNdquSSeddw+xqMxGdhKY6K/XeYbHJzeN2Z8IOikNEJ6psR2/a8g=="],
+    "oh-my-opencode-darwin-arm64": ["oh-my-opencode-darwin-arm64@3.5.3", "", { "os": "darwin", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-Dq0+PC2dyAqG7c3DUnQmdOkKbKmOsRHwoqgLCQNKN1lTRllF8zbWqp5B+LGKxSPxPqJIPS3mKt+wIR2KvkYJVw=="],
 
-    "oh-my-opencode-darwin-x64": ["oh-my-opencode-darwin-x64@3.5.2", "", { "os": "darwin", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-OAdXo4ZCCYO4kRWtnyz3tdmaGYPUB3WcXimXAxp+/sEZxAnh7n1RQkpLn6UxWX4AIAdRT9dfrOfRic6VoCYv2g=="],
+    "oh-my-opencode-darwin-x64": ["oh-my-opencode-darwin-x64@3.5.3", "", { "os": "darwin", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-Ke45Bv/ygZm3YUSUumIyk647KZ2PFzw30tH597cOpG8MDPGbNVBCM6EKFezcukUPT+gPFVpE1IiGzEkn4JmgZA=="],
 
-    "oh-my-opencode-linux-arm64": ["oh-my-opencode-linux-arm64@3.5.2", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-5XXNMFhp1VsyrGNRBoXcOyoaUeVkbrWkBRPDGZfpiq+kRXH3aaSWdR5G7Pl/TadOQv9Bl8/8YaxsuHRTFT1aXw=="],
+    "oh-my-opencode-linux-arm64": ["oh-my-opencode-linux-arm64@3.5.3", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-aP5S3DngUhFkNeqYM33Ge6zccCWLzB/O3FLXLFXy/Iws03N8xugw72pnMK6lUbIia9QQBKK7IZBoYm9C79pZ3g=="],
 
-    "oh-my-opencode-linux-arm64-musl": ["oh-my-opencode-linux-arm64-musl@3.5.2", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-/woIpqvEI85MgJvEVnz4g5FBLeiQNK7srRsueIFPBmtTahh42HFleCDaIltOl/ndjsE5nCHacQVJHkC9W9/F3Q=="],
+    "oh-my-opencode-linux-arm64-musl": ["oh-my-opencode-linux-arm64-musl@3.5.3", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-UiD/hVKYZQyX4D5N5SnZT4M5Z/B2SDtJWBW4MibpYSAcPKNCEBKi/5E4hOPxAtTfFGR8tIXFmYZdQJDkVfvluw=="],
 
-    "oh-my-opencode-linux-x64": ["oh-my-opencode-linux-x64@3.5.2", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-vTL2A+6zzGhi+m7sC8peLDq5OAp2dRR0UEb4RbZAOHtlEruF7qFEmcK3ccWxwc3+Z3G/ITfwn5VNa72ZS4pNTg=="],
+    "oh-my-opencode-linux-x64": ["oh-my-opencode-linux-x64@3.5.3", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-L9kqwzElGkaQ8pgtv1ZjcHARw9LPaU4UEVjzauByTMi+/5Js/PTsNXBggxSRzZfQ8/MNBPSCiA4K10Kc0YjjvA=="],
 
-    "oh-my-opencode-linux-x64-musl": ["oh-my-opencode-linux-x64-musl@3.5.2", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-bOAA55snLsK2QB00IkQy8le0Oqh/GJ7pxEHtm1oUezlQrW/nX5SS/hJ7dPHMmOd9FoiqnqyqWZxNkLmFoG463A=="],
+    "oh-my-opencode-linux-x64-musl": ["oh-my-opencode-linux-x64-musl@3.5.3", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-Z0fVVih/b2dbNeb9DK9oca5dNYCZyPySBRtxRhDXod5d7fJNgIPrvUoEd3SNfkRGORyFB3hGBZ6nqQ6N8+8DEA=="],
 
-    "oh-my-opencode-windows-x64": ["oh-my-opencode-windows-x64@3.5.2", "", { "os": "win32", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode.exe" } }, "sha512-fnHiAPYglw3unPckmQBoCT6+VqjSWCE3S3J551mRo0ZFrxuEP2ZKyHZeFMMOtKwDepCvmKgd1W040+KmuVUXOA=="],
+    "oh-my-opencode-windows-x64": ["oh-my-opencode-windows-x64@3.5.3", "", { "os": "win32", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode.exe" } }, "sha512-ocWPjRs2sJgN02PJnEIYtqdMVDex1YhEj1FzAU5XIicfzQbgxLh9nz1yhHZzfqGJq69QStU6ofpc5kQpfX1LMg=="],
 
     "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -74,13 +74,13 @@
     "typescript": "^5.7.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "3.5.3",
-    "oh-my-opencode-darwin-x64": "3.5.3",
-    "oh-my-opencode-linux-arm64": "3.5.3",
-    "oh-my-opencode-linux-arm64-musl": "3.5.3",
-    "oh-my-opencode-linux-x64": "3.5.3",
-    "oh-my-opencode-linux-x64-musl": "3.5.3",
-    "oh-my-opencode-windows-x64": "3.5.3"
+    "oh-my-opencode-darwin-arm64": "3.5.4",
+    "oh-my-opencode-darwin-x64": "3.5.4",
+    "oh-my-opencode-linux-arm64": "3.5.4",
+    "oh-my-opencode-linux-arm64-musl": "3.5.4",
+    "oh-my-opencode-linux-x64": "3.5.4",
+    "oh-my-opencode-linux-x64-musl": "3.5.4",
+    "oh-my-opencode-windows-x64": "3.5.4"
   },
   "trustedDependencies": [
     "@ast-grep/cli",

packages/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-darwin-arm64",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (darwin-arm64)",
   "license": "MIT",
   "repository": {

packages/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-darwin-x64",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (darwin-x64)",
   "license": "MIT",
   "repository": {

packages/linux-arm64-musl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-arm64-musl",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (linux-arm64-musl)",
   "license": "MIT",
   "repository": {

packages/linux-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-arm64",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (linux-arm64)",
   "license": "MIT",
   "repository": {

packages/linux-x64-musl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-x64-musl",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (linux-x64-musl)",
   "license": "MIT",
   "repository": {

packages/linux-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-x64",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (linux-x64)",
   "license": "MIT",
   "repository": {

packages/windows-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-windows-x64",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "description": "Platform-specific binary for oh-my-opencode (windows-x64)",
   "license": "MIT",
   "repository": {

signatures/cla.json

@@ -1471,6 +1471,38 @@
       "created_at": "2026-02-14T04:15:19Z",
       "repoId": 1108837393,
       "pullRequestNo": 1827
+    },
+    {
+      "name": "morphaxl",
+      "id": 57144942,
+      "comment_id": 3872741516,
+      "created_at": "2026-02-09T16:21:56Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 1699
+    },
+    {
+      "name": "morphaxl",
+      "id": 57144942,
+      "comment_id": 3872742242,
+      "created_at": "2026-02-09T16:22:04Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 1699
+    },
+    {
+      "name": "liu-qingyuan",
+      "id": 57737268,
+      "comment_id": 3902402078,
+      "created_at": "2026-02-14T19:39:58Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 1844
+    },
+    {
+      "name": "iyoda",
+      "id": 31020,
+      "comment_id": 3902426789,
+      "created_at": "2026-02-14T19:58:19Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 1845
     }
   ]
 }

src/cli/run/runner.test.ts

@@ -1,6 +1,8 @@
-import { describe, it, expect } from "bun:test"
+/// <reference types="bun-types" />
+
+import { describe, it, expect, spyOn, afterEach } from "bun:test"
 import type { OhMyOpenCodeConfig } from "../../config"
-import { resolveRunAgent } from "./runner"
+import { resolveRunAgent, waitForEventProcessorShutdown } from "./runner"
 
 const createConfig = (overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOpenCodeConfig => ({
   ...overrides,
@@ -68,3 +70,59 @@ describe("resolveRunAgent", () => {
     expect(agent).toBe("hephaestus")
   })
 })
+
+describe("waitForEventProcessorShutdown", () => {
+  let consoleLogSpy: ReturnType<typeof spyOn<typeof console, "log">> | null = null
+
+  afterEach(() => {
+    if (consoleLogSpy) {
+      consoleLogSpy.mockRestore()
+      consoleLogSpy = null
+    }
+  })
+
+  it("returns quickly when event processor completes", async () => {
+    //#given
+    const eventProcessor = new Promise<void>((resolve) => {
+      setTimeout(() => {
+        resolve()
+      }, 25)
+    })
+    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {})
+    const start = performance.now()
+
+    //#when
+    await waitForEventProcessorShutdown(eventProcessor, 200)
+
+    //#then
+    const elapsed = performance.now() - start
+    expect(elapsed).toBeLessThan(200)
+    expect(console.log).not.toHaveBeenCalledWith(
+      "[run] Event stream did not close within 200ms after abort; continuing shutdown.",
+    )
+  })
+
+  it("times out and continues when event processor does not complete", async () => {
+    //#given
+    const eventProcessor = new Promise<void>(() => {})
+    const spy = spyOn(console, "log").mockImplementation(() => {})
+    consoleLogSpy = spy
+    const timeoutMs = 50
+    const start = performance.now()
+
+    try {
+      //#when
+      await waitForEventProcessorShutdown(eventProcessor, timeoutMs)
+
+      //#then
+      const elapsed = performance.now() - start
+      expect(elapsed).toBeGreaterThanOrEqual(timeoutMs)
+      const callArgs = spy.mock.calls.flat().join("")
+      expect(callArgs).toContain(
+        `[run] Event stream did not close within ${timeoutMs}ms after abort; continuing shutdown.`,
+      )
+    } finally {
+      spy.mockRestore()
+    }
+  })
+})

src/cli/run/runner.ts

@@ -12,6 +12,25 @@ import { pollForCompletion } from "./poll-for-completion"
 export { resolveRunAgent }
 
 const DEFAULT_TIMEOUT_MS = 600_000
+const EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2_000
+
+export async function waitForEventProcessorShutdown(
+  eventProcessor: Promise<void>,
+  timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS,
+): Promise<void> {
+  const completed = await Promise.race([
+    eventProcessor.then(() => true),
+    new Promise<boolean>((resolve) => setTimeout(() => resolve(false), timeoutMs)),
+  ])
+
+  if (!completed) {
+    console.log(
+      pc.dim(
+        `[run] Event stream did not close within ${timeoutMs}ms after abort; continuing shutdown.`,
+      ),
+    )
+  }
+}
 
 export async function run(options: RunOptions): Promise<number> {
   process.env.OPENCODE_CLI_RUN_MODE = "true"
@@ -81,14 +100,14 @@ export async function run(options: RunOptions): Promise<number> {
         query: { directory },
       })
 
-       console.log(pc.dim("Waiting for completion...\n"))
-       const exitCode = await pollForCompletion(ctx, eventState, abortController)
+      console.log(pc.dim("Waiting for completion...\n"))
+      const exitCode = await pollForCompletion(ctx, eventState, abortController)
 
-       // Abort the event stream to stop the processor
-       abortController.abort()
+      // Abort the event stream to stop the processor
+      abortController.abort()
 
-       await eventProcessor
-       cleanup()
+      await waitForEventProcessorShutdown(eventProcessor)
+      cleanup()
 
       const durationMs = Date.now() - startTime
 
@@ -127,4 +146,3 @@ export async function run(options: RunOptions): Promise<number> {
     return 1
   }
 }
-

src/config/schema/background-task.ts

@@ -6,6 +6,8 @@ export const BackgroundTaskConfigSchema = z.object({
   modelConcurrency: z.record(z.string(), z.number().min(0)).optional(),
   /** Stale timeout in milliseconds - interrupt tasks with no activity for this duration (default: 180000 = 3 minutes, minimum: 60000 = 1 minute) */
   staleTimeoutMs: z.number().min(60000).optional(),
+  /** Timeout for tasks that never received any progress update, falling back to startedAt (default: 600000 = 10 minutes, minimum: 60000 = 1 minute) */
+  messageStalenessTimeoutMs: z.number().min(60000).optional(),
 })
 
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>

src/features/background-agent/constants.ts

@@ -4,6 +4,7 @@ import type { BackgroundTask, LaunchInput } from "./types"
 export const TASK_TTL_MS = 30 * 60 * 1000
 export const MIN_STABILITY_TIME_MS = 10 * 1000
 export const DEFAULT_STALE_TIMEOUT_MS = 180_000
+export const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600_000
 export const MIN_RUNTIME_BEFORE_STALE_MS = 30_000
 export const MIN_IDLE_TIME_MS = 5000
 export const POLLING_INTERVAL_MS = 3000

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

@@ -2289,10 +2289,221 @@ describe("BackgroundManager.checkAndInterruptStaleTasks", () => {
 
     getTaskMap(manager).set(task.id, task)
 
-    await manager["checkAndInterruptStaleTasks"]()
+     await manager["checkAndInterruptStaleTasks"]()
 
     expect(task.status).toBe("cancelled")
   })
+
+  test("should NOT interrupt task when session is running, even with stale lastUpdate", async () => {
+    //#given
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task: BackgroundTask = {
+      id: "task-running-session",
+      sessionID: "session-running",
+      parentSessionID: "parent-rs",
+      parentMessageID: "msg-rs",
+      description: "Task with running session",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 300_000),
+      },
+    }
+
+    getTaskMap(manager).set(task.id, task)
+
+    //#when — session is actively running
+    await manager["checkAndInterruptStaleTasks"]({ "session-running": { type: "running" } })
+
+    //#then — task survives because session is running
+    expect(task.status).toBe("running")
+  })
+
+  test("should interrupt task when session is idle and lastUpdate exceeds stale timeout", async () => {
+    //#given
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+    stubNotifyParentSession(manager)
+
+    const task: BackgroundTask = {
+      id: "task-idle-session",
+      sessionID: "session-idle",
+      parentSessionID: "parent-is",
+      parentMessageID: "msg-is",
+      description: "Task with idle session",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 300_000),
+      },
+    }
+
+    getTaskMap(manager).set(task.id, task)
+
+    //#when — session is idle
+    await manager["checkAndInterruptStaleTasks"]({ "session-idle": { type: "idle" } })
+
+    //#then — killed because session is idle with stale lastUpdate
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
+
+  test("should NOT interrupt running session even with very old lastUpdate (no safety net)", async () => {
+    //#given
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task: BackgroundTask = {
+      id: "task-long-running",
+      sessionID: "session-long",
+      parentSessionID: "parent-lr",
+      parentMessageID: "msg-lr",
+      description: "Long running task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 900_000),
+      progress: {
+        toolCalls: 5,
+        lastUpdate: new Date(Date.now() - 900_000),
+      },
+    }
+
+    getTaskMap(manager).set(task.id, task)
+
+    //#when — session is running, lastUpdate 15min old
+    await manager["checkAndInterruptStaleTasks"]({ "session-long": { type: "running" } })
+
+    //#then — running sessions are NEVER stale-killed
+    expect(task.status).toBe("running")
+  })
+
+  test("should NOT interrupt running session with no progress (undefined lastUpdate)", async () => {
+    //#given — no progress at all, but session is running
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { messageStalenessTimeoutMs: 600_000 })
+
+    const task: BackgroundTask = {
+      id: "task-running-no-progress",
+      sessionID: "session-rnp",
+      parentSessionID: "parent-rnp",
+      parentMessageID: "msg-rnp",
+      description: "Running no progress",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 15 * 60 * 1000),
+      progress: undefined,
+    }
+
+    getTaskMap(manager).set(task.id, task)
+
+    //#when — session is running despite no progress
+    await manager["checkAndInterruptStaleTasks"]({ "session-rnp": { type: "running" } })
+
+    //#then — running sessions are NEVER killed
+    expect(task.status).toBe("running")
+  })
+
+  test("should interrupt task with no lastUpdate after messageStalenessTimeout", async () => {
+    //#given
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { messageStalenessTimeoutMs: 600_000 })
+    stubNotifyParentSession(manager)
+
+    const task: BackgroundTask = {
+      id: "task-no-update",
+      sessionID: "session-no-update",
+      parentSessionID: "parent-nu",
+      parentMessageID: "msg-nu",
+      description: "No update task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 15 * 60 * 1000),
+      progress: undefined,
+    }
+
+    getTaskMap(manager).set(task.id, task)
+
+    //#when — no progress update for 15 minutes
+    await manager["checkAndInterruptStaleTasks"]({})
+
+    //#then — killed after messageStalenessTimeout
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("no activity")
+  })
+
+  test("should NOT interrupt task with no lastUpdate within messageStalenessTimeout", async () => {
+    //#given
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        promptAsync: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { messageStalenessTimeoutMs: 600_000 })
+
+    const task: BackgroundTask = {
+      id: "task-fresh-no-update",
+      sessionID: "session-fresh",
+      parentSessionID: "parent-fn",
+      parentMessageID: "msg-fn",
+      description: "Fresh no-update task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 5 * 60 * 1000),
+      progress: undefined,
+    }
+
+    getTaskMap(manager).set(task.id, task)
+
+    //#when — only 5 min since start, within 10min timeout
+    await manager["checkAndInterruptStaleTasks"]({})
+
+    //#then — task survives
+    expect(task.status).toBe("running")
+  })
 })
 
 describe("BackgroundManager.shutdown session abort", () => {

src/features/background-agent/manager.ts

@@ -12,6 +12,7 @@ import { ConcurrencyManager } from "./concurrency"
 import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema"
 import { isInsideTmux } from "../../shared/tmux"
 import {
+  DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS,
   DEFAULT_STALE_TIMEOUT_MS,
   MIN_IDLE_TIME_MS,
   MIN_RUNTIME_BEFORE_STALE_MS,
@@ -1437,24 +1438,54 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
   }
 
-  private async checkAndInterruptStaleTasks(): Promise<void> {
+  private async checkAndInterruptStaleTasks(
+    allStatuses: Record<string, { type: string }> = {},
+  ): Promise<void> {
     const staleTimeoutMs = this.config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
+    const messageStalenessMs = this.config?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS
     const now = Date.now()
 
     for (const task of this.tasks.values()) {
       if (task.status !== "running") continue
-      if (!task.progress?.lastUpdate) continue
-      
+
       const startedAt = task.startedAt
       const sessionID = task.sessionID
       if (!startedAt || !sessionID) continue
 
+      const sessionIsRunning = allStatuses[sessionID]?.type === "running"
       const runtime = now - startedAt.getTime()
+
+      if (!task.progress?.lastUpdate) {
+        if (sessionIsRunning) continue
+        if (runtime <= messageStalenessMs) continue
+
+        const staleMinutes = Math.round(runtime / 60000)
+        task.status = "cancelled"
+        task.error = `Stale timeout (no activity for ${staleMinutes}min since start)`
+        task.completedAt = new Date()
+
+        if (task.concurrencyKey) {
+          this.concurrencyManager.release(task.concurrencyKey)
+          task.concurrencyKey = undefined
+        }
+
+        this.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+        log(`[background-agent] Task ${task.id} interrupted: no progress since start`)
+
+        try {
+          await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task))
+        } catch (err) {
+          log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
+        }
+        continue
+      }
+
+      if (sessionIsRunning) continue
+
       if (runtime < MIN_RUNTIME_BEFORE_STALE_MS) continue
 
       const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime()
       if (timeSinceLastUpdate <= staleTimeoutMs) continue
-
       if (task.status !== "running") continue
 
       const staleMinutes = Math.round(timeSinceLastUpdate / 60000)
@@ -1467,10 +1498,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         task.concurrencyKey = undefined
       }
 
-      this.client.session.abort({
-        path: { id: sessionID },
-      }).catch(() => {})
-
+      this.client.session.abort({ path: { id: sessionID } }).catch(() => {})
       log(`[background-agent] Task ${task.id} interrupted: stale timeout`)
 
       try {
@@ -1483,11 +1511,12 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 
   private async pollRunningTasks(): Promise<void> {
     this.pruneStaleTasksAndNotifications()
-    await this.checkAndInterruptStaleTasks()
 
     const statusResult = await this.client.session.status()
     const allStatuses = (statusResult.data ?? {}) as Record<string, { type: string }>
 
+    await this.checkAndInterruptStaleTasks(allStatuses)
+
     for (const task of this.tasks.values()) {
       if (task.status !== "running") continue
       
@@ -1497,7 +1526,6 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
       try {
         const sessionStatus = allStatuses[sessionID]
         
-        // Don't skip if session not in status - fall through to message-based detection
         if (sessionStatus?.type === "idle") {
           // Edge guard: Validate session has actual output before completing
           const hasValidOutput = await this.validateSessionHasOutput(sessionID)

src/features/background-agent/poll-running-tasks.ts

@@ -34,7 +34,7 @@ export async function pollRunningTasks(args: {
   tasks: Iterable<BackgroundTask>
   client: OpencodeClient
   pruneStaleTasksAndNotifications: () => void
-  checkAndInterruptStaleTasks: () => Promise<void>
+  checkAndInterruptStaleTasks: (statuses: Record<string, { type: string }>) => Promise<void>
   validateSessionHasOutput: (sessionID: string) => Promise<boolean>
   checkSessionTodos: (sessionID: string) => Promise<boolean>
   tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>
@@ -54,11 +54,12 @@ export async function pollRunningTasks(args: {
   } = args
 
   pruneStaleTasksAndNotifications()
-  await checkAndInterruptStaleTasks()
 
   const statusResult = await client.session.status()
   const allStatuses = ((statusResult as { data?: unknown }).data ?? {}) as SessionStatusMap
 
+  await checkAndInterruptStaleTasks(allStatuses)
+
   for (const task of tasks) {
     if (task.status !== "running") continue
 

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

@@ -0,0 +1,311 @@
+import { describe, it, expect, mock } from "bun:test"
+
+import { checkAndInterruptStaleTasks, pruneStaleTasksAndNotifications } from "./task-poller"
+import type { BackgroundTask } from "./types"
+
+describe("checkAndInterruptStaleTasks", () => {
+  const mockClient = {
+    session: {
+      abort: mock(() => Promise.resolve()),
+    },
+  }
+  const mockConcurrencyManager = {
+    release: mock(() => {}),
+  }
+  const mockNotify = mock(() => Promise.resolve())
+
+  function createRunningTask(overrides: Partial<BackgroundTask> = {}): BackgroundTask {
+    return {
+      id: "task-1",
+      sessionID: "ses-1",
+      parentSessionID: "parent-ses-1",
+      parentMessageID: "msg-1",
+      description: "test",
+      prompt: "test",
+      agent: "explore",
+      status: "running",
+      startedAt: new Date(Date.now() - 120_000),
+      ...overrides,
+    }
+  }
+
+  it("should interrupt tasks with lastUpdate exceeding stale timeout", async () => {
+    //#given
+    const task = createRunningTask({
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+    })
+
+    //#when
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+    })
+
+    //#then
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
+
+  it("should NOT interrupt tasks with recent lastUpdate", async () => {
+    //#given
+    const task = createRunningTask({
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 10_000),
+      },
+    })
+
+    //#when
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+    })
+
+    //#then
+    expect(task.status).toBe("running")
+  })
+
+  it("should interrupt tasks with NO progress.lastUpdate that exceeded messageStalenessTimeoutMs since startedAt", async () => {
+    //#given — task started 15 minutes ago, never received any progress update
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 15 * 60 * 1000),
+      progress: undefined,
+    })
+
+    //#when
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { messageStalenessTimeoutMs: 600_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+    })
+
+    //#then
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("no activity")
+  })
+
+  it("should NOT interrupt tasks with NO progress.lastUpdate that are within messageStalenessTimeoutMs", async () => {
+    //#given — task started 5 minutes ago, default timeout is 10 minutes
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 5 * 60 * 1000),
+      progress: undefined,
+    })
+
+    //#when
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { messageStalenessTimeoutMs: 600_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+    })
+
+    //#then
+    expect(task.status).toBe("running")
+  })
+
+  it("should use DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS when messageStalenessTimeoutMs is not configured", async () => {
+    //#given — task started 15 minutes ago, no config for messageStalenessTimeoutMs
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 15 * 60 * 1000),
+      progress: undefined,
+    })
+
+    //#when — default is 10 minutes (600_000ms)
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: undefined,
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+    })
+
+    //#then
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("no activity")
+  })
+
+  it("should NOT interrupt task when session is running, even if lastUpdate exceeds stale timeout", async () => {
+    //#given — lastUpdate is 5min old but session is actively running
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 300_000),
+      },
+    })
+
+    //#when — session status is "running"
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: { "ses-1": { type: "running" } },
+    })
+
+    //#then — task should survive because session is actively running
+    expect(task.status).toBe("running")
+  })
+
+  it("should interrupt task when session is idle and lastUpdate exceeds stale timeout", async () => {
+    //#given — lastUpdate is 5min old and session is idle
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 300_000),
+      },
+    })
+
+    //#when — session status is "idle"
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: { "ses-1": { type: "idle" } },
+    })
+
+    //#then — task should be killed because session is idle with stale lastUpdate
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
+
+  it("should NOT interrupt running session task even with very old lastUpdate", async () => {
+    //#given — lastUpdate is 15min old, but session is still running
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 900_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 900_000),
+      },
+    })
+
+    //#when — session running, lastUpdate far exceeds any timeout
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000, messageStalenessTimeoutMs: 600_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: { "ses-1": { type: "running" } },
+    })
+
+    //#then — running sessions are NEVER stale-killed (babysitter + TTL prune handle these)
+    expect(task.status).toBe("running")
+  })
+
+  it("should NOT interrupt running session even with no progress (undefined lastUpdate)", async () => {
+    //#given — task has no progress at all, but session is running
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 15 * 60 * 1000),
+      progress: undefined,
+    })
+
+    //#when — session is running
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { messageStalenessTimeoutMs: 600_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: { "ses-1": { type: "running" } },
+    })
+
+    //#then — running sessions are NEVER killed, even without progress
+    expect(task.status).toBe("running")
+  })
+
+  it("should use default stale timeout when session status is unknown/missing", async () => {
+    //#given — lastUpdate exceeds stale timeout, session not in status map
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+    })
+
+    //#when — empty sessionStatuses (session not found)
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { staleTimeoutMs: 180_000 },
+      concurrencyManager: mockConcurrencyManager as never,
+      notifyParentSession: mockNotify,
+      sessionStatuses: {},
+    })
+
+    //#then — unknown session treated as potentially stale, apply default timeout
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
+
+  it("should release concurrency key when interrupting a never-updated task", async () => {
+    //#given
+    const releaseMock = mock(() => {})
+    const task = createRunningTask({
+      startedAt: new Date(Date.now() - 15 * 60 * 1000),
+      progress: undefined,
+      concurrencyKey: "anthropic/claude-opus-4-6",
+    })
+
+    //#when
+    await checkAndInterruptStaleTasks({
+      tasks: [task],
+      client: mockClient as never,
+      config: { messageStalenessTimeoutMs: 600_000 },
+      concurrencyManager: { release: releaseMock } as never,
+      notifyParentSession: mockNotify,
+    })
+
+    //#then
+    expect(releaseMock).toHaveBeenCalledWith("anthropic/claude-opus-4-6")
+    expect(task.concurrencyKey).toBeUndefined()
+  })
+})
+
+describe("pruneStaleTasksAndNotifications", () => {
+  it("should prune tasks that exceeded TTL", () => {
+    //#given
+    const tasks = new Map<string, BackgroundTask>()
+    const oldTask: BackgroundTask = {
+      id: "old-task",
+      parentSessionID: "parent",
+      parentMessageID: "msg",
+      description: "old",
+      prompt: "old",
+      agent: "explore",
+      status: "running",
+      startedAt: new Date(Date.now() - 31 * 60 * 1000),
+    }
+    tasks.set("old-task", oldTask)
+
+    const pruned: string[] = []
+    const notifications = new Map<string, BackgroundTask[]>()
+
+    //#when
+    pruneStaleTasksAndNotifications({
+      tasks,
+      notifications,
+      onTaskPruned: (taskId) => pruned.push(taskId),
+    })
+
+    //#then
+    expect(pruned).toContain("old-task")
+  })
+})

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

@@ -6,6 +6,7 @@ import type { ConcurrencyManager } from "./concurrency"
 import type { OpencodeClient } from "./opencode-client"
 
 import {
+  DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS,
   DEFAULT_STALE_TIMEOUT_MS,
   MIN_RUNTIME_BEFORE_STALE_MS,
   TASK_TTL_MS,
@@ -56,26 +57,59 @@ export function pruneStaleTasksAndNotifications(args: {
   }
 }
 
+export type SessionStatusMap = Record<string, { type: string }>
+
 export async function checkAndInterruptStaleTasks(args: {
   tasks: Iterable<BackgroundTask>
   client: OpencodeClient
   config: BackgroundTaskConfig | undefined
   concurrencyManager: ConcurrencyManager
   notifyParentSession: (task: BackgroundTask) => Promise<void>
+  sessionStatuses?: SessionStatusMap
 }): Promise<void> {
-  const { tasks, client, config, concurrencyManager, notifyParentSession } = args
+  const { tasks, client, config, concurrencyManager, notifyParentSession, sessionStatuses } = args
   const staleTimeoutMs = config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
   const now = Date.now()
 
+  const messageStalenessMs = config?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS
+
   for (const task of tasks) {
     if (task.status !== "running") continue
-    if (!task.progress?.lastUpdate) continue
 
     const startedAt = task.startedAt
     const sessionID = task.sessionID
     if (!startedAt || !sessionID) continue
 
+    const sessionIsRunning = sessionStatuses?.[sessionID]?.type === "running"
     const runtime = now - startedAt.getTime()
+
+    if (!task.progress?.lastUpdate) {
+      if (sessionIsRunning) continue
+      if (runtime <= messageStalenessMs) continue
+
+      const staleMinutes = Math.round(runtime / 60000)
+      task.status = "cancelled"
+      task.error = `Stale timeout (no activity for ${staleMinutes}min since start)`
+      task.completedAt = new Date()
+
+      if (task.concurrencyKey) {
+        concurrencyManager.release(task.concurrencyKey)
+        task.concurrencyKey = undefined
+      }
+
+      client.session.abort({ path: { id: sessionID } }).catch(() => {})
+      log(`[background-agent] Task ${task.id} interrupted: no progress since start`)
+
+      try {
+        await notifyParentSession(task)
+      } catch (err) {
+        log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
+      }
+      continue
+    }
+
+    if (sessionIsRunning) continue
+
     if (runtime < MIN_RUNTIME_BEFORE_STALE_MS) continue
 
     const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime()
@@ -92,10 +126,7 @@ export async function checkAndInterruptStaleTasks(args: {
       task.concurrencyKey = undefined
     }
 
-    client.session.abort({
-      path: { id: sessionID },
-    }).catch(() => {})
-
+    client.session.abort({ path: { id: sessionID } }).catch(() => {})
     log(`[background-agent] Task ${task.id} interrupted: stale timeout`)
 
     try {

src/features/opencode-skill-loader/agents-skills-global.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test"
+import { mkdirSync, writeFileSync, rmSync } from "fs"
+import { join } from "path"
+import { tmpdir } from "os"
+
+const TEST_DIR = join(tmpdir(), "agents-global-skills-test-" + Date.now())
+const TEMP_HOME = join(TEST_DIR, "home")
+
+describe("discoverGlobalAgentsSkills", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true })
+    mkdirSync(TEMP_HOME, { recursive: true })
+  })
+
+  afterEach(() => {
+    mock.restore()
+    rmSync(TEST_DIR, { recursive: true, force: true })
+  })
+
+  it("#given a skill in ~/.agents/skills/ #when discoverGlobalAgentsSkills is called #then it discovers the skill", async () => {
+    //#given
+    const skillContent = `---
+name: agent-global-skill
+description: A skill from global .agents/skills directory
+---
+Skill body.
+`
+    const agentsGlobalSkillsDir = join(TEMP_HOME, ".agents", "skills")
+    const skillDir = join(agentsGlobalSkillsDir, "agent-global-skill")
+    mkdirSync(skillDir, { recursive: true })
+    writeFileSync(join(skillDir, "SKILL.md"), skillContent)
+
+    mock.module("os", () => ({
+      homedir: () => TEMP_HOME,
+      tmpdir,
+    }))
+
+    //#when
+    const { discoverGlobalAgentsSkills } = await import("./loader")
+    const skills = await discoverGlobalAgentsSkills()
+    const skill = skills.find(s => s.name === "agent-global-skill")
+
+    //#then
+    expect(skill).toBeDefined()
+    expect(skill?.scope).toBe("user")
+    expect(skill?.definition.description).toContain("A skill from global .agents/skills directory")
+  })
+})

src/features/opencode-skill-loader/loader.test.ts

@@ -552,7 +552,7 @@ Skill body.
         expect(names.length).toBe(uniqueNames.length)
       } finally {
         process.chdir(originalCwd)
-        if (originalOpenCodeConfigDir === undefined) {
+         if (originalOpenCodeConfigDir === undefined) {
           delete process.env.OPENCODE_CONFIG_DIR
         } else {
           process.env.OPENCODE_CONFIG_DIR = originalOpenCodeConfigDir
@@ -560,4 +560,60 @@ Skill body.
       }
     })
   })
+
+  describe("agents skills discovery (.agents/skills/)", () => {
+    it("#given a skill in .agents/skills/ #when discoverProjectAgentsSkills is called #then it discovers the skill", async () => {
+      //#given
+      const skillContent = `---
+name: agent-project-skill
+description: A skill from project .agents/skills directory
+---
+Skill body.
+`
+      const agentsProjectSkillsDir = join(TEST_DIR, ".agents", "skills")
+      const skillDir = join(agentsProjectSkillsDir, "agent-project-skill")
+      mkdirSync(skillDir, { recursive: true })
+      writeFileSync(join(skillDir, "SKILL.md"), skillContent)
+
+      //#when
+      const { discoverProjectAgentsSkills } = await import("./loader")
+      const originalCwd = process.cwd()
+      process.chdir(TEST_DIR)
+
+      try {
+        const skills = await discoverProjectAgentsSkills()
+        const skill = skills.find(s => s.name === "agent-project-skill")
+
+        //#then
+        expect(skill).toBeDefined()
+        expect(skill?.scope).toBe("project")
+        expect(skill?.definition.description).toContain("A skill from project .agents/skills directory")
+      } finally {
+        process.chdir(originalCwd)
+      }
+    })
+
+    it("#given a skill in .agents/skills/ #when discoverProjectAgentsSkills is called with directory #then it discovers the skill", async () => {
+      //#given
+      const skillContent = `---
+name: agent-dir-skill
+description: A skill via explicit directory param
+---
+Skill body.
+`
+      const agentsProjectSkillsDir = join(TEST_DIR, ".agents", "skills")
+      const skillDir = join(agentsProjectSkillsDir, "agent-dir-skill")
+      mkdirSync(skillDir, { recursive: true })
+      writeFileSync(join(skillDir, "SKILL.md"), skillContent)
+
+      //#when
+      const { discoverProjectAgentsSkills } = await import("./loader")
+      const skills = await discoverProjectAgentsSkills(TEST_DIR)
+      const skill = skills.find(s => s.name === "agent-dir-skill")
+
+      //#then
+      expect(skill).toBeDefined()
+      expect(skill?.scope).toBe("project")
+    })
+  })
 })

src/features/opencode-skill-loader/loader.ts

@@ -1,4 +1,5 @@
 import { join } from "path"
+import { homedir } from "os"
 import { getClaudeConfigDir } from "../../shared/claude-config-dir"
 import { getOpenCodeConfigDir } from "../../shared/opencode-config-dir"
 import type { CommandDefinition } from "../claude-code-command-loader/types"
@@ -38,15 +39,25 @@ export interface DiscoverSkillsOptions {
 }
 
 export async function discoverAllSkills(directory?: string): Promise<LoadedSkill[]> {
-  const [opencodeProjectSkills, opencodeGlobalSkills, projectSkills, userSkills] = await Promise.all([
-    discoverOpencodeProjectSkills(directory),
-    discoverOpencodeGlobalSkills(),
-    discoverProjectClaudeSkills(directory),
-    discoverUserClaudeSkills(),
-  ])
+  const [opencodeProjectSkills, opencodeGlobalSkills, projectSkills, userSkills, agentsProjectSkills, agentsGlobalSkills] =
+    await Promise.all([
+      discoverOpencodeProjectSkills(directory),
+      discoverOpencodeGlobalSkills(),
+      discoverProjectClaudeSkills(directory),
+      discoverUserClaudeSkills(),
+      discoverProjectAgentsSkills(directory),
+      discoverGlobalAgentsSkills(),
+    ])
 
-  // Priority: opencode-project > opencode > project > user
-  return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills, ...projectSkills, ...userSkills])
+  // Priority: opencode-project > opencode > project (.claude + .agents) > user (.claude + .agents)
+  return deduplicateSkillsByName([
+    ...opencodeProjectSkills,
+    ...opencodeGlobalSkills,
+    ...projectSkills,
+    ...agentsProjectSkills,
+    ...userSkills,
+    ...agentsGlobalSkills,
+  ])
 }
 
 export async function discoverSkills(options: DiscoverSkillsOptions = {}): Promise<LoadedSkill[]> {
@@ -62,13 +73,22 @@ export async function discoverSkills(options: DiscoverSkillsOptions = {}): Promi
     return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills])
   }
 
-  const [projectSkills, userSkills] = await Promise.all([
+  const [projectSkills, userSkills, agentsProjectSkills, agentsGlobalSkills] = await Promise.all([
     discoverProjectClaudeSkills(directory),
     discoverUserClaudeSkills(),
+    discoverProjectAgentsSkills(directory),
+    discoverGlobalAgentsSkills(),
   ])
 
-  // Priority: opencode-project > opencode > project > user
-  return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills, ...projectSkills, ...userSkills])
+  // Priority: opencode-project > opencode > project (.claude + .agents) > user (.claude + .agents)
+  return deduplicateSkillsByName([
+    ...opencodeProjectSkills,
+    ...opencodeGlobalSkills,
+    ...projectSkills,
+    ...agentsProjectSkills,
+    ...userSkills,
+    ...agentsGlobalSkills,
+  ])
 }
 
 export async function getSkillByName(name: string, options: DiscoverSkillsOptions = {}): Promise<LoadedSkill | undefined> {
@@ -96,3 +116,13 @@ export async function discoverOpencodeProjectSkills(directory?: string): Promise
   const opencodeProjectDir = join(directory ?? process.cwd(), ".opencode", "skills")
   return loadSkillsFromDir({ skillsDir: opencodeProjectDir, scope: "opencode-project" })
 }
+
+export async function discoverProjectAgentsSkills(directory?: string): Promise<LoadedSkill[]> {
+  const agentsProjectDir = join(directory ?? process.cwd(), ".agents", "skills")
+  return loadSkillsFromDir({ skillsDir: agentsProjectDir, scope: "project" })
+}
+
+export async function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]> {
+  const agentsGlobalDir = join(homedir(), ".agents", "skills")
+  return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" })
+}

src/features/tmux-subagent/decision-engine.test.ts

@@ -351,4 +351,47 @@ describe("calculateCapacity", () => {
     expect(capacity.rows).toBe(4)
     expect(capacity.total).toBe(12)
   })
+
+  it("#given a smaller minPaneWidth #when calculating capacity #then fits more columns", () => {
+    //#given
+    const smallMinWidth = 30
+
+    //#when
+    const defaultCapacity = calculateCapacity(212, 44)
+    const customCapacity = calculateCapacity(212, 44, smallMinWidth)
+
+    //#then
+    expect(customCapacity.cols).toBeGreaterThanOrEqual(defaultCapacity.cols)
+  })
+})
+
+describe("decideSpawnActions with custom agentPaneWidth", () => {
+  const createWindowState = (
+    windowWidth: number,
+    windowHeight: number,
+    agentPanes: Array<{ paneId: string; width: number; height: number; left: number; top: number }> = []
+  ): WindowState => ({
+    windowWidth,
+    windowHeight,
+    mainPane: { paneId: "%0", width: Math.floor(windowWidth / 2), height: windowHeight, left: 0, top: 0, title: "main", isActive: true },
+    agentPanes: agentPanes.map((p, i) => ({
+      ...p,
+      title: `agent-${i}`,
+      isActive: false,
+    })),
+  })
+
+  it("#given a smaller agentPaneWidth #when window would be too small for default #then spawns with custom config", () => {
+    //#given
+    const smallConfig: CapacityConfig = { mainPaneMinWidth: 120, agentPaneWidth: 25 }
+    const state = createWindowState(100, 30)
+
+    //#when
+    const defaultResult = decideSpawnActions(state, "ses1", "test", { mainPaneMinWidth: 120, agentPaneWidth: 52 }, [])
+    const customResult = decideSpawnActions(state, "ses1", "test", smallConfig, [])
+
+    //#then
+    expect(defaultResult.canSpawn).toBe(false)
+    expect(customResult.canSpawn).toBe(true)
+  })
 })

src/features/tmux-subagent/grid-planning.ts

@@ -1,10 +1,10 @@
+import { MIN_PANE_HEIGHT, MIN_PANE_WIDTH } from "./types"
 import type { TmuxPaneInfo } from "./types"
 import {
 	DIVIDER_SIZE,
 	MAIN_PANE_RATIO,
 	MAX_GRID_SIZE,
 } from "./tmux-grid-constants"
-import { MIN_PANE_HEIGHT, MIN_PANE_WIDTH } from "./types"
 
 export interface GridCapacity {
 	cols: number
@@ -27,6 +27,7 @@ export interface GridPlan {
 export function calculateCapacity(
 	windowWidth: number,
 	windowHeight: number,
+	minPaneWidth: number = MIN_PANE_WIDTH,
 ): GridCapacity {
 	const availableWidth = Math.floor(windowWidth * (1 - MAIN_PANE_RATIO))
 	const cols = Math.min(
@@ -34,7 +35,7 @@ export function calculateCapacity(
 		Math.max(
 			0,
 			Math.floor(
-				(availableWidth + DIVIDER_SIZE) / (MIN_PANE_WIDTH + DIVIDER_SIZE),
+				(availableWidth + DIVIDER_SIZE) / (minPaneWidth + DIVIDER_SIZE),
 			),
 		),
 	)

src/features/tmux-subagent/pane-split-availability.ts

@@ -1,3 +1,4 @@
+import { MIN_PANE_HEIGHT, MIN_PANE_WIDTH } from "./types"
 import type { SplitDirection, TmuxPaneInfo } from "./types"
 import {
 	DIVIDER_SIZE,
@@ -7,6 +8,10 @@ import {
 	MIN_SPLIT_WIDTH,
 } from "./tmux-grid-constants"
 
+function minSplitWidthFor(minPaneWidth: number): number {
+	return 2 * minPaneWidth + DIVIDER_SIZE
+}
+
 export function getColumnCount(paneCount: number): number {
 	if (paneCount <= 0) return 1
 	return Math.min(MAX_COLS, Math.max(1, Math.ceil(paneCount / MAX_ROWS)))
@@ -21,26 +26,32 @@ export function getColumnWidth(agentAreaWidth: number, paneCount: number): numbe
 export function isSplittableAtCount(
 	agentAreaWidth: number,
 	paneCount: number,
+	minPaneWidth: number = MIN_PANE_WIDTH,
 ): boolean {
 	const columnWidth = getColumnWidth(agentAreaWidth, paneCount)
-	return columnWidth >= MIN_SPLIT_WIDTH
+	return columnWidth >= minSplitWidthFor(minPaneWidth)
 }
 
 export function findMinimalEvictions(
 	agentAreaWidth: number,
 	currentCount: number,
+	minPaneWidth: number = MIN_PANE_WIDTH,
 ): number | null {
 	for (let k = 1; k <= currentCount; k++) {
-		if (isSplittableAtCount(agentAreaWidth, currentCount - k)) {
+		if (isSplittableAtCount(agentAreaWidth, currentCount - k, minPaneWidth)) {
 			return k
 		}
 	}
 	return null
 }
 
-export function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection): boolean {
+export function canSplitPane(
+	pane: TmuxPaneInfo,
+	direction: SplitDirection,
+	minPaneWidth: number = MIN_PANE_WIDTH,
+): boolean {
 	if (direction === "-h") {
-		return pane.width >= MIN_SPLIT_WIDTH
+		return pane.width >= minSplitWidthFor(minPaneWidth)
 	}
 	return pane.height >= MIN_SPLIT_HEIGHT
 }

src/features/tmux-subagent/spawn-action-decider.ts

@@ -13,23 +13,23 @@ import {
 } from "./pane-split-availability"
 import { findSpawnTarget } from "./spawn-target-finder"
 import { findOldestAgentPane, type SessionMapping } from "./oldest-agent-pane"
-import { MIN_PANE_WIDTH } from "./types"
 
 export function decideSpawnActions(
 	state: WindowState,
 	sessionId: string,
 	description: string,
-	_config: CapacityConfig,
+	config: CapacityConfig,
 	sessionMappings: SessionMapping[],
 ): SpawnDecision {
 	if (!state.mainPane) {
 		return { canSpawn: false, actions: [], reason: "no main pane found" }
 	}
 
+	const minPaneWidth = config.agentPaneWidth
 	const agentAreaWidth = Math.floor(state.windowWidth * (1 - MAIN_PANE_RATIO))
 	const currentCount = state.agentPanes.length
 
-	if (agentAreaWidth < MIN_PANE_WIDTH) {
+	if (agentAreaWidth < minPaneWidth) {
 		return {
 			canSpawn: false,
 			actions: [],
@@ -44,7 +44,7 @@ export function decideSpawnActions(
 
 	if (currentCount === 0) {
 		const virtualMainPane: TmuxPaneInfo = { ...state.mainPane, width: state.windowWidth }
-		if (canSplitPane(virtualMainPane, "-h")) {
+		if (canSplitPane(virtualMainPane, "-h", minPaneWidth)) {
 			return {
 				canSpawn: true,
 				actions: [
@@ -61,7 +61,7 @@ export function decideSpawnActions(
 		return { canSpawn: false, actions: [], reason: "mainPane too small to split" }
 	}
 
-	if (isSplittableAtCount(agentAreaWidth, currentCount)) {
+	if (isSplittableAtCount(agentAreaWidth, currentCount, minPaneWidth)) {
 		const spawnTarget = findSpawnTarget(state)
 		if (spawnTarget) {
 			return {
@@ -79,7 +79,7 @@ export function decideSpawnActions(
 		}
 	}
 
-	const minEvictions = findMinimalEvictions(agentAreaWidth, currentCount)
+	const minEvictions = findMinimalEvictions(agentAreaWidth, currentCount, minPaneWidth)
 	if (minEvictions === 1 && oldestPane) {
 		return {
 			canSpawn: true,

src/hooks/anthropic-context-window-limit-recovery/parser.test.ts

@@ -0,0 +1,97 @@
+/// <reference types="bun-types" />
+import { describe, expect, it } from "bun:test"
+import { parseAnthropicTokenLimitError } from "./parser"
+
+describe("parseAnthropicTokenLimitError", () => {
+  it("#given a standard token limit error string #when parsing #then extracts tokens", () => {
+    //#given
+    const error = "prompt is too long: 250000 tokens > 200000 maximum"
+
+    //#when
+    const result = parseAnthropicTokenLimitError(error)
+
+    //#then
+    expect(result).not.toBeNull()
+    expect(result!.currentTokens).toBe(250000)
+    expect(result!.maxTokens).toBe(200000)
+  })
+
+  it("#given a non-token-limit error #when parsing #then returns null", () => {
+    //#given
+    const error = { message: "internal server error" }
+
+    //#when
+    const result = parseAnthropicTokenLimitError(error)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given null input #when parsing #then returns null", () => {
+    //#given
+    const error = null
+
+    //#when
+    const result = parseAnthropicTokenLimitError(error)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given a proxy error with non-standard structure #when parsing #then returns null without crashing", () => {
+    //#given
+    const proxyError = {
+      data: [1, 2, 3],
+      error: "string-not-object",
+      message: "Failed to process error response",
+    }
+
+    //#when
+    const result = parseAnthropicTokenLimitError(proxyError)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given a circular reference error #when parsing #then returns null without crashing", () => {
+    //#given
+    const circular: Record<string, unknown> = { message: "prompt is too long" }
+    circular.self = circular
+
+    //#when
+    const result = parseAnthropicTokenLimitError(circular)
+
+    //#then
+    expect(result).not.toBeNull()
+  })
+
+  it("#given an error where data.responseBody has invalid JSON #when parsing #then handles gracefully", () => {
+    //#given
+    const error = {
+      data: { responseBody: "not valid json {{{" },
+      message: "prompt is too long with 300000 tokens exceeds 200000",
+    }
+
+    //#when
+    const result = parseAnthropicTokenLimitError(error)
+
+    //#then
+    expect(result).not.toBeNull()
+    expect(result!.currentTokens).toBe(300000)
+    expect(result!.maxTokens).toBe(200000)
+  })
+
+  it("#given an error with data as a string (not object) #when parsing #then does not crash", () => {
+    //#given
+    const error = {
+      data: "some-string-data",
+      message: "token limit exceeded",
+    }
+
+    //#when
+    const result = parseAnthropicTokenLimitError(error)
+
+    //#then
+    expect(result).not.toBeNull()
+  })
+})

src/hooks/anthropic-context-window-limit-recovery/parser.ts

@@ -74,6 +74,14 @@ function isTokenLimitError(text: string): boolean {
 }
 
 export function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitError | null {
+  try {
+    return parseAnthropicTokenLimitErrorUnsafe(err)
+  } catch {
+    return null
+  }
+}
+
+function parseAnthropicTokenLimitErrorUnsafe(err: unknown): ParsedTokenLimitError | null {
   if (typeof err === "string") {
     if (err.toLowerCase().includes("non-empty content")) {
       return {

src/hooks/atlas/index.test.ts

@@ -10,18 +10,9 @@ import {
 } from "../../features/boulder-state"
 import type { BoulderState } from "../../features/boulder-state"
 
-const TEST_STORAGE_ROOT = join(tmpdir(), `atlas-message-storage-${randomUUID()}`)
-const TEST_MESSAGE_STORAGE = join(TEST_STORAGE_ROOT, "message")
-const TEST_PART_STORAGE = join(TEST_STORAGE_ROOT, "part")
-
-mock.module("../../features/hook-message-injector/constants", () => ({
-  OPENCODE_STORAGE: TEST_STORAGE_ROOT,
-  MESSAGE_STORAGE: TEST_MESSAGE_STORAGE,
-  PART_STORAGE: TEST_PART_STORAGE,
-}))
-
-const { createAtlasHook } = await import("./index")
-const { MESSAGE_STORAGE } = await import("../../features/hook-message-injector")
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
+import { _resetForTesting, subagentSessions } from "../../features/claude-code-session-state"
+import { createAtlasHook } from "./index"
 
 describe("atlas hook", () => {
   let TEST_DIR: string
@@ -77,7 +68,6 @@ describe("atlas hook", () => {
     if (existsSync(TEST_DIR)) {
       rmSync(TEST_DIR, { recursive: true, force: true })
     }
-    rmSync(TEST_STORAGE_ROOT, { recursive: true, force: true })
   })
 
   describe("tool.execute.after handler", () => {
@@ -631,15 +621,14 @@ describe("atlas hook", () => {
     }
 
      beforeEach(() => {
-       mock.module("../../features/claude-code-session-state", () => ({
-         getMainSessionID: () => MAIN_SESSION_ID,
-         subagentSessions: new Set<string>(),
-       }))
+       _resetForTesting()
+       subagentSessions.clear()
        setupMessageStorage(MAIN_SESSION_ID, "atlas")
      })
 
     afterEach(() => {
       cleanupMessageStorage(MAIN_SESSION_ID)
+      _resetForTesting()
     })
 
     test("should inject continuation when boulder has incomplete tasks", async () => {

src/hooks/directory-agents-injector/injector.test.ts

@@ -1,53 +1,67 @@
-import { beforeEach, describe, expect, it, mock } from "bun:test"
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
 
-const readFileSyncMock = mock((_: string, __: string) => "# AGENTS")
 const findAgentsMdUpMock = mock((_: { startDir: string; rootDir: string }) => [] as string[])
 const resolveFilePathMock = mock((_: string, path: string) => path)
 const loadInjectedPathsMock = mock((_: string) => new Set<string>())
 const saveInjectedPathsMock = mock((_: string, __: Set<string>) => {})
 
-mock.module("node:fs", () => ({
-  readFileSync: readFileSyncMock,
-}))
-
-mock.module("./finder", () => ({
-  findAgentsMdUp: findAgentsMdUpMock,
-  resolveFilePath: resolveFilePathMock,
-}))
-
-mock.module("./storage", () => ({
-  loadInjectedPaths: loadInjectedPathsMock,
-  saveInjectedPaths: saveInjectedPathsMock,
-}))
-
-const { processFilePathForAgentsInjection } = await import("./injector")
-
 describe("processFilePathForAgentsInjection", () => {
+  let testRoot = ""
+
   beforeEach(() => {
-    readFileSyncMock.mockClear()
     findAgentsMdUpMock.mockClear()
     resolveFilePathMock.mockClear()
     loadInjectedPathsMock.mockClear()
     saveInjectedPathsMock.mockClear()
+
+    testRoot = join(
+      tmpdir(),
+      `directory-agents-injector-${Date.now()}-${Math.random().toString(16).slice(2)}`
+    )
+    mkdirSync(testRoot, { recursive: true })
+  })
+
+  afterEach(() => {
+    mock.restore()
+    rmSync(testRoot, { recursive: true, force: true })
   })
 
   it("does not save when all discovered paths are already cached", async () => {
     //#given
     const sessionID = "session-1"
-    const cachedDirectory = "/repo/src"
+    const repoRoot = join(testRoot, "repo")
+    const agentsPath = join(repoRoot, "src", "AGENTS.md")
+    const cachedDirectory = join(repoRoot, "src")
+    mkdirSync(join(repoRoot, "src"), { recursive: true })
+    writeFileSync(agentsPath, "# AGENTS")
+
     loadInjectedPathsMock.mockReturnValueOnce(new Set([cachedDirectory]))
-    findAgentsMdUpMock.mockReturnValueOnce(["/repo/src/AGENTS.md"])
+    findAgentsMdUpMock.mockReturnValueOnce([agentsPath])
 
     const truncator = {
       truncate: mock(async () => ({ result: "trimmed", truncated: false })),
     }
 
+    mock.module("./finder", () => ({
+      findAgentsMdUp: findAgentsMdUpMock,
+      resolveFilePath: resolveFilePathMock,
+    }))
+    mock.module("./storage", () => ({
+      loadInjectedPaths: loadInjectedPathsMock,
+      saveInjectedPaths: saveInjectedPathsMock,
+    }))
+
+    const { processFilePathForAgentsInjection } = await import("./injector")
+
     //#when
     await processFilePathForAgentsInjection({
-      ctx: { directory: "/repo" } as never,
+      ctx: { directory: repoRoot } as never,
       truncator: truncator as never,
       sessionCaches: new Map(),
-      filePath: "/repo/src/file.ts",
+      filePath: join(repoRoot, "src", "file.ts"),
       sessionID,
       output: { title: "Result", output: "", metadata: {} },
     })
@@ -59,19 +73,36 @@ describe("processFilePathForAgentsInjection", () => {
   it("saves when a new path is injected", async () => {
     //#given
     const sessionID = "session-2"
+    const repoRoot = join(testRoot, "repo")
+    const agentsPath = join(repoRoot, "src", "AGENTS.md")
+    const injectedDirectory = join(repoRoot, "src")
+    mkdirSync(join(repoRoot, "src"), { recursive: true })
+    writeFileSync(agentsPath, "# AGENTS")
+
     loadInjectedPathsMock.mockReturnValueOnce(new Set())
-    findAgentsMdUpMock.mockReturnValueOnce(["/repo/src/AGENTS.md"])
+    findAgentsMdUpMock.mockReturnValueOnce([agentsPath])
 
     const truncator = {
       truncate: mock(async () => ({ result: "trimmed", truncated: false })),
     }
 
+    mock.module("./finder", () => ({
+      findAgentsMdUp: findAgentsMdUpMock,
+      resolveFilePath: resolveFilePathMock,
+    }))
+    mock.module("./storage", () => ({
+      loadInjectedPaths: loadInjectedPathsMock,
+      saveInjectedPaths: saveInjectedPathsMock,
+    }))
+
+    const { processFilePathForAgentsInjection } = await import("./injector")
+
     //#when
     await processFilePathForAgentsInjection({
-      ctx: { directory: "/repo" } as never,
+      ctx: { directory: repoRoot } as never,
       truncator: truncator as never,
       sessionCaches: new Map(),
-      filePath: "/repo/src/file.ts",
+      filePath: join(repoRoot, "src", "file.ts"),
       sessionID,
       output: { title: "Result", output: "", metadata: {} },
     })
@@ -80,28 +111,44 @@ describe("processFilePathForAgentsInjection", () => {
     expect(saveInjectedPathsMock).toHaveBeenCalledTimes(1)
     const saveCall = saveInjectedPathsMock.mock.calls[0]
     expect(saveCall[0]).toBe(sessionID)
-    expect((saveCall[1] as Set<string>).has("/repo/src")).toBe(true)
+    expect((saveCall[1] as Set<string>).has(injectedDirectory)).toBe(true)
   })
 
   it("saves once when cached and new paths are mixed", async () => {
     //#given
     const sessionID = "session-3"
-    loadInjectedPathsMock.mockReturnValueOnce(new Set(["/repo/already-cached"]))
-    findAgentsMdUpMock.mockReturnValueOnce([
-      "/repo/already-cached/AGENTS.md",
-      "/repo/new-dir/AGENTS.md",
-    ])
+    const repoRoot = join(testRoot, "repo")
+    const cachedAgentsPath = join(repoRoot, "already-cached", "AGENTS.md")
+    const newAgentsPath = join(repoRoot, "new-dir", "AGENTS.md")
+    mkdirSync(join(repoRoot, "already-cached"), { recursive: true })
+    mkdirSync(join(repoRoot, "new-dir"), { recursive: true })
+    writeFileSync(cachedAgentsPath, "# AGENTS")
+    writeFileSync(newAgentsPath, "# AGENTS")
+
+    loadInjectedPathsMock.mockReturnValueOnce(new Set([join(repoRoot, "already-cached")]))
+    findAgentsMdUpMock.mockReturnValueOnce([cachedAgentsPath, newAgentsPath])
 
     const truncator = {
       truncate: mock(async () => ({ result: "trimmed", truncated: false })),
     }
 
+    mock.module("./finder", () => ({
+      findAgentsMdUp: findAgentsMdUpMock,
+      resolveFilePath: resolveFilePathMock,
+    }))
+    mock.module("./storage", () => ({
+      loadInjectedPaths: loadInjectedPathsMock,
+      saveInjectedPaths: saveInjectedPathsMock,
+    }))
+
+    const { processFilePathForAgentsInjection } = await import("./injector")
+
     //#when
     await processFilePathForAgentsInjection({
-      ctx: { directory: "/repo" } as never,
+      ctx: { directory: repoRoot } as never,
       truncator: truncator as never,
       sessionCaches: new Map(),
-      filePath: "/repo/new-dir/file.ts",
+      filePath: join(repoRoot, "new-dir", "file.ts"),
       sessionID,
       output: { title: "Result", output: "", metadata: {} },
     })
@@ -109,6 +156,6 @@ describe("processFilePathForAgentsInjection", () => {
     //#then
     expect(saveInjectedPathsMock).toHaveBeenCalledTimes(1)
     const saveCall = saveInjectedPathsMock.mock.calls[0]
-    expect((saveCall[1] as Set<string>).has("/repo/new-dir")).toBe(true)
+    expect((saveCall[1] as Set<string>).has(join(repoRoot, "new-dir"))).toBe(true)
   })
 })

src/hooks/directory-readme-injector/injector.test.ts

@@ -1,53 +1,67 @@
-import { beforeEach, describe, expect, it, mock } from "bun:test"
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
 
-const readFileSyncMock = mock((_: string, __: string) => "# README")
 const findReadmeMdUpMock = mock((_: { startDir: string; rootDir: string }) => [] as string[])
 const resolveFilePathMock = mock((_: string, path: string) => path)
 const loadInjectedPathsMock = mock((_: string) => new Set<string>())
 const saveInjectedPathsMock = mock((_: string, __: Set<string>) => {})
 
-mock.module("node:fs", () => ({
-  readFileSync: readFileSyncMock,
-}))
-
-mock.module("./finder", () => ({
-  findReadmeMdUp: findReadmeMdUpMock,
-  resolveFilePath: resolveFilePathMock,
-}))
-
-mock.module("./storage", () => ({
-  loadInjectedPaths: loadInjectedPathsMock,
-  saveInjectedPaths: saveInjectedPathsMock,
-}))
-
-const { processFilePathForReadmeInjection } = await import("./injector")
-
 describe("processFilePathForReadmeInjection", () => {
+  let testRoot = ""
+
   beforeEach(() => {
-    readFileSyncMock.mockClear()
     findReadmeMdUpMock.mockClear()
     resolveFilePathMock.mockClear()
     loadInjectedPathsMock.mockClear()
     saveInjectedPathsMock.mockClear()
+
+    testRoot = join(
+      tmpdir(),
+      `directory-readme-injector-${Date.now()}-${Math.random().toString(16).slice(2)}`
+    )
+    mkdirSync(testRoot, { recursive: true })
+  })
+
+  afterEach(() => {
+    mock.restore()
+    rmSync(testRoot, { recursive: true, force: true })
   })
 
   it("does not save when all discovered paths are already cached", async () => {
     //#given
     const sessionID = "session-1"
-    const cachedDirectory = "/repo/src"
+    const repoRoot = join(testRoot, "repo")
+    const readmePath = join(repoRoot, "src", "README.md")
+    const cachedDirectory = join(repoRoot, "src")
+    mkdirSync(join(repoRoot, "src"), { recursive: true })
+    writeFileSync(readmePath, "# README")
+
     loadInjectedPathsMock.mockReturnValueOnce(new Set([cachedDirectory]))
-    findReadmeMdUpMock.mockReturnValueOnce(["/repo/src/README.md"])
+    findReadmeMdUpMock.mockReturnValueOnce([readmePath])
 
     const truncator = {
       truncate: mock(async () => ({ result: "trimmed", truncated: false })),
     }
 
+    mock.module("./finder", () => ({
+      findReadmeMdUp: findReadmeMdUpMock,
+      resolveFilePath: resolveFilePathMock,
+    }))
+    mock.module("./storage", () => ({
+      loadInjectedPaths: loadInjectedPathsMock,
+      saveInjectedPaths: saveInjectedPathsMock,
+    }))
+
+    const { processFilePathForReadmeInjection } = await import("./injector")
+
     //#when
     await processFilePathForReadmeInjection({
-      ctx: { directory: "/repo" } as never,
+      ctx: { directory: repoRoot } as never,
       truncator: truncator as never,
       sessionCaches: new Map(),
-      filePath: "/repo/src/file.ts",
+      filePath: join(repoRoot, "src", "file.ts"),
       sessionID,
       output: { title: "Result", output: "", metadata: {} },
     })
@@ -59,19 +73,36 @@ describe("processFilePathForReadmeInjection", () => {
   it("saves when a new path is injected", async () => {
     //#given
     const sessionID = "session-2"
+    const repoRoot = join(testRoot, "repo")
+    const readmePath = join(repoRoot, "src", "README.md")
+    const injectedDirectory = join(repoRoot, "src")
+    mkdirSync(join(repoRoot, "src"), { recursive: true })
+    writeFileSync(readmePath, "# README")
+
     loadInjectedPathsMock.mockReturnValueOnce(new Set())
-    findReadmeMdUpMock.mockReturnValueOnce(["/repo/src/README.md"])
+    findReadmeMdUpMock.mockReturnValueOnce([readmePath])
 
     const truncator = {
       truncate: mock(async () => ({ result: "trimmed", truncated: false })),
     }
 
+    mock.module("./finder", () => ({
+      findReadmeMdUp: findReadmeMdUpMock,
+      resolveFilePath: resolveFilePathMock,
+    }))
+    mock.module("./storage", () => ({
+      loadInjectedPaths: loadInjectedPathsMock,
+      saveInjectedPaths: saveInjectedPathsMock,
+    }))
+
+    const { processFilePathForReadmeInjection } = await import("./injector")
+
     //#when
     await processFilePathForReadmeInjection({
-      ctx: { directory: "/repo" } as never,
+      ctx: { directory: repoRoot } as never,
       truncator: truncator as never,
       sessionCaches: new Map(),
-      filePath: "/repo/src/file.ts",
+      filePath: join(repoRoot, "src", "file.ts"),
       sessionID,
       output: { title: "Result", output: "", metadata: {} },
     })
@@ -80,28 +111,44 @@ describe("processFilePathForReadmeInjection", () => {
     expect(saveInjectedPathsMock).toHaveBeenCalledTimes(1)
     const saveCall = saveInjectedPathsMock.mock.calls[0]
     expect(saveCall[0]).toBe(sessionID)
-    expect((saveCall[1] as Set<string>).has("/repo/src")).toBe(true)
+    expect((saveCall[1] as Set<string>).has(injectedDirectory)).toBe(true)
   })
 
   it("saves once when cached and new paths are mixed", async () => {
     //#given
     const sessionID = "session-3"
-    loadInjectedPathsMock.mockReturnValueOnce(new Set(["/repo/already-cached"]))
-    findReadmeMdUpMock.mockReturnValueOnce([
-      "/repo/already-cached/README.md",
-      "/repo/new-dir/README.md",
-    ])
+    const repoRoot = join(testRoot, "repo")
+    const cachedReadmePath = join(repoRoot, "already-cached", "README.md")
+    const newReadmePath = join(repoRoot, "new-dir", "README.md")
+    mkdirSync(join(repoRoot, "already-cached"), { recursive: true })
+    mkdirSync(join(repoRoot, "new-dir"), { recursive: true })
+    writeFileSync(cachedReadmePath, "# README")
+    writeFileSync(newReadmePath, "# README")
+
+    loadInjectedPathsMock.mockReturnValueOnce(new Set([join(repoRoot, "already-cached")]))
+    findReadmeMdUpMock.mockReturnValueOnce([cachedReadmePath, newReadmePath])
 
     const truncator = {
       truncate: mock(async () => ({ result: "trimmed", truncated: false })),
     }
 
+    mock.module("./finder", () => ({
+      findReadmeMdUp: findReadmeMdUpMock,
+      resolveFilePath: resolveFilePathMock,
+    }))
+    mock.module("./storage", () => ({
+      loadInjectedPaths: loadInjectedPathsMock,
+      saveInjectedPaths: saveInjectedPathsMock,
+    }))
+
+    const { processFilePathForReadmeInjection } = await import("./injector")
+
     //#when
     await processFilePathForReadmeInjection({
-      ctx: { directory: "/repo" } as never,
+      ctx: { directory: repoRoot } as never,
       truncator: truncator as never,
       sessionCaches: new Map(),
-      filePath: "/repo/new-dir/file.ts",
+      filePath: join(repoRoot, "new-dir", "file.ts"),
       sessionID,
       output: { title: "Result", output: "", metadata: {} },
     })
@@ -109,6 +156,6 @@ describe("processFilePathForReadmeInjection", () => {
     //#then
     expect(saveInjectedPathsMock).toHaveBeenCalledTimes(1)
     const saveCall = saveInjectedPathsMock.mock.calls[0]
-    expect((saveCall[1] as Set<string>).has("/repo/new-dir")).toBe(true)
+    expect((saveCall[1] as Set<string>).has(join(repoRoot, "new-dir"))).toBe(true)
   })
 })

src/hooks/prometheus-md-only/index.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, beforeEach, afterEach, mock } from "bun:test"
+import { describe, expect, test, beforeEach, afterEach } from "bun:test"
 import { mkdirSync, rmSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { tmpdir } from "node:os"
@@ -6,18 +6,8 @@ import { randomUUID } from "node:crypto"
 import { SYSTEM_DIRECTIVE_PREFIX } from "../../shared/system-directive"
 import { clearSessionAgent } from "../../features/claude-code-session-state"
 
-const TEST_STORAGE_ROOT = join(tmpdir(), `prometheus-md-only-${randomUUID()}`)
-const TEST_MESSAGE_STORAGE = join(TEST_STORAGE_ROOT, "message")
-const TEST_PART_STORAGE = join(TEST_STORAGE_ROOT, "part")
-
-mock.module("../../features/hook-message-injector/constants", () => ({
-  OPENCODE_STORAGE: TEST_STORAGE_ROOT,
-  MESSAGE_STORAGE: TEST_MESSAGE_STORAGE,
-  PART_STORAGE: TEST_PART_STORAGE,
-}))
-
-const { createPrometheusMdOnlyHook } = await import("./index")
-const { MESSAGE_STORAGE } = await import("../../features/hook-message-injector")
+import { createPrometheusMdOnlyHook } from "./index"
+import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
 
 describe("prometheus-md-only", () => {
   const TEST_SESSION_ID = "test-session-prometheus"
@@ -52,7 +42,6 @@ describe("prometheus-md-only", () => {
         // ignore
       }
     }
-    rmSync(TEST_STORAGE_ROOT, { recursive: true, force: true })
   })
 
   describe("agent name matching", () => {

src/hooks/rules-injector/injector.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+import { afterAll, afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
 import * as fs from "node:fs";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import * as os from "node:os";
@@ -102,6 +102,10 @@ function getInjectedRulesPath(sessionID: string): string {
 }
 
 describe("createRuleInjectionProcessor", () => {
+  afterAll(() => {
+    mock.restore();
+  });
+
   let testRoot: string;
   let projectRoot: string;
   let homeRoot: string;

src/hooks/session-recovery/detect-error-type.test.ts

@@ -0,0 +1,129 @@
+/// <reference types="bun-types" />
+import { describe, expect, it } from "bun:test"
+import { detectErrorType, extractMessageIndex } from "./detect-error-type"
+
+describe("detectErrorType", () => {
+  it("#given a tool_use/tool_result error #when detecting #then returns tool_result_missing", () => {
+    //#given
+    const error = { message: "tool_use block must be followed by tool_result" }
+
+    //#when
+    const result = detectErrorType(error)
+
+    //#then
+    expect(result).toBe("tool_result_missing")
+  })
+
+  it("#given a thinking block order error #when detecting #then returns thinking_block_order", () => {
+    //#given
+    const error = { message: "thinking must be the first block in the response" }
+
+    //#when
+    const result = detectErrorType(error)
+
+    //#then
+    expect(result).toBe("thinking_block_order")
+  })
+
+  it("#given a thinking disabled violation #when detecting #then returns thinking_disabled_violation", () => {
+    //#given
+    const error = { message: "thinking is disabled and cannot contain thinking blocks" }
+
+    //#when
+    const result = detectErrorType(error)
+
+    //#then
+    expect(result).toBe("thinking_disabled_violation")
+  })
+
+  it("#given an unrecognized error #when detecting #then returns null", () => {
+    //#given
+    const error = { message: "some random error" }
+
+    //#when
+    const result = detectErrorType(error)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given a malformed error with circular references #when detecting #then returns null without crashing", () => {
+    //#given
+    const circular: Record<string, unknown> = {}
+    circular.self = circular
+
+    //#when
+    const result = detectErrorType(circular)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given a proxy error with non-standard structure #when detecting #then returns null without crashing", () => {
+    //#given
+    const proxyError = {
+      data: "not-an-object",
+      error: 42,
+      nested: { deeply: { error: true } },
+    }
+
+    //#when
+    const result = detectErrorType(proxyError)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given a null error #when detecting #then returns null", () => {
+    //#given
+    const error = null
+
+    //#when
+    const result = detectErrorType(error)
+
+    //#then
+    expect(result).toBeNull()
+  })
+
+  it("#given an error with data.error containing message #when detecting #then extracts correctly", () => {
+    //#given
+    const error = {
+      data: {
+        error: {
+          message: "tool_use block requires tool_result",
+        },
+      },
+    }
+
+    //#when
+    const result = detectErrorType(error)
+
+    //#then
+    expect(result).toBe("tool_result_missing")
+  })
+})
+
+describe("extractMessageIndex", () => {
+  it("#given an error referencing messages.5 #when extracting #then returns 5", () => {
+    //#given
+    const error = { message: "Invalid value at messages.5: tool_result is required" }
+
+    //#when
+    const result = extractMessageIndex(error)
+
+    //#then
+    expect(result).toBe(5)
+  })
+
+  it("#given a malformed error #when extracting #then returns null without crashing", () => {
+    //#given
+    const circular: Record<string, unknown> = {}
+    circular.self = circular
+
+    //#when
+    const result = extractMessageIndex(circular)
+
+    //#then
+    expect(result).toBeNull()
+  })
+})

src/hooks/session-recovery/detect-error-type.ts

@@ -34,40 +34,48 @@ function getErrorMessage(error: unknown): string {
 }
 
 export function extractMessageIndex(error: unknown): number | null {
-  const message = getErrorMessage(error)
-  const match = message.match(/messages\.(\d+)/)
-  return match ? parseInt(match[1], 10) : null
+  try {
+    const message = getErrorMessage(error)
+    const match = message.match(/messages\.(\d+)/)
+    return match ? parseInt(match[1], 10) : null
+  } catch {
+    return null
+  }
 }
 
 export function detectErrorType(error: unknown): RecoveryErrorType {
-  const message = getErrorMessage(error)
+  try {
+    const message = getErrorMessage(error)
 
-  if (
-    message.includes("assistant message prefill") ||
-    message.includes("conversation must end with a user message")
-  ) {
-    return "assistant_prefill_unsupported"
+    if (
+      message.includes("assistant message prefill") ||
+      message.includes("conversation must end with a user message")
+    ) {
+      return "assistant_prefill_unsupported"
+    }
+
+    if (
+      message.includes("thinking") &&
+      (message.includes("first block") ||
+        message.includes("must start with") ||
+        message.includes("preceeding") ||
+        message.includes("final block") ||
+        message.includes("cannot be thinking") ||
+        (message.includes("expected") && message.includes("found")))
+    ) {
+      return "thinking_block_order"
+    }
+
+    if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
+      return "thinking_disabled_violation"
+    }
+
+    if (message.includes("tool_use") && message.includes("tool_result")) {
+      return "tool_result_missing"
+    }
+
+    return null
+  } catch {
+    return null
   }
-
-  if (
-    message.includes("thinking") &&
-    (message.includes("first block") ||
-      message.includes("must start with") ||
-      message.includes("preceeding") ||
-      message.includes("final block") ||
-      message.includes("cannot be thinking") ||
-      (message.includes("expected") && message.includes("found")))
-  ) {
-    return "thinking_block_order"
-  }
-
-  if (message.includes("thinking is disabled") && message.includes("cannot contain")) {
-    return "thinking_disabled_violation"
-  }
-
-  if (message.includes("tool_use") && message.includes("tool_result")) {
-    return "tool_result_missing"
-  }
-
-  return null
 }

src/hooks/think-mode/hook.ts

@@ -10,6 +10,45 @@ export function clearThinkModeState(sessionID: string): void {
 }
 
 export function createThinkModeHook() {
+  function isDisabledThinkingConfig(config: Record<string, unknown>): boolean {
+    const thinkingConfig = config.thinking
+    if (
+      typeof thinkingConfig === "object" &&
+      thinkingConfig !== null &&
+      "type" in thinkingConfig &&
+      (thinkingConfig as { type?: string }).type === "disabled"
+    ) {
+      return true
+    }
+
+    const providerOptions = config.providerOptions
+    if (typeof providerOptions !== "object" || providerOptions === null) {
+      return false
+    }
+
+    return Object.values(providerOptions as Record<string, unknown>).some(
+      (providerConfig) => {
+        if (typeof providerConfig !== "object" || providerConfig === null) {
+          return false
+        }
+
+        const providerConfigMap = providerConfig as Record<string, unknown>
+        const extraBody = providerConfigMap.extra_body
+        if (typeof extraBody !== "object" || extraBody === null) {
+          return false
+        }
+
+        const extraBodyMap = extraBody as Record<string, unknown>
+        const extraThinking = extraBodyMap.thinking
+        return (
+          typeof extraThinking === "object" &&
+          extraThinking !== null &&
+          (extraThinking as { type?: string }).type === "disabled"
+        )
+      }
+    )
+  }
+
   return {
     "chat.params": async (output: ThinkModeInput, sessionID: string): Promise<void> => {
       const promptText = extractPromptText(output.parts)
@@ -75,7 +114,9 @@ export function createThinkModeHook() {
             sessionID,
             provider: currentModel.providerID,
           })
-        } else {
+        } else if (
+          !isDisabledThinkingConfig(thinkingConfig as Record<string, unknown>)
+        ) {
           Object.assign(output.message, thinkingConfig)
           state.thinkingConfigInjected = true
           log("Think mode: thinking config injected", {
@@ -83,6 +124,11 @@ export function createThinkModeHook() {
             provider: currentModel.providerID,
             config: thinkingConfig,
           })
+        } else {
+          log("Think mode: skipping disabled thinking config", {
+            sessionID,
+            provider: currentModel.providerID,
+          })
         }
       }
 

src/hooks/think-mode/index.test.ts

@@ -352,6 +352,25 @@ describe("createThinkModeHook integration", () => {
   })
 
   describe("Agent-level thinking configuration respect", () => {
+    it("should omit Z.ai GLM disabled thinking config", async () => {
+      //#given a Z.ai GLM model with think prompt
+      const hook = createThinkModeHook()
+      const input = createMockInput(
+        "zai-coding-plan",
+        "glm-4.7",
+        "ultrathink mode"
+      )
+
+      //#when think mode resolves Z.ai thinking configuration
+      await hook["chat.params"](input, sessionID)
+
+      //#then thinking config should be omitted from request
+      const message = input.message as MessageWithInjectedProps
+      expect(input.message.model?.modelID).toBe("glm-4.7")
+      expect(message.thinking).toBeUndefined()
+      expect(message.providerOptions).toBeUndefined()
+    })
+
     it("should NOT inject thinking config when agent has thinking disabled", async () => {
       // given agent with thinking explicitly disabled
       const hook = createThinkModeHook()

src/hooks/think-mode/switcher.test.ts

@@ -470,10 +470,12 @@ describe("think-mode switcher", () => {
   describe("Z.AI GLM-4.7 provider support", () => {
     describe("getThinkingConfig for zai-coding-plan", () => {
       it("should return thinking config for glm-4.7", () => {
-        // given zai-coding-plan provider with glm-4.7 model
+        //#given a Z.ai GLM model
         const config = getThinkingConfig("zai-coding-plan", "glm-4.7")
 
-        // then should return zai-coding-plan thinking config
+        //#when thinking config is resolved
+
+        //#then thinking type is "disabled"
         expect(config).not.toBeNull()
         expect(config?.providerOptions).toBeDefined()
         const zaiOptions = (config?.providerOptions as Record<string, unknown>)?.[
@@ -482,8 +484,7 @@ describe("think-mode switcher", () => {
         expect(zaiOptions?.extra_body).toBeDefined()
         const extraBody = zaiOptions?.extra_body as Record<string, unknown>
         expect(extraBody?.thinking).toBeDefined()
-        expect((extraBody?.thinking as Record<string, unknown>)?.type).toBe("enabled")
-        expect((extraBody?.thinking as Record<string, unknown>)?.clear_thinking).toBe(false)
+        expect((extraBody?.thinking as Record<string, unknown>)?.type).toBe("disabled")
       })
 
       it("should return thinking config for glm-4.6v (multimodal)", () => {
@@ -505,7 +506,7 @@ describe("think-mode switcher", () => {
     })
 
     describe("HIGH_VARIANT_MAP for GLM", () => {
-      it("should NOT have high variant for glm-4.7 (thinking enabled by default)", () => {
+      it("should NOT have high variant for glm-4.7", () => {
         // given glm-4.7 model
         const variant = getHighVariant("glm-4.7")
 

src/hooks/think-mode/switcher.ts

@@ -154,8 +154,7 @@ export const THINKING_CONFIGS = {
       "zai-coding-plan": {
         extra_body: {
           thinking: {
-            type: "enabled",
-            clear_thinking: false,
+            type: "disabled",
           },
         },
       },

src/hooks/todo-continuation-enforcer/todo-continuation-enforcer.test.ts

@@ -1,3 +1,4 @@
+/// <reference types="bun-types" />
 import { afterEach, beforeEach, describe, expect, test } from "bun:test"
 
 import type { BackgroundManager } from "../../features/background-agent"
@@ -9,10 +10,13 @@ type TimerCallback = (...args: any[]) => void
 
 interface FakeTimers {
   advanceBy: (ms: number, advanceClock?: boolean) => Promise<void>
+  advanceClockBy: (ms: number) => Promise<void>
   restore: () => void
 }
 
 function createFakeTimers(): FakeTimers {
+  const FAKE_MIN_DELAY_MS = 500
+  const REAL_MAX_DELAY_MS = 5000
   const originalNow = Date.now()
   let clockNow = originalNow
   let timerNow = 0
@@ -52,20 +56,41 @@ function createFakeTimers(): FakeTimers {
   }
 
   globalThis.setTimeout = ((callback: TimerCallback, delay?: number, ...args: any[]) => {
-    return schedule(callback, delay, null, args) as unknown as ReturnType<typeof setTimeout>
+    const normalized = normalizeDelay(delay)
+    if (normalized < FAKE_MIN_DELAY_MS) {
+      return original.setTimeout(callback, delay, ...args)
+    }
+    if (normalized >= REAL_MAX_DELAY_MS) {
+      return original.setTimeout(callback, delay, ...args)
+    }
+    return schedule(callback, normalized, null, args) as unknown as ReturnType<typeof setTimeout>
   }) as typeof setTimeout
 
   globalThis.setInterval = ((callback: TimerCallback, delay?: number, ...args: any[]) => {
     const interval = normalizeDelay(delay)
-    return schedule(callback, delay, interval, args) as unknown as ReturnType<typeof setInterval>
+    if (interval < FAKE_MIN_DELAY_MS) {
+      return original.setInterval(callback, delay, ...args)
+    }
+    if (interval >= REAL_MAX_DELAY_MS) {
+      return original.setInterval(callback, delay, ...args)
+    }
+    return schedule(callback, interval, interval, args) as unknown as ReturnType<typeof setInterval>
   }) as typeof setInterval
 
-  globalThis.clearTimeout = ((id?: number) => {
-    clear(id)
+  globalThis.clearTimeout = ((id?: Parameters<typeof clearTimeout>[0]) => {
+    if (typeof id === "number" && timers.has(id)) {
+      clear(id)
+      return
+    }
+    original.clearTimeout(id)
   }) as typeof clearTimeout
 
-  globalThis.clearInterval = ((id?: number) => {
-    clear(id)
+  globalThis.clearInterval = ((id?: Parameters<typeof clearInterval>[0]) => {
+    if (typeof id === "number" && timers.has(id)) {
+      clear(id)
+      return
+    }
+    original.clearInterval(id)
   }) as typeof clearInterval
 
   Date.now = () => clockNow
@@ -107,6 +132,12 @@ function createFakeTimers(): FakeTimers {
     await Promise.resolve()
   }
 
+  const advanceClockBy = async (ms: number) => {
+    const clamped = Math.max(0, ms)
+    clockNow += clamped
+    await Promise.resolve()
+  }
+
   const restore = () => {
     globalThis.setTimeout = original.setTimeout
     globalThis.clearTimeout = original.clearTimeout
@@ -115,7 +146,7 @@ function createFakeTimers(): FakeTimers {
     Date.now = original.dateNow
   }
 
-  return { advanceBy, restore }
+  return { advanceBy, advanceClockBy, restore }
 }
 
 const wait = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
@@ -510,7 +541,7 @@ describe("todo-continuation-enforcer", () => {
       event: { type: "session.idle", properties: { sessionID } },
     })
     await fakeTimers.advanceBy(2500, true)
-    await fakeTimers.advanceBy(CONTINUATION_COOLDOWN_MS, true)
+    await fakeTimers.advanceClockBy(CONTINUATION_COOLDOWN_MS)
     await hook.handler({
       event: { type: "session.idle", properties: { sessionID } },
     })
@@ -518,7 +549,7 @@ describe("todo-continuation-enforcer", () => {
 
     //#then
     expect(promptCalls).toHaveLength(2)
-  })
+  }, { timeout: 15000 })
 
   test("should keep injecting even when todos remain unchanged across cycles", async () => {
     //#given
@@ -534,26 +565,26 @@ describe("todo-continuation-enforcer", () => {
     //#when — 5 consecutive idle cycles with unchanged todos
     await hook.handler({ event: { type: "session.idle", properties: { sessionID } } })
     await fakeTimers.advanceBy(2500, true)
-    await fakeTimers.advanceBy(CONTINUATION_COOLDOWN_MS, true)
+    await fakeTimers.advanceClockBy(CONTINUATION_COOLDOWN_MS)
 
     await hook.handler({ event: { type: "session.idle", properties: { sessionID } } })
     await fakeTimers.advanceBy(2500, true)
-    await fakeTimers.advanceBy(CONTINUATION_COOLDOWN_MS, true)
+    await fakeTimers.advanceClockBy(CONTINUATION_COOLDOWN_MS)
 
     await hook.handler({ event: { type: "session.idle", properties: { sessionID } } })
     await fakeTimers.advanceBy(2500, true)
-    await fakeTimers.advanceBy(CONTINUATION_COOLDOWN_MS, true)
+    await fakeTimers.advanceClockBy(CONTINUATION_COOLDOWN_MS)
 
     await hook.handler({ event: { type: "session.idle", properties: { sessionID } } })
     await fakeTimers.advanceBy(2500, true)
-    await fakeTimers.advanceBy(CONTINUATION_COOLDOWN_MS, true)
+    await fakeTimers.advanceClockBy(CONTINUATION_COOLDOWN_MS)
 
     await hook.handler({ event: { type: "session.idle", properties: { sessionID } } })
     await fakeTimers.advanceBy(2500, true)
 
     //#then — all 5 injections should fire (no stagnation cap)
     expect(promptCalls).toHaveLength(5)
-  })
+  }, { timeout: 60000 })
 
   test("should skip idle handling while injection is in flight", async () => {
     //#given
@@ -613,7 +644,7 @@ describe("todo-continuation-enforcer", () => {
 
     //#then
     expect(promptCalls).toHaveLength(2)
-  })
+  }, { timeout: 15000 })
 
   test("should accept skipAgents option without error", async () => {
     // given - session with skipAgents configured for Prometheus

src/plugin/skill-context.ts

@@ -12,6 +12,8 @@ import {
   discoverProjectClaudeSkills,
   discoverOpencodeGlobalSkills,
   discoverOpencodeProjectSkills,
+  discoverProjectAgentsSkills,
+  discoverGlobalAgentsSkills,
   mergeSkills,
 } from "../features/opencode-skill-loader"
 import { createBuiltinSkills } from "../features/builtin-skills"
@@ -55,7 +57,7 @@ export async function createSkillContext(args: {
   })
 
   const includeClaudeSkills = pluginConfig.claude_code?.skills !== false
-  const [configSourceSkills, userSkills, globalSkills, projectSkills, opencodeProjectSkills] =
+  const [configSourceSkills, userSkills, globalSkills, projectSkills, opencodeProjectSkills, agentsProjectSkills, agentsGlobalSkills] =
     await Promise.all([
       discoverConfigSourceSkills({
         config: pluginConfig.skills,
@@ -65,15 +67,17 @@ export async function createSkillContext(args: {
       discoverOpencodeGlobalSkills(),
       includeClaudeSkills ? discoverProjectClaudeSkills(directory) : Promise.resolve([]),
       discoverOpencodeProjectSkills(directory),
+      discoverProjectAgentsSkills(directory),
+      discoverGlobalAgentsSkills(),
     ])
 
   const mergedSkills = mergeSkills(
     builtinSkills,
     pluginConfig.skills,
     configSourceSkills,
-    userSkills,
+    [...userSkills, ...agentsGlobalSkills],
     globalSkills,
-    projectSkills,
+    [...projectSkills, ...agentsProjectSkills],
     opencodeProjectSkills,
     { configDir: directory },
   )

src/shared/file-utils.ts

@@ -1,6 +1,10 @@
 import { lstatSync, realpathSync } from "fs"
 import { promises as fs } from "fs"
 
+function normalizeDarwinRealpath(filePath: string): string {
+  return filePath.startsWith("/private/var/") ? filePath.slice("/private".length) : filePath
+}
+
 export function isMarkdownFile(entry: { name: string; isFile: () => boolean }): boolean {
   return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile()
 }
@@ -15,7 +19,7 @@ export function isSymbolicLink(filePath: string): boolean {
 
 export function resolveSymlink(filePath: string): string {
   try {
-    return realpathSync(filePath)
+    return normalizeDarwinRealpath(realpathSync(filePath))
   } catch {
     return filePath
   }
@@ -23,7 +27,7 @@ export function resolveSymlink(filePath: string): string {
 
 export async function resolveSymlinkAsync(filePath: string): Promise<string> {
   try {
-    return await fs.realpath(filePath)
+    return normalizeDarwinRealpath(await fs.realpath(filePath))
   } catch {
     return filePath
   }

src/tools/call-omo-agent/sync-executor.test.ts

@@ -1,22 +1,16 @@
 const { describe, test, expect, mock } = require("bun:test")
 
-mock.module("./session-creator", () => ({
-  createOrGetSession: mock(async () => ({ sessionID: "ses-test-123" })),
-}))
-
-mock.module("./completion-poller", () => ({
-  waitForCompletion: mock(async () => {}),
-}))
-
-mock.module("./message-processor", () => ({
-  processMessages: mock(async () => "agent response"),
-}))
-
 describe("executeSync", () => {
   test("passes question=false via tools parameter to block question tool", async () => {
     //#given
     const { executeSync } = require("./sync-executor")
 
+    const deps = {
+      createOrGetSession: mock(async () => ({ sessionID: "ses-test-123", isNew: true })),
+      waitForCompletion: mock(async () => {}),
+      processMessages: mock(async () => "agent response"),
+    }
+
     let promptArgs: any
     const promptAsync = mock(async (input: any) => {
       promptArgs = input
@@ -44,7 +38,7 @@ describe("executeSync", () => {
     }
 
     //#when
-    await executeSync(args, toolContext, ctx as any)
+    await executeSync(args, toolContext, ctx as any, deps)
 
     //#then
     expect(promptAsync).toHaveBeenCalled()
@@ -55,6 +49,12 @@ describe("executeSync", () => {
     //#given
     const { executeSync } = require("./sync-executor")
 
+    const deps = {
+      createOrGetSession: mock(async () => ({ sessionID: "ses-test-123", isNew: true })),
+      waitForCompletion: mock(async () => {}),
+      processMessages: mock(async () => "agent response"),
+    }
+
     let promptArgs: any
     const promptAsync = mock(async (input: any) => {
       promptArgs = input
@@ -82,7 +82,7 @@ describe("executeSync", () => {
     }
 
     //#when
-    await executeSync(args, toolContext, ctx as any)
+    await executeSync(args, toolContext, ctx as any, deps)
 
     //#then
     expect(promptAsync).toHaveBeenCalled()

src/tools/call-omo-agent/sync-executor.ts

@@ -6,6 +6,18 @@ import { createOrGetSession } from "./session-creator"
 import { waitForCompletion } from "./completion-poller"
 import { processMessages } from "./message-processor"
 
+type ExecuteSyncDeps = {
+  createOrGetSession: typeof createOrGetSession
+  waitForCompletion: typeof waitForCompletion
+  processMessages: typeof processMessages
+}
+
+const defaultDeps: ExecuteSyncDeps = {
+  createOrGetSession,
+  waitForCompletion,
+  processMessages,
+}
+
 export async function executeSync(
   args: CallOmoAgentArgs,
   toolContext: {
@@ -15,9 +27,10 @@ export async function executeSync(
     abort: AbortSignal
     metadata?: (input: { title?: string; metadata?: Record<string, unknown> }) => void
   },
-  ctx: PluginInput
+  ctx: PluginInput,
+  deps: ExecuteSyncDeps = defaultDeps
 ): Promise<string> {
-  const { sessionID } = await createOrGetSession(args, toolContext, ctx)
+  const { sessionID } = await deps.createOrGetSession(args, toolContext, ctx)
 
   await toolContext.metadata?.({
     title: args.description,
@@ -49,9 +62,9 @@ export async function executeSync(
     return `Error: Failed to send prompt: ${errorMessage}\n\n<task_metadata>\nsession_id: ${sessionID}\n</task_metadata>`
   }
 
-  await waitForCompletion(sessionID, toolContext, ctx)
+  await deps.waitForCompletion(sessionID, toolContext, ctx)
 
-  const responseText = await processMessages(sessionID, ctx)
+  const responseText = await deps.processMessages(sessionID, ctx)
 
   const output =
     responseText + "\n\n" + ["<task_metadata>", `session_id: ${sessionID}`, "</task_metadata>"].join("\n")

src/tools/delegate-task/tools.test.ts

@@ -3,10 +3,12 @@ const { describe, test, expect, beforeEach, afterEach, spyOn, mock } = require("
 import { DEFAULT_CATEGORIES, CATEGORY_PROMPT_APPENDS, CATEGORY_DESCRIPTIONS, isPlanAgent, PLAN_AGENT_NAMES, isPlanFamily, PLAN_FAMILY_NAMES } from "./constants"
 import { resolveCategoryConfig } from "./tools"
 import type { CategoryConfig } from "../../config/schema"
+import type { DelegateTaskArgs } from "./types"
 import { __resetModelCache } from "../../shared/model-availability"
 import { clearSkillCache } from "../../features/opencode-skill-loader/skill-content"
 import { __setTimingConfig, __resetTimingConfig } from "./timing"
 import * as connectedProvidersCache from "../../shared/connected-providers-cache"
+import * as executor from "./executor"
 
 const SYSTEM_DEFAULT_MODEL = "anthropic/claude-sonnet-4-5"
 
@@ -21,6 +23,10 @@ const TEST_AVAILABLE_MODELS = new Set([
   "openai/gpt-5.3-codex",
 ])
 
+type DelegateTaskArgsWithSerializedSkills = Omit<DelegateTaskArgs, "load_skills"> & {
+  load_skills: string
+}
+
 function createTestAvailableModels(): Set<string> {
   return new Set(TEST_AVAILABLE_MODELS)
 }
@@ -256,6 +262,134 @@ describe("sisyphus-task", () => {
     })
   })
 
+  describe("load_skills parsing", () => {
+    test("parses valid JSON string into array before validation", async () => {
+      //#given
+      const { createDelegateTask } = require("./tools")
+
+      const mockManager = {
+        launch: async () => ({
+          id: "task-123",
+          status: "pending",
+          description: "Parse test",
+          agent: "sisyphus-junior",
+          sessionID: "test-session",
+        }),
+      }
+
+      const mockClient = {
+        app: { agents: async () => ({ data: [] }) },
+        config: { get: async () => ({}) },
+        provider: { list: async () => ({ data: { connected: ["openai"] } }) },
+        model: { list: async () => ({ data: [{ provider: "openai", id: "gpt-5.3-codex" }] }) },
+        session: {
+          create: async () => ({ data: { id: "test-session" } }),
+          prompt: async () => ({ data: {} }),
+          promptAsync: async () => ({ data: {} }),
+          messages: async () => ({ data: [] }),
+          status: async () => ({ data: {} }),
+        },
+      }
+
+      const tool = createDelegateTask({
+        manager: mockManager,
+        client: mockClient,
+        connectedProvidersOverride: TEST_CONNECTED_PROVIDERS,
+        availableModelsOverride: createTestAvailableModels(),
+      })
+
+      const toolContext = {
+        sessionID: "parent-session",
+        messageID: "parent-message",
+        agent: "sisyphus",
+        abort: new AbortController().signal,
+      }
+
+      const resolveSkillContentSpy = spyOn(executor, "resolveSkillContent").mockResolvedValue({
+        content: "resolved skill content",
+        error: null,
+      })
+
+      const args: DelegateTaskArgsWithSerializedSkills = {
+        description: "Parse valid string",
+        prompt: "Load skill parsing test",
+        category: "quick",
+        run_in_background: true,
+        load_skills: '["playwright", "git-master"]',
+      }
+
+      //#when
+      await tool.execute(args as unknown as DelegateTaskArgs, toolContext)
+
+      //#then
+      expect(args.load_skills).toEqual(["playwright", "git-master"])
+      expect(resolveSkillContentSpy).toHaveBeenCalledWith(["playwright", "git-master"], expect.any(Object))
+    }, { timeout: 10000 })
+
+    test("defaults to [] when load_skills is malformed JSON", async () => {
+      //#given
+      const { createDelegateTask } = require("./tools")
+
+      const mockManager = {
+        launch: async () => ({
+          id: "task-456",
+          status: "pending",
+          description: "Parse test",
+          agent: "sisyphus-junior",
+          sessionID: "test-session",
+        }),
+      }
+
+      const mockClient = {
+        app: { agents: async () => ({ data: [] }) },
+        config: { get: async () => ({}) },
+        provider: { list: async () => ({ data: { connected: ["openai"] } }) },
+        model: { list: async () => ({ data: [{ provider: "openai", id: "gpt-5.3-codex" }] }) },
+        session: {
+          create: async () => ({ data: { id: "test-session" } }),
+          prompt: async () => ({ data: {} }),
+          promptAsync: async () => ({ data: {} }),
+          messages: async () => ({ data: [] }),
+          status: async () => ({ data: {} }),
+        },
+      }
+
+      const tool = createDelegateTask({
+        manager: mockManager,
+        client: mockClient,
+        connectedProvidersOverride: TEST_CONNECTED_PROVIDERS,
+        availableModelsOverride: createTestAvailableModels(),
+      })
+
+      const toolContext = {
+        sessionID: "parent-session",
+        messageID: "parent-message",
+        agent: "sisyphus",
+        abort: new AbortController().signal,
+      }
+
+      const resolveSkillContentSpy = spyOn(executor, "resolveSkillContent").mockResolvedValue({
+        content: "resolved skill content",
+        error: null,
+      })
+
+      const args: DelegateTaskArgsWithSerializedSkills = {
+        description: "Parse malformed string",
+        prompt: "Load skill parsing test",
+        category: "quick",
+        run_in_background: true,
+        load_skills: '["playwright", "git-master"',
+      }
+
+      //#when
+      await tool.execute(args as unknown as DelegateTaskArgs, toolContext)
+
+      //#then
+      expect(args.load_skills).toEqual([])
+      expect(resolveSkillContentSpy).toHaveBeenCalledWith([], expect.any(Object))
+    }, { timeout: 10000 })
+  })
+
   describe("category delegation config validation", () => {
     test("fills subagent_type as sisyphus-junior when category is provided without subagent_type", async () => {
       // given

src/tools/delegate-task/tools.ts

@@ -103,6 +103,14 @@ Prompts MUST be in English.`
       if (args.run_in_background === undefined) {
         throw new Error(`Invalid arguments: 'run_in_background' parameter is REQUIRED. Use run_in_background=false for task delegation, run_in_background=true only for parallel exploration.`)
       }
+      if (typeof args.load_skills === "string") {
+        try {
+          const parsed = JSON.parse(args.load_skills)
+          args.load_skills = Array.isArray(parsed) ? parsed : []
+        } catch {
+          args.load_skills = []
+        }
+      }
       if (args.load_skills === undefined) {
         throw new Error(`Invalid arguments: 'load_skills' parameter is REQUIRED. Pass [] if no skills needed, but IT IS HIGHLY RECOMMENDED to pass proper skills like ["playwright"], ["git-master"] for best results.`)
       }

src/tools/lsp/lsp-process.test.ts

@@ -0,0 +1,37 @@
+import { mkdtempSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+import { describe, expect, it, spyOn } from "bun:test"
+
+describe("spawnProcess", () => {
+  it("proceeds to node spawn on Windows when command is available", async () => {
+    //#given
+    const originalPlatform = process.platform
+    const rootDir = mkdtempSync(join(tmpdir(), "lsp-process-test-"))
+    const childProcess = await import("node:child_process")
+    const nodeSpawnSpy = spyOn(childProcess, "spawn")
+
+    try {
+      Object.defineProperty(process, "platform", { value: "win32" })
+      const { spawnProcess } = await import("./lsp-process")
+
+      //#when
+      let result: ReturnType<typeof spawnProcess> | null = null
+      expect(() => {
+        result = spawnProcess(["node", "--version"], {
+          cwd: rootDir,
+          env: process.env,
+        })
+      }).not.toThrow(/Binary 'node' not found/)
+
+      //#then
+      expect(nodeSpawnSpy).toHaveBeenCalled()
+      expect(result).not.toBeNull()
+    } finally {
+      Object.defineProperty(process, "platform", { value: originalPlatform })
+      nodeSpawnSpy.mockRestore()
+      rmSync(rootDir, { recursive: true, force: true })
+    }
+  })
+})

src/tools/lsp/lsp-process.ts

@@ -1,5 +1,5 @@
 import { spawn as bunSpawn } from "bun"
-import { spawn as nodeSpawn, spawnSync, type ChildProcess } from "node:child_process"
+import { spawn as nodeSpawn, type ChildProcess } from "node:child_process"
 import { existsSync, statSync } from "fs"
 import { log } from "../../shared/logger"
 // Bun spawn segfaults on Windows (oven-sh/bun#25798) — unfixed as of v1.3.8+
@@ -21,24 +21,6 @@ export function validateCwd(cwd: string): { valid: boolean; error?: string } {
     return { valid: false, error: `Cannot access working directory: ${cwd} (${err instanceof Error ? err.message : String(err)})` }
   }
 }
-function isBinaryAvailableOnWindows(command: string): boolean {
-  if (process.platform !== "win32") return true
-
-  if (command.includes("/") || command.includes("\\")) {
-    return existsSync(command)
-  }
-
-  try {
-    const result = spawnSync("where", [command], {
-      shell: true,
-      windowsHide: true,
-      timeout: 5000,
-    })
-    return result.status === 0
-  } catch {
-    return true
-  }
-}
 interface StreamReader {
   read(): Promise<{ done: boolean; value: Uint8Array | undefined }>
 }
@@ -158,13 +140,6 @@ export function spawnProcess(
   }
   if (shouldUseNodeSpawn()) {
     const [cmd, ...args] = command
-    if (!isBinaryAvailableOnWindows(cmd)) {
-      throw new Error(
-        `[LSP] Binary '${cmd}' not found on Windows. ` +
-          `Ensure the LSP server is installed and available in PATH. ` +
-          `For npm packages, try: npm install -g ${cmd}`
-      )
-    }
     log("[LSP] Using Node.js child_process on Windows to avoid Bun spawn segfault")
     const proc = nodeSpawn(cmd, args, {
       cwd: options.cwd,

src/tools/skill/tools.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, mock, spyOn } from "bun:test"
+import { afterAll, beforeEach, describe, expect, it, mock, spyOn } from "bun:test"
 import type { ToolContext } from "@opencode-ai/plugin/tool"
 import * as fs from "node:fs"
 import { createSkillTool } from "./tools"
@@ -21,6 +21,10 @@ Test skill body content`
   },
 }))
 
+afterAll(() => {
+  mock.restore()
+})
+
 function createMockSkill(name: string, options: { agent?: string } = {}): LoadedSkill {
   return {
     name,