opencode-matrixx 2.1.0 → 2.2.0

package/dist/index.js

@@ -4531,7 +4531,7 @@ var require_picomatch2 = __commonJS((exports, module) => {
 });
 
 // src/hooks/matrix-loop/constants.ts
-var HOOK_NAME4 = "matrix-loop", DEFAULT_STATE_FILE = ".matrixx/matrix-loop.local.md", DEFAULT_MAX_ITERATIONS = 100, DEFAULT_COMPLETION_PROMISE = "DONE", DEFAULT_VERIFICATION_AGENT = "merovingian", DEFAULT_VERIFICATION_TIMEOUT_MS = 30000, DEFAULT_VERIFICATION_MAX_RETRIES = 2;
+var HOOK_NAME5 = "matrix-loop", DEFAULT_STATE_FILE = ".matrixx/matrix-loop.local.md", DEFAULT_MAX_ITERATIONS = 100, DEFAULT_COMPLETION_PROMISE = "DONE", DEFAULT_VERIFICATION_AGENT = "merovingian", DEFAULT_VERIFICATION_TIMEOUT_MS = 30000, DEFAULT_VERIFICATION_MAX_RETRIES = 2;
 
 // src/hooks/matrix-loop/storage.ts
 var exports_storage = {};
@@ -18968,6 +18968,7 @@ function getCurrentPaneId() {
 var {spawn: spawn4 } = globalThis.Bun;
 
 // src/tools/interactive-bash/tmux-path-resolver.ts
+init_logger();
 var {spawn: spawn3 } = globalThis.Bun;
 var tmuxPath = null;
 var initPromise = null;
@@ -19022,7 +19023,9 @@ function getCachedTmuxPath() {
 function startBackgroundCheck() {
   if (!initPromise) {
     initPromise = getTmuxPath();
-    initPromise.catch(() => {});
+    initPromise.catch((err) => {
+      log("[interactive-bash] Background tmux path resolution failed:", err);
+    });
   }
 }
 
@@ -19252,6 +19255,13 @@ async function spawnTmuxPane(sessionId, description, config, serverUrl, targetPa
   }
   return { success: true, paneId };
 }
+// src/shared/tool-guards.ts
+function isReadTool(toolName) {
+  return toolName.toLowerCase() === "read";
+}
+function isWriteTool(toolName) {
+  return toolName.toLowerCase() === "write";
+}
 // src/shared/transcript-path.ts
 import { join as join15 } from "path";
 var TRANSCRIPT_DIR = join15(getClaudeConfigDir(), "transcripts");
@@ -19406,6 +19416,9 @@ function createAgentUsageReminderHook(_ctx) {
     event: eventHandler
   };
 }
+// src/hooks/anthropic-context-window-limit-recovery/executor.ts
+init_logger();
+
 // src/hooks/anthropic-context-window-limit-recovery/aggressive-truncation-strategy.ts
 init_logger();
 
@@ -20270,7 +20283,9 @@ async function runAggressiveTruncationStrategy(params) {
       variant: aggressiveResult.sufficient ? "success" : "warning",
       duration: 4000
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[auto-compact] Toast failed:", err);
+  });
   log("[auto-compact] aggressive truncation completed", aggressiveResult);
   if (aggressiveResult.sufficient) {
     clearSessionState(params.autoCompactState, params.sessionID);
@@ -20284,7 +20299,9 @@ async function runAggressiveTruncationStrategy(params) {
           },
           query: { directory: params.directory }
         });
-      } catch {}
+      } catch (err) {
+        log("[auto-compact] Failed to send continue prompt:", err);
+      }
     }, 500);
     return { handled: true, nextTruncateAttempt };
   }
@@ -20295,6 +20312,12 @@ async function runAggressiveTruncationStrategy(params) {
   });
   return { handled: false, nextTruncateAttempt };
 }
+// src/hooks/anthropic-context-window-limit-recovery/summarize-retry-strategy.ts
+init_logger();
+
+// src/hooks/anthropic-context-window-limit-recovery/empty-content-recovery.ts
+init_logger();
+
 // src/hooks/anthropic-context-window-limit-recovery/empty-content-recovery-sdk.ts
 var IGNORE_TYPES2 = new Set(["thinking", "redacted_thinking", "meta"]);
 var TOOL_TYPES2 = new Set(["tool", "tool_use", "tool_result"]);
@@ -20441,7 +20464,9 @@ async function fixEmptyMessages(params) {
           variant: "error",
           duration: 5000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[auto-compact] Toast failed:", err);
+      });
       return false;
     }
     if (result.fixed) {
@@ -20452,7 +20477,9 @@ async function fixEmptyMessages(params) {
           variant: "warning",
           duration: 3000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[auto-compact] Toast failed:", err);
+      });
     }
     return result.fixed;
   }
@@ -20482,7 +20509,9 @@ async function fixEmptyMessages(params) {
           variant: "error",
           duration: 5000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[auto-compact] Toast failed:", err);
+      });
       return false;
     }
     for (const messageID of emptyMessageIds) {
@@ -20507,7 +20536,9 @@ async function fixEmptyMessages(params) {
         variant: "warning",
         duration: 3000
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[auto-compact] Toast failed:", err);
+    });
   }
   return fixed;
 }
@@ -20538,7 +20569,9 @@ async function runSummarizeRetryStrategy(params) {
           variant: "error",
           duration: 1e4
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[auto-compact] Toast failed:", err);
+      });
       return;
     }
   }
@@ -20561,7 +20594,9 @@ async function runSummarizeRetryStrategy(params) {
             variant: "warning",
             duration: 3000
           }
-        }).catch(() => {});
+        }).catch((err) => {
+          log("[auto-compact] Toast failed:", err);
+        });
         const summarizeBody = { providerID, modelID, auto: true };
         await params.client.session.summarize({
           path: { id: params.sessionID },
@@ -20585,7 +20620,9 @@ async function runSummarizeRetryStrategy(params) {
           variant: "warning",
           duration: 3000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[auto-compact] Toast failed:", err);
+      });
     }
   }
   clearSessionState(params.autoCompactState, params.sessionID);
@@ -20596,7 +20633,9 @@ async function runSummarizeRetryStrategy(params) {
       variant: "error",
       duration: 5000
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[auto-compact] Toast failed:", err);
+  });
 }
 // src/hooks/anthropic-context-window-limit-recovery/executor.ts
 async function executeCompact(sessionID, msg, autoCompactState, client, directory, experimental) {
@@ -20608,7 +20647,9 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
         variant: "warning",
         duration: 5000
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[auto-compact] Toast failed:", err);
+    });
     return;
   }
   autoCompactState.compactionInProgress.add(sessionID);
@@ -20884,7 +20925,9 @@ function createAnthropicContextWindowLimitRecoveryHook(ctx, options) {
             variant: "warning",
             duration: 3000
           }
-        }).catch(() => {});
+        }).catch((err) => {
+          log("[auto-compact] Toast failed:", err);
+        });
         const timeoutID = setTimeout(() => {
           pendingCompactionTimeoutBySession.delete(sessionID);
           executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory, experimental);
@@ -20935,7 +20978,9 @@ function createAnthropicContextWindowLimitRecoveryHook(ctx, options) {
           variant: "warning",
           duration: 3000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[auto-compact] Toast failed:", err);
+      });
       await executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory, experimental);
     }
   };
@@ -21884,6 +21929,22 @@ function findSlashCommandPartIndex(parts) {
 import { existsSync as existsSync22, readdirSync as readdirSync10, readFileSync as readFileSync17 } from "fs";
 import { basename as basename3, dirname as dirname4, join as join31 } from "path";
 
+// src/features/builtin-commands/templates/assembly.ts
+var ASSEMBLY_TEMPLATE = `Toggle assembly tool availability for the current session.
+
+This command will:
+1. Enable the assembly tool \u2014 makes multi-model voting available to the LLM
+2. Disable the assembly tool \u2014 hides it from the LLM for this session
+3. Show current assembly tool status
+
+Usage:
+  /assembly enable \u2014 Show assembly tool
+  /assembly disable \u2014 Hide assembly tool
+  /assembly status \u2014 Show current state
+
+The change is per-session and clears when the session ends.
+By default, the assembly tool is enabled and available in every session.`;
+
 // src/features/builtin-commands/templates/end-ultrawork.ts
 var END_ULTRAWORK_TEMPLATE = `Deactivate ultrawork mode for the current session.
 
@@ -23452,6 +23513,51 @@ $ARGUMENTS
 </user-request>
 `;
 
+// src/features/builtin-commands/templates/research.ts
+var RESEARCH_TEMPLATE = `# /research \u2014 Saturation Research Command
+
+Execute a systematic multi-round research process on the given topic.
+
+## Usage
+
+\`\`\`
+/research <topic>                          \u2192 Full research (all directions)
+/research <topic> --scope=code            \u2192 Local codebase only
+/research <topic> --scope=docs            \u2192 Documentation only
+/research <topic> --scope=web             \u2192 Web search only
+/research <topic> --scope=oss             \u2192 OSS repos only
+/research <topic> --max-rounds=3          \u2192 Limit to 3 rounds
+\`\`\`
+
+## What Happens
+
+1. Creates artifact directory: \`.matrixx/research-<topic>-<timestamp>/\`
+2. Spawns 4 parallel research agents (explore + operator swarms)
+3. Collects findings, identifies new leads
+4. Recursively follows leads until convergence (novelty-based stop, max 5 rounds)
+5. Verifies contested claims by running code
+6. Produces cited synthesis in \`final-synthesis.md\`
+
+## Output
+
+All artifacts written to \`.matrixx/research-<topic>-<timestamp>/\`:
+- \`round-N-findings.md\` \u2014 per-round findings
+- \`leads.md\` \u2014 tracked leads
+- \`contested-claims.md\` \u2014 claims needing verification
+- \`final-synthesis.md\` \u2014 the final cited synthesis
+
+## Examples
+
+\`\`\`
+/research how does context window management work in this codebase
+/research React 19 server component patterns --scope=web --max-rounds=3
+/research authentication middleware best practices --scope=all
+\`\`\`
+
+---
+
+Execute the full research protocol using the ulw-research skill.`;
+
 // src/features/builtin-commands/templates/start-work.ts
 var START_WORK_TEMPLATE = `You are starting a Morpheus work session.
 
@@ -23541,6 +23647,22 @@ After running this command:
 
 Use this when you need to pause automated continuation and take manual control.`;
 
+// src/features/builtin-commands/templates/ultrawork.ts
+var ULTRAWORK_TEMPLATE = `Toggle ultrawork mode for the current session.
+
+This command will:
+1. Enable ultrawork mode \u2014 injects ultrawork mode instructions into every message
+2. Disable ultrawork mode \u2014 prevents ultrawork mode from activating (even on "ultrawork" keyword)
+3. Show current ultrawork mode status
+
+Usage:
+  /ultrawork enable \u2014 Force ultrawork mode on all messages
+  /ultrawork disable \u2014 Block ultrawork mode (keyword ignored)
+  /ultrawork status \u2014 Show current state
+
+The change is per-session and clears when the session ends.
+By default, ultrawork mode activates when the LLM or user mentions the "ultrawork" keyword.`;
+
 // src/features/builtin-commands/commands.ts
 var BUILTIN_COMMAND_DEFINITIONS = {
   "init-deep": {
@@ -23667,6 +23789,39 @@ ${END_ULTRAWORK_TEMPLATE}
 $ARGUMENTS
 </user-request>`,
     argumentHint: "[optional follow-up task]"
+  },
+  research: {
+    description: "(builtin) Saturation research with parallel swarms and convergence \u2014 code, docs, web, and OSS repos",
+    template: `<command-instruction>
+${RESEARCH_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "<topic> [--scope=code|docs|web|oss|all] [--max-rounds=N]"
+  },
+  assembly: {
+    description: "(builtin) Toggle assembly tool enable/disable for the current session",
+    template: `<command-instruction>
+${ASSEMBLY_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "[enable|disable|status]"
+  },
+  ultrawork: {
+    description: "(builtin) Toggle ultrawork mode on/off for the current session",
+    template: `<command-instruction>
+${ULTRAWORK_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "[enable|disable|status]"
   }
 };
 function loadBuiltinCommands(disabledCommands) {
@@ -30266,17 +30421,306 @@ Fix these inline when possible. For bulk fixes, run \`bun run lint:fix\`.
 | Report done without running verification | Never trust \u2014 always verify |
 `
 };
+// src/features/builtin-skills/skills/remove-ai-slops.ts
+var REMOVE_AI_SLOPS_SKILL_NAME = "remove-ai-slops";
+var REMOVE_AI_SLOPS_SKILL_DESCRIPTION = "Detects and removes AI-generated code smells across 7 categories: verbose comments, redundant error handling, over-engineered patterns, generic AI phrasing, cargo-cult boilerplate, padding/verbosity, weird codegen artifacts. Hybrid mode: scan first, then guide fixes. Triggers: 'cleanup code', 'remove ai slop', 'code cleanup', 'fix ai code', 'de-ai', 'remove ai comments', 'clean ai smells'.";
+var removeAiSlopsSkill = {
+  name: REMOVE_AI_SLOPS_SKILL_NAME,
+  description: REMOVE_AI_SLOPS_SKILL_DESCRIPTION,
+  allowedTools: [
+    "read",
+    "write",
+    "edit",
+    "grep",
+    "glob",
+    "ast_grep_search",
+    "ast_grep_replace",
+    "lsp_diagnostics",
+    "lsp_find_references"
+  ],
+  template: `# Remove AI Slops \u2014 Code Smell Detector & Fixer
+
+Detect and fix AI-generated code smells across 7 categories. Operates in **hybrid mode**: scan first to identify issues, then guide you through fixes one finding at a time.
+
+## Phase 0: Scope & Setup
+
+Determine scope:
+- If no files specified, scan recently changed files (\`git diff --name-only HEAD~1\`)
+- If a file/dir is specified, scan those
+- If \`--all\` flag, scan entire \`src/\` directory
+
+Create \`.matrixx/slop-scan-<timestamp>.md\` for tracking findings.
+
+## Phase 1: Scan for Slop
+
+Run all 7 category detectors. For each category, output findings grouped by file with line ranges.
+
+---
+
+### Category 1: Verbose Comments
+
+**Detect**: AST patterns and regex for comments that restate the obvious.
+
+**Patterns to flag:**
+- \`// This function does X by doing Y\` \u2014 describes implementation, not intent
+- \`// Loop through each item\` \u2014 obvious from the \`for\` loop itself
+- \`// Initialize variable\` \u2014 obvious from \`const x =\`
+- \`// Return result\` \u2014 obvious from \`return\`
+- \`// Call the API\` \u2014 obvious from the function call on the next line
+- \`// Check if condition is true\` \u2014 obvious from \`if\`
+- Block comments that just repeat what the function signature says
+
+**Detection:**
+- Use \`ast_grep_search\` with patterns like:
+  - \`// $COMMENT\` where $COMMENT matches obvious patterns
+  - Function-level JSDoc that adds no info beyond the signature
+- Use \`grep\` with regex for known AI comment phrases
+
+**Severity**: LOW (cosmetic, but clutters code)
+
+---
+
+### Category 2: Redundant Error Handling
+
+**Detect**: Error handling patterns that add no value.
+
+**Patterns to flag:**
+- Empty catch blocks: \`catch (e) {}\`
+- Catch-and-rethrow: \`catch(e) { console.error(e); throw e; }\` (re-throw with no added value)
+- Redundant null checks on already-guarded paths
+- \`try/catch\` that wraps every single function call individually
+- \`catch (error: any)\` (TypeScript \u2014 \`unknown\` preferred)
+
+**Detection:**
+- Use \`ast_grep_search\` for \`catch($$$) { $$$ }\` and analyze body
+- \`ast_grep_search\` for \`if ($VAR != null)\` patterns on already-checked variables
+- Use \`lsp_find_references\` to check if null checks are redundant
+
+**Severity**: MEDIUM (adds noise, but doesn't break things)
+
+---
+
+### Category 3: Over-Engineered Patterns
+
+**Detect**: Unnecessary abstraction layers and overly complex patterns.
+
+**Patterns to flag:**
+- Abstract factory factory or other nested indirection
+- AbstractSingletonProxyBean-style pattern names
+- Single-implementation interfaces (unless part of a public API contract)
+- Builder pattern for objects with 1-3 simple properties
+- Strategy pattern with a single strategy
+- Decorator patterns around every function
+- Excessive generic constraints (\`<T extends X extends Y extends Z>\`)
+
+**Detection:**
+- Use \`lsp_find_references\` to check if interfaces have exactly 1 implementation
+- \`ast_grep_search\` for class names containing "Abstract", "Factory", "Builder", "Manager"
+- \`grep\` for pattern names like \`*Abstract*\`, \`*Factory*\`, \`*Proxy*\`, \`*Singleton*\`
+- Check for builder functions/classes with very few properties
+
+**Severity**: HIGH (indicates misunderstanding of the codebase)
+
+---
+
+### Category 4: Generic AI Phrasing
+
+**Detect**: Code comments and documentation with AI-typical phrasing.
+
+**Phrases to flag (regex case-insensitive):**
+- "It's worth noting that"
+- "It is important to note"
+- "It is important to mention"
+- "Let's step through this"
+- "In conclusion"
+- "As previously mentioned"
+- "It should be noted that"
+- "It's crucial to understand"
+- "Let's break this down"
+- "The beauty of this approach"
+- "This is a classic example of"
+- "Essentially, what this does is"
+- "In the world of"
+- "When it comes to"
+- "One might argue that"
+- "It goes without saying"
+
+**Detection:**
+- Use \`grep -i\` with regex patterns for each phrase in \`*.ts\` and \`*.md\` files
+- Focus comments, docstrings, and inline documentation
+
+**Severity**: LOW (cosmetic, but unprofessional)
+
+---
+
+### Category 5: Cargo-Cult Boilerplate
+
+**Detect**: Patterns copied without understanding.
+
+**Patterns to flag:**
+- Excessive defensive programming (checking the same condition at multiple levels)
+- \`try/catch\` with \`console.error\` and rethrow in every function
+- Identical error handling block copy-pasted across multiple functions
+- Redundant type guards on already-typed parameters
+- \`if (process.env.NODE_ENV !== 'production')\` debug logging patterns
+- \`// TODO: implement\` stubs in production code
+- Mock implementations that replicate the real implementation exactly
+
+**Detection:**
+- Use \`grep\` to find repeated identical code blocks across files
+- \`ast_grep_search\` for try/catch patterns in every function of a file
+- \`grep\` for TODO/FIXME/HACK comments in non-test files
+- Check for \`console.log\` statements in production code
+
+**Severity**: MEDIUM (code bloat, maintenance burden)
+
+---
+
+### Category 6: Padding/Verbosity
+
+**Detect**: Unnecessary code that adds no information.
+
+**Patterns to flag:**
+- Empty \`@returns\` tags in JSDoc
+- \`@param {string} name - The name\` \u2014 repeats the obvious
+- Redundant type annotations: \`const x: string = "hello"\` (type is obvious)
+- Unnecessary intermediate variables: \`const result = doSomething(); return result;\` when \`return doSomething()\` works
+- \`const x = y as SomeType\` when y is already SomeType
+- \`() => { return x }\` when \`() => x\` works
+- Destructuring with unused variables
+- \`export default\` for a single export (prefer named)
+- Variables assigned but never read
+
+**Detection:**
+- Use \`ast_grep_search\` for \`const $VAR = $EXPR as $TYPE\` where $VAR is typed
+- \`ast_grep_search\` for \`() => { return { $$$ } }\`
+- \`grep\` for \`@returns\` without description in JSDoc
+- \`lsp_diagnostics\` will catch unused variables
+
+**Severity**: LOW (cosmetic, minor bloat)
+
+---
+
+### Category 7: Weird Codegen Artifacts
+
+**Detect**: Inconsistencies that suggest AI-generated code was inserted without review.
+
+**Patterns to flag:**
+- Mix of import styles in the same file (CommonJS + ESM, default + named)
+- Inconsistent error handling within the same file (some async/await, some .then())
+- Mixed indentation or naming conventions in the same file
+- Unused imports (LSP will catch these)
+- \`import * as\` that imports everything but only uses one thing
+- Code that doesn't follow the file's established patterns
+- Types/interfaces defined inline instead of in a shared types file
+- Magic numbers and strings that should be constants
+- Language-mismatched conventions (e.g., Java-style getters/setters in TypeScript)
+
+**Detection:**
+- Use \`grep\` for mixed module systems in the same file
+- \`lsp_diagnostics\` for unused imports
+- \`ast_grep_search\` for inline type definitions that should be shared
+- Manual review of file-level pattern consistency
+
+**Severity**: MEDIUM-HIGH (indicates un-reviewed code)
+
+---
+
+## Phase 2: Report Findings
+
+After scanning all categories, present a structured report:
+
+\`\`\`markdown
+# AI Slop Scan Results
+
+Scanned: <files/dirs>
+Total findings: <count>
+
+| Category | Count | Critical | High | Medium | Low |
+|----------|-------|----------|------|--------|-----|
+| 1. Verbose Comments | N | - | - | - | N |
+| 2. Redundant Error Handling | N | - | N | N | - |
+| ... | ... | ... | ... | ... | ... |
+
+## Findings by File
+
+### <file-path.ts>
+
+#### [HIGH] Category 3: Over-Engineered \u2014 AbstractUserFactoryManager
+- **Location**: line 42-89
+- **Current**: \`class AbstractUserFactoryManager<T extends ...>\`
+- **Suggestion**: Replace with simple function \`createUser()\`
+- **Severity**: HIGH
+- **Status**: PENDING
+
+#### [MED] Category 2: Redundant Error Handling
+- **Location**: line 15-18
+- **Current**: 
+\`\`\`typescript
+try {
+  await doSomething()
+} catch (e) {
+  console.error(e)
+  throw e
+}
+\`\`\`
+- **Suggestion**: Remove try/catch \u2014 caller handles errors. Or add meaningful error context.
+- **Severity**: MEDIUM
+- **Status**: PENDING
+
+... (repeat for all findings)
+\`\`\`
+
+## Phase 3: Guided Fix
+
+For each finding, present the user with options:
+
+1. **Apply fix** \u2014 Show the proposed change as a diff, ask for confirmation
+2. **Skip** \u2014 Mark as reviewed and acceptable
+3. **Snooze** \u2014 Skip for now but flag for later review
+4. **Adjust** \u2014 User provides alternative fix
+
+Apply fixes using the \`edit\` tool only after user confirmation.
+
+**Fix application pattern:**
+1. Present the proposed replacement code
+2. Wait for user response (\`y\`/\`n\`/\`skip\`/\`adjust\`)
+3. On approval: \`edit\` the file
+4. Run \`lsp_diagnostics\` on the file to verify no new errors
+5. Mark finding as FIXED / SKIPPED
+
+**Batch support**: User can say "apply all LOW" or "apply all for file X" to batch-approve.
+
+## Phase 4: Verify
+
+After all fixes applied:
+1. \`bun run typecheck\` \u2014 no new type errors
+2. \`bun run lint\` \u2014 no new lint errors
+3. Verify no changes broke tests for affected files
+
+Write final summary to \`.matrixx/slop-scan-<timestamp>.md\`.
+
+## Rules
+
+- NEVER auto-apply fixes without user approval
+- ALWAYS show the proposed change before applying
+- ALWAYS run \`lsp_diagnostics\` after each edit
+- Scan ALL 7 categories every time \u2014 don't skip categories
+- Flag findings only once (deduplicate across rounds)
+- For \`--all\` mode, process files in batches of 5 to avoid overload
+- If a pattern is clearly intentional (pre-existing convention), skip it`
+};
 // src/features/builtin-skills/skills/review-work.ts
 var REVIEW_WORK_SKILL_NAME = "review-work";
-var REVIEW_WORK_SKILL_DESCRIPTION = "Post-implementation review orchestrator. Launches 5 parallel background sub-agents: Oracle (goal/constraint verification), Oracle (code quality), Oracle (security), unspecified-high (hands-on QA execution), unspecified-high (context mining from GitHub/git/Slack/Notion). All must pass for review to pass. MUST USE after completing any significant implementation work. Triggers: 'review work', 'review my work', 'review changes', 'QA my work', 'verify implementation', 'check my work', 'validate changes', 'post-implementation review'.";
+var REVIEW_WORK_SKILL_DESCRIPTION = "Post-implementation review orchestrator. Launches 6 parallel background sub-agents: Oracle (goal/constraint verification), Oracle (code quality), Oracle (security), unspecified-high (hands-on QA execution), unspecified-high (context mining from GitHub/git/Slack/Notion), unspecified-high (AI slop detection). All must pass for review to pass. MUST USE after completing any significant implementation work. Triggers: 'review work', 'review my work', 'review changes', 'QA my work', 'verify implementation', 'check my work', 'validate changes', 'post-implementation review'.";
 var reviewWorkSkill = {
   name: REVIEW_WORK_SKILL_NAME,
   description: REVIEW_WORK_SKILL_DESCRIPTION,
   template: `# Review Work - 5-Agent Parallel Review Orchestrator
 
-Launch 5 specialized sub-agents in parallel to review completed implementation work from every angle. All 5 must pass for the review to pass. If even ONE fails, the review fails.
+Launch 6 specialized sub-agents in parallel to review completed implementation work from every angle. All 6 must pass for the review to pass. If even ONE fails, the review fails.
 
-The 5 agents cover complementary concerns - together they form a comprehensive review that no single reviewer could match:
+The 6 agents cover complementary concerns - together they form a comprehensive review that no single reviewer could match:
 
 | # | Agent | Type | Role | Focus Level |
 |---|-------|------|------|-------------|
@@ -30285,6 +30729,7 @@ The 5 agents cover complementary concerns - together they form a comprehensive r
 | 3 | Code Reviewer | Oracle | Is the code well-written? | MAIN |
 | 4 | Security Auditor | Oracle | Is it secure? | SUB |
 | 5 | Context Miner | unspecified-high | Did we miss any context? | MAIN |
+| 6 | AI Slop Detector | unspecified-high | Remove AI-generated code smells | SUP |
 
 ---
 
@@ -30618,9 +31063,54 @@ OUTPUT FORMAT:
 
 ---
 
+### Agent 6: AI Slop Detection (unspecified-high) - SUP
+
+\`\`\`
+task(
+  category="unspecified-high",
+  run_in_background=true,
+  load_skills=["remove-ai-slops"],
+  description="Detect AI-generated code smells in changes",
+  prompt="""
+<review_type>AI SLOP DETECTION (supplementary)</review_type>
+
+<original_goal>
+{GOAL}
+</original_goal>
+
+<changed_files>
+{CHANGED_FILES}
+</changed_files>
+
+<background>
+{BACKGROUND}
+</background>
+
+Review the changed files for AI-generated code smells. Load and follow the \`remove-ai-slops\` skill.
+
+Run the scan across all 7 categories:
+1. Verbose Comments \u2014 comments that restate the obvious
+2. Redundant Error Handling \u2014 catch-and-rethrow, empty catches, redundant null checks
+3. Over-Engineered Patterns \u2014 unnecessary abstractions, single-use interfaces
+4. Generic AI Phrasing \u2014 "It's worth noting...", "Let's step through..."
+5. Cargo-Cult Boilerplate \u2014 repeated identical blocks, TODO stubs
+6. Padding/Verbosity \u2014 empty JSDoc, redundant type annotations
+7. Weird Codegen Artifacts \u2014 mixed import styles, inconsistent patterns
+
+OUTPUT FORMAT:
+<verdict>PASS or FAIL (FAIL only if HIGH severity issues found)</verdict>
+<severity>NONE / LOW / MEDIUM / HIGH</severity>
+<summary>1-3 sentence overall assessment</summary>
+<findings>- [CATEGORY_N] [HIGH/MEDIUM/LOW] Description - File:path:line - Current / Suggestion</findings>
+<recommendations>Suggested fixes for findings. Empty if PASS.</recommendations>
+""")
+\`\`\`
+
+---
+
 ## Phase 2: Wait & Collect
 
-After launching all 5 agents in one turn, **end your response**. Wait for system notifications as each agent completes.
+After launching all 6 agents in one turn, **end your response**. Wait for system notifications as each agent completes.
 
 Collect via \`background_output(task_id="...")\` as each completes. Track verdicts:
 
@@ -30631,14 +31121,15 @@ Collect via \`background_output(task_id="...")\` as each completes. Track verdic
 | 3. Code Quality | pending | - |
 | 4. Security | pending | - |
 | 5. Context Mining | pending | - |
+| 6. AI Slop Detection | pending | - |
 
-Do NOT deliver the final report until ALL 5 have completed.
+Do NOT deliver the final report until ALL 6 have completed.
 
 ---
 
 ## Phase 3: Deliver Verdict
 
-ALL 5 returned PASS \u2192 **REVIEW PASSED**
+ALL 6 returned PASS \u2192 **REVIEW PASSED**
 ANY returned FAIL \u2192 **REVIEW FAILED**
 
 Final report format:
@@ -30655,6 +31146,7 @@ Final report format:
 | 3 | Code Quality | Oracle | PASS/FAIL | HIGH/MED/LOW |
 | 4 | Security (supplementary) | Oracle | PASS/FAIL | Severity |
 | 5 | Context Mining | unspecified-high | PASS/FAIL | HIGH/MED/LOW |
+| 6 | AI Slop Detection (supplementary) | unspecified-high | PASS/FAIL | NONE/LOW/MED/HIGH |
 
 ## Blocking Issues
 [Aggregated from all agents - deduplicated, prioritized]
@@ -31842,6 +32334,252 @@ NEVER write tests AFTER implementation \u2014 write them BEFORE
 \`\`\`
 `
 };
+// src/features/builtin-skills/skills/ulw-research.ts
+var ULW_RESEARCH_SKILL_NAME = "ulw-research";
+var ULW_RESEARCH_SKILL_DESCRIPTION = "Saturation research orchestrator. Spawns parallel explore/librarian swarms across code, docs, web, and OSS repos. Recursively follows EXPAND leads until convergence (novelty-based, max 5 rounds). Proves contested claims by running code. Returns cited synthesis. Writes artifacts to .matrixx/. Triggers: 'research', 'deep dive', 'investigate', 'explore codebase', 'find how', 'saturation research', 'ulw research'.";
+var ulwResearchSkill = {
+  name: ULW_RESEARCH_SKILL_NAME,
+  description: ULW_RESEARCH_SKILL_DESCRIPTION,
+  agent: "oracle",
+  allowedTools: [
+    "read",
+    "write",
+    "edit",
+    "bash",
+    "grep",
+    "glob",
+    "look_at",
+    "delegate_agent",
+    "websearch_web_search_exa",
+    "grep_app_searchGitHub",
+    "context7_resolve-library-id",
+    "context7_query-docs"
+  ],
+  template: `# ULW-Research \u2014 Saturation Research Orchestrator
+
+Run a systematic, multi-round research process that converges on comprehensive coverage.
+
+## Inputs
+
+- **TOPIC**: The research question or topic (from user message)
+- **SCOPE**: Optional scope narrowing (--scope=code|docs|web|oss|all, default: all)
+- **MAX_ROUNDS**: Optional (--max-rounds=N, default: 5, hard limit: 5)
+
+## Artifact Directory
+
+Create \`.matrixx/research-<slug>-<timestamp>/\` for all outputs:
+- \`meta.md\` \u2014 Research metadata (topic, scope, start time, max rounds)
+- \`round-<N>-findings.md\` \u2014 Per-round combined findings
+- \`leads.md\` \u2014 Tracked EXPAND leads across rounds (status: pending/explored/exhausted)
+- \`contested-claims.md\` \u2014 Claims that need code verification
+- \`convergence-log.md\` \u2014 Novelty scores and decisions per round
+- \`final-synthesis.md\` \u2014 Cited synthesis (final deliverable)
+
+All artifacts are written via the \`write\` tool. The next session can resume from artifacts if interrupted.
+
+## Phase 0: Parse and Seed
+
+1. Create artifact directory: \`.matrixx/research-<topic-slug>-<YYYYMMDD-HHmmss>/\`
+2. Write \`meta.md\` with topic, timestamp, scope, max rounds
+3. Initialize \`leads.md\` with seed queries extracted from the topic:
+   - 1-3 code-local search terms
+   - 1-3 documentation/Context7 search terms
+   - 1-3 web search terms
+   - 1-3 OSS repository search terms
+4. Write round 0 to \`convergence-log.md\`
+
+## Phase 1: Parallel Swarm (per round)
+
+For each round, spawn 4 parallel background agents. Each agent gets ONLY its direction-specific query (not the full research state).
+
+### Direction 1: Local Code (explore agent)
+
+\`\`\`
+task(
+  subagent_type="explore",
+  run_in_background=true,
+  description="Research code: <lead>",
+  prompt="""
+Search the local codebase for implementations, patterns, and references related to: <CURRENT_LEAD>
+
+Use grep, glob, and read tools. Find:
+- Relevant source files and their key functions
+- Architectural patterns used
+- Configuration and usage examples
+- Related tests that reveal intended behavior
+
+OUTPUT: List of findings with file paths, line numbers, and brief descriptions.
+Flag any claims that seem contested or unverifiable by reading alone.
+""")
+\`\`\`
+
+### Direction 2: Documentation (explore agent)
+
+\`\`\`
+task(
+  subagent_type="explore",
+  run_in_background=true,
+  description="Research docs: <lead>",
+  prompt="""
+Research documentation and knowledge base files related to: <CURRENT_LEAD>
+
+Read AGENTS.md files, README.md, doc/ directories, and inline documentation.
+Use context7_resolve-library-id and context7_query-docs for library/framework docs.
+
+OUTPUT: Structured findings from docs with source attribution.
+Flag any claims that contradict other sources.
+""")
+\`\`\`
+
+### Direction 3: Web (operator agent)
+
+\`\`\`
+task(
+  subagent_type="operator",
+  run_in_background=true,
+  description="Research web: <lead>",
+  prompt="""
+Research the web for information about: <CURRENT_LEAD>
+
+Use websearch_web_search_exa and context7 tools. Find:
+- Official documentation and blog posts
+- Technical articles and tutorials
+- Implementation patterns and best practices
+- Real-world usage examples
+
+OUTPUT: Cited findings with URLs, publication dates, and reliability assessment.
+Flag any contested claims or conflicting information.
+""")
+\`\`\`
+
+### Direction 4: OSS Repos (operator agent)
+
+\`\`\`
+task(
+  subagent_type="operator",
+  run_in_background=true,
+  description="Research OSS: <lead>",
+  prompt="""
+Search open source repositories for implementations related to: <CURRENT_LEAD>
+
+Use grep_app_searchGitHub to find real-world code patterns.
+Focus on:
+- Production implementations in similar projects
+- Reference implementations or canonical examples
+- Common patterns and anti-patterns
+- Version-specific changes or migrations
+
+OUTPUT: Code patterns with repo URLs, file paths, and usage context.
+Flag any patterns that seem contested or deprecated.
+""")
+\`\`\`
+
+### Collect Results
+
+After all 4 agents complete, collect via \`background_output(task_id="...")\`:
+1. Merge findings into \`round-<N>-findings.md\`
+2. Extract new EXPAND leads \u2192 append to \`leads.md\`
+3. Extract contested claims \u2192 append to \`contested-claims.md\`
+
+## Phase 2: Convergence Check (after each round)
+
+Evaluate novelty by comparing this round's findings against ALL previous rounds:
+
+1. **Total items this round**: Count of unique file paths, URLs, code patterns, concepts, library names
+2. **Novel items**: Items not present in ANY prior round
+3. **Novelty ratio**: novel_items / total_items_this_round
+
+**Decision:**
+- \`novelty_ratio > 0.3\` AND \`round < MAX_ROUNDS\` \u2192 **EXPAND**: Pick top 3 new leads, go to Phase 1
+- \`novelty_ratio <= 0.3\` \u2192 **STOP**: Natural convergence, proceed to Phase 4
+- \`round == MAX_ROUNDS\` \u2192 **STOP**: Forced convergence
+- \`total_items_this_round == 0\` \u2192 **STOP**: No findings
+
+Record convergence state in \`convergence-log.md\` with round number and novelty score.
+
+**Lead selection for next round**: Pick top 3 leads prioritizing:
+- Specificity (concrete file paths or URLs > vague concepts)
+- Freshness (leads from current round > old leads)
+- Diversity (one per direction preferred)
+
+## Phase 3: Contested Claim Verification (if needed)
+
+If \`contested-claims.md\` is non-empty after convergence, verify each claim:
+
+\`\`\`
+task(
+  subagent_type="explore",
+  run_in_background=true,
+  description="Verify claim: <summary>",
+  prompt="""
+Verify this contested claim by examining code:
+
+CLAIM: <claim_text>
+EVIDENCE FOR: <supporting_evidence>
+EVIDENCE AGAINST: <opposing_evidence>
+
+Verification steps:
+1. Find the relevant source files
+2. Read the implementation
+3. If runnable: write a minimal test script and execute it
+4. Determine verdict
+
+OUTPUT:
+<verdict>CONFIRMED / REFUTED / INCONCLUSIVE</verdict>
+<evidence>Specific code or outputs supporting the verdict</evidence>
+""")
+\`\`\`
+
+Max 10 contested claims verified. If none, skip Phase 3.
+
+## Phase 4: Final Synthesis
+
+Produce \`final-synthesis.md\`:
+
+\`\`\`markdown
+# Research Synthesis: <TOPIC>
+
+**Date**: <timestamp>
+**Rounds**: <N> (converged at round <M>)
+**Sources**: <count> unique sources
+
+## Executive Summary
+2-3 paragraphs synthesizing the most important findings.
+
+## Key Findings
+
+### Finding 1: <title>
+- **Status**: CONFIRMED / CONTESTED / INCONCLUSIVE
+- **Confidence**: HIGH / MEDIUM / LOW
+- **Summary**: 2-3 sentence synthesis
+- **Evidence**: Details with citations
+- **Sources**: [1] path, [2] URL, [3] repo
+
+(Repeat for all significant findings)
+
+## Contested Claims Resolution
+| Claim | Verdict | Evidence |
+|-------|---------|----------|
+
+## Research Gaps
+- Areas not fully covered
+- Questions remaining unanswered
+
+## Source Index
+| # | Type | Source | Key Insight |
+|---|------|--------|-------------|
+\`\`\`
+
+## Rules
+
+- NEVER fabricate citations \u2014 every claim must reference a real source found during research
+- ALWAYS write intermediate artifacts \u2014 preserves partial results if interrupted
+- MAX 5 rounds regardless of novelty
+- Each background agent gets a FOCUSED prompt \u2014 never dump the entire research state
+- Contested claims MUST be verified by code execution when possible
+- The final synthesis must be self-contained without intermediate artifacts
+- If a round produces zero findings, STOP immediately`
+};
 // src/features/builtin-skills/skills.ts
 function createBuiltinSkills(options = {}) {
   const { browserProvider = "playwright", disabledSkills: rawDisabledSkills } = options;
@@ -31854,7 +32592,7 @@ function createBuiltinSkills(options = {}) {
   } else {
     browserSkill = playwrightSkill;
   }
-  const skills = [browserSkill, frontendUiUxSkill, gitMasterSkill, devBrowserSkill, dslCoreSkill, dslGrammarSkill, dslCodegenSkill, dslMetamodelSkill, dslToolingSkill, dslTextxEcosystemSkill, dslPyecoreAdvancedSkill, dslModelTransformationSkill, dslTestingSkill, dslValidationSkill, dslCompositionSkill, frontendA11ySkill, frontendBuildToolingSkill, frontendPerfSkill, frontendStateDataSkill, frontendTestingSkill, reactNextjsPatternsSkill, svelteSveltekitPatternsSkill, documentReaderSkill, securityCoreSkill, securitySecretsSkill, securitySastSkill, securityDastSkill, securityDependenciesSkill, securityApiSkill, securityCryptoSkill, securityInfraSkill, securityReviewSkill, tddEnforcerSkill, reviewWorkSkill, qualityGateSkill, softwareDevSkill, matrixxSelfConfigSkill];
+  const skills = [browserSkill, frontendUiUxSkill, gitMasterSkill, devBrowserSkill, dslCoreSkill, dslGrammarSkill, dslCodegenSkill, dslMetamodelSkill, dslToolingSkill, dslTextxEcosystemSkill, dslPyecoreAdvancedSkill, dslModelTransformationSkill, dslTestingSkill, dslValidationSkill, dslCompositionSkill, frontendA11ySkill, frontendBuildToolingSkill, frontendPerfSkill, frontendStateDataSkill, frontendTestingSkill, reactNextjsPatternsSkill, svelteSveltekitPatternsSkill, documentReaderSkill, securityCoreSkill, securitySecretsSkill, securitySastSkill, securityDastSkill, securityDependenciesSkill, securityApiSkill, securityCryptoSkill, securityInfraSkill, securityReviewSkill, tddEnforcerSkill, reviewWorkSkill, qualityGateSkill, softwareDevSkill, matrixxSelfConfigSkill, ulwResearchSkill, removeAiSlopsSkill];
   if (!disabledSkills) {
     return skills;
   }
@@ -32555,67 +33293,6 @@ function revertPinnedVersion(configPath, failedVersion, originalEntry) {
 // src/hooks/auto-update-checker/hook.ts
 init_logger();
 
-// src/cli/config-manager/config-context.ts
-var configContext = null;
-function getConfigContext() {
-  if (!configContext) {
-    if (true) {
-      console.warn("[config-context] getConfigContext() called before initConfigContext(); defaulting to CLI paths.");
-    }
-    const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
-    configContext = { binary: "opencode", version: null, paths };
-  }
-  return configContext;
-}
-function getConfigDir() {
-  return getConfigContext().paths.configDir;
-}
-// src/cli/config-manager/bun-install.ts
-var BUN_INSTALL_TIMEOUT_SECONDS = 60;
-var BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000;
-async function runBunInstall() {
-  const result = await runBunInstallWithDetails();
-  return result.success;
-}
-async function runBunInstallWithDetails() {
-  try {
-    const proc = Bun.spawn(["bun", "install"], {
-      cwd: getConfigDir(),
-      stdout: "inherit",
-      stderr: "inherit"
-    });
-    let timeoutId;
-    const timeoutPromise = new Promise((resolve3) => {
-      timeoutId = setTimeout(() => resolve3("timeout"), BUN_INSTALL_TIMEOUT_MS);
-    });
-    const exitPromise = proc.exited.then(() => "completed");
-    const result = await Promise.race([exitPromise, timeoutPromise]);
-    clearTimeout(timeoutId);
-    if (result === "timeout") {
-      try {
-        proc.kill();
-      } catch {}
-      return {
-        success: false,
-        timedOut: true,
-        error: `bun install timed out after ${BUN_INSTALL_TIMEOUT_SECONDS} seconds. Try running manually: cd ${getConfigDir()} && bun i`
-      };
-    }
-    if (proc.exitCode !== 0) {
-      return {
-        success: false,
-        error: `bun install failed with exit code ${proc.exitCode}`
-      };
-    }
-    return { success: true };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      error: `bun install failed: ${message}. Is bun installed? Try: curl -fsSL https://bun.sh/install | bash`
-    };
-  }
-}
 // src/hooks/auto-update-checker/hook/background-update-check.ts
 init_logger();
 
@@ -32629,7 +33306,9 @@ async function showUpdateAvailableToast(ctx, latestVersion, getToastMessage) {
       variant: "info",
       duration: 8000
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[auto-update] Update available toast failed:", err);
+  });
   log(`[auto-update-checker] Update available toast shown: v${latestVersion}`);
 }
 async function showAutoUpdatedToast(ctx, oldVersion, newVersion) {
@@ -32641,14 +33320,36 @@ Restart OpenCode to apply.`,
       variant: "success",
       duration: 8000
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[auto-update] Auto-updated toast failed:", err);
+  });
   log(`[auto-update-checker] Auto-updated toast shown: v${oldVersion} \u2192 v${newVersion}`);
 }
 
 // src/hooks/auto-update-checker/hook/background-update-check.ts
+var BUN_INSTALL_TIMEOUT_SECONDS = 60;
+var BUN_INSTALL_TIMEOUT_MS = BUN_INSTALL_TIMEOUT_SECONDS * 1000;
 async function runBunInstallSafe() {
   try {
-    return await runBunInstall();
+    const configPaths = getOpenCodeConfigPaths({ binary: "opencode", version: null });
+    const proc = Bun.spawn(["bun", "install"], {
+      cwd: configPaths.configDir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve3) => {
+      timeoutId = setTimeout(() => resolve3(false), BUN_INSTALL_TIMEOUT_MS);
+    });
+    const exitPromise = proc.exited.then(() => true);
+    const result = await Promise.race([exitPromise, timeoutPromise]);
+    clearTimeout(timeoutId);
+    if (!result) {
+      try {
+        proc.kill();
+      } catch {}
+    }
+    return result;
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
     log("[auto-update-checker] bun install error:", errorMessage);
@@ -32719,7 +33420,9 @@ ${errorMessages}`,
       variant: "error",
       duration: 1e4
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[auto-update] Config errors toast failed:", err);
+  });
   log(`[auto-update-checker] Config load errors shown: ${errors.length} error(s)`);
   clearConfigLoadErrors();
 }
@@ -32728,7 +33431,9 @@ ${errorMessages}`,
 init_logger();
 async function updateAndShowConnectedProvidersCacheStatus(ctx) {
   const hadCache = hasConnectedProvidersCache();
-  updateConnectedProvidersCache(ctx.client).catch(() => {});
+  updateConnectedProvidersCache(ctx.client).catch((err) => {
+    log("[auto-update] Provider cache update failed:", err);
+  });
   if (!hadCache) {
     await ctx.client.tui.showToast({
       body: {
@@ -32737,7 +33442,9 @@ async function updateAndShowConnectedProvidersCacheStatus(ctx) {
         variant: "info",
         duration: 8000
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[auto-update] Providers toast failed:", err);
+    });
     log("[auto-update-checker] Connected providers cache toast shown (first run)");
   } else {
     log("[auto-update-checker] Connected providers cache exists, updating in background");
@@ -32756,7 +33463,9 @@ async function showModelCacheWarningIfNeeded(ctx) {
       variant: "warning",
       duration: 1e4
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[auto-update] Model cache warning toast failed:", err);
+  });
   log("[auto-update-checker] Model cache warning shown");
 }
 
@@ -32764,6 +33473,7 @@ async function showModelCacheWarningIfNeeded(ctx) {
 init_logger();
 
 // src/hooks/auto-update-checker/hook/spinner-toast.ts
+init_logger();
 var SISYPHUS_SPINNER = ["\xB7", "\u2022", "\u25CF", "\u25CB", "\u25CC", "\u25E6", " "];
 async function showSpinnerToast(ctx, version, message) {
   const totalDuration = 5000;
@@ -32778,7 +33488,9 @@ async function showSpinnerToast(ctx, version, message) {
         variant: "info",
         duration: frameInterval + 50
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[auto-update] Spinner toast failed:", err);
+    });
     await new Promise((resolve3) => setTimeout(resolve3, frameInterval));
   }
 }
@@ -32830,13 +33542,17 @@ v${latestVersion} available. Restart OpenCode to apply.` : "OpenCode is now on S
         await updateAndShowConnectedProvidersCacheStatus(ctx);
         if (localDevVersion) {
           if (showStartupToast) {
-            showLocalDevToast(ctx, displayVersion, isMorpheusEnabled).catch(() => {});
+            showLocalDevToast(ctx, displayVersion, isMorpheusEnabled).catch((err) => {
+              log("[auto-update] Startup toast failed:", err);
+            });
           }
           log("[auto-update-checker] Local development mode");
           return;
         }
         if (showStartupToast) {
-          showVersionToast(ctx, displayVersion, getToastMessage(false)).catch(() => {});
+          showVersionToast(ctx, displayVersion, getToastMessage(false)).catch((err) => {
+            log("[auto-update] Version toast failed:", err);
+          });
         }
         runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage).catch((err) => {
           log("[auto-update-checker] Background update check failed:", err);
@@ -48741,9 +49457,6 @@ function cleanupStaleEntries() {
     }
   }
 }
-function isWriteTool(toolName) {
-  return toolName.toLowerCase() === "write";
-}
 function extractFilePath(args) {
   const path10 = args.path ?? args.filePath ?? args.file_path;
   return typeof path10 === "string" ? path10 : undefined;
@@ -48815,12 +49528,6 @@ var CONTENT_CLOSE_TAG = "</content>";
 var FILE_OPEN_TAG = "<file>";
 var FILE_CLOSE_TAG = "</file>";
 var OPENCODE_LINE_TRUNCATION_SUFFIX = "... (line truncated to 2000 chars)";
-function isReadTool(toolName) {
-  return toolName.toLowerCase() === "read";
-}
-function isWriteTool2(toolName) {
-  return toolName.toLowerCase() === "write";
-}
 function shouldProcess(config2) {
   return config2.hashline_edit?.enabled ?? false;
 }
@@ -48941,7 +49648,7 @@ function createHashlineReadEnhancerHook(_ctx, config2) {
   return {
     "tool.execute.after": async (input, output) => {
       if (!isReadTool(input.tool)) {
-        if (isWriteTool2(input.tool) && typeof output.output === "string" && shouldProcess(config2)) {
+        if (isWriteTool(input.tool) && typeof output.output === "string" && shouldProcess(config2)) {
           await appendWriteHashlineOutput(output);
         }
         return;
@@ -48956,6 +49663,9 @@ function createHashlineReadEnhancerHook(_ctx, config2) {
     }
   };
 }
+// src/hooks/interactive-bash-session/hook.ts
+init_logger();
+
 // src/hooks/interactive-bash-session/constants.ts
 import { join as join46 } from "path";
 var INTERACTIVE_BASH_SESSION_STORAGE = join46(OPENCODE_STORAGE, "interactive-bash-session");
@@ -49135,7 +49845,9 @@ function createInteractiveBashSessionHook(ctx) {
   async function killAllTrackedSessionsLocal(state3) {
     await killAllTrackedSessions(state3);
     for (const sessionId of subagentSessions) {
-      ctx.client.session.abort({ path: { id: sessionId } }).catch(() => {});
+      ctx.client.session.abort({ path: { id: sessionId } }).catch((err) => {
+        log("[interactive-bash] Session abort failed:", err);
+      });
     }
   }
   const toolExecuteAfter = async (input, output) => {
@@ -49964,6 +50676,21 @@ function detectKeywordsWithType(text, agentName, modelID) {
 function extractPromptText3(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text || "").join(" ");
 }
+// src/features/ultrawork-state/manager.ts
+init_logger();
+var HOOK_NAME4 = "ultrawork-state";
+var sessionStates = new Map;
+function getUltraworkState(sessionID) {
+  return sessionStates.get(sessionID);
+}
+function enableUltrawork(sessionID) {
+  sessionStates.set(sessionID, "enabled");
+  log(`[${HOOK_NAME4}] Ultrawork enabled for session`, { sessionID });
+}
+function disableUltrawork(sessionID) {
+  sessionStates.set(sessionID, "disabled");
+  log(`[${HOOK_NAME4}] Ultrawork disabled for session`, { sessionID });
+}
 // src/hooks/keyword-detector/hook.ts
 function createKeywordDetectorHook(ctx, _collector) {
   return {
@@ -49999,8 +50726,15 @@ function createKeywordDetectorHook(ctx, _collector) {
           return;
         }
       }
+      const ultraworkState = getUltraworkState(input.sessionID);
       const hasUltrawork = detectedKeywords.some((k) => k.type === "ultrawork");
-      if (hasUltrawork) {
+      const isUltraworkBlocked = ultraworkState === "disabled";
+      const isUltraworkForced = ultraworkState === "enabled";
+      if (isUltraworkBlocked) {
+        log(`[keyword-detector] Ultrawork blocked by runtime state`, { sessionID: input.sessionID });
+        return;
+      }
+      if (hasUltrawork || isUltraworkForced) {
         log(`[keyword-detector] Ultrawork mode activated`, { sessionID: input.sessionID });
         if (output.message.variant === undefined) {
           output.message.variant = "max";
@@ -50088,7 +50822,7 @@ function createLoopStateController(options) {
       };
       const success2 = writeState(directory, state3, stateDir);
       if (success2) {
-        log(`[${HOOK_NAME4}] Loop started`, {
+        log(`[${HOOK_NAME5}] Loop started`, {
           sessionID,
           maxIterations: state3.max_iterations,
           completionPromise: state3.completion_promise
@@ -50103,7 +50837,7 @@ function createLoopStateController(options) {
       }
       const success2 = clearState(directory, stateDir);
       if (success2) {
-        log(`[${HOOK_NAME4}] Loop cancelled`, { sessionID, iteration: state3.iteration });
+        log(`[${HOOK_NAME5}] Loop cancelled`, { sessionID, iteration: state3.iteration });
       }
       return success2;
     },
@@ -50199,7 +50933,7 @@ async function detectCompletionInSessionMessages(ctx, options) {
     return false;
   } catch (err) {
     setTimeout(() => {
-      log(`[${HOOK_NAME4}] Session messages check failed`, {
+      log(`[${HOOK_NAME5}] Session messages check failed`, {
         sessionID: options.sessionID,
         error: String(err)
       });
@@ -50280,7 +51014,7 @@ async function verifyCompletion(ctx, options) {
       query: { directory: options.directory }
     });
     if (createResult.error || !createResult.data?.id) {
-      log(`[${HOOK_NAME4}] Verification session creation failed`);
+      log(`[${HOOK_NAME5}] Verification session creation failed`);
       return { verified: true };
     }
     verifySessionID = createResult.data.id;
@@ -50310,20 +51044,22 @@ async function verifyCompletion(ctx, options) {
           return parseVerificationResponse(assistantText);
         }
       } catch {
-        log(`[${HOOK_NAME4}] Verification poll error`);
+        log(`[${HOOK_NAME5}] Verification poll error`);
       }
       await new Promise((resolve5) => {
         setTimeout(resolve5, pollIntervalMs);
       });
     }
-    log(`[${HOOK_NAME4}] Verification timed out, assuming pass`);
+    log(`[${HOOK_NAME5}] Verification timed out, assuming pass`);
     return { verified: true };
   } catch (err) {
-    log(`[${HOOK_NAME4}] Verification error: ${String(err)}`);
+    log(`[${HOOK_NAME5}] Verification error: ${String(err)}`);
     return { verified: true };
   } finally {
     if (verifySessionID) {
-      ctx.client.session.delete({ path: { id: verifySessionID } }).catch(() => {});
+      ctx.client.session.delete({ path: { id: verifySessionID } }).catch((err) => {
+        log("[matrix-loop] Verification session cleanup failed:", err);
+      });
     }
   }
 }
@@ -50393,7 +51129,7 @@ async function injectContinuationPrompt(ctx, options) {
 
 // src/hooks/matrix-loop/matrix-loop-event-handler.ts
 async function handleVerificationFailure(ctx, options, state3, sessionID, reason, failedCount) {
-  log(`[${HOOK_NAME4}] Verification failed`, { sessionID, reason });
+  log(`[${HOOK_NAME5}] Verification failed`, { sessionID, reason });
   const newState = options.loopState.incrementIteration();
   if (newState) {
     newState.verification_failed_count = failedCount + 1;
@@ -50411,7 +51147,7 @@ ${buildContinuationPrompt(newState ?? state3)}`,
       apiTimeoutMs: options.apiTimeoutMs
     });
   } catch (err) {
-    log(`[${HOOK_NAME4}] Failed to inject verification feedback`, { sessionID, error: String(err) });
+    log(`[${HOOK_NAME5}] Failed to inject verification feedback`, { sessionID, error: String(err) });
   }
 }
 function createMatrixLoopEventHandler(ctx, options) {
@@ -50423,13 +51159,13 @@ function createMatrixLoopEventHandler(ctx, options) {
       if (!sessionID)
         return;
       if (inFlightSessions.has(sessionID)) {
-        log(`[${HOOK_NAME4}] Skipped: handler in flight`, { sessionID });
+        log(`[${HOOK_NAME5}] Skipped: handler in flight`, { sessionID });
         return;
       }
       inFlightSessions.add(sessionID);
       try {
         if (options.sessionRecovery.isRecovering(sessionID)) {
-          log(`[${HOOK_NAME4}] Skipped: in recovery`, { sessionID });
+          log(`[${HOOK_NAME5}] Skipped: in recovery`, { sessionID });
           return;
         }
         const state3 = options.loopState.getState();
@@ -50441,11 +51177,11 @@ function createMatrixLoopEventHandler(ctx, options) {
               const exists = await options.checkSessionExists(state3.session_id);
               if (!exists) {
                 options.loopState.clear();
-                log(`[${HOOK_NAME4}] Cleared orphaned state from deleted session`, { orphanedSessionId: state3.session_id, currentSessionId: sessionID });
+                log(`[${HOOK_NAME5}] Cleared orphaned state from deleted session`, { orphanedSessionId: state3.session_id, currentSessionId: sessionID });
                 return;
               }
             } catch (err) {
-              log(`[${HOOK_NAME4}] Failed to check session existence`, { sessionId: state3.session_id, error: String(err) });
+              log(`[${HOOK_NAME5}] Failed to check session existence`, { sessionId: state3.session_id, error: String(err) });
             }
           }
           return;
@@ -50464,7 +51200,7 @@ function createMatrixLoopEventHandler(ctx, options) {
             messages = Array.isArray(messagesResponse) ? messagesResponse : Array.isArray(responseData) ? responseData : [];
           } catch (err) {
             setTimeout(() => {
-              log(`[${HOOK_NAME4}] Session messages fetch failed`, { sessionID, error: String(err) });
+              log(`[${HOOK_NAME5}] Session messages fetch failed`, { sessionID, error: String(err) });
             }, 0);
             messages = [];
           }
@@ -50477,13 +51213,15 @@ function createMatrixLoopEventHandler(ctx, options) {
           preFetchedMessages: messages
         });
         if (completionViaTranscript || completionViaApi) {
-          log(`[${HOOK_NAME4}] Completion detected!`, { sessionID, iteration: state3.iteration, promise: state3.completion_promise, detectedVia: completionViaTranscript ? "transcript_file" : "session_messages_api" });
+          log(`[${HOOK_NAME5}] Completion detected!`, { sessionID, iteration: state3.iteration, promise: state3.completion_promise, detectedVia: completionViaTranscript ? "transcript_file" : "session_messages_api" });
           if (options.verification?.enabled === true) {
             const maxRetries = options.verification?.maxRetries ?? DEFAULT_VERIFICATION_MAX_RETRIES;
             const failedCount = state3.verification_failed_count ?? 0;
             if (failedCount >= maxRetries) {
               options.loopState.clear();
-              await ctx.client.tui.showToast({ body: { title: "Matrix Loop Complete", message: `Force-completed after ${failedCount} failed verification(s)`, variant: "warning", duration: 5000 } }).catch(() => {});
+              await ctx.client.tui.showToast({ body: { title: "Matrix Loop Complete", message: `Force-completed after ${failedCount} failed verification(s)`, variant: "warning", duration: 5000 } }).catch((err) => {
+                log("[matrix-loop] Force complete toast failed:", err);
+              });
               return;
             }
             const result = await verifyCompletion(ctx, {
@@ -50504,26 +51242,32 @@ function createMatrixLoopEventHandler(ctx, options) {
           options.loopState.clear();
           const title = state3.ultrawork ? "ULTRAWORK LOOP COMPLETE!" : "Matrix Loop Complete!";
           const message = state3.ultrawork ? `JUST ULW ULW! Task completed after ${state3.iteration} iteration(s)` : `Task completed after ${state3.iteration} iteration(s)`;
-          await ctx.client.tui.showToast({ body: { title, message, variant: "success", duration: 5000 } }).catch(() => {});
+          await ctx.client.tui.showToast({ body: { title, message, variant: "success", duration: 5000 } }).catch((err) => {
+            log("[matrix-loop] Loop complete toast failed:", err);
+          });
           return;
         }
         if (state3.iteration >= state3.max_iterations) {
-          log(`[${HOOK_NAME4}] Max iterations reached`, { sessionID, iteration: state3.iteration, max: state3.max_iterations });
+          log(`[${HOOK_NAME5}] Max iterations reached`, { sessionID, iteration: state3.iteration, max: state3.max_iterations });
           options.loopState.clear();
-          await ctx.client.tui.showToast({ body: { title: "Matrix Loop Stopped", message: `Max iterations (${state3.max_iterations}) reached without completion`, variant: "warning", duration: 5000 } }).catch(() => {});
+          await ctx.client.tui.showToast({ body: { title: "Matrix Loop Stopped", message: `Max iterations (${state3.max_iterations}) reached without completion`, variant: "warning", duration: 5000 } }).catch((err) => {
+            log("[matrix-loop] Max iterations toast failed:", err);
+          });
           return;
         }
         const newState = options.loopState.incrementIteration();
         if (!newState) {
-          log(`[${HOOK_NAME4}] Failed to increment iteration`, { sessionID });
+          log(`[${HOOK_NAME5}] Failed to increment iteration`, { sessionID });
           return;
         }
-        log(`[${HOOK_NAME4}] Continuing loop`, { sessionID, iteration: newState.iteration, max: newState.max_iterations });
-        await ctx.client.tui.showToast({ body: { title: "Matrix Loop", message: `Iteration ${newState.iteration}/${newState.max_iterations}`, variant: "info", duration: 2000 } }).catch(() => {});
+        log(`[${HOOK_NAME5}] Continuing loop`, { sessionID, iteration: newState.iteration, max: newState.max_iterations });
+        await ctx.client.tui.showToast({ body: { title: "Matrix Loop", message: `Iteration ${newState.iteration}/${newState.max_iterations}`, variant: "info", duration: 2000 } }).catch((err) => {
+          log("[matrix-loop] Iteration toast failed:", err);
+        });
         try {
           await injectContinuationPrompt(ctx, { sessionID, prompt: buildContinuationPrompt(newState), directory: options.directory, apiTimeoutMs: options.apiTimeoutMs });
         } catch (err) {
-          log(`[${HOOK_NAME4}] Failed to inject continuation`, { sessionID, error: String(err) });
+          log(`[${HOOK_NAME5}] Failed to inject continuation`, { sessionID, error: String(err) });
         }
         return;
       } finally {
@@ -50537,7 +51281,7 @@ function createMatrixLoopEventHandler(ctx, options) {
       const state3 = options.loopState.getState();
       if (state3?.session_id === sessionInfo.id) {
         options.loopState.clear();
-        log(`[${HOOK_NAME4}] Session deleted, loop cleared`, { sessionID: sessionInfo.id });
+        log(`[${HOOK_NAME5}] Session deleted, loop cleared`, { sessionID: sessionInfo.id });
       }
       options.sessionRecovery.clear(sessionInfo.id);
       return;
@@ -50550,7 +51294,7 @@ function createMatrixLoopEventHandler(ctx, options) {
           const state3 = options.loopState.getState();
           if (state3?.session_id === sessionID) {
             options.loopState.clear();
-            log(`[${HOOK_NAME4}] User aborted, loop cleared`, { sessionID });
+            log(`[${HOOK_NAME5}] User aborted, loop cleared`, { sessionID });
           }
           options.sessionRecovery.clear(sessionID);
         }
@@ -50597,7 +51341,7 @@ function createMatrixLoopHook(ctx, options) {
 // src/hooks/matrix-loop/index.ts
 init_storage();
 // src/hooks/mouse-notepad/constants.ts
-var HOOK_NAME5 = "mouse-notepad";
+var HOOK_NAME6 = "mouse-notepad";
 var NOTEPAD_DIRECTIVE = `
 <Work_Context>
 ## Notepad Location (for recording learnings)
@@ -50644,14 +51388,14 @@ function createMouseNotepadHook(ctx) {
         return;
       }
       output.args.prompt = NOTEPAD_DIRECTIVE + prompt;
-      log(`[${HOOK_NAME5}] Injected notepad directive to task`, {
+      log(`[${HOOK_NAME6}] Injected notepad directive to task`, {
         sessionID: input.sessionID
       });
     }
   };
 }
 // src/hooks/non-interactive-env/constants.ts
-var HOOK_NAME6 = "non-interactive-env";
+var HOOK_NAME7 = "non-interactive-env";
 var NON_INTERACTIVE_ENV = {
   CI: "true",
   DEBIAN_FRONTEND: "noninteractive",
@@ -50742,7 +51486,7 @@ function createNonInteractiveEnvHook(_ctx) {
       }
       const envPrefix = buildEnvPrefix(NON_INTERACTIVE_ENV, "unix");
       output.args.command = `${envPrefix} ${command}`;
-      log(`[${HOOK_NAME6}] Prepended non-interactive env vars to git command`, {
+      log(`[${HOOK_NAME7}] Prepended non-interactive env vars to git command`, {
         sessionID: input.sessionID,
         envPrefix
       });
@@ -50891,7 +51635,9 @@ function createPostCompactionDegradationMonitor(args) {
           variant: "warning",
           duration: 5000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[preemptive-compaction] Degradation toast failed:", err);
+      });
       await withTimeout2(client.session.summarize({
         path: { id: sessionID },
         body: { providerID: targetProviderID, modelID: targetModelID },
@@ -51129,7 +51875,7 @@ function createPreemptiveCompactionHook(ctx, pluginConfig = {}, modelCacheState)
   };
 }
 // src/hooks/prometheus-md-only/constants.ts
-var HOOK_NAME7 = "prometheus-md-only";
+var HOOK_NAME8 = "prometheus-md-only";
 var ORACLE_AGENT = "oracle";
 var ALLOWED_EXTENSIONS = [".md"];
 var BLOCKED_TOOLS = ["Write", "Edit", "write", "edit"];
@@ -51262,7 +52008,7 @@ function createOracleMdOnlyHook(ctx) {
         const prompt = output.args.prompt;
         if (prompt && !prompt.includes(SYSTEM_DIRECTIVE_PREFIX)) {
           output.args.prompt = PLANNING_CONSULT_WARNING + prompt;
-          log(`[${HOOK_NAME7}] Injected read-only planning warning to ${toolName}`, {
+          log(`[${HOOK_NAME8}] Injected read-only planning warning to ${toolName}`, {
             sessionID: input.sessionID,
             tool: toolName,
             agent: agentName
@@ -51278,17 +52024,17 @@ function createOracleMdOnlyHook(ctx) {
         return;
       }
       if (!isAllowedFile(filePath, ctx.directory)) {
-        log(`[${HOOK_NAME7}] Blocked: Oracle can only write to .matrixx/*.md`, {
+        log(`[${HOOK_NAME8}] Blocked: Oracle can only write to .matrixx/*.md`, {
           sessionID: input.sessionID,
           tool: toolName,
           filePath,
           agent: agentName
         });
-        throw new Error(`[${HOOK_NAME7}] ${getAgentDisplayName("oracle")} can only write/edit .md files inside .matrixx/ directory. ` + `Attempted to modify: ${filePath}. ` + `${getAgentDisplayName("oracle")} is a READ-ONLY planner. Use /start-work to execute the plan. ` + `APOLOGIZE TO THE USER, REMIND OF YOUR PLAN WRITING PROCESSES, TELL USER WHAT YOU WILL GOING TO DO AS THE PROCESS, WRITE THE PLAN`);
+        throw new Error(`[${HOOK_NAME8}] ${getAgentDisplayName("oracle")} can only write/edit .md files inside .matrixx/ directory. ` + `Attempted to modify: ${filePath}. ` + `${getAgentDisplayName("oracle")} is a READ-ONLY planner. Use /start-work to execute the plan. ` + `APOLOGIZE TO THE USER, REMIND OF YOUR PLAN WRITING PROCESSES, TELL USER WHAT YOU WILL GOING TO DO AS THE PROCESS, WRITE THE PLAN`);
       }
       const normalizedPath = filePath.toLowerCase().replace(/\\/g, "/");
       if (normalizedPath.includes(".matrixx/plans/") || normalizedPath.includes(".matrixx\\plans\\")) {
-        log(`[${HOOK_NAME7}] Injecting workflow reminder for plan write`, {
+        log(`[${HOOK_NAME8}] Injecting workflow reminder for plan write`, {
           sessionID: input.sessionID,
           tool: toolName,
           filePath,
@@ -51296,7 +52042,7 @@ function createOracleMdOnlyHook(ctx) {
         });
         output.message = (output.message || "") + PROMETHEUS_WORKFLOW_REMINDER;
       }
-      log(`[${HOOK_NAME7}] Allowed: .matrixx/*.md write permitted`, {
+      log(`[${HOOK_NAME8}] Allowed: .matrixx/*.md write permitted`, {
         sessionID: input.sessionID,
         tool: toolName,
         filePath,
@@ -52029,9 +52775,6 @@ async function resizeImage(base64DataUrl, mimeType, target, deps = {}) {
 // src/hooks/read-image-resizer/hook.ts
 var SUPPORTED_IMAGE_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
 var TOKEN_DIVISOR = 750;
-function isReadTool2(toolName) {
-  return toolName.toLowerCase() === "read";
-}
 function asRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return null;
@@ -52115,7 +52858,7 @@ function resolveFilename(attachment, index) {
 function createReadImageResizerHook(_ctx) {
   return {
     "tool.execute.after": async (input, output) => {
-      if (!isReadTool2(input.tool)) {
+      if (!isReadTool(input.tool)) {
         return;
       }
       const sessionModel = getSessionModel(input.sessionID);
@@ -52852,7 +53595,7 @@ var RETRYABLE_ERROR_PATTERNS = [
   /(?:^|\s)503(?:\s|$)/,
   /(?:^|\s)529(?:\s|$)/
 ];
-var HOOK_NAME8 = "runtime-fallback";
+var HOOK_NAME9 = "runtime-fallback";
 
 // src/hooks/runtime-fallback/fallback-models.ts
 init_logger();
@@ -52943,7 +53686,7 @@ function getRawFallbackModelsForSession(sessionID, agent, pluginConfig) {
     if (result)
       return result;
   }
-  log(`[${HOOK_NAME8}] No category/agent fallback models resolved for session`, { sessionID, agent });
+  log(`[${HOOK_NAME9}] No category/agent fallback models resolved for session`, { sessionID, agent });
   return;
 }
 
@@ -52972,21 +53715,21 @@ function findNextAvailableFallback(state3, fallbackModels, cooldownSeconds) {
     if (!isModelInCooldown(candidate, state3, cooldownSeconds)) {
       return candidate;
     }
-    log(`[${HOOK_NAME8}] Skipping fallback model in cooldown`, { model: candidate, index: i });
+    log(`[${HOOK_NAME9}] Skipping fallback model in cooldown`, { model: candidate, index: i });
   }
   return;
 }
 function prepareFallback(sessionID, state3, fallbackModels, config2) {
   if (state3.attemptCount >= config2.max_fallback_attempts) {
-    log(`[${HOOK_NAME8}] Max fallback attempts reached`, { sessionID, attempts: state3.attemptCount });
+    log(`[${HOOK_NAME9}] Max fallback attempts reached`, { sessionID, attempts: state3.attemptCount });
     return { success: false, error: "Max fallback attempts reached", maxAttemptsReached: true };
   }
   const nextModel = findNextAvailableFallback(state3, fallbackModels, config2.cooldown_seconds);
   if (!nextModel) {
-    log(`[${HOOK_NAME8}] No available fallback models`, { sessionID });
+    log(`[${HOOK_NAME9}] No available fallback models`, { sessionID });
     return { success: false, error: "No available fallback models (all in cooldown or exhausted)" };
   }
-  log(`[${HOOK_NAME8}] Preparing fallback`, {
+  log(`[${HOOK_NAME9}] Preparing fallback`, {
     sessionID,
     from: state3.currentModel,
     to: nextModel,
@@ -53064,7 +53807,7 @@ function createAutoRetryHelpers(deps) {
     ctx,
     config: config2,
     options,
-    sessionStates,
+    sessionStates: sessionStates2,
     sessionLastAccess,
     sessionRetryInFlight,
     sessionAwaitingFallbackResult,
@@ -53075,9 +53818,9 @@ function createAutoRetryHelpers(deps) {
   const abortSessionRequest = async (sessionID, source) => {
     try {
       await ctx.client.session.abort({ path: { id: sessionID } });
-      log(`[${HOOK_NAME8}] Aborted in-flight session request (${source})`, { sessionID });
+      log(`[${HOOK_NAME9}] Aborted in-flight session request (${source})`, { sessionID });
     } catch (error51) {
-      log(`[${HOOK_NAME8}] Failed to abort in-flight session request (${source})`, {
+      log(`[${HOOK_NAME9}] Failed to abort in-flight session request (${source})`, {
         sessionID,
         error: String(error51)
       });
@@ -53097,11 +53840,11 @@ function createAutoRetryHelpers(deps) {
       return;
     const timer = setTimeout(async () => {
       sessionFallbackTimeouts.delete(sessionID);
-      const state3 = sessionStates.get(sessionID);
+      const state3 = sessionStates2.get(sessionID);
       if (!state3)
         return;
       if (sessionRetryInFlight.has(sessionID)) {
-        log(`[${HOOK_NAME8}] Overriding in-flight retry due to session timeout`, { sessionID });
+        log(`[${HOOK_NAME9}] Overriding in-flight retry due to session timeout`, { sessionID });
       }
       await abortSessionRequest(sessionID, "session.timeout");
       sessionRetryInFlight.delete(sessionID);
@@ -53111,7 +53854,7 @@ function createAutoRetryHelpers(deps) {
       const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig);
       if (fallbackModels.length === 0)
         return;
-      log(`[${HOOK_NAME8}] Session fallback timeout reached`, {
+      log(`[${HOOK_NAME9}] Session fallback timeout reached`, {
         sessionID,
         timeoutSeconds: config2.timeout_seconds,
         currentModel: state3.currentModel
@@ -53125,7 +53868,7 @@ function createAutoRetryHelpers(deps) {
   };
   const autoRetryWithFallback = async (sessionID, newModel, resolvedAgent, source) => {
     if (sessionRetryInFlight.has(sessionID)) {
-      log(`[${HOOK_NAME8}] Retry already in flight, skipping (${source})`, { sessionID });
+      log(`[${HOOK_NAME9}] Retry already in flight, skipping (${source})`, { sessionID });
       return;
     }
     const agentSettings = resolvedAgent ? pluginConfig?.agents?.[resolvedAgent] : undefined;
@@ -53134,8 +53877,8 @@ function createAutoRetryHelpers(deps) {
       reasoningEffort: agentSettings.reasoningEffort
     } : undefined);
     if (!retryModelPayload) {
-      log(`[${HOOK_NAME8}] Invalid model format (missing provider prefix): ${newModel}`);
-      const state3 = sessionStates.get(sessionID);
+      log(`[${HOOK_NAME9}] Invalid model format (missing provider prefix): ${newModel}`);
+      const state3 = sessionStates2.get(sessionID);
       if (state3?.pendingFallbackModel) {
         state3.pendingFallbackModel = undefined;
       }
@@ -53150,7 +53893,7 @@ function createAutoRetryHelpers(deps) {
       });
       const retryParts = getLastUserRetryParts(messagesResp);
       if (retryParts.length > 0) {
-        log(`[${HOOK_NAME8}] Auto-retrying with fallback model (${source})`, {
+        log(`[${HOOK_NAME9}] Auto-retrying with fallback model (${source})`, {
           sessionID,
           model: newModel
         });
@@ -53169,16 +53912,16 @@ function createAutoRetryHelpers(deps) {
         });
         retryDispatched = true;
       } else {
-        log(`[${HOOK_NAME8}] No user message found for auto-retry (${source})`, { sessionID });
+        log(`[${HOOK_NAME9}] No user message found for auto-retry (${source})`, { sessionID });
       }
     } catch (retryError) {
-      log(`[${HOOK_NAME8}] Auto-retry failed (${source})`, { sessionID, error: String(retryError) });
+      log(`[${HOOK_NAME9}] Auto-retry failed (${source})`, { sessionID, error: String(retryError) });
     } finally {
       sessionRetryInFlight.delete(sessionID);
       if (!retryDispatched) {
         sessionAwaitingFallbackResult.delete(sessionID);
         clearSessionFallbackTimeout(sessionID);
-        const state3 = sessionStates.get(sessionID);
+        const state3 = sessionStates2.get(sessionID);
         if (state3?.pendingFallbackModel) {
           state3.pendingFallbackModel = undefined;
         }
@@ -53215,7 +53958,7 @@ function createAutoRetryHelpers(deps) {
     let cleanedCount = 0;
     for (const [sessionID, lastAccess] of sessionLastAccess.entries()) {
       if (now - lastAccess > SESSION_TTL_MS) {
-        sessionStates.delete(sessionID);
+        sessionStates2.delete(sessionID);
         sessionLastAccess.delete(sessionID);
         sessionRetryInFlight.delete(sessionID);
         sessionAwaitingFallbackResult.delete(sessionID);
@@ -53226,7 +53969,7 @@ function createAutoRetryHelpers(deps) {
       }
     }
     if (cleanedCount > 0) {
-      log(`[${HOOK_NAME8}] Cleaned up ${cleanedCount} stale session states`);
+      log(`[${HOOK_NAME9}] Cleaned up ${cleanedCount} stale session states`);
     }
   };
   return {
@@ -53242,12 +53985,12 @@ function createAutoRetryHelpers(deps) {
 // src/hooks/runtime-fallback/chat-message-handler.ts
 init_logger();
 function createChatMessageHandler(deps) {
-  const { config: config2, sessionStates, sessionLastAccess } = deps;
+  const { config: config2, sessionStates: sessionStates2, sessionLastAccess } = deps;
   return async (input, output) => {
     if (!config2.enabled)
       return;
     const { sessionID } = input;
-    let state3 = sessionStates.get(sessionID);
+    let state3 = sessionStates2.get(sessionID);
     if (!state3)
       return;
     sessionLastAccess.set(sessionID, Date.now());
@@ -53257,19 +54000,19 @@ function createChatMessageHandler(deps) {
         state3.pendingFallbackModel = undefined;
         return;
       }
-      log(`[${HOOK_NAME8}] Detected manual model change, resetting fallback state`, {
+      log(`[${HOOK_NAME9}] Detected manual model change, resetting fallback state`, {
         sessionID,
         from: state3.currentModel,
         to: requestedModel
       });
       state3 = createFallbackState(requestedModel);
-      sessionStates.set(sessionID, state3);
+      sessionStates2.set(sessionID, state3);
       return;
     }
     if (state3.currentModel === state3.originalModel)
       return;
     const activeModel = state3.currentModel;
-    log(`[${HOOK_NAME8}] Applying fallback model override`, {
+    log(`[${HOOK_NAME9}] Applying fallback model override`, {
       sessionID,
       from: input.model,
       to: activeModel
@@ -53456,7 +54199,7 @@ function resolveFallbackBootstrapModel(options) {
   const agentConfig = options.resolvedAgent && agentConfigs ? agentConfigs[options.resolvedAgent] : undefined;
   const agentModel = typeof agentConfig?.model === "string" ? agentConfig.model : undefined;
   if (agentModel) {
-    log(`[${HOOK_NAME8}] Derived model from agent config for ${options.source}`, {
+    log(`[${HOOK_NAME9}] Derived model from agent config for ${options.source}`, {
       sessionID: options.sessionID,
       agent: options.resolvedAgent,
       model: agentModel
@@ -53467,7 +54210,7 @@ function resolveFallbackBootstrapModel(options) {
   if (agentCategory) {
     const agentCategoryModel = options.pluginConfig?.categories?.[agentCategory]?.model;
     if (typeof agentCategoryModel === "string" && agentCategoryModel.length > 0) {
-      log(`[${HOOK_NAME8}] Derived model from agent category config for ${options.source}`, {
+      log(`[${HOOK_NAME9}] Derived model from agent category config for ${options.source}`, {
         sessionID: options.sessionID,
         agent: options.resolvedAgent,
         category: agentCategory,
@@ -53479,7 +54222,7 @@ function resolveFallbackBootstrapModel(options) {
   const sessionCategory = SessionCategoryRegistry.get(options.sessionID);
   const categoryModel = sessionCategory ? options.pluginConfig?.categories?.[sessionCategory]?.model : undefined;
   if (typeof categoryModel === "string" && categoryModel.length > 0) {
-    log(`[${HOOK_NAME8}] Derived model from session category config for ${options.source}`, {
+    log(`[${HOOK_NAME9}] Derived model from session category config for ${options.source}`, {
       sessionID: options.sessionID,
       category: sessionCategory,
       model: categoryModel
@@ -53501,13 +54244,15 @@ async function dispatchFallbackRetry(deps, helpers, options) {
         variant: "warning",
         duration: 5000
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[runtime-fallback] Fallback notification toast failed:", err);
+    });
   }
   if (result.success && result.newModel) {
     await helpers.autoRetryWithFallback(options.sessionID, result.newModel, options.resolvedAgent, options.source);
     return;
   }
-  log(`[${HOOK_NAME8}] Fallback preparation failed`, {
+  log(`[${HOOK_NAME9}] Fallback preparation failed`, {
     sessionID: options.sessionID,
     source: options.source,
     error: result.error
@@ -53555,7 +54300,7 @@ function extractRetryAttempt(statusAttempt, message) {
 function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
   const {
     pluginConfig,
-    sessionStates,
+    sessionStates: sessionStates2,
     sessionLastAccess,
     sessionRetryInFlight
   } = deps;
@@ -53582,26 +54327,26 @@ function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
     sessionStatusRetryKeys.set(sessionID, retryKey);
     if (sessionRetryInFlight.has(sessionID)) {
       if (timeoutEnabled) {
-        log(`[${HOOK_NAME8}] Overriding in-flight retry due to provider auto-retry signal`, {
+        log(`[${HOOK_NAME9}] Overriding in-flight retry due to provider auto-retry signal`, {
           sessionID,
           model
         });
         await helpers.abortSessionRequest(sessionID, "session.status.retry-signal");
         sessionRetryInFlight.delete(sessionID);
       } else {
-        log(`[${HOOK_NAME8}] session.status retry skipped - retry already in flight`, { sessionID });
+        log(`[${HOOK_NAME9}] session.status retry skipped - retry already in flight`, { sessionID });
         return;
       }
     }
     const resolvedAgent = await helpers.resolveAgentForSessionFromContext(sessionID, agent);
     const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig);
     if (fallbackModels.length === 0) {
-      if (!sessionStates.has(sessionID)) {
+      if (!sessionStates2.has(sessionID)) {
         sessionStatusRetryKeys.delete(sessionID);
       }
       return;
     }
-    let state3 = sessionStates.get(sessionID);
+    let state3 = sessionStates2.get(sessionID);
     if (!state3) {
       const initialModel = resolveFallbackBootstrapModel({
         sessionID,
@@ -53612,29 +54357,29 @@ function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
       });
       if (!initialModel) {
         sessionStatusRetryKeys.delete(sessionID);
-        log(`[${HOOK_NAME8}] session.status retry missing model info, cannot fallback`, { sessionID });
+        log(`[${HOOK_NAME9}] session.status retry missing model info, cannot fallback`, { sessionID });
         return;
       }
       state3 = createFallbackState(initialModel);
-      sessionStates.set(sessionID, state3);
+      sessionStates2.set(sessionID, state3);
     }
     sessionLastAccess.set(sessionID, Date.now());
     if (state3.pendingFallbackModel) {
       if (timeoutEnabled) {
-        log(`[${HOOK_NAME8}] Clearing pending fallback due to provider auto-retry signal`, {
+        log(`[${HOOK_NAME9}] Clearing pending fallback due to provider auto-retry signal`, {
           sessionID,
           pendingFallbackModel: state3.pendingFallbackModel
         });
         state3.pendingFallbackModel = undefined;
       } else {
-        log(`[${HOOK_NAME8}] session.status retry skipped (pending fallback in progress)`, {
+        log(`[${HOOK_NAME9}] session.status retry skipped (pending fallback in progress)`, {
           sessionID,
           pendingFallbackModel: state3.pendingFallbackModel
         });
         return;
       }
     }
-    log(`[${HOOK_NAME8}] Detected provider auto-retry signal in session.status`, {
+    log(`[${HOOK_NAME9}] Detected provider auto-retry signal in session.status`, {
       sessionID,
       model: state3.currentModel,
       retryAttempt: status.attempt
@@ -53652,13 +54397,13 @@ function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
 
 // src/hooks/runtime-fallback/event-handler.ts
 function createEventHandler(deps, helpers) {
-  const { config: config2, pluginConfig, sessionStates, sessionLastAccess, sessionRetryInFlight, sessionAwaitingFallbackResult, sessionFallbackTimeouts, sessionStatusRetryKeys } = deps;
+  const { config: config2, pluginConfig, sessionStates: sessionStates2, sessionLastAccess, sessionRetryInFlight, sessionAwaitingFallbackResult, sessionFallbackTimeouts, sessionStatusRetryKeys } = deps;
   const sessionStatusHandler = createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys);
   const cancelledSessions = new Set;
   const resetRetryState = (sessionID) => {
-    const state3 = sessionStates.get(sessionID);
+    const state3 = sessionStates2.get(sessionID);
     if (state3) {
-      sessionStates.set(sessionID, createFallbackState(state3.originalModel));
+      sessionStates2.set(sessionID, createFallbackState(state3.originalModel));
     }
     sessionRetryInFlight.delete(sessionID);
     sessionAwaitingFallbackResult.delete(sessionID);
@@ -53670,8 +54415,8 @@ function createEventHandler(deps, helpers) {
     const sessionID = sessionInfo?.id;
     const model = sessionInfo?.model;
     if (sessionID && model) {
-      log(`[${HOOK_NAME8}] Session created with model`, { sessionID, model });
-      sessionStates.set(sessionID, createFallbackState(model));
+      log(`[${HOOK_NAME9}] Session created with model`, { sessionID, model });
+      sessionStates2.set(sessionID, createFallbackState(model));
       sessionLastAccess.set(sessionID, Date.now());
     }
   };
@@ -53679,9 +54424,9 @@ function createEventHandler(deps, helpers) {
     const sessionInfo = props?.info;
     const sessionID = sessionInfo?.id;
     if (sessionID) {
-      log(`[${HOOK_NAME8}] Cleaning up session state`, { sessionID });
+      log(`[${HOOK_NAME9}] Cleaning up session state`, { sessionID });
       cancelledSessions.delete(sessionID);
-      sessionStates.delete(sessionID);
+      sessionStates2.delete(sessionID);
       sessionLastAccess.delete(sessionID);
       sessionRetryInFlight.delete(sessionID);
       sessionAwaitingFallbackResult.delete(sessionID);
@@ -53699,7 +54444,7 @@ function createEventHandler(deps, helpers) {
     }
     cancelledSessions.add(sessionID);
     resetRetryState(sessionID);
-    log(`[${HOOK_NAME8}] Cleared fallback retry state on session.stop`, { sessionID });
+    log(`[${HOOK_NAME9}] Cleared fallback retry state on session.stop`, { sessionID });
   };
   const handleMessageUpdated = (props) => {
     const info = props?.info;
@@ -53715,23 +54460,23 @@ function createEventHandler(deps, helpers) {
       return;
     if (cancelledSessions.has(sessionID)) {
       resetRetryState(sessionID);
-      log(`[${HOOK_NAME8}] Cleared fallback retry state for cancelled session on idle`, { sessionID });
+      log(`[${HOOK_NAME9}] Cleared fallback retry state for cancelled session on idle`, { sessionID });
       return;
     }
     if (sessionAwaitingFallbackResult.has(sessionID)) {
-      log(`[${HOOK_NAME8}] session.idle while awaiting fallback result; keeping timeout armed`, { sessionID });
+      log(`[${HOOK_NAME9}] session.idle while awaiting fallback result; keeping timeout armed`, { sessionID });
       return;
     }
     const hadTimeout = sessionFallbackTimeouts.has(sessionID);
     helpers.clearSessionFallbackTimeout(sessionID);
     sessionRetryInFlight.delete(sessionID);
     sessionStatusRetryKeys.delete(sessionID);
-    const state3 = sessionStates.get(sessionID);
+    const state3 = sessionStates2.get(sessionID);
     if (state3?.pendingFallbackModel) {
       state3.pendingFallbackModel = undefined;
     }
     if (hadTimeout) {
-      log(`[${HOOK_NAME8}] Cleared fallback timeout after session completion`, { sessionID });
+      log(`[${HOOK_NAME9}] Cleared fallback timeout after session completion`, { sessionID });
     }
   };
   const handleSessionError = async (props) => {
@@ -53739,18 +54484,18 @@ function createEventHandler(deps, helpers) {
     const error51 = props?.error;
     const agent = props?.agent;
     if (!sessionID) {
-      log(`[${HOOK_NAME8}] session.error without sessionID, skipping`);
+      log(`[${HOOK_NAME9}] session.error without sessionID, skipping`);
       return;
     }
     const resolvedAgent = await helpers.resolveAgentForSessionFromContext(sessionID, agent);
     if (isAbortError2(error51)) {
       cancelledSessions.add(sessionID);
       resetRetryState(sessionID);
-      log(`[${HOOK_NAME8}] session.error matched cancellation; cleared retry state`, { sessionID, resolvedAgent });
+      log(`[${HOOK_NAME9}] session.error matched cancellation; cleared retry state`, { sessionID, resolvedAgent });
       return;
     }
     if (sessionRetryInFlight.has(sessionID)) {
-      log(`[${HOOK_NAME8}] session.error skipped - retry in flight`, {
+      log(`[${HOOK_NAME9}] session.error skipped - retry in flight`, {
         sessionID,
         retryInFlight: true
       });
@@ -53758,7 +54503,7 @@ function createEventHandler(deps, helpers) {
     }
     sessionAwaitingFallbackResult.delete(sessionID);
     helpers.clearSessionFallbackTimeout(sessionID);
-    log(`[${HOOK_NAME8}] session.error received`, {
+    log(`[${HOOK_NAME9}] session.error received`, {
       sessionID,
       agent,
       resolvedAgent,
@@ -53767,7 +54512,7 @@ function createEventHandler(deps, helpers) {
       errorType: classifyErrorType(error51)
     });
     if (!isRetryableError(error51, config2.retry_on_errors)) {
-      log(`[${HOOK_NAME8}] Error not retryable, skipping fallback`, {
+      log(`[${HOOK_NAME9}] Error not retryable, skipping fallback`, {
         sessionID,
         retryable: false,
         statusCode: extractStatusCode(error51, config2.retry_on_errors),
@@ -53776,10 +54521,10 @@ function createEventHandler(deps, helpers) {
       });
       return;
     }
-    let state3 = sessionStates.get(sessionID);
+    let state3 = sessionStates2.get(sessionID);
     const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig);
     if (fallbackModels.length === 0) {
-      log(`[${HOOK_NAME8}] No fallback models configured`, { sessionID, agent });
+      log(`[${HOOK_NAME9}] No fallback models configured`, { sessionID, agent });
       return;
     }
     if (!state3) {
@@ -53791,11 +54536,11 @@ function createEventHandler(deps, helpers) {
         pluginConfig
       });
       if (!initialModel) {
-        log(`[${HOOK_NAME8}] No model info available, cannot fallback`, { sessionID });
+        log(`[${HOOK_NAME9}] No model info available, cannot fallback`, { sessionID });
         return;
       }
       state3 = createFallbackState(initialModel);
-      sessionStates.set(sessionID, state3);
+      sessionStates2.set(sessionID, state3);
       sessionLastAccess.set(sessionID, Date.now());
     } else {
       sessionLastAccess.set(sessionID, Date.now());
@@ -53907,7 +54652,7 @@ function hasVisibleAssistantResponse(extractAutoRetrySignalFn) {
 
 // src/hooks/runtime-fallback/message-update-handler.ts
 function createMessageUpdateHandler(deps, helpers) {
-  const { ctx, config: config2, pluginConfig, sessionStates, sessionLastAccess, sessionRetryInFlight, sessionAwaitingFallbackResult, sessionStatusRetryKeys } = deps;
+  const { ctx, config: config2, pluginConfig, sessionStates: sessionStates2, sessionLastAccess, sessionRetryInFlight, sessionAwaitingFallbackResult, sessionStatusRetryKeys } = deps;
   const checkVisibleResponse = hasVisibleAssistantResponse(extractAutoRetrySignal);
   return async (props) => {
     const info = props?.info;
@@ -53931,7 +54676,7 @@ function createMessageUpdateHandler(deps, helpers) {
       }
       const hasVisible = await checkVisibleResponse(ctx, sessionID, info);
       if (!hasVisible) {
-        log(`[${HOOK_NAME8}] Assistant update observed without visible final response; keeping fallback timeout`, {
+        log(`[${HOOK_NAME9}] Assistant update observed without visible final response; keeping fallback timeout`, {
           sessionID,
           model
         });
@@ -53940,21 +54685,21 @@ function createMessageUpdateHandler(deps, helpers) {
       sessionAwaitingFallbackResult.delete(sessionID);
       sessionStatusRetryKeys.delete(sessionID);
       helpers.clearSessionFallbackTimeout(sessionID);
-      const state3 = sessionStates.get(sessionID);
+      const state3 = sessionStates2.get(sessionID);
       if (state3?.pendingFallbackModel) {
         state3.pendingFallbackModel = undefined;
       }
-      log(`[${HOOK_NAME8}] Assistant response observed; cleared fallback timeout`, { sessionID, model });
+      log(`[${HOOK_NAME9}] Assistant response observed; cleared fallback timeout`, { sessionID, model });
       return;
     }
     if (sessionID && role === "assistant" && error51) {
       sessionAwaitingFallbackResult.delete(sessionID);
       if (sessionRetryInFlight.has(sessionID) && !retrySignal) {
-        log(`[${HOOK_NAME8}] message.updated fallback skipped (retry in flight)`, { sessionID });
+        log(`[${HOOK_NAME9}] message.updated fallback skipped (retry in flight)`, { sessionID });
         return;
       }
       if (retrySignal && sessionRetryInFlight.has(sessionID) && timeoutEnabled) {
-        log(`[${HOOK_NAME8}] Overriding in-flight retry due to provider auto-retry signal`, {
+        log(`[${HOOK_NAME9}] Overriding in-flight retry due to provider auto-retry signal`, {
           sessionID,
           model
         });
@@ -53962,12 +54707,12 @@ function createMessageUpdateHandler(deps, helpers) {
         sessionRetryInFlight.delete(sessionID);
       }
       if (retrySignal && timeoutEnabled) {
-        log(`[${HOOK_NAME8}] Detected provider auto-retry signal`, { sessionID, model });
+        log(`[${HOOK_NAME9}] Detected provider auto-retry signal`, { sessionID, model });
       }
       if (!retrySignal) {
         helpers.clearSessionFallbackTimeout(sessionID);
       }
-      log(`[${HOOK_NAME8}] message.updated with assistant error`, {
+      log(`[${HOOK_NAME9}] message.updated with assistant error`, {
         sessionID,
         model,
         statusCode: extractStatusCode(error51, config2.retry_on_errors),
@@ -53975,7 +54720,7 @@ function createMessageUpdateHandler(deps, helpers) {
         errorType: classifyErrorType(error51)
       });
       if (!isRetryableError(error51, config2.retry_on_errors)) {
-        log(`[${HOOK_NAME8}] message.updated error not retryable, skipping fallback`, {
+        log(`[${HOOK_NAME9}] message.updated error not retryable, skipping fallback`, {
           sessionID,
           statusCode: extractStatusCode(error51, config2.retry_on_errors),
           errorName: extractErrorName(error51),
@@ -53983,7 +54728,7 @@ function createMessageUpdateHandler(deps, helpers) {
         });
         return;
       }
-      let state3 = sessionStates.get(sessionID);
+      let state3 = sessionStates2.get(sessionID);
       const agent = info?.agent;
       const resolvedAgent = await helpers.resolveAgentForSessionFromContext(sessionID, agent);
       const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig);
@@ -53999,7 +54744,7 @@ function createMessageUpdateHandler(deps, helpers) {
           pluginConfig
         });
         if (!initialModel) {
-          log(`[${HOOK_NAME8}] message.updated missing model info, cannot fallback`, {
+          log(`[${HOOK_NAME9}] message.updated missing model info, cannot fallback`, {
             sessionID,
             errorName: extractErrorName(error51),
             errorType: classifyErrorType(error51)
@@ -54007,19 +54752,19 @@ function createMessageUpdateHandler(deps, helpers) {
           return;
         }
         state3 = createFallbackState(initialModel);
-        sessionStates.set(sessionID, state3);
+        sessionStates2.set(sessionID, state3);
         sessionLastAccess.set(sessionID, Date.now());
       } else {
         sessionLastAccess.set(sessionID, Date.now());
         if (state3.pendingFallbackModel) {
           if (retrySignal && timeoutEnabled) {
-            log(`[${HOOK_NAME8}] Clearing pending fallback due to provider auto-retry signal`, {
+            log(`[${HOOK_NAME9}] Clearing pending fallback due to provider auto-retry signal`, {
               sessionID,
               pendingFallbackModel: state3.pendingFallbackModel
             });
             state3.pendingFallbackModel = undefined;
           } else {
-            log(`[${HOOK_NAME8}] message.updated fallback skipped (pending fallback in progress)`, {
+            log(`[${HOOK_NAME9}] message.updated fallback skipped (pending fallback in progress)`, {
               sessionID,
               pendingFallbackModel: state3.pendingFallbackModel
             });
@@ -54363,6 +55108,7 @@ function createIdleNotificationScheduler(options) {
 }
 
 // src/hooks/session-notification-sender.ts
+init_logger();
 import { platform } from "os";
 
 // src/hooks/session-notification-formatting.ts
@@ -54390,6 +55136,7 @@ $Notifier.Show($Toast)
 }
 
 // src/hooks/session-notification-utils.ts
+init_logger();
 async function findCommand2(commandName) {
   try {
     return Bun.which(commandName);
@@ -54421,14 +55168,26 @@ var getPaplayPath = createCommandFinder("paplay");
 var getAplayPath = createCommandFinder("aplay");
 function startBackgroundCheck2(platform) {
   if (platform === "darwin") {
-    getOsascriptPath().catch(() => {});
-    getAfplayPath().catch(() => {});
+    getOsascriptPath().catch((err) => {
+      log("[notification] Background check failed for osascript:", err);
+    });
+    getAfplayPath().catch((err) => {
+      log("[notification] Background check failed for afplay:", err);
+    });
   } else if (platform === "linux") {
-    getNotifySendPath().catch(() => {});
-    getPaplayPath().catch(() => {});
-    getAplayPath().catch(() => {});
+    getNotifySendPath().catch((err) => {
+      log("[notification] Background check failed for notify-send:", err);
+    });
+    getPaplayPath().catch((err) => {
+      log("[notification] Background check failed for paplay:", err);
+    });
+    getAplayPath().catch((err) => {
+      log("[notification] Background check failed for aplay:", err);
+    });
   } else if (platform === "win32") {
-    getPowershellPath().catch(() => {});
+    getPowershellPath().catch((err) => {
+      log("[notification] Background check failed for powershell:", err);
+    });
   }
 }
 
@@ -54459,14 +55218,18 @@ async function sendSessionNotification(ctx, platform2, title, message) {
         return;
       const escapedTitle = escapeAppleScriptText(title);
       const escapedMessage = escapeAppleScriptText(message);
-      await ctx.$`${osascriptPath} -e ${`display notification "${escapedMessage}" with title "${escapedTitle}"`}`.catch(() => {});
+      await ctx.$`${osascriptPath} -e ${`display notification "${escapedMessage}" with title "${escapedTitle}"`}`.catch((err) => {
+        log("[notification] macOS notification failed:", err);
+      });
       break;
     }
     case "linux": {
       const notifySendPath = await getNotifySendPath();
       if (!notifySendPath)
         return;
-      await ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`.catch(() => {});
+      await ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`.catch((err) => {
+        log("[notification] Linux notification failed:", err);
+      });
       break;
     }
     case "win32": {
@@ -54474,7 +55237,9 @@ async function sendSessionNotification(ctx, platform2, title, message) {
       if (!powershellPath)
         return;
       const toastScript = buildWindowsToastScript(title, message);
-      await ctx.$`${powershellPath} -Command ${toastScript}`.catch(() => {});
+      await ctx.$`${powershellPath} -Command ${toastScript}`.catch((err) => {
+        log("[notification] Windows notification failed:", err);
+      });
       break;
     }
   }
@@ -54485,17 +55250,23 @@ async function playSessionNotificationSound(ctx, platform2, soundPath) {
       const afplayPath = await getAfplayPath();
       if (!afplayPath)
         return;
-      ctx.$`${afplayPath} ${soundPath}`.catch(() => {});
+      ctx.$`${afplayPath} ${soundPath}`.catch((err) => {
+        log("[notification] macOS sound playback failed:", err);
+      });
       break;
     }
     case "linux": {
       const paplayPath = await getPaplayPath();
       if (paplayPath) {
-        ctx.$`${paplayPath} ${soundPath} 2>/dev/null`.catch(() => {});
+        ctx.$`${paplayPath} ${soundPath} 2>/dev/null`.catch((err) => {
+          log("[notification] Linux sound playback (paplay) failed:", err);
+        });
       } else {
         const aplayPath = await getAplayPath();
         if (aplayPath) {
-          ctx.$`${aplayPath} ${soundPath} 2>/dev/null`.catch(() => {});
+          ctx.$`${aplayPath} ${soundPath} 2>/dev/null`.catch((err) => {
+            log("[notification] Linux sound playback (aplay) failed:", err);
+          });
         }
       }
       break;
@@ -54505,7 +55276,9 @@ async function playSessionNotificationSound(ctx, platform2, soundPath) {
       if (!powershellPath)
         return;
       const escaped = escapePowerShellSingleQuotedText(soundPath);
-      ctx.$`${powershellPath} -Command ${`(New-Object Media.SoundPlayer '${escaped}').PlaySync()`}`.catch(() => {});
+      ctx.$`${powershellPath} -Command ${`(New-Object Media.SoundPlayer '${escaped}').PlaySync()`}`.catch((err) => {
+        log("[notification] Windows sound playback failed:", err);
+      });
       break;
     }
   }
@@ -54923,7 +55696,9 @@ function createSessionRecoveryHook(ctx, options) {
       if (onAbortCallback) {
         onAbortCallback(sessionID);
       }
-      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+      await ctx.client.session.abort({ path: { id: sessionID } }).catch((err) => {
+        log("[session-recovery] Session abort failed:", err);
+      });
       const messagesResp = await ctx.client.session.messages({
         path: { id: sessionID },
         query: { directory: ctx.directory }
@@ -54952,7 +55727,9 @@ function createSessionRecoveryHook(ctx, options) {
           variant: "warning",
           duration: 3000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[session-recovery] Recovery toast failed:", err);
+      });
       let success2 = false;
       if (errorType === "tool_result_missing") {
         success2 = await recoverToolResultMissing(ctx.client, sessionID, failedMsg);
@@ -54993,7 +55770,7 @@ function createSessionRecoveryHook(ctx, options) {
 }
 // src/hooks/start-work/start-work-hook.ts
 init_logger();
-var HOOK_NAME9 = "start-work";
+var HOOK_NAME10 = "start-work";
 var KEYWORD_PATTERN = /\b(ultrawork|ulw)\b/gi;
 function extractUserRequestPlanName(promptText) {
   const userRequestMatch = promptText.match(/<user-request>\s*([\s\S]*?)\s*<\/user-request>/i);
@@ -55023,7 +55800,7 @@ function createStartWorkHook(ctx) {
       if (!isStartWorkCommand) {
         return;
       }
-      log(`[${HOOK_NAME9}] Processing start-work command`, {
+      log(`[${HOOK_NAME10}] Processing start-work command`, {
         sessionID: input.sessionID
       });
       updateSessionAgent(input.sessionID, "architect");
@@ -55033,7 +55810,7 @@ function createStartWorkHook(ctx) {
       let contextInfo = "";
       const explicitPlanName = extractUserRequestPlanName(promptText);
       if (explicitPlanName) {
-        log(`[${HOOK_NAME9}] Explicit plan name requested: ${explicitPlanName}`, {
+        log(`[${HOOK_NAME10}] Explicit plan name requested: ${explicitPlanName}`, {
           sessionID: input.sessionID
         });
         const allPlans = findOraclePlans(ctx.directory);
@@ -55174,7 +55951,7 @@ Ask the user which plan to work on. Present the options above and wait for their
 ---
 ${contextInfo}`;
       }
-      log(`[${HOOK_NAME9}] Context injected`, {
+      log(`[${HOOK_NAME10}] Context injected`, {
         sessionID: input.sessionID,
         hasExistingState: !!existingState
       });
@@ -55183,16 +55960,16 @@ ${contextInfo}`;
 }
 // src/hooks/stop-continuation-guard/hook.ts
 init_logger();
-var HOOK_NAME10 = "stop-continuation-guard";
+var HOOK_NAME11 = "stop-continuation-guard";
 function createStopContinuationGuardHook(_ctx, options) {
   const stoppedSessions = new Set;
   const stop = (sessionID) => {
     stoppedSessions.add(sessionID);
-    log(`[${HOOK_NAME10}] Continuation stopped for session`, { sessionID });
+    log(`[${HOOK_NAME11}] Continuation stopped for session`, { sessionID });
     if (options?.backgroundManager) {
       const cancelled = options.backgroundManager.cancelAllForSession(sessionID);
       if (cancelled > 0) {
-        log(`[${HOOK_NAME10}] Cancelled ${cancelled} background task(s) for session`, { sessionID });
+        log(`[${HOOK_NAME11}] Cancelled ${cancelled} background task(s) for session`, { sessionID });
       }
     }
   };
@@ -55201,7 +55978,7 @@ function createStopContinuationGuardHook(_ctx, options) {
   };
   const clear = (sessionID) => {
     stoppedSessions.delete(sessionID);
-    log(`[${HOOK_NAME10}] Continuation guard cleared for session`, { sessionID });
+    log(`[${HOOK_NAME11}] Continuation guard cleared for session`, { sessionID });
   };
   const event = async ({
     event: event2
@@ -55211,7 +55988,7 @@ function createStopContinuationGuardHook(_ctx, options) {
       const sessionInfo = props?.info;
       if (sessionInfo?.id) {
         clear(sessionInfo.id);
-        log(`[${HOOK_NAME10}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
+        log(`[${HOOK_NAME11}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
       }
     }
   };
@@ -55220,7 +55997,7 @@ function createStopContinuationGuardHook(_ctx, options) {
   }) => {
     if (sessionID && stoppedSessions.has(sessionID)) {
       clear(sessionID);
-      log(`[${HOOK_NAME10}] Cleared stop state on new user message`, { sessionID });
+      log(`[${HOOK_NAME11}] Cleared stop state on new user message`, { sessionID });
     }
   };
   return {
@@ -55232,7 +56009,7 @@ function createStopContinuationGuardHook(_ctx, options) {
   };
 }
 // src/hooks/task-notepad/constants.ts
-var HOOK_NAME11 = "task-notepad";
+var HOOK_NAME12 = "task-notepad";
 var PLAN_DIR_NAME = ".matrixx";
 var PLANS_SUBDIR = "plans";
 var NOTEPAD_DIR_NAME = "notepads";
@@ -55261,7 +56038,7 @@ function createTaskNotepadHook(ctx) {
       const plan = resolveActivePlan(ctx.directory);
       if (inProgress) {
         if (!plan) {
-          log(`[${HOOK_NAME11}] No active plan, skipping notepad creation`, {
+          log(`[${HOOK_NAME12}] No active plan, skipping notepad creation`, {
             sessionID: input.sessionID
           });
         } else {
@@ -55288,7 +56065,7 @@ async function fetchTodos(ctx, sessionID) {
     }
     return [];
   } catch (err) {
-    log(`[${HOOK_NAME11}] ${TODO_FETCH_ERROR_FRAGMENT}`, {
+    log(`[${HOOK_NAME12}] ${TODO_FETCH_ERROR_FRAGMENT}`, {
       sessionID,
       error: String(err)
     });
@@ -55333,7 +56110,7 @@ function ensureNotepad(directory, planName, todo) {
   mkdirSync12(dirname15(notepadPath), { recursive: true });
   const content = renderNotepad(todo);
   writeFileSync16(notepadPath, content, "utf-8");
-  log(`[${HOOK_NAME11}] Created task notepad`, { plan: planName, taskID: todo.id });
+  log(`[${HOOK_NAME12}] Created task notepad`, { plan: planName, taskID: todo.id });
 }
 function appendCompletion(directory, planName, todo) {
   const notepadPath = notepadPathFor(directory, planName, todo.id);
@@ -55349,7 +56126,7 @@ function appendCompletion(directory, planName, todo) {
 - status: completed
 `;
   writeFileSync16(notepadPath, updated, "utf-8");
-  log(`[${HOOK_NAME11}] Appended completion to notepad`, { plan: planName, taskID: todo.id });
+  log(`[${HOOK_NAME12}] Appended completion to notepad`, { plan: planName, taskID: todo.id });
 }
 function notepadPathFor(directory, planName, taskID) {
   return join54(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
@@ -55931,7 +56708,7 @@ function createThinkingBlockValidatorHook() {
 init_logger();
 
 // src/hooks/todo-continuation-enforcer/constants.ts
-var HOOK_NAME12 = "todo-continuation-enforcer";
+var HOOK_NAME13 = "todo-continuation-enforcer";
 var DEFAULT_SKIP_AGENTS = ["oracle", "compaction"];
 var CONTINUATION_PROMPT2 = `${createSystemDirective(SystemDirectiveTypes.TODO_CONTINUATION)}
 
@@ -55997,12 +56774,12 @@ async function injectContinuation(args) {
   } = args;
   const state3 = sessionStateStore.getExistingState(sessionID);
   if (state3?.isRecovering) {
-    log(`[${HOOK_NAME12}] Skipped injection: in recovery`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped injection: in recovery`, { sessionID });
     return;
   }
   const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
   if (hasRunningBgTasks) {
-    log(`[${HOOK_NAME12}] Skipped injection: background tasks running`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped injection: background tasks running`, { sessionID });
     return;
   }
   let todos = [];
@@ -56010,12 +56787,12 @@ async function injectContinuation(args) {
     const response = await ctx.client.session.todo({ path: { id: sessionID } });
     todos = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
   } catch (error51) {
-    log(`[${HOOK_NAME12}] Failed to fetch todos`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME13}] Failed to fetch todos`, { sessionID, error: String(error51) });
     return;
   }
   const freshIncompleteCount = getIncompleteCount(todos);
   if (freshIncompleteCount === 0) {
-    log(`[${HOOK_NAME12}] Skipped injection: no incomplete todos`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped injection: no incomplete todos`, { sessionID });
     return;
   }
   let agentName = resolvedInfo?.agent;
@@ -56038,11 +56815,11 @@ async function injectContinuation(args) {
     tools = tools ?? previousMessage?.tools;
   }
   if (agentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(agentName))) {
-    log(`[${HOOK_NAME12}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
+    log(`[${HOOK_NAME13}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
     return;
   }
   if (!hasWritePermission(tools)) {
-    log(`[${HOOK_NAME12}] Skipped: agent lacks write permission`, { sessionID, agent: agentName });
+    log(`[${HOOK_NAME13}] Skipped: agent lacks write permission`, { sessionID, agent: agentName });
     return;
   }
   const incompleteTodos = todos.filter((todo) => todo.status !== "completed" && todo.status !== "cancelled");
@@ -56059,7 +56836,7 @@ ${todoList}`;
     injectionState.inFlight = true;
   }
   try {
-    log(`[${HOOK_NAME12}] Injecting continuation`, {
+    log(`[${HOOK_NAME13}] Injecting continuation`, {
       sessionID,
       agent: agentName,
       model,
@@ -56074,14 +56851,14 @@ ${todoList}`;
       },
       query: { directory: ctx.directory }
     });
-    log(`[${HOOK_NAME12}] Injection successful`, { sessionID });
+    log(`[${HOOK_NAME13}] Injection successful`, { sessionID });
     if (injectionState) {
       injectionState.inFlight = false;
       injectionState.lastInjectedAt = Date.now();
       injectionState.consecutiveFailures = 0;
     }
   } catch (error51) {
-    log(`[${HOOK_NAME12}] Injection failed`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME13}] Injection failed`, { sessionID, error: String(error51) });
     if (injectionState) {
       injectionState.inFlight = false;
       injectionState.lastInjectedAt = Date.now();
@@ -56099,7 +56876,9 @@ async function showCountdownToast(ctx, seconds, incompleteCount) {
       variant: "warning",
       duration: TOAST_DURATION_MS
     }
-  }).catch(() => {});
+  }).catch((err) => {
+    log("[todo-continuation] Countdown toast failed:", err);
+  });
 }
 function startCountdown(args) {
   const {
@@ -56133,7 +56912,7 @@ function startCountdown(args) {
       sessionStateStore
     });
   }, COUNTDOWN_SECONDS * 1000);
-  log(`[${HOOK_NAME12}] Countdown started`, {
+  log(`[${HOOK_NAME13}] Countdown started`, {
     sessionID,
     seconds: COUNTDOWN_SECONDS,
     incompleteCount
@@ -56150,16 +56929,16 @@ async function handleSessionIdle(args) {
     skipAgents = DEFAULT_SKIP_AGENTS,
     isContinuationStopped
   } = args;
-  log(`[${HOOK_NAME12}] session.idle`, { sessionID });
+  log(`[${HOOK_NAME13}] session.idle`, { sessionID });
   const state3 = sessionStateStore.getState(sessionID);
   if (state3.isRecovering) {
-    log(`[${HOOK_NAME12}] Skipped: in recovery`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped: in recovery`, { sessionID });
     return;
   }
   if (state3.abortDetectedAt) {
     const timeSinceAbort = Date.now() - state3.abortDetectedAt;
     if (timeSinceAbort < ABORT_WINDOW_MS) {
-      log(`[${HOOK_NAME12}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
+      log(`[${HOOK_NAME13}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
       state3.abortDetectedAt = undefined;
       return;
     }
@@ -56167,7 +56946,7 @@ async function handleSessionIdle(args) {
   }
   const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
   if (hasRunningBgTasks) {
-    log(`[${HOOK_NAME12}] Skipped: background tasks running`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped: background tasks running`, { sessionID });
     return;
   }
   try {
@@ -56177,42 +56956,42 @@ async function handleSessionIdle(args) {
     });
     const messages = normalizeSDKResponse(messagesResp, []);
     if (isLastAssistantMessageAborted(messages)) {
-      log(`[${HOOK_NAME12}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
+      log(`[${HOOK_NAME13}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
       return;
     }
   } catch (error51) {
-    log(`[${HOOK_NAME12}] Messages fetch failed, continuing`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME13}] Messages fetch failed, continuing`, { sessionID, error: String(error51) });
   }
   let todos = [];
   try {
     const response = await ctx.client.session.todo({ path: { id: sessionID } });
     todos = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
   } catch (error51) {
-    log(`[${HOOK_NAME12}] Todo fetch failed`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME13}] Todo fetch failed`, { sessionID, error: String(error51) });
     return;
   }
   if (!todos || todos.length === 0) {
-    log(`[${HOOK_NAME12}] No todos`, { sessionID });
+    log(`[${HOOK_NAME13}] No todos`, { sessionID });
     return;
   }
   const incompleteCount = getIncompleteCount(todos);
   if (incompleteCount === 0) {
-    log(`[${HOOK_NAME12}] All todos complete`, { sessionID, total: todos.length });
+    log(`[${HOOK_NAME13}] All todos complete`, { sessionID, total: todos.length });
     return;
   }
   if (state3.inFlight) {
-    log(`[${HOOK_NAME12}] Skipped: injection in flight`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped: injection in flight`, { sessionID });
     return;
   }
   if (state3.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && state3.lastInjectedAt && Date.now() - state3.lastInjectedAt >= FAILURE_RESET_WINDOW_MS) {
     state3.consecutiveFailures = 0;
-    log(`[${HOOK_NAME12}] Reset consecutive failures after recovery window`, {
+    log(`[${HOOK_NAME13}] Reset consecutive failures after recovery window`, {
       sessionID,
       failureResetWindowMs: FAILURE_RESET_WINDOW_MS
     });
   }
   if (state3.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-    log(`[${HOOK_NAME12}] Skipped: max consecutive failures reached`, {
+    log(`[${HOOK_NAME13}] Skipped: max consecutive failures reached`, {
       sessionID,
       consecutiveFailures: state3.consecutiveFailures,
       maxConsecutiveFailures: MAX_CONSECUTIVE_FAILURES
@@ -56221,7 +57000,7 @@ async function handleSessionIdle(args) {
   }
   const effectiveCooldown = CONTINUATION_COOLDOWN_MS2 * 2 ** Math.min(state3.consecutiveFailures, 5);
   if (state3.lastInjectedAt && Date.now() - state3.lastInjectedAt < effectiveCooldown) {
-    log(`[${HOOK_NAME12}] Skipped: cooldown active`, {
+    log(`[${HOOK_NAME13}] Skipped: cooldown active`, {
       sessionID,
       effectiveCooldown,
       consecutiveFailures: state3.consecutiveFailures
@@ -56251,20 +57030,20 @@ async function handleSessionIdle(args) {
       }
     }
   } catch (error51) {
-    log(`[${HOOK_NAME12}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME13}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
   }
-  log(`[${HOOK_NAME12}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
+  log(`[${HOOK_NAME13}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
   const resolvedAgentName = resolvedInfo?.agent;
   if (resolvedAgentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(resolvedAgentName))) {
-    log(`[${HOOK_NAME12}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
+    log(`[${HOOK_NAME13}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
     return;
   }
   if (hasCompactionMessage && !resolvedInfo?.agent) {
-    log(`[${HOOK_NAME12}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
     return;
   }
   if (isContinuationStopped?.(sessionID)) {
-    log(`[${HOOK_NAME12}] Skipped: continuation stopped for session`, { sessionID });
+    log(`[${HOOK_NAME13}] Skipped: continuation stopped for session`, { sessionID });
     return;
   }
   startCountdown({
@@ -56294,7 +57073,7 @@ function handleNonIdleEvent(args) {
       if (state3?.countdownStartedAt) {
         const elapsed = Date.now() - state3.countdownStartedAt;
         if (elapsed < COUNTDOWN_GRACE_PERIOD_MS) {
-          log(`[${HOOK_NAME12}] Ignoring user message in grace period`, { sessionID, elapsed });
+          log(`[${HOOK_NAME13}] Ignoring user message in grace period`, { sessionID, elapsed });
           return;
         }
       }
@@ -56338,7 +57117,7 @@ function handleNonIdleEvent(args) {
     const sessionInfo = properties?.info;
     if (sessionInfo?.id) {
       sessionStateStore.cleanup(sessionInfo.id);
-      log(`[${HOOK_NAME12}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
+      log(`[${HOOK_NAME13}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
     }
     return;
   }
@@ -56363,10 +57142,10 @@ function createTodoContinuationHandler(args) {
       if (error51?.name === "MessageAbortedError" || error51?.name === "AbortError") {
         const state3 = sessionStateStore.getState(sessionID);
         state3.abortDetectedAt = Date.now();
-        log(`[${HOOK_NAME12}] Abort detected via session.error`, { sessionID, errorName: error51.name });
+        log(`[${HOOK_NAME13}] Abort detected via session.error`, { sessionID, errorName: error51.name });
       }
       sessionStateStore.cancelCountdown(sessionID);
-      log(`[${HOOK_NAME12}] session.error`, { sessionID });
+      log(`[${HOOK_NAME13}] session.error`, { sessionID });
       return;
     }
     if (event.type === "session.idle") {
@@ -56481,13 +57260,13 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
     const state3 = sessionStateStore.getState(sessionID);
     state3.isRecovering = true;
     sessionStateStore.cancelCountdown(sessionID);
-    log(`[${HOOK_NAME12}] Session marked as recovering`, { sessionID });
+    log(`[${HOOK_NAME13}] Session marked as recovering`, { sessionID });
   };
   const markRecoveryComplete = (sessionID) => {
     const state3 = sessionStateStore.getExistingState(sessionID);
     if (state3) {
       state3.isRecovering = false;
-      log(`[${HOOK_NAME12}] Session recovery complete`, { sessionID });
+      log(`[${HOOK_NAME13}] Session recovery complete`, { sessionID });
     }
   };
   const handler = createTodoContinuationHandler({
@@ -56499,7 +57278,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
   });
   const cancelAllCountdowns = () => {
     sessionStateStore.cancelAllCountdowns();
-    log(`[${HOOK_NAME12}] All countdowns cancelled`);
+    log(`[${HOOK_NAME13}] All countdowns cancelled`);
   };
   return {
     handler,
@@ -56759,7 +57538,7 @@ This is a reminder only. No automatic action was taken.`;
 }
 // src/hooks/unstable-agent-babysitter/unstable-agent-babysitter-hook.ts
 init_logger();
-var HOOK_NAME13 = "unstable-agent-babysitter";
+var HOOK_NAME14 = "unstable-agent-babysitter";
 var DEFAULT_TIMEOUT_MS = 120000;
 var COOLDOWN_MS = 5 * 60 * 1000;
 async function resolveMainSessionTarget(ctx, sessionID) {
@@ -56779,7 +57558,7 @@ async function resolveMainSessionTarget(ctx, sessionID) {
       }
     }
   } catch (error51) {
-    log(`[${HOOK_NAME13}] Failed to resolve main session agent`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME14}] Failed to resolve main session agent`, { sessionID, error: String(error51) });
   }
   return { agent, model };
 }
@@ -56812,7 +57591,7 @@ async function getThinkingSummary(ctx, sessionID) {
       return combined;
     return `${combined.slice(0, THINKING_SUMMARY_MAX_CHARS)}...`;
   } catch (error51) {
-    log(`[${HOOK_NAME13}] Failed to fetch thinking summary`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME14}] Failed to fetch thinking summary`, { sessionID, error: String(error51) });
     return null;
   }
 }
@@ -56861,9 +57640,9 @@ function createUnstableAgentBabysitterHook(ctx, options) {
           query: { directory: ctx.directory }
         });
         reminderCooldowns.set(task.id, now);
-        log(`[${HOOK_NAME13}] Reminder injected`, { taskId: task.id, sessionID: mainSessionID });
+        log(`[${HOOK_NAME14}] Reminder injected`, { taskId: task.id, sessionID: mainSessionID });
       } catch (error51) {
-        log(`[${HOOK_NAME13}] Reminder injection failed`, { taskId: task.id, error: String(error51) });
+        log(`[${HOOK_NAME14}] Reminder injection failed`, { taskId: task.id, error: String(error51) });
       }
     }
   };
@@ -58120,12 +58899,18 @@ class LSPClient extends LSPClientConnection {
     });
   }
 }
+// src/tools/lsp/lsp-server.ts
+init_logger();
+
 // src/tools/lsp/lsp-manager-process-cleanup.ts
+init_logger();
 function registerLspManagerProcessCleanup(options) {
   const syncCleanup = () => {
     for (const [, managed] of options.getClients()) {
       try {
-        managed.client.stop().catch(() => {});
+        managed.client.stop().catch((err) => {
+          log("[lsp] Sync cleanup failed:", err);
+        });
       } catch {}
     }
     options.clearClients();
@@ -58134,17 +58919,26 @@ function registerLspManagerProcessCleanup(options) {
   const asyncCleanup = async () => {
     const stopPromises = [];
     for (const [, managed] of options.getClients()) {
-      stopPromises.push(managed.client.stop().catch(() => {}));
+      stopPromises.push(managed.client.stop().catch((err) => {
+        log("[lsp] Async cleanup failed:", err);
+        return;
+      }));
     }
     await Promise.allSettled(stopPromises);
     options.clearClients();
     options.clearCleanupInterval();
   };
   process.on("exit", syncCleanup);
-  process.on("SIGINT", () => void asyncCleanup().catch(() => {}));
-  process.on("SIGTERM", () => void asyncCleanup().catch(() => {}));
+  process.on("SIGINT", () => void asyncCleanup().catch((err) => {
+    log("[lsp] Signal handler cleanup failed:", err);
+  }));
+  process.on("SIGTERM", () => void asyncCleanup().catch((err) => {
+    log("[lsp] Signal handler cleanup failed:", err);
+  }));
   if (process.platform === "win32") {
-    process.on("SIGBREAK", () => void asyncCleanup().catch(() => {}));
+    process.on("SIGBREAK", () => void asyncCleanup().catch((err) => {
+      log("[lsp] Signal handler cleanup failed:", err);
+    }));
   }
 }
 
@@ -58314,7 +59108,9 @@ class LSPServerManager {
       }
     }).catch(() => {
       this.clients.delete(key);
-      client.stop().catch(() => {});
+      client.stop().catch((err) => {
+        log("[lsp] Warmup client stop failed:", err);
+      });
     });
   }
   releaseClient(root, serverId) {
@@ -71172,6 +71968,7 @@ import { existsSync as existsSync48 } from "fs";
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/ast-grep/cli-binary-path-resolution.ts
+init_logger();
 import { existsSync as existsSync47 } from "fs";
 
 // src/tools/ast-grep/language-support.ts
@@ -72798,6 +73595,9 @@ function createHandoffTools(ctx) {
   });
   return { handoff };
 }
+// src/tools/interactive-bash/tools.ts
+init_logger();
+
 // src/tools/interactive-bash/constants.ts
 var DEFAULT_TIMEOUT_MS5 = 60000;
 var BLOCKED_TMUX_SUBCOMMANDS = [
@@ -72899,7 +73699,9 @@ The Bash tool can execute these commands directly. Do NOT retry with interactive
           const timeoutError = new Error(`Timeout after ${DEFAULT_TIMEOUT_MS5}ms`);
           try {
             proc.kill();
-            proc.exited.catch(() => {});
+            proc.exited.catch((err) => {
+              log("[interactive-bash] Process cleanup failed:", err);
+            });
           } catch {}
           reject(timeoutError);
         }, DEFAULT_TIMEOUT_MS5);
@@ -74728,6 +75530,376 @@ function createBackgroundOutput(manager, client2) {
 }
 // src/tools/background-task/create-background-task.ts
 init_logger();
+// src/tools/assembly/constants.ts
+var DEFAULT_VOTERS = 3;
+var DEFAULT_ROUNDS = 2;
+var VOTER_TIMEOUT_MS = 120000;
+var POLL_INTERVAL_MS = 1000;
+var DEFAULT_PROVIDERS = [
+  { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
+  { providerID: "openai", modelID: "gpt-4o" },
+  { providerID: "google", modelID: "gemini-2.5-pro" }
+];
+
+// src/tools/assembly/provider-selector.ts
+function selectProviders(count, modelsOverride, config4) {
+  if (modelsOverride && modelsOverride.length > 0) {
+    return modelsOverride.slice(0, count).map((m) => {
+      const parts = m.split(":");
+      if (parts.length >= 2) {
+        return { providerID: parts[0], modelID: parts.slice(1).join(":") };
+      }
+      return { providerID: "custom", modelID: m };
+    });
+  }
+  const configuredProviders = config4?.providers ?? DEFAULT_PROVIDERS;
+  if (configuredProviders.length === 0) {
+    return DEFAULT_PROVIDERS.slice(0, count);
+  }
+  if (configuredProviders.length <= count) {
+    return configuredProviders;
+  }
+  const selected = [];
+  const usedProviderIds = new Set;
+  for (const p of configuredProviders) {
+    if (selected.length >= count)
+      break;
+    if (!usedProviderIds.has(p.providerID)) {
+      selected.push(p);
+      usedProviderIds.add(p.providerID);
+    }
+  }
+  if (selected.length < count) {
+    for (const p of configuredProviders) {
+      if (selected.length >= count)
+        break;
+      if (!selected.includes(p)) {
+        selected.push(p);
+      }
+    }
+  }
+  return selected;
+}
+
+// src/tools/assembly/synthesizer.ts
+async function synthesizeResults(manager, question, voterResults, round, parentSessionID, parentMessageID) {
+  const voterContext = voterResults.map((v, i) => `--- Voter ${i + 1} (${v.modelLabel}) ---
+Status: ${v.status}
+${v.status === "completed" ? v.reasoning : `Error: ${v.error}`}`).join(`
+
+`);
+  const synthesisPrompt = `You are the synthesis agent. Multiple AI voters have independently analyzed a question. Your task is to synthesize their reasoning into a unified consensus.
+
+## Question
+${question}
+
+## Voter Analyses
+${voterContext}
+
+## Synthesis Round
+This is round #${round}.
+
+## Your Task
+1. Identify points of agreement across all voters
+2. Identify points of disagreement or divergence
+3. Weigh the strength of evidence and reasoning from each
+4. Produce a unified consensus with confidence level
+
+## Output Format
+## Consensus
+[Your unified answer/conclusion]
+
+## Confidence Level
+[High/Medium/Low - with rationale]
+
+## Key Agreements
+- [Point 1]
+- [Point 2]
+
+## Key Disagreements
+- [Point 1]
+- [Point 2]
+`;
+  const synthesisTask = await manager.launch({
+    description: `Assembly synthesis round ${round}`,
+    prompt: synthesisPrompt,
+    agent: "mouse",
+    parentSessionID,
+    parentMessageID,
+    model: {
+      providerID: "anthropic",
+      modelID: "claude-sonnet-4-20250514",
+      temperature: 0.1
+    }
+  });
+  const deadline = Date.now() + 120000;
+  while (Date.now() < deadline) {
+    const current = manager.getTask(synthesisTask.id);
+    if (!current)
+      break;
+    if (current.status === "completed") {
+      return parseSynthesis(current.result ?? "", round);
+    }
+    if (current.status === "error" || current.status === "cancelled" || current.status === "interrupt") {
+      return {
+        round,
+        consensus: `Synthesis failed: ${current.error ?? "Unknown"}`,
+        confidence: "low",
+        disagreements: voterResults.filter((v) => v.status === "completed").map((v) => v.modelLabel)
+      };
+    }
+    await delay4(POLL_INTERVAL_MS);
+  }
+  return {
+    round,
+    consensus: "Synthesis timed out",
+    confidence: "low",
+    disagreements: voterResults.filter((v) => v.status === "completed").map((v) => v.modelLabel)
+  };
+}
+function parseSynthesis(text, round) {
+  const confidenceMatch = text.match(/## Confidence Level\s*\n([^\n]+)/);
+  const confidenceRaw = (confidenceMatch?.[1] ?? "medium").toLowerCase();
+  const confidence = confidenceRaw.includes("high") ? "high" : confidenceRaw.includes("low") ? "low" : "medium";
+  const consensusMatch = text.match(/## Consensus\s*\n([\s\S]*?)(?=\n## Confidence Level|\n## Key Agreements|\n$)/);
+  const consensus = consensusMatch?.[1]?.trim() ?? text;
+  const disagreements = [];
+  const disagreementsMatch = text.match(/## Key Disagreements\s*\n([\s\S]*?)(?=\n## |$)/);
+  if (disagreementsMatch) {
+    const lines = disagreementsMatch[1].trim().split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.replace(/^[-*]\s*/, "").trim();
+      if (trimmed)
+        disagreements.push(trimmed);
+    }
+  }
+  return { round, consensus, confidence, disagreements };
+}
+function delay4(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+
+// src/tools/assembly/voter-spawner.ts
+async function spawnVoters(manager, question, providers, parentSessionID, parentMessageID) {
+  const tasks = providers.map((provider, index) => manager.launch({
+    description: `Assembly voter ${index + 1}`,
+    prompt: `You are voter #${index + 1} in a multi-model assembly process. Analyze the following question independently and provide your reasoning. Be thorough and consider multiple angles.
+
+Question: ${question}
+
+Output your analysis in this format:
+## Reasoning
+[Your detailed step-by-step reasoning]
+
+## Conclusion
+[Your final answer/conclusion]
+
+## Confidence
+[High/Medium/Low - with justification]`,
+    agent: "mouse",
+    parentSessionID,
+    parentMessageID,
+    model: {
+      providerID: provider.providerID,
+      modelID: provider.modelID,
+      temperature: 0.3
+    }
+  }));
+  const launchedTasks = await Promise.all(tasks);
+  const results = await Promise.all(launchedTasks.map(async (task, index) => {
+    const provider = providers[index];
+    const deadline = Date.now() + VOTER_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      const current = manager.getTask(task.id);
+      if (!current)
+        break;
+      if (current.status === "completed") {
+        return {
+          voterIndex: index,
+          modelLabel: `${provider.providerID}:${provider.modelID}`,
+          reasoning: current.result ?? "",
+          status: "completed"
+        };
+      }
+      if (current.status === "error") {
+        return {
+          voterIndex: index,
+          modelLabel: `${provider.providerID}:${provider.modelID}`,
+          reasoning: "",
+          status: "error",
+          error: current.error ?? "Unknown error"
+        };
+      }
+      if (current.status === "cancelled" || current.status === "interrupt") {
+        return {
+          voterIndex: index,
+          modelLabel: `${provider.providerID}:${provider.modelID}`,
+          reasoning: "",
+          status: "error",
+          error: `Voter ${index + 1} was ${current.status}`
+        };
+      }
+      await delay5(POLL_INTERVAL_MS);
+    }
+    return {
+      voterIndex: index,
+      modelLabel: `${provider.providerID}:${provider.modelID}`,
+      reasoning: "",
+      status: "timeout",
+      error: `Voter ${index + 1} timed out after ${VOTER_TIMEOUT_MS}ms`
+    };
+  }));
+  return results;
+}
+function delay5(ms) {
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
+}
+
+// src/tools/assembly/assembly-executor.ts
+async function executeAssembly(input) {
+  const { manager, args, config: config4, sessionID, messageID } = input;
+  const voterCount = args.voters ?? config4?.default_voters ?? DEFAULT_VOTERS;
+  const roundCount = args.rounds ?? config4?.default_rounds ?? DEFAULT_ROUNDS;
+  const providers = selectProviders(voterCount, args.models, config4);
+  let currentVoterResults = [];
+  const synthesisRounds = [];
+  for (let round = 0;round < roundCount; round++) {
+    if (round === 0) {
+      currentVoterResults = await spawnVoters(manager, args.question, providers, sessionID, messageID);
+    }
+    const synthesis = await synthesizeResults(manager, args.question, currentVoterResults, round + 1, sessionID, messageID);
+    synthesisRounds.push(synthesis);
+    if (synthesis.confidence === "high" && round < roundCount - 1) {
+      break;
+    }
+    if (round < roundCount - 1) {
+      currentVoterResults = currentVoterResults.map((v, _i) => ({
+        ...v,
+        reasoning: `${v.reasoning}
+
+--- Round ${round + 1} Synthesis Feedback ---
+${synthesis.consensus}`
+      }));
+    }
+  }
+  const finalSynthesis = synthesisRounds[synthesisRounds.length - 1];
+  return {
+    question: args.question,
+    voters: currentVoterResults,
+    rounds: synthesisRounds,
+    finalConsensus: formatFinalConsensus(args.question, finalSynthesis, currentVoterResults)
+  };
+}
+function formatFinalConsensus(question, final, voterResults) {
+  const completed = voterResults.filter((v) => v.status === "completed");
+  const errored = voterResults.filter((v) => v.status !== "completed");
+  let output = `# Assembly Result
+
+`;
+  output += `**Question**: ${question}
+`;
+  output += `**Confidence**: ${final.confidence}
+`;
+  output += `**Voters**: ${completed.length}/${voterResults.length} completed`;
+  if (errored.length > 0) {
+    output += ` (${errored.map((v) => `${v.voterIndex + 1}: ${v.error}`).join(", ")})`;
+  }
+  output += `
+
+## Final Consensus
+
+${final.consensus}
+
+`;
+  if (final.disagreements.length > 0) {
+    output += `## Disagreements
+
+`;
+    for (const d of final.disagreements) {
+      output += `- ${d}
+`;
+    }
+    output += `
+`;
+  }
+  output += `## Per-Voter Reasoning
+
+`;
+  for (const v of voterResults) {
+    output += `### Voter ${v.voterIndex + 1} (${v.modelLabel})
+`;
+    output += `Status: ${v.status}
+`;
+    if (v.status === "completed") {
+      output += `
+${v.reasoning}
+
+`;
+    } else {
+      output += `Error: ${v.error}
+
+`;
+    }
+  }
+  return output;
+}
+
+// src/tools/assembly/tool-description.ts
+var TOOL_DESCRIPTION = `
+Spawns multiple AI agents (voters) with different model providers to independently analyze a question or decision, then synthesizes their reasoning into a unified consensus.
+
+## When to use
+- Making critical decisions that benefit from multiple perspectives
+- Evaluating complex tradeoffs where bias reduction matters
+- Validating architectural choices through multi-model reasoning
+- When you need confidence scoring on analysis
+
+## How it works
+1. **Voter selection**: Auto-selects N models from configured providers (or use your override)
+2. **Independent voting**: Each voter independently analyzes the question
+3. **Synthesis**: All voter outputs are fed to a synthesis round that identifies agreement, disagreement, and confidence
+4. **Multi-round**: Optionally repeat synthesis for deeper convergence
+
+## Output format
+Returns a structured consensus with:
+- Unified answer/conclusion
+- Confidence level (high/medium/low)
+- Key disagreements between voters
+- Per-voter reasoning traces
+`;
+
+// src/tools/assembly/types.ts
+var AssemblyArgsSchema = exports_external.object({
+  question: exports_external.string().min(1).describe("The question or decision to reach consensus on"),
+  voters: exports_external.number().int().min(2).max(5).optional().describe("Number of voters (default: 3)"),
+  rounds: exports_external.number().int().min(1).max(3).optional().describe("Number of synthesis rounds (default: 2)"),
+  models: exports_external.array(exports_external.string()).optional().describe("Override auto-selected models (e.g., ['anthropic:claude-sonnet-4-20250514', 'openai:gpt-4o'])")
+});
+
+// src/tools/assembly/tools.ts
+function createAssemblyTool(options) {
+  return tool({
+    description: TOOL_DESCRIPTION,
+    args: {
+      question: tool.schema.string().describe("The question or decision to reach consensus on"),
+      voters: tool.schema.number().optional().describe("Number of voters (2-5, default: 3)"),
+      rounds: tool.schema.number().optional().describe("Number of synthesis rounds (1-3, default: 2)"),
+      models: tool.schema.array(tool.schema.string()).optional().describe("Override auto-selected models")
+    },
+    async execute(args, toolContext) {
+      const parsed = AssemblyArgsSchema.parse(args);
+      const output = await executeAssembly({
+        manager: options.manager,
+        args: parsed,
+        config: options.pluginConfig?.assembly,
+        sessionID: toolContext.sessionID,
+        messageID: toolContext.messageID
+      });
+      return output.finalConsensus;
+    }
+  });
+}
 // src/tools/delegate-agent/constants.ts
 var ALLOWED_AGENTS = [
   "trinity",
@@ -74827,7 +75999,7 @@ Use \`background_output\` tool with task_id="${task.id}" to check progress:
 // src/tools/delegate-agent/completion-poller.ts
 async function waitForCompletion(sessionID, toolContext, ctx) {
   log(`[delegate_agent] Polling for completion...`);
-  const POLL_INTERVAL_MS = 500;
+  const POLL_INTERVAL_MS2 = 500;
   const MAX_POLL_TIME_MS = 5 * 60 * 1000;
   const pollStart = Date.now();
   let lastMsgCount = 0;
@@ -74838,7 +76010,7 @@ async function waitForCompletion(sessionID, toolContext, ctx) {
       log(`[delegate_agent] Aborted by user`);
       throw new Error("Task aborted.");
     }
-    await new Promise((resolve10) => setTimeout(resolve10, POLL_INTERVAL_MS));
+    await new Promise((resolve10) => setTimeout(resolve10, POLL_INTERVAL_MS2));
     const statusResult = await ctx.client.session.status();
     const allStatuses = normalizeSDKResponse(statusResult, {});
     const sessionStatus = allStatuses[sessionID];
@@ -75132,7 +76304,7 @@ ${task.agent ? `subagent: ${task.agent}
   }
 }
 // src/tools/delegate-task/timing.ts
-var POLL_INTERVAL_MS = 1000;
+var POLL_INTERVAL_MS2 = 1000;
 var MIN_STABILITY_TIME_MS = 1e4;
 var STABILITY_POLLS_REQUIRED = 3;
 var WAIT_FOR_SESSION_INTERVAL_MS = 100;
@@ -75141,7 +76313,7 @@ var MAX_POLL_TIME_MS = 10 * 60 * 1000;
 var SESSION_CONTINUATION_STABILITY_MS = 5000;
 function getTimingConfig() {
   return {
-    POLL_INTERVAL_MS,
+    POLL_INTERVAL_MS: POLL_INTERVAL_MS2,
     MIN_STABILITY_TIME_MS,
     STABILITY_POLLS_REQUIRED,
     WAIT_FOR_SESSION_INTERVAL_MS,
@@ -75644,6 +76816,8 @@ Create the work plan directly - that's your job as the planning agent.`
   return { agentToUse, categoryModel };
 }
 // src/features/task-toast-manager/manager.ts
+init_logger();
+
 class TaskToastManager {
   tasks = new Map;
   client;
@@ -75763,7 +76937,9 @@ class TaskToastManager {
         variant: "info",
         duration: running.length + queued.length > 2 ? 5000 : 3000
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[task-toast] Toast failed:", err);
+    });
   }
   showCompletionToast(task) {
     const tuiClient = this.client;
@@ -75785,7 +76961,9 @@ Still running: ${remaining.length} | Queued: ${queued.length}`;
         variant: "success",
         duration: 5000
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[task-toast] Toast failed:", err);
+    });
   }
 }
 var instance = null;
@@ -76260,18 +77438,19 @@ async function sendSyncPrompt(client2, input, deps = sendSyncPromptDeps) {
   try {
     await deps.promptWithModelSuggestionRetry(client2, promptArgs);
   } catch (promptError) {
+    let lastError = promptError;
     if (isOracleAgent2(input.agentToUse) && isUnexpectedEofError(promptError)) {
       try {
         await deps.promptSyncWithModelSuggestionRetry(client2, promptArgs);
         return null;
       } catch (oracleRetryError) {
-        promptError = oracleRetryError;
+        lastError = oracleRetryError;
       }
     }
     if (input.toastManager && input.taskId !== undefined) {
       input.toastManager.removeTask(input.taskId);
     }
-    const errorMessage = promptError instanceof Error ? promptError.message : String(promptError);
+    const errorMessage = lastError instanceof Error ? lastError.message : String(lastError);
     if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
       return formatDetailedError(new Error(`Agent "${input.agentToUse}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`), {
         operation: "Send prompt to agent",
@@ -76281,7 +77460,7 @@ async function sendSyncPrompt(client2, input, deps = sendSyncPromptDeps) {
         category: input.args.category
       });
     }
-    return formatDetailedError(promptError, {
+    return formatDetailedError(lastError, {
       operation: "Send prompt",
       args: input.args,
       sessionID: input.sessionID,
@@ -76444,7 +77623,9 @@ session_id: ${sessionID}
   } finally {
     if (syncSessionID) {
       subagentSessions.delete(syncSessionID);
-      client2.session.abort({ path: { id: syncSessionID } }).catch(() => {});
+      client2.session.abort({ path: { id: syncSessionID } }).catch((err) => {
+        log("[delegate-task] Sync session abort failed:", err);
+      });
     }
   }
 }
@@ -79171,10 +80352,6 @@ class ConcurrencyManager {
     return this.queues.get(model)?.length ?? 0;
   }
 }
-// src/features/background-agent/manager.ts
-import { existsSync as existsSync57, readdirSync as readdirSync19, readFileSync as readFileSync39 } from "fs";
-import { join as join72 } from "path";
-
 // src/features/background-agent/constants.ts
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS2 = 10 * 1000;
@@ -79189,6 +80366,59 @@ var POLLING_INTERVAL_MS = 3000;
 var PRUNE_THROTTLE_MS = 30000;
 var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
 
+// src/features/background-agent/error-helpers.ts
+function formatDuration2(start, end) {
+  const duration5 = (end ?? new Date).getTime() - start.getTime();
+  const seconds = Math.floor(duration5 / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+function getErrorText(error95) {
+  if (!error95)
+    return "";
+  if (typeof error95 === "string")
+    return error95;
+  if (error95 instanceof Error) {
+    return `${error95.name}: ${error95.message}`;
+  }
+  if (typeof error95 === "object" && error95 !== null) {
+    if ("message" in error95 && typeof error95.message === "string") {
+      return error95.message;
+    }
+    if ("name" in error95 && typeof error95.name === "string") {
+      return error95.name;
+    }
+  }
+  return "";
+}
+function isAbortedSessionError(error95) {
+  const message = getErrorText(error95);
+  return message.toLowerCase().includes("aborted");
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function getSessionErrorMessage(properties) {
+  const errorRaw = properties.error;
+  if (!isRecord5(errorRaw))
+    return;
+  const dataRaw = errorRaw.data;
+  if (isRecord5(dataRaw)) {
+    const message2 = dataRaw.message;
+    if (typeof message2 === "string")
+      return message2;
+  }
+  const message = errorRaw.message;
+  return typeof message === "string" ? message : undefined;
+}
+
 // src/features/background-agent/loop-detector.ts
 function resolveCircuitBreakerSettings(config4) {
   return {
@@ -79253,6 +80483,145 @@ function detectRepetitiveToolUse(window) {
   };
 }
 
+// src/features/background-agent/message-dir.ts
+import { existsSync as existsSync57, readdirSync as readdirSync19, readFileSync as readFileSync39 } from "fs";
+import { join as join72 } from "path";
+var MESSAGE_DIR_CACHE_CAP = 1000;
+var messageDirCache = new Map;
+function computeMessageDir(sessionID) {
+  if (!existsSync57(MESSAGE_STORAGE))
+    return null;
+  const directPath = join72(MESSAGE_STORAGE, sessionID);
+  if (existsSync57(directPath))
+    return directPath;
+  for (const dir of readdirSync19(MESSAGE_STORAGE)) {
+    const sessionPath = join72(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync57(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
+function getMessageDir2(sessionID) {
+  const cached3 = messageDirCache.get(sessionID);
+  if (cached3 !== undefined) {
+    messageDirCache.delete(sessionID);
+    messageDirCache.set(sessionID, cached3);
+    return cached3;
+  }
+  const result = computeMessageDir(sessionID);
+  if (messageDirCache.size >= MESSAGE_DIR_CACHE_CAP) {
+    const oldest = messageDirCache.keys().next().value;
+    if (oldest !== undefined)
+      messageDirCache.delete(oldest);
+  }
+  messageDirCache.set(sessionID, result);
+  return result;
+}
+function isCompactionAgent(agent) {
+  return agent?.trim().toLowerCase() === "compaction";
+}
+function hasFullAgentAndModel(message) {
+  return !!message.agent && !isCompactionAgent(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
+}
+function hasPartialAgentOrModel(message) {
+  const hasAgent = !!message.agent && !isCompactionAgent(message.agent);
+  const hasModel = !!message.model?.providerID && !!message.model?.modelID;
+  return hasAgent || hasModel;
+}
+function findNearestMessageExcludingCompaction(messageDir) {
+  try {
+    const files = readdirSync19(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
+    const parsedByFile = new Map;
+    for (const file3 of files) {
+      try {
+        const content = readFileSync39(join72(messageDir, file3), "utf-8");
+        const parsed = JSON.parse(content);
+        parsedByFile.set(file3, parsed);
+        if (hasFullAgentAndModel(parsed)) {
+          return parsed;
+        }
+      } catch {}
+    }
+    for (const parsed of parsedByFile.values()) {
+      if (hasPartialAgentOrModel(parsed)) {
+        return parsed;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/features/background-agent/notification-builder.ts
+function buildCompletionNotification(task, allComplete, completedTasks, remainingCount, duration5, errorInfo) {
+  if (allComplete) {
+    const completedTasksText = completedTasks.map((t) => `- \`${t.id}\`: ${t.description}`).join(`
+`);
+    return `<system-reminder>
+[ALL BACKGROUND TASKS COMPLETE]
+
+**Completed:**
+${completedTasksText || `- \`${task.id}\`: ${task.description}`}
+
+Use \`background_output(task_id="<id>")\` to retrieve each result.
+</system-reminder>`;
+  }
+  const statusText = task.status === "completed" ? "COMPLETED" : task.status === "interrupt" ? "INTERRUPTED" : "CANCELLED";
+  return `<system-reminder>
+[BACKGROUND TASK ${statusText}]
+**ID:** \`${task.id}\`
+**Description:** ${task.description}
+**Duration:** ${duration5}${errorInfo}
+
+**${remainingCount} task${remainingCount === 1 ? "" : "s"} still in progress.** You WILL be notified when ALL complete.
+Do NOT poll - continue productive work.
+
+Use \`background_output(task_id="${task.id}")\` to retrieve this result when ready.
+</system-reminder>`;
+}
+async function resolveAgentAndModel(client2, task, enableParentSessionNotifications) {
+  let agent = task.parentAgent;
+  let model;
+  if (!enableParentSessionNotifications) {
+    return { agent, model };
+  }
+  try {
+    const messagesResp = await client2.session.messages({
+      path: { id: task.parentSessionID }
+    });
+    const messages = normalizeSDKResponse(messagesResp, []);
+    for (let i = messages.length - 1;i >= 0; i--) {
+      const info = messages[i].info;
+      if (isCompactionAgent(info?.agent)) {
+        continue;
+      }
+      if (info?.agent || info?.model || info?.modelID && info?.providerID) {
+        agent = info.agent ?? task.parentAgent;
+        model = info.model ?? (info.providerID && info.modelID ? {
+          providerID: info.providerID,
+          modelID: info.modelID
+        } : undefined);
+        break;
+      }
+    }
+  } catch (error95) {
+    if (isAbortedSessionError(error95)) {
+      log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
+        taskParentSessionID: task.parentSessionID
+      });
+    }
+    const messageDir = getMessageDir2(task.parentSessionID);
+    const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir) : null;
+    agent = currentMessage?.agent ?? task.parentAgent;
+    model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? {
+      providerID: currentMessage.model.providerID,
+      modelID: currentMessage.model.modelID
+    } : undefined;
+  }
+  return { agent, model };
+}
+
 // src/features/background-agent/task-history.ts
 var MAX_ENTRIES_PER_PARENT = 100;
 
@@ -79559,9 +80928,7 @@ class BackgroundManager {
           this.concurrencyManager.release(existingTask.concurrencyKey);
           existingTask.concurrencyKey = undefined;
         }
-        this.client.session.abort({
-          path: { id: sessionID }
-        }).catch(() => {});
+        this.abortSessionQuietly(sessionID, "error-recovery");
         this.markForNotification(existingTask);
         this.cleanupPendingByParent(existingTask);
         this.enqueueNotificationForParent(existingTask.parentSessionID, () => this.notifyParentSession(existingTask)).catch((err) => {
@@ -79765,9 +81132,7 @@ class BackgroundManager {
         existingTask.concurrencyKey = undefined;
       }
       if (existingTask.sessionID) {
-        this.client.session.abort({
-          path: { id: existingTask.sessionID }
-        }).catch(() => {});
+        this.abortSessionQuietly(existingTask.sessionID, "resume-error");
       }
       this.markForNotification(existingTask);
       this.cleanupPendingByParent(existingTask);
@@ -79922,7 +81287,7 @@ class BackgroundManager {
       const task = this.findBySession(sessionID);
       if (task?.status !== "running")
         return;
-      const errorMessage = props ? this.getSessionErrorMessage(props) : undefined;
+      const errorMessage = props ? getSessionErrorMessage(props) : undefined;
       task.status = "error";
       task.error = errorMessage ?? "Session error";
       task.completedAt = new Date;
@@ -80062,6 +81427,14 @@ class BackgroundManager {
       }
     }
   }
+  abortSessionQuietly(sessionID, context) {
+    this.client.session.abort({ path: { id: sessionID } }).catch((err) => {
+      log(`[background-agent] Session abort failed${context ? ` (${context})` : ""}:`, {
+        sessionID,
+        error: err
+      });
+    });
+  }
   async cancelTask(taskId, options) {
     const task = this.tasks.get(taskId);
     if (!task || task.status !== "running" && task.status !== "pending") {
@@ -80106,9 +81479,7 @@ class BackgroundManager {
     }
     this.cleanupPendingByParent(task);
     if (abortSession && task.sessionID) {
-      this.client.session.abort({
-        path: { id: task.sessionID }
-      }).catch(() => {});
+      this.abortSessionQuietly(task.sessionID, "cancel");
     }
     if (options?.skipNotification) {
       const toastManager = getTaskToastManager();
@@ -80223,9 +81594,7 @@ class BackgroundManager {
       this.idleDeferralTimers.delete(task.id);
     }
     if (task.sessionID) {
-      this.client.session.abort({
-        path: { id: task.sessionID }
-      }).catch(() => {});
+      this.abortSessionQuietly(task.sessionID, "complete");
     }
     try {
       await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task));
@@ -80236,7 +81605,7 @@ class BackgroundManager {
     return true;
   }
   async notifyParentSession(task) {
-    const duration5 = this.formatDuration(task.startedAt ?? new Date, task.completedAt);
+    const duration5 = formatDuration2(task.startedAt ?? new Date, task.completedAt);
     log("[background-agent] notifyParentSession called for task:", task.id);
     const toastManager = getTaskToastManager();
     if (toastManager) {
@@ -80260,68 +81629,16 @@ class BackgroundManager {
       allComplete = true;
     }
     const completedTasks = allComplete ? Array.from(this.tasks.values()).filter((t) => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending") : [];
-    const statusText = task.status === "completed" ? "COMPLETED" : task.status === "interrupt" ? "INTERRUPTED" : "CANCELLED";
     const errorInfo = task.error ? `
 **Error:** ${task.error}` : "";
-    let notification;
-    if (allComplete) {
-      const completedTasksText = completedTasks.map((t) => `- \`${t.id}\`: ${t.description}`).join(`
-`);
-      notification = `<system-reminder>
-[ALL BACKGROUND TASKS COMPLETE]
-
-**Completed:**
-${completedTasksText || `- \`${task.id}\`: ${task.description}`}
-
-Use \`background_output(task_id="<id>")\` to retrieve each result.
-</system-reminder>`;
-    } else {
-      notification = `<system-reminder>
-[BACKGROUND TASK ${statusText}]
-**ID:** \`${task.id}\`
-**Description:** ${task.description}
-**Duration:** ${duration5}${errorInfo}
-
-**${remainingCount} task${remainingCount === 1 ? "" : "s"} still in progress.** You WILL be notified when ALL complete.
-Do NOT poll - continue productive work.
-
-Use \`background_output(task_id="${task.id}")\` to retrieve this result when ready.
-</system-reminder>`;
-    }
-    let agent = task.parentAgent;
-    let model;
+    const notification = buildCompletionNotification(task, allComplete, completedTasks, remainingCount, duration5, errorInfo);
+    const { agent, model } = await resolveAgentAndModel(this.client, task, this.enableParentSessionNotifications);
+    log("[background-agent] notifyParentSession context:", {
+      taskId: task.id,
+      resolvedAgent: agent,
+      resolvedModel: model
+    });
     if (this.enableParentSessionNotifications) {
-      try {
-        const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } });
-        const messages = normalizeSDKResponse(messagesResp, []);
-        for (let i = messages.length - 1;i >= 0; i--) {
-          const info = messages[i].info;
-          if (isCompactionAgent(info?.agent)) {
-            continue;
-          }
-          if (info?.agent || info?.model || info?.modelID && info?.providerID) {
-            agent = info.agent ?? task.parentAgent;
-            model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined);
-            break;
-          }
-        }
-      } catch (error95) {
-        if (this.isAbortedSessionError(error95)) {
-          log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
-            taskId: task.id,
-            parentSessionID: task.parentSessionID
-          });
-        }
-        const messageDir = getMessageDir2(task.parentSessionID);
-        const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir) : null;
-        agent = currentMessage?.agent ?? task.parentAgent;
-        model = currentMessage?.model?.providerID && currentMessage?.model?.modelID ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID } : undefined;
-      }
-      log("[background-agent] notifyParentSession context:", {
-        taskId: task.id,
-        resolvedAgent: agent,
-        resolvedModel: model
-      });
       try {
         await this.client.session.promptAsync({
           path: { id: task.parentSessionID },
@@ -80339,7 +81656,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           noReply: !allComplete
         });
       } catch (error95) {
-        if (this.isAbortedSessionError(error95)) {
+        if (isAbortedSessionError(error95)) {
           log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
             taskId: task.id,
             parentSessionID: task.parentSessionID
@@ -80374,56 +81691,6 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
       }
     }
   }
-  formatDuration(start, end) {
-    const duration5 = (end ?? new Date).getTime() - start.getTime();
-    const seconds = Math.floor(duration5 / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-    } else if (minutes > 0) {
-      return `${minutes}m ${seconds % 60}s`;
-    }
-    return `${seconds}s`;
-  }
-  isAbortedSessionError(error95) {
-    const message = this.getErrorText(error95);
-    return message.toLowerCase().includes("aborted");
-  }
-  getErrorText(error95) {
-    if (!error95)
-      return "";
-    if (typeof error95 === "string")
-      return error95;
-    if (error95 instanceof Error) {
-      return `${error95.name}: ${error95.message}`;
-    }
-    if (typeof error95 === "object" && error95 !== null) {
-      if ("message" in error95 && typeof error95.message === "string") {
-        return error95.message;
-      }
-      if ("name" in error95 && typeof error95.name === "string") {
-        return error95.name;
-      }
-    }
-    return "";
-  }
-  isRecord(value) {
-    return typeof value === "object" && value !== null;
-  }
-  getSessionErrorMessage(properties) {
-    const errorRaw = properties.error;
-    if (!this.isRecord(errorRaw))
-      return;
-    const dataRaw = errorRaw.data;
-    if (this.isRecord(dataRaw)) {
-      const message2 = dataRaw.message;
-      if (typeof message2 === "string")
-        return message2;
-    }
-    const message = errorRaw.message;
-    return typeof message === "string" ? message : undefined;
-  }
   hasRunningTasks() {
     for (const task of this.tasks.values()) {
       if (task.status === "running")
@@ -80520,7 +81787,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           this.concurrencyManager.release(task.concurrencyKey);
           task.concurrencyKey = undefined;
         }
-        this.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+        this.abortSessionQuietly(sessionID, "stale-no-progress");
         log(`[background-agent] Task ${task.id} interrupted: no progress since start`);
         try {
           await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task));
@@ -80546,7 +81813,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         this.concurrencyManager.release(task.concurrencyKey);
         task.concurrencyKey = undefined;
       }
-      this.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+      this.abortSessionQuietly(sessionID, "stale-timeout");
       log(`[background-agent] Task ${task.id} interrupted: stale timeout`);
       try {
         await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task));
@@ -80616,9 +81883,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     this.stopPolling();
     for (const task of this.tasks.values()) {
       if (task.status === "running" && task.sessionID) {
-        this.client.session.abort({
-          path: { id: task.sessionID }
-        }).catch(() => {});
+        this.abortSessionQuietly(task.sessionID, "shutdown");
       }
     }
     if (this.onShutdown) {
@@ -80657,13 +81922,17 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
       return operation();
     }
     const previous = this.notificationQueueByParent.get(parentSessionID) ?? Promise.resolve();
-    const current = previous.catch(() => {}).then(operation);
+    const current = previous.catch((err) => {
+      log("[background-agent] Previous notification failed, continuing queue:", err);
+    }).then(operation);
     this.notificationQueueByParent.set(parentSessionID, current);
     current.finally(() => {
       if (this.notificationQueueByParent.get(parentSessionID) === current) {
         this.notificationQueueByParent.delete(parentSessionID);
       }
-    }).catch(() => {});
+    }).catch((err) => {
+      log("[background-agent] Notification queue cleanup failed:", err);
+    });
     return current;
   }
 }
@@ -80678,72 +81947,6 @@ function registerProcessSignal(signal, handler, exitAfter) {
   process.on(signal, listener);
   return listener;
 }
-function computeMessageDir(sessionID) {
-  if (!existsSync57(MESSAGE_STORAGE))
-    return null;
-  const directPath = join72(MESSAGE_STORAGE, sessionID);
-  if (existsSync57(directPath))
-    return directPath;
-  for (const dir of readdirSync19(MESSAGE_STORAGE)) {
-    const sessionPath = join72(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync57(sessionPath))
-      return sessionPath;
-  }
-  return null;
-}
-var MESSAGE_DIR_CACHE_CAP = 1000;
-var messageDirCache = new Map;
-function getMessageDir2(sessionID) {
-  const cached3 = messageDirCache.get(sessionID);
-  if (cached3 !== undefined) {
-    messageDirCache.delete(sessionID);
-    messageDirCache.set(sessionID, cached3);
-    return cached3;
-  }
-  const result = computeMessageDir(sessionID);
-  if (messageDirCache.size >= MESSAGE_DIR_CACHE_CAP) {
-    const oldest = messageDirCache.keys().next().value;
-    if (oldest !== undefined)
-      messageDirCache.delete(oldest);
-  }
-  messageDirCache.set(sessionID, result);
-  return result;
-}
-function isCompactionAgent(agent) {
-  return agent?.trim().toLowerCase() === "compaction";
-}
-function hasFullAgentAndModel(message) {
-  return !!message.agent && !isCompactionAgent(message.agent) && !!message.model?.providerID && !!message.model?.modelID;
-}
-function hasPartialAgentOrModel(message) {
-  const hasAgent = !!message.agent && !isCompactionAgent(message.agent);
-  const hasModel = !!message.model?.providerID && !!message.model?.modelID;
-  return hasAgent || hasModel;
-}
-function findNearestMessageExcludingCompaction(messageDir) {
-  try {
-    const files = readdirSync19(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
-    const parsedByFile = new Map;
-    for (const file3 of files) {
-      try {
-        const content = readFileSync39(join72(messageDir, file3), "utf-8");
-        const parsed = JSON.parse(content);
-        parsedByFile.set(file3, parsed);
-        if (hasFullAgentAndModel(parsed)) {
-          return parsed;
-        }
-      } catch {}
-    }
-    for (const parsed of parsedByFile.values()) {
-      if (hasPartialAgentOrModel(parsed)) {
-        return parsed;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
 // src/features/background-agent/state.ts
 class TaskStateManager {
   tasks = new Map;
@@ -80916,6 +82119,7 @@ class TaskStateManager {
   }
 }
 // src/features/skill-mcp-manager/cleanup.ts
+init_logger();
 async function closeManagedClient(managed) {
   try {
     await managed.client.close();
@@ -80936,7 +82140,9 @@ function registerProcessCleanup(state3) {
     state3.pendingConnections.clear();
   };
   const register = (signal) => {
-    const listener = () => void cleanup().catch(() => {});
+    const listener = () => void cleanup().catch((err) => {
+      log("[skill-mcp] Signal handler cleanup failed:", err);
+    });
     state3.cleanupHandlers.push({ signal, listener });
     process.on(signal, listener);
   };
@@ -80959,7 +82165,9 @@ function startCleanupTimer(state3) {
   if (state3.cleanupInterval)
     return;
   state3.cleanupInterval = setInterval(() => {
-    cleanupIdleClients(state3).catch(() => {});
+    cleanupIdleClients(state3).catch((err) => {
+      log("[skill-mcp] Idle client cleanup failed:", err);
+    });
   }, 60000);
   state3.cleanupInterval.unref();
 }
@@ -84616,13 +85824,13 @@ class StreamableHTTPClientTransport {
       this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
       return;
     }
-    const delay4 = this._getNextReconnectionDelay(attemptCount);
+    const delay6 = this._getNextReconnectionDelay(attemptCount);
     this._reconnectionTimeout = setTimeout(() => {
       this._startOrAuthSse(options).catch((error95) => {
         this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error95 instanceof Error ? error95.message : String(error95)}`));
         this._scheduleReconnection(options, attemptCount + 1);
       });
-    }, delay4);
+    }, delay6);
   }
   _handleSseStream(stream, options, isReconnectable) {
     if (!stream) {
@@ -84933,7 +86141,7 @@ async function getOrRegisterClient(options) {
   }
 }
 function parseRegistrationResponse(data) {
-  if (!isRecord5(data))
+  if (!isRecord6(data))
     return null;
   const clientId = data.client_id;
   if (typeof clientId !== "string" || clientId.length === 0)
@@ -84944,7 +86152,7 @@ function parseRegistrationResponse(data) {
   }
   return { clientId };
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -88290,7 +89498,7 @@ function collectPendingBuiltinAgents(input) {
   if (oracleMetadata) {
     availableAgents.push({
       name: "oracle",
-      description: "Read-only consultation agent. High-IQ reasoning specialist for debugging hard problems and high-difficulty architecture design. (Oracle - Matrixx)",
+      description: "Plan Builder agent. Creates detailed, structured work plans from user requests. (Oracle - Matrixx)",
       metadata: oracleMetadata
     });
   }
@@ -89651,7 +90859,7 @@ createMultimodalLookerAgent.mode = MODE5;
 function sanitizeMarkdownTableCell(value) {
   return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
 }
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function parseRegisteredAgentSummaries(input) {
@@ -89659,7 +90867,7 @@ function parseRegisteredAgentSummaries(input) {
     return [];
   const result = [];
   for (const item of input) {
-    if (!isRecord6(item))
+    if (!isRecord7(item))
       continue;
     const name = typeof item.name === "string" ? item.name : undefined;
     if (!name)
@@ -89723,6 +90931,7 @@ var ORACLE_PROMPT_METADATA = {
 var ORACLE_PLAN_BUILDER_METADATA = {
   category: "advisor",
   cost: "EXPENSIVE",
+  keyTrigger: "Complex feature implementation, refactoring, or architecture design \u2192 consult Oracle for planning first",
   triggers: [
     { domain: "Architecture decisions", trigger: "Multi-system tradeoffs, unfamiliar patterns" },
     { domain: "Work planning", trigger: "Complex feature implementation, refactoring" },
@@ -89854,7 +91063,7 @@ Before finalizing answers on architecture, security, or performance:
 <delivery>
 Your response goes directly to the user with no intermediate processing. Make your final message self-contained: a clear recommendation they can act on immediately, covering both what to do and why.
 </delivery>`;
-function createOracleAgent(model) {
+function createMerovingianAgent(model) {
   const restrictions = createAgentToolRestrictions([
     "write",
     "edit",
@@ -89862,7 +91071,7 @@ function createOracleAgent(model) {
     "task"
   ]);
   const base = {
-    description: "Read-only consultation agent. High-IQ reasoning specialist for debugging hard problems and high-difficulty architecture design. (Oracle - Matrixx)",
+    description: "Read-only consultation agent. High-IQ reasoning specialist for debugging hard problems and high-difficulty architecture design. (Merovingian - Matrixx)",
     mode: MODE6,
     model,
     temperature: 0.1,
@@ -89874,7 +91083,7 @@ function createOracleAgent(model) {
   }
   return { ...base, thinking: { type: "enabled", budgetTokens: 16000 } };
 }
-createOracleAgent.mode = MODE6;
+createMerovingianAgent.mode = MODE6;
 
 // src/agents/operator.ts
 var MODE7 = "subagent";
@@ -91191,7 +92400,7 @@ createExploreAgent.mode = MODE12;
 var agentSources = {
   morpheus: createMorpheusAgent,
   keymaker: createKeymakerAgent,
-  merovingian: createOracleAgent,
+  merovingian: createMerovingianAgent,
   operator: createLibrarianAgent,
   trinity: createExploreAgent,
   construct: createMultimodalLookerAgent,
@@ -94481,6 +95690,11 @@ function createToolRegistry(args) {
   } : {};
   const hashlineEnabled = pluginConfig.experimental?.hashline_edit ?? false;
   const hashlineToolsRecord = hashlineEnabled ? { edit: createHashlineEditTool(ctx) } : {};
+  const assemblyEnabled = pluginConfig.assembly?.enabled !== false;
+  const assemblyTool = assemblyEnabled ? createAssemblyTool({
+    manager: managers.backgroundManager,
+    pluginConfig
+  }) : null;
   const allTools = {
     ...builtinTools,
     ...createGrepTools(ctx),
@@ -94497,7 +95711,8 @@ function createToolRegistry(args) {
     slashcommand: slashcommandTool,
     interactive_bash,
     ...taskToolsRecord,
-    ...hashlineToolsRecord
+    ...hashlineToolsRecord,
+    ...assemblyTool ? { assembly: assemblyTool } : {}
   };
   const filteredTools = filterDisabledTools(allTools, pluginConfig.disabled_tools);
   return {
@@ -94921,7 +96136,9 @@ var BuiltinSkillNameSchema = exports_external.enum([
   "review-work",
   "quality-gate",
   "software-dev",
-  "matrixx-self-config"
+  "matrixx-self-config",
+  "ulw-research",
+  "remove-ai-slops"
 ]);
 // src/config/schema/internal/permission.ts
 var PermissionValueSchema = exports_external.enum(["ask", "allow", "deny"]);
@@ -94987,6 +96204,17 @@ var AgentOverridesSchema = exports_external.object({
   sentinel: AgentOverrideConfigSchema.optional(),
   sati: AgentOverrideConfigSchema.optional()
 });
+// src/config/schema/assembly.ts
+var AssemblyConfigSchema = exports_external.object({
+  providers: exports_external.array(exports_external.object({
+    providerID: exports_external.string(),
+    modelID: exports_external.string()
+  })).optional(),
+  default_voters: exports_external.number().int().min(2).max(5).optional(),
+  default_rounds: exports_external.number().int().min(1).max(3).optional(),
+  timeout_ms: exports_external.number().int().min(1e4).max(300000).optional(),
+  enabled: exports_external.boolean().default(false)
+});
 // src/config/schema/babysitting.ts
 var BabysittingConfigSchema = exports_external.object({
   timeout_ms: exports_external.number().default(120000)
@@ -95066,7 +96294,11 @@ var BuiltinCommandNameSchema = exports_external.enum([
   "start-work",
   "stop-continuation",
   "profile",
-  "end-ultrawork"
+  "end-ultrawork",
+  "handoff",
+  "research",
+  "assembly",
+  "ultrawork"
 ]);
 // src/config/schema/comment-checker.ts
 var CommentCheckerConfigSchema = exports_external.object({
@@ -95120,7 +96352,6 @@ var HookNameSchema = exports_external.enum([
   "start-work",
   "architect",
   "unstable-agent-babysitter",
-  "task-reminder",
   "task-resume-info",
   "stop-continuation-guard",
   "tasks-todowrite-disabler",
@@ -95321,6 +96552,7 @@ var MatrixxConfigSchema = exports_external.object({
   websearch: WebsearchConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
   morpheus: MorpheusConfigSchema.optional(),
+  assembly: AssemblyConfigSchema.optional(),
   security: SecurityConfigSchema.optional(),
   runtime_fallback: RuntimeFallbackConfigSchema.optional(),
   agent_definitions: AgentDefinitionsConfigSchema.optional(),
@@ -95468,6 +96700,7 @@ function loadPluginConfig(directory, ctx) {
 }
 
 // src/plugin/chat-message.ts
+init_logger();
 function isStartWorkHookOutput(value) {
   if (typeof value !== "object" || value === null)
     return false;
@@ -95521,7 +96754,9 @@ function createChatMessageHandler2(args) {
           variant: "warning",
           duration: 6000
         }
-      }).catch(() => {});
+      }).catch((err) => {
+        log("[plugin] Provider cache toast failed:", err);
+      });
     }
     if (hooks2.matrixLoop) {
       const parts = output.parts;
@@ -95548,11 +96783,11 @@ function createChatMessageHandler2(args) {
 }
 
 // src/plugin/chat-params.ts
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null;
 }
 function buildChatParamsInput(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return null;
   const sessionID = raw.sessionID;
   const agent = raw.agent;
@@ -95563,11 +96798,11 @@ function buildChatParamsInput(raw) {
     return null;
   if (typeof agent !== "string")
     return null;
-  if (!isRecord7(model))
+  if (!isRecord8(model))
     return null;
-  if (!isRecord7(provider))
+  if (!isRecord8(provider))
     return null;
-  if (!isRecord7(message))
+  if (!isRecord8(message))
     return null;
   const providerID = model.providerID;
   const modelID = model.modelID;
@@ -95588,12 +96823,12 @@ function buildChatParamsInput(raw) {
   };
 }
 function isChatParamsOutput(raw) {
-  if (!isRecord7(raw))
+  if (!isRecord8(raw))
     return false;
-  if (!isRecord7(raw.options)) {
+  if (!isRecord8(raw.options)) {
     raw.options = {};
   }
-  return isRecord7(raw.options);
+  return isRecord8(raw.options);
 }
 function createChatParamsHandler(args) {
   return async (input, output) => {
@@ -95611,6 +96846,9 @@ function createChatParamsHandler(args) {
   };
 }
 
+// src/plugin/event.ts
+init_logger();
+
 // src/plugin/recent-synthetic-idles.ts
 function pruneRecentSyntheticIdles(args) {
   const { recentSyntheticIdles, recentRealIdles, now, dedupWindowMs } = args;
@@ -95754,7 +96992,9 @@ function createEventHandler2(args) {
             path: { id: sessionID },
             body: { parts: [{ type: "text", text: "continue" }] },
             query: { directory: ctx.directory }
-          }).catch(() => {});
+          }).catch((err) => {
+            log("[plugin] Session prompt failed:", err);
+          });
         }
       }
     }
@@ -95868,6 +97108,25 @@ function createToolExecuteAfterHandler2(args) {
   };
 }
 
+// src/features/assembly-state/manager.ts
+init_logger();
+var HOOK_NAME15 = "assembly-state";
+var disabledSessions = new Set;
+function isAssemblyDisabled(sessionID) {
+  return disabledSessions.has(sessionID);
+}
+function disableAssembly(sessionID) {
+  disabledSessions.add(sessionID);
+  log(`[${HOOK_NAME15}] Assembly disabled for session`, { sessionID });
+  disabledSessions.add(sessionID);
+  log(`[${HOOK_NAME15}] Consensus disabled for session`, { sessionID });
+}
+function enableAssembly(sessionID) {
+  disabledSessions.delete(sessionID);
+  log(`[${HOOK_NAME15}] Assembly enabled for session`, { sessionID });
+  disabledSessions.delete(sessionID);
+  log(`[${HOOK_NAME15}] Consensus enabled for session`, { sessionID });
+}
 // src/plugin/session-agent-resolver.ts
 async function resolveSessionAgent(client2, sessionId, timeoutMs = 5000) {
   try {
@@ -95990,6 +97249,32 @@ function createToolExecuteBeforeHandler2(args) {
           sessionID
         });
       }
+      if (command === "assembly" && sessionID) {
+        const subcommand = rawCommand?.replace(/^\/?assembly\s*/i, "").trim().toLowerCase();
+        if (subcommand === "disable" || subcommand === "off") {
+          disableAssembly(sessionID);
+        } else if (subcommand === "enable" || subcommand === "on") {
+          enableAssembly(sessionID);
+        } else {
+          const state3 = isAssemblyDisabled(sessionID) ? "disabled" : "enabled";
+          log("[assembly] Assembly state check", { sessionID, state: state3 });
+        }
+      }
+      if (command === "ultrawork" && sessionID) {
+        const subcommand = rawCommand?.replace(/^\/?ultrawork\s*/i, "").trim().toLowerCase();
+        if (subcommand === "disable" || subcommand === "off") {
+          disableUltrawork(sessionID);
+        } else if (subcommand === "enable" || subcommand === "on") {
+          enableUltrawork(sessionID);
+        } else {
+          const state3 = getUltraworkState(sessionID) ?? "default (keyword-triggered)";
+          log("[ultrawork] Ultrawork state check", { sessionID, state: state3 });
+        }
+      }
+      if (command === "end-ultrawork" && sessionID) {
+        disableUltrawork(sessionID);
+        log("[end-ultrawork] Ultrawork disabled via /end-ultrawork", { sessionID });
+      }
     }
   };
 }