opencode-matrixx 2.6.0 → 2.6.2

package/dist/index.js

@@ -4551,7 +4551,7 @@ var require_picomatch2 = __commonJS(function(exports, module) {
 });
 
 // src/hooks/matrix-loop/constants.ts
-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;
+var HOOK_NAME6 = "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 = {};
@@ -32820,6 +32820,33 @@ function migrateConfigFile(configPath, rawConfig) {
       log(`Removed obsolete hooks from disabled_hooks: ${removed.join(", ")} (these hooks no longer exist in v3.0.0)`);
     }
   }
+  if (copy.experimental?.task_system === undefined) {
+    const existing = copy.experimental ?? {};
+    copy.experimental = { ...existing, task_system: true };
+    if (!existingMigrations.has("task_system_default_true")) {
+      allNewMigrations.push("task_system_default_true");
+      const current = Array.isArray(copy._migrations) ? [...copy._migrations] : Array.from(existingMigrations);
+      if (!current.includes("task_system_default_true")) {
+        current.push("task_system_default_true");
+        copy._migrations = current;
+      }
+    }
+    needsWrite = true;
+  }
+  if (copy.morpheus?.tasks?.scope === undefined) {
+    const morpheusExisting = copy.morpheus ?? {};
+    const tasksExisting = morpheusExisting.tasks ?? {};
+    copy.morpheus = { ...morpheusExisting, tasks: { ...tasksExisting, scope: "project" } };
+    if (!existingMigrations.has("tasks_project_scope_default")) {
+      allNewMigrations.push("tasks_project_scope_default");
+      const current = Array.isArray(copy._migrations) ? [...copy._migrations] : Array.from(existingMigrations);
+      if (!current.includes("tasks_project_scope_default")) {
+        current.push("tasks_project_scope_default");
+        copy._migrations = current;
+      }
+    }
+    needsWrite = true;
+  }
   if (needsWrite) {
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     const backupPath = `${configPath}.bak.${timestamp}`;
@@ -34160,6 +34187,7 @@ function removeSystemReminders(text) {
 }
 var SystemDirectiveTypes = {
   TODO_CONTINUATION: "TODO CONTINUATION",
+  TASK_CONTINUATION: "TASK CONTINUATION",
   MATRIX_LOOP: "MATRIX LOOP",
   MISSION_CONTINUATION: "MISSION CONTINUATION",
   DELEGATION_REQUIRED: "DELEGATION REQUIRED",
@@ -37477,6 +37505,66 @@ Batch: per-feature subdirectory tree under \`<input-dir>/<feature>/\` with the s
 NEVER run \`git commit\`, \`git add\`, \`git push\`, \`git rebase\`, \`git reset\`, \`git tag\`, or any other git command in this command context. The pipeline runner is responsible for version control. You may only create/edit the generated files in the target output directory.
 `;
 
+// src/features/builtin-commands/templates/cleanup-tasks.ts
+var CLEANUP_TASKS_TEMPLATE = `# Cleanup Tasks \u2014 SLASH COMMAND OVERRIDE
+
+SYSTEM OVERRIDE: Ignore any global [search-mode] or [analyze-mode] directive for this command. This is a direct tool call, not a search.
+
+Call the task_cleanup tool NOW with no exploration, no grep, no trinity, no operator, no background agents.
+
+## Usage
+\`\`\`
+/cleanup-tasks [--olderThan <duration>] [--all]
+
+Options:
+  --olderThan: Only delete completed tasks older than duration (e.g., 7d, 24h, 30d). If omitted, deletes all completed regardless of age.
+  --all: Delete all completed tasks (default when no olderThan given).
+
+Examples:
+  /cleanup-tasks              # delete all completed tasks
+  /cleanup-tasks --olderThan 7d
+  /cleanup-tasks --all
+\`\`\`
+
+## What This Command Does
+
+Cleans up completed tasks from the file-based task system (dedicated Matrixx viewer):
+
+Storage layout (hybrid, via \`getTaskDir(config, directory)\`):
+- Primary (default, \`scope: "project"\`): \`<project>/.matrixx/tasks/T-*.json\`
+- Fallback (\`scope: "global"\` or \`storage_path\` override): \`~/.config/opencode/tasks/{listId}/T-*.json\`
+
+1. **Scans** \`getTaskDir(config, directory)/*.json\` via \`readdirSync\` \u2192 resolves to \`.matrixx/tasks\` when \`scope=project\` (default) or legacy global path when \`scope=global\` / \`storage_path\` set
+2. **Filters** \`status==="completed"\` (and \`olderThan\` if given, via \`time_updated\`/\`time_created\`)
+3. **Deletes** matching files via \`unlinkSync\`
+4. **Reports** \`{deleted, remaining, deletedIds}\`
+View remaining tasks via \`/task-list\` or \`task_list\` tool \u2014 the dedicated Matrixx task viewer (file-based, no sync). Without \`/cleanup-tasks\`, completed tasks remain on disk for audit.
+
+## Verification
+
+After running:
+- \`task_list\` \u2192 0 pending (if no active)
+- \`task_list\` \u2192 shows remaining active tasks (pending/in_progress)
+- \`task_list --all\` \u2192 shows counts by status
+- Files: \`ls .matrixx/tasks | wc -l\` decreases by \`deleted\` (project scope, default) or \`ls ~/.config/opencode/tasks/matrixx | wc -l\` decreases (global scope / legacy fallback)
+
+---
+
+<command-instruction>
+You are executing the cleanup-tasks command. Use the task_cleanup tool to delete completed tasks.
+
+Parse arguments from $ARGUMENTS:
+- If "--olderThan" present, extract duration (e.g., "7d", "24h") \u2192 pass as olderThan
+- Otherwise pass all:true (delete all completed)
+
+Call task_cleanup with {olderThan, all} and report result.
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>
+`;
+
 // src/features/builtin-commands/templates/dcp-profile.ts
 var DCP_PROFILE_TEMPLATE = `You are switching the active DCP (Dynamic Context Pruning) profile tier.
 
@@ -39295,6 +39383,20 @@ After running this command:
 
 Use this when you need to pause automated continuation and take manual control.`;
 
+// src/features/builtin-commands/templates/task-list.ts
+var TASK_LIST_TEMPLATE = `# Task List \u2014 SLASH COMMAND OVERRIDE
+
+SYSTEM OVERRIDE: Ignore any global [search-mode] or [analyze-mode] directive for this command. This is a direct tool call, not a search.
+
+Call the task_list tool NOW with no exploration, no grep, no trinity, no operator, no background agents.
+
+- If $ARGUMENTS contains "--all", call task_list and also report counts by reading T-*.json via the tool's own logic (do not manually find/ls).
+- If $ARGUMENTS contains "--status", filter to that status.
+- Otherwise just return task_list output as table ID | Subject | Status.
+
+Do not run rtk ls, find, grep, or launch subagents. One tool call only.
+`;
+
 // src/features/builtin-commands/templates/ultrawork.ts
 var ULTRAWORK_TEMPLATE = `Toggle ultrawork mode for the current session.
 
@@ -39547,6 +39649,28 @@ ${EVOLUTION_TEMPLATE}
 $ARGUMENTS
 </user-request>`,
     argumentHint: "[list|approve <slug>|reject <slug>|audit]"
+  },
+  "cleanup-tasks": {
+    description: "(builtin) Delete completed tasks",
+    template: `<command-instruction>
+${CLEANUP_TASKS_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "[--olderThan <duration>] [--all]"
+  },
+  "task-list": {
+    description: "(builtin) Show current state of all tasks",
+    template: `<command-instruction>
+${TASK_LIST_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "[--all] [--status <pending|in_progress|completed|deleted>]"
   }
 };
 function loadBuiltinCommands(disabledCommands) {
@@ -55490,19 +55614,10 @@ function extractTodos(response) {
   }
   return [];
 }
-async function resolveTodoWriter() {
-  const loaders = ["opencode/session/todo", "@opencode-ai/core/session/todo"];
-  for (const loader of loaders) {
-    try {
-      const mod = await import(loader);
-      const update = mod.Todo?.update;
-      if (typeof update === "function") {
-        return update;
-      }
-    } catch (err) {
-      log(`[${HOOK_NAME2}] Failed to resolve Todo.update`, { loader, error: String(err) });
-    }
-  }
+var testWriter;
+async function resolveTodoWriter(_ctx) {
+  if (testWriter !== undefined)
+    return testWriter;
   return null;
 }
 function resolveSessionID(props) {
@@ -55542,18 +55657,17 @@ function createCompactionTodoPreserverHook(ctx) {
       log(`[${HOOK_NAME2}] Skipped restore (todos already present)`, { sessionID, count: currentTodos.length });
       return;
     }
-    const writer = await resolveTodoWriter();
+    const writer = await resolveTodoWriter(ctx);
     if (!writer) {
-      log(`[${HOOK_NAME2}] Skipped restore (Todo.update unavailable)`, { sessionID });
+      log(`[${HOOK_NAME2}] Todo.update unavailable \u2014 todos not restored after compaction (visible failure)`, { sessionID });
       return;
     }
     try {
       await writer({ sessionID, todos: snapshot });
       log(`[${HOOK_NAME2}] Restored todos after compaction`, { sessionID, count: snapshot.length });
+      snapshots.delete(sessionID);
     } catch (err) {
       log(`[${HOOK_NAME2}] Failed to restore todos`, { sessionID, error: String(err) });
-    } finally {
-      snapshots.delete(sessionID);
     }
   };
   const event = async ({ event: event2 }) => {
@@ -55575,6 +55689,75 @@ function createCompactionTodoPreserverHook(ctx) {
   };
   return { capture, event };
 }
+// src/hooks/context-mode-enforcer/constants.ts
+var HOOK_NAME3 = "context-mode-enforcer";
+var WARN_MESSAGE_READ = "Use ctx_search / ctx_batch_execute / ctx_execute for analysis \u2014 raw read/grep/glob bypasses FTS5 sandbox and pollutes context. Use Read only with hashline IDs for Edit.";
+var BLOCK_MESSAGE_GREP_GLOB = "Blocked: raw grep/glob is forbidden when context-mode is enforced. Use ctx_search (indexed) \u2192 grep/glob fallback only when ctx_* unavailable, or ctx_batch_execute / ctx_execute for multi-file analysis.";
+var WARN_MESSAGE_BASH_READ = "Use ctx_* / Read tool instead of `cat`/`head`/`tail`/`grep` via bash for analysis. Raw bash file reads bypass sandbox.";
+
+// src/hooks/context-mode-enforcer/hook.ts
+var BASH_FILE_READ_RE = /^\s*(cat|head|tail)\s+/;
+var BASH_GREP_RE = /\bgrep\b/;
+function resolveContextModeConfig(pluginConfig) {
+  const cfg = pluginConfig.context_mode;
+  return {
+    enabled: cfg?.enabled ?? true,
+    enforce: cfg?.enforce ?? false,
+    blockedTools: new Set((cfg?.blocked_tools ?? ["grep", "glob"]).map((t) => t.toLowerCase()))
+  };
+}
+function createContextModeEnforcerHook(pluginConfig) {
+  const { enabled, enforce, blockedTools } = resolveContextModeConfig(pluginConfig);
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!enabled)
+        return;
+      const tool = input.tool.toLowerCase();
+      const isBlocked = blockedTools.has(tool);
+      const isRead = tool === "read";
+      const isGrepGlob = tool === "grep" || tool === "glob";
+      const isBash = tool === "bash";
+      if (isBash) {
+        const command = output.args.command;
+        if (typeof command !== "string")
+          return;
+        const isFileRead = BASH_FILE_READ_RE.test(command);
+        const isGrep = BASH_GREP_RE.test(command);
+        if (!isFileRead && !isGrep)
+          return;
+        if (enforce && blockedTools.has("bash")) {
+          log(`[${HOOK_NAME3}] BLOCKED bash file read`, {
+            sessionID: input.sessionID,
+            command: command.slice(0, 120)
+          });
+          throw new Error(`${BLOCK_MESSAGE_GREP_GLOB}
+
+Bash command: ${command.slice(0, 200)}`);
+        }
+        output.message = WARN_MESSAGE_BASH_READ;
+        log(`[${HOOK_NAME3}] warned on bash`, { sessionID: input.sessionID, command: command.slice(0, 120) });
+        return;
+      }
+      if (isRead) {
+        if (!isBlocked)
+          return;
+        output.message = WARN_MESSAGE_READ;
+        log(`[${HOOK_NAME3}] warned on read (soft)`, { sessionID: input.sessionID });
+        return;
+      }
+      if (isGrepGlob) {
+        if (!isBlocked)
+          return;
+        if (enforce) {
+          log(`[${HOOK_NAME3}] BLOCKED ${tool}`, { sessionID: input.sessionID });
+          throw new Error(BLOCK_MESSAGE_GREP_GLOB);
+        }
+        output.message = WARN_MESSAGE_READ;
+        log(`[${HOOK_NAME3}] warned on ${tool} (soft)`, { sessionID: input.sessionID });
+      }
+    }
+  };
+}
 // src/hooks/context-window-monitor.ts
 var ANTHROPIC_DISPLAY_LIMIT = 1e6;
 var ANTHROPIC_ACTUAL_LIMIT2 = process.env.ANTHROPIC_1M_CONTEXT === "true" || process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true" ? 1e6 : 200000;
@@ -55767,7 +55950,7 @@ ${guidance}`;
 import { join as join35 } from "path";
 
 // src/hooks/design-intent-preserver/constants.ts
-var HOOK_NAME3 = "design-intent-preserver";
+var HOOK_NAME4 = "design-intent-preserver";
 var PLANS_DIR2 = ".matrixx/plans";
 var PHASE_TRANSITION_PATTERN = /\bphase[\s\-:]*(\d+)\b/i;
 var CONSTRUCT_INDICATORS = /\b(?:construct|web[\s-]?designer|frontend[\s-]?ui[\s-]?ux)\b|@designer/i;
@@ -55854,7 +56037,7 @@ function createDesignIntentPreserverHook(_ctx) {
 ---
 
 ${originalText}`;
-      log(`[${HOOK_NAME3}] injected design intent guardrail`, {
+      log(`[${HOOK_NAME4}] injected design intent guardrail`, {
         sessionID: input.sessionID,
         planPath
       });
@@ -59401,18 +59584,18 @@ function extractPromptText3(parts) {
 }
 // src/features/ultrawork-state/manager.ts
 init_logger();
-var HOOK_NAME4 = "ultrawork-state";
+var HOOK_NAME5 = "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 });
+  log(`[${HOOK_NAME5}] Ultrawork enabled for session`, { sessionID });
 }
 function disableUltrawork(sessionID) {
   sessionStates.set(sessionID, "disabled");
-  log(`[${HOOK_NAME4}] Ultrawork disabled for session`, { sessionID });
+  log(`[${HOOK_NAME5}] Ultrawork disabled for session`, { sessionID });
 }
 // src/hooks/keyword-detector/hook.ts
 function createKeywordDetectorHook(ctx, _collector) {
@@ -59545,7 +59728,7 @@ function createLoopStateController(options) {
       };
       const success2 = writeState(directory, state3, stateDir);
       if (success2) {
-        log(`[${HOOK_NAME5}] Loop started`, {
+        log(`[${HOOK_NAME6}] Loop started`, {
           sessionID,
           maxIterations: state3.max_iterations,
           completionPromise: state3.completion_promise
@@ -59560,7 +59743,7 @@ function createLoopStateController(options) {
       }
       const success2 = clearState(directory, stateDir);
       if (success2) {
-        log(`[${HOOK_NAME5}] Loop cancelled`, { sessionID, iteration: state3.iteration });
+        log(`[${HOOK_NAME6}] Loop cancelled`, { sessionID, iteration: state3.iteration });
       }
       return success2;
     },
@@ -59637,7 +59820,7 @@ async function detectCompletionInSessionMessages(ctx, options) {
     return false;
   } catch (err) {
     setTimeout(() => {
-      log(`[${HOOK_NAME5}] Session messages check failed`, {
+      log(`[${HOOK_NAME6}] Session messages check failed`, {
         sessionID: options.sessionID,
         error: String(err)
       });
@@ -59718,7 +59901,7 @@ async function verifyCompletion(ctx, options) {
       query: { directory: options.directory }
     });
     if (createResult.error || !createResult.data?.id) {
-      log(`[${HOOK_NAME5}] Verification session creation failed`);
+      log(`[${HOOK_NAME6}] Verification session creation failed`);
       return { verified: true };
     }
     verifySessionID = createResult.data.id;
@@ -59748,16 +59931,16 @@ async function verifyCompletion(ctx, options) {
           return parseVerificationResponse(assistantText);
         }
       } catch {
-        log(`[${HOOK_NAME5}] Verification poll error`);
+        log(`[${HOOK_NAME6}] Verification poll error`);
       }
       await new Promise((resolve5) => {
         setTimeout(resolve5, pollIntervalMs);
       });
     }
-    log(`[${HOOK_NAME5}] Verification timed out, assuming pass`);
+    log(`[${HOOK_NAME6}] Verification timed out, assuming pass`);
     return { verified: true };
   } catch (err) {
-    log(`[${HOOK_NAME5}] Verification error: ${String(err)}`);
+    log(`[${HOOK_NAME6}] Verification error: ${String(err)}`);
     return { verified: true };
   } finally {
     if (verifySessionID) {
@@ -59833,7 +60016,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_NAME5}] Verification failed`, { sessionID, reason });
+  log(`[${HOOK_NAME6}] Verification failed`, { sessionID, reason });
   const newState = options.loopState.incrementIteration();
   if (newState) {
     newState.verification_failed_count = failedCount + 1;
@@ -59851,7 +60034,7 @@ ${buildContinuationPrompt(newState ?? state3)}`,
       apiTimeoutMs: options.apiTimeoutMs
     });
   } catch (err) {
-    log(`[${HOOK_NAME5}] Failed to inject verification feedback`, { sessionID, error: String(err) });
+    log(`[${HOOK_NAME6}] Failed to inject verification feedback`, { sessionID, error: String(err) });
   }
 }
 function createMatrixLoopEventHandler(ctx, options) {
@@ -59863,13 +60046,13 @@ function createMatrixLoopEventHandler(ctx, options) {
       if (!sessionID)
         return;
       if (inFlightSessions.has(sessionID)) {
-        log(`[${HOOK_NAME5}] Skipped: handler in flight`, { sessionID });
+        log(`[${HOOK_NAME6}] Skipped: handler in flight`, { sessionID });
         return;
       }
       inFlightSessions.add(sessionID);
       try {
         if (options.sessionRecovery.isRecovering(sessionID)) {
-          log(`[${HOOK_NAME5}] Skipped: in recovery`, { sessionID });
+          log(`[${HOOK_NAME6}] Skipped: in recovery`, { sessionID });
           return;
         }
         const state3 = options.loopState.getState();
@@ -59881,11 +60064,11 @@ function createMatrixLoopEventHandler(ctx, options) {
               const exists = await options.checkSessionExists(state3.session_id);
               if (!exists) {
                 options.loopState.clear();
-                log(`[${HOOK_NAME5}] Cleared orphaned state from deleted session`, { orphanedSessionId: state3.session_id, currentSessionId: sessionID });
+                log(`[${HOOK_NAME6}] Cleared orphaned state from deleted session`, { orphanedSessionId: state3.session_id, currentSessionId: sessionID });
                 return;
               }
             } catch (err) {
-              log(`[${HOOK_NAME5}] Failed to check session existence`, { sessionId: state3.session_id, error: String(err) });
+              log(`[${HOOK_NAME6}] Failed to check session existence`, { sessionId: state3.session_id, error: String(err) });
             }
           }
           return;
@@ -59904,7 +60087,7 @@ function createMatrixLoopEventHandler(ctx, options) {
             messages = Array.isArray(messagesResponse) ? messagesResponse : Array.isArray(responseData) ? responseData : [];
           } catch (err) {
             setTimeout(() => {
-              log(`[${HOOK_NAME5}] Session messages fetch failed`, { sessionID, error: String(err) });
+              log(`[${HOOK_NAME6}] Session messages fetch failed`, { sessionID, error: String(err) });
             }, 0);
             messages = [];
           }
@@ -59917,7 +60100,7 @@ function createMatrixLoopEventHandler(ctx, options) {
           preFetchedMessages: messages
         });
         if (completionViaTranscript || completionViaApi) {
-          log(`[${HOOK_NAME5}] Completion detected!`, { sessionID, iteration: state3.iteration, promise: state3.completion_promise, detectedVia: completionViaTranscript ? "transcript_file" : "session_messages_api" });
+          log(`[${HOOK_NAME6}] 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;
@@ -59952,7 +60135,7 @@ function createMatrixLoopEventHandler(ctx, options) {
           return;
         }
         if (state3.iteration >= state3.max_iterations) {
-          log(`[${HOOK_NAME5}] Max iterations reached`, { sessionID, iteration: state3.iteration, max: state3.max_iterations });
+          log(`[${HOOK_NAME6}] 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((err) => {
             log("[matrix-loop] Max iterations toast failed:", err);
@@ -59961,17 +60144,17 @@ function createMatrixLoopEventHandler(ctx, options) {
         }
         const newState = options.loopState.incrementIteration();
         if (!newState) {
-          log(`[${HOOK_NAME5}] Failed to increment iteration`, { sessionID });
+          log(`[${HOOK_NAME6}] Failed to increment iteration`, { sessionID });
           return;
         }
-        log(`[${HOOK_NAME5}] Continuing loop`, { sessionID, iteration: newState.iteration, max: newState.max_iterations });
+        log(`[${HOOK_NAME6}] 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_NAME5}] Failed to inject continuation`, { sessionID, error: String(err) });
+          log(`[${HOOK_NAME6}] Failed to inject continuation`, { sessionID, error: String(err) });
         }
         return;
       } finally {
@@ -59985,7 +60168,7 @@ function createMatrixLoopEventHandler(ctx, options) {
       const state3 = options.loopState.getState();
       if (state3?.session_id === sessionInfo.id) {
         options.loopState.clear();
-        log(`[${HOOK_NAME5}] Session deleted, loop cleared`, { sessionID: sessionInfo.id });
+        log(`[${HOOK_NAME6}] Session deleted, loop cleared`, { sessionID: sessionInfo.id });
       }
       options.sessionRecovery.clear(sessionInfo.id);
       return;
@@ -59998,7 +60181,7 @@ function createMatrixLoopEventHandler(ctx, options) {
           const state3 = options.loopState.getState();
           if (state3?.session_id === sessionID) {
             options.loopState.clear();
-            log(`[${HOOK_NAME5}] User aborted, loop cleared`, { sessionID });
+            log(`[${HOOK_NAME6}] User aborted, loop cleared`, { sessionID });
           }
           options.sessionRecovery.clear(sessionID);
         }
@@ -60091,7 +60274,7 @@ function createMcpStartupNotificationHook(ctx) {
   };
 }
 // src/hooks/mouse-notepad/constants.ts
-var HOOK_NAME6 = "mouse-notepad";
+var HOOK_NAME7 = "mouse-notepad";
 var NOTEPAD_DIRECTIVE = `
 <Work_Context>
 ## Notepad Location (for recording learnings)
@@ -60138,14 +60321,14 @@ function createMouseNotepadHook(ctx) {
         return;
       }
       output.args.prompt = NOTEPAD_DIRECTIVE + prompt;
-      log(`[${HOOK_NAME6}] Injected notepad directive to task`, {
+      log(`[${HOOK_NAME7}] Injected notepad directive to task`, {
         sessionID: input.sessionID
       });
     }
   };
 }
 // src/hooks/non-interactive-env/constants.ts
-var HOOK_NAME7 = "non-interactive-env";
+var HOOK_NAME8 = "non-interactive-env";
 var NON_INTERACTIVE_ENV = {
   CI: "true",
   DEBIAN_FRONTEND: "noninteractive",
@@ -60236,7 +60419,7 @@ function createNonInteractiveEnvHook(_ctx) {
       }
       const envPrefix = buildEnvPrefix(NON_INTERACTIVE_ENV, "unix");
       output.args.command = `${envPrefix} ${command}`;
-      log(`[${HOOK_NAME7}] Prepended non-interactive env vars to git command`, {
+      log(`[${HOOK_NAME8}] Prepended non-interactive env vars to git command`, {
         sessionID: input.sessionID,
         envPrefix
       });
@@ -60244,7 +60427,7 @@ function createNonInteractiveEnvHook(_ctx) {
   };
 }
 // src/hooks/oracle-md-only/constants.ts
-var HOOK_NAME8 = "oracle-md-only";
+var HOOK_NAME9 = "oracle-md-only";
 var ORACLE_AGENT = "oracle";
 var ALLOWED_EXTENSIONS = [".md"];
 var BLOCKED_TOOLS = ["Write", "Edit", "write", "edit"];
@@ -60377,7 +60560,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_NAME8}] Injected read-only planning warning to ${toolName}`, {
+          log(`[${HOOK_NAME9}] Injected read-only planning warning to ${toolName}`, {
             sessionID: input.sessionID,
             tool: toolName,
             agent: agentName
@@ -60393,17 +60576,17 @@ function createOracleMdOnlyHook(ctx) {
         return;
       }
       if (!isAllowedFile(filePath, ctx.directory)) {
-        log(`[${HOOK_NAME8}] Blocked: Oracle can only write to .matrixx/*.md`, {
+        log(`[${HOOK_NAME9}] Blocked: Oracle can only write to .matrixx/*.md`, {
           sessionID: input.sessionID,
           tool: toolName,
           filePath,
           agent: agentName
         });
-        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`);
+        throw new Error(`[${HOOK_NAME9}] ${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_NAME8}] Injecting workflow reminder for plan write`, {
+        log(`[${HOOK_NAME9}] Injecting workflow reminder for plan write`, {
           sessionID: input.sessionID,
           tool: toolName,
           filePath,
@@ -60411,7 +60594,7 @@ function createOracleMdOnlyHook(ctx) {
         });
         output.message = (output.message || "") + ORACLE_WORKFLOW_REMINDER;
       }
-      log(`[${HOOK_NAME8}] Allowed: .matrixx/*.md write permitted`, {
+      log(`[${HOOK_NAME9}] Allowed: .matrixx/*.md write permitted`, {
         sessionID: input.sessionID,
         tool: toolName,
         filePath,
@@ -60482,7 +60665,7 @@ async function getGitHead(directory) {
 }
 
 // src/hooks/plan-persister/hook.ts
-var HOOK_NAME9 = "plan-persister";
+var HOOK_NAME10 = "plan-persister";
 function createPlanPersister(ctx, options) {
   const { directory } = options;
   const capture = async (sessionID) => {
@@ -60501,7 +60684,7 @@ function createPlanPersister(ctx, options) {
       const response = await ctx.client.session.todo({ path: { id: sessionID } });
       todos = normalizeTodos(response);
     } catch (err) {
-      log(`[${HOOK_NAME9}] Failed to fetch todos`, { sessionID, error: String(err) });
+      log(`[${HOOK_NAME10}] Failed to fetch todos`, { sessionID, error: String(err) });
       return;
     }
     const content = readPlanFile(planPath);
@@ -60523,9 +60706,9 @@ function createPlanPersister(ctx, options) {
     ensurePlanDir(directory);
     const ok = atomicWrite(planPath, finalContent);
     if (ok) {
-      log(`[${HOOK_NAME9}] Plan file updated`, { planPath, completed, total });
+      log(`[${HOOK_NAME10}] Plan file updated`, { planPath, completed, total });
     } else {
-      log(`[${HOOK_NAME9}] Failed to write plan file`, { planPath });
+      log(`[${HOOK_NAME10}] Failed to write plan file`, { planPath });
     }
   };
   const event = async ({ event: evt }) => {
@@ -61823,13 +62006,11 @@ function createReadImageResizerHook(_ctx) {
 }
 // src/hooks/rtk-bash-rewriter/constants.ts
 var RTK_BINARY_NAME = "rtk";
-var DEFAULT_TIMEOUT_MS = 5000;
 var RTK_REWRITE_COMMAND = "rewrite";
 
 // src/hooks/rtk-bash-rewriter/hook.ts
 function createRtkBashRewriterHook(_ctx, config2) {
   const rtkConfig = config2.rtk;
-  const _timeoutMs = rtkConfig?.timeout_ms ?? DEFAULT_TIMEOUT_MS;
   const binaryPath = rtkConfig?.binary_path ?? RTK_BINARY_NAME;
   const hasRtk = Bun.which(binaryPath) !== null;
   if (!hasRtk) {
@@ -62528,7 +62709,7 @@ var RETRYABLE_ERROR_PATTERNS = [
   /(?:^|\s)503(?:\s|$)/,
   /(?:^|\s)529(?:\s|$)/
 ];
-var HOOK_NAME10 = "runtime-fallback";
+var HOOK_NAME11 = "runtime-fallback";
 
 // src/hooks/runtime-fallback/fallback-models.ts
 init_logger();
@@ -62619,7 +62800,7 @@ function getRawFallbackModelsForSession(sessionID, agent, pluginConfig) {
     if (result)
       return result;
   }
-  log(`[${HOOK_NAME10}] No category/agent fallback models resolved for session`, { sessionID, agent });
+  log(`[${HOOK_NAME11}] No category/agent fallback models resolved for session`, { sessionID, agent });
   return;
 }
 
@@ -62648,21 +62829,21 @@ function findNextAvailableFallback(state3, fallbackModels, cooldownSeconds) {
     if (!isModelInCooldown(candidate, state3, cooldownSeconds)) {
       return candidate;
     }
-    log(`[${HOOK_NAME10}] Skipping fallback model in cooldown`, { model: candidate, index: i });
+    log(`[${HOOK_NAME11}] 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_NAME10}] Max fallback attempts reached`, { sessionID, attempts: state3.attemptCount });
+    log(`[${HOOK_NAME11}] 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_NAME10}] No available fallback models`, { sessionID });
+    log(`[${HOOK_NAME11}] No available fallback models`, { sessionID });
     return { success: false, error: "No available fallback models (all in cooldown or exhausted)" };
   }
-  log(`[${HOOK_NAME10}] Preparing fallback`, {
+  log(`[${HOOK_NAME11}] Preparing fallback`, {
     sessionID,
     from: state3.currentModel,
     to: nextModel,
@@ -62748,9 +62929,9 @@ function createAutoRetryHelpers(deps) {
   const abortSessionRequest = async (sessionID, source) => {
     try {
       await ctx.client.session.abort({ path: { id: sessionID } });
-      log(`[${HOOK_NAME10}] Aborted in-flight session request (${source})`, { sessionID });
+      log(`[${HOOK_NAME11}] Aborted in-flight session request (${source})`, { sessionID });
     } catch (error51) {
-      log(`[${HOOK_NAME10}] Failed to abort in-flight session request (${source})`, {
+      log(`[${HOOK_NAME11}] Failed to abort in-flight session request (${source})`, {
         sessionID,
         error: String(error51)
       });
@@ -62774,7 +62955,7 @@ function createAutoRetryHelpers(deps) {
       if (!state3)
         return;
       if (sessionRetryInFlight.has(sessionID)) {
-        log(`[${HOOK_NAME10}] Overriding in-flight retry due to session timeout`, { sessionID });
+        log(`[${HOOK_NAME11}] Overriding in-flight retry due to session timeout`, { sessionID });
       }
       await abortSessionRequest(sessionID, "session.timeout");
       sessionRetryInFlight.delete(sessionID);
@@ -62784,7 +62965,7 @@ function createAutoRetryHelpers(deps) {
       const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig);
       if (fallbackModels.length === 0)
         return;
-      log(`[${HOOK_NAME10}] Session fallback timeout reached`, {
+      log(`[${HOOK_NAME11}] Session fallback timeout reached`, {
         sessionID,
         timeoutSeconds: config2.timeout_seconds,
         currentModel: state3.currentModel
@@ -62798,7 +62979,7 @@ function createAutoRetryHelpers(deps) {
   };
   const autoRetryWithFallback = async (sessionID, newModel, resolvedAgent, source) => {
     if (sessionRetryInFlight.has(sessionID)) {
-      log(`[${HOOK_NAME10}] Retry already in flight, skipping (${source})`, { sessionID });
+      log(`[${HOOK_NAME11}] Retry already in flight, skipping (${source})`, { sessionID });
       return;
     }
     const agentSettings = resolvedAgent ? pluginConfig?.agents?.[resolvedAgent] : undefined;
@@ -62807,7 +62988,7 @@ function createAutoRetryHelpers(deps) {
       reasoningEffort: agentSettings.reasoningEffort
     } : undefined);
     if (!retryModelPayload) {
-      log(`[${HOOK_NAME10}] Invalid model format (missing provider prefix): ${newModel}`);
+      log(`[${HOOK_NAME11}] Invalid model format (missing provider prefix): ${newModel}`);
       const state3 = sessionStates2.get(sessionID);
       if (state3?.pendingFallbackModel) {
         state3.pendingFallbackModel = undefined;
@@ -62823,7 +63004,7 @@ function createAutoRetryHelpers(deps) {
       });
       const retryParts = getLastUserRetryParts(messagesResp);
       if (retryParts.length > 0) {
-        log(`[${HOOK_NAME10}] Auto-retrying with fallback model (${source})`, {
+        log(`[${HOOK_NAME11}] Auto-retrying with fallback model (${source})`, {
           sessionID,
           model: newModel
         });
@@ -62842,10 +63023,10 @@ function createAutoRetryHelpers(deps) {
         });
         retryDispatched = true;
       } else {
-        log(`[${HOOK_NAME10}] No user message found for auto-retry (${source})`, { sessionID });
+        log(`[${HOOK_NAME11}] No user message found for auto-retry (${source})`, { sessionID });
       }
     } catch (retryError) {
-      log(`[${HOOK_NAME10}] Auto-retry failed (${source})`, { sessionID, error: String(retryError) });
+      log(`[${HOOK_NAME11}] Auto-retry failed (${source})`, { sessionID, error: String(retryError) });
     } finally {
       sessionRetryInFlight.delete(sessionID);
       if (!retryDispatched) {
@@ -62899,7 +63080,7 @@ function createAutoRetryHelpers(deps) {
       }
     }
     if (cleanedCount > 0) {
-      log(`[${HOOK_NAME10}] Cleaned up ${cleanedCount} stale session states`);
+      log(`[${HOOK_NAME11}] Cleaned up ${cleanedCount} stale session states`);
     }
   };
   return {
@@ -62930,7 +63111,7 @@ function createChatMessageHandler(deps) {
         state3.pendingFallbackModel = undefined;
         return;
       }
-      log(`[${HOOK_NAME10}] Detected manual model change, resetting fallback state`, {
+      log(`[${HOOK_NAME11}] Detected manual model change, resetting fallback state`, {
         sessionID,
         from: state3.currentModel,
         to: requestedModel
@@ -62942,7 +63123,7 @@ function createChatMessageHandler(deps) {
     if (state3.currentModel === state3.originalModel)
       return;
     const activeModel = state3.currentModel;
-    log(`[${HOOK_NAME10}] Applying fallback model override`, {
+    log(`[${HOOK_NAME11}] Applying fallback model override`, {
       sessionID,
       from: input.model,
       to: activeModel
@@ -63129,7 +63310,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_NAME10}] Derived model from agent config for ${options.source}`, {
+    log(`[${HOOK_NAME11}] Derived model from agent config for ${options.source}`, {
       sessionID: options.sessionID,
       agent: options.resolvedAgent,
       model: agentModel
@@ -63140,7 +63321,7 @@ function resolveFallbackBootstrapModel(options) {
   if (agentCategory) {
     const agentCategoryModel = options.pluginConfig?.categories?.[agentCategory]?.model;
     if (typeof agentCategoryModel === "string" && agentCategoryModel.length > 0) {
-      log(`[${HOOK_NAME10}] Derived model from agent category config for ${options.source}`, {
+      log(`[${HOOK_NAME11}] Derived model from agent category config for ${options.source}`, {
         sessionID: options.sessionID,
         agent: options.resolvedAgent,
         category: agentCategory,
@@ -63152,7 +63333,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_NAME10}] Derived model from session category config for ${options.source}`, {
+    log(`[${HOOK_NAME11}] Derived model from session category config for ${options.source}`, {
       sessionID: options.sessionID,
       category: sessionCategory,
       model: categoryModel
@@ -63182,7 +63363,7 @@ async function dispatchFallbackRetry(deps, helpers, options) {
     await helpers.autoRetryWithFallback(options.sessionID, result.newModel, options.resolvedAgent, options.source);
     return;
   }
-  log(`[${HOOK_NAME10}] Fallback preparation failed`, {
+  log(`[${HOOK_NAME11}] Fallback preparation failed`, {
     sessionID: options.sessionID,
     source: options.source,
     error: result.error
@@ -63235,14 +63416,14 @@ function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
     sessionStatusRetryKeys.set(sessionID, retryKey);
     if (sessionRetryInFlight.has(sessionID)) {
       if (timeoutEnabled) {
-        log(`[${HOOK_NAME10}] Overriding in-flight retry due to provider auto-retry signal`, {
+        log(`[${HOOK_NAME11}] 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_NAME10}] session.status retry skipped - retry already in flight`, { sessionID });
+        log(`[${HOOK_NAME11}] session.status retry skipped - retry already in flight`, { sessionID });
         return;
       }
     }
@@ -63265,7 +63446,7 @@ function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
       });
       if (!initialModel) {
         sessionStatusRetryKeys.delete(sessionID);
-        log(`[${HOOK_NAME10}] session.status retry missing model info, cannot fallback`, { sessionID });
+        log(`[${HOOK_NAME11}] session.status retry missing model info, cannot fallback`, { sessionID });
         return;
       }
       state3 = createFallbackState(initialModel);
@@ -63274,20 +63455,20 @@ function createSessionStatusHandler(deps, helpers, sessionStatusRetryKeys) {
     sessionLastAccess.set(sessionID, Date.now());
     if (state3.pendingFallbackModel) {
       if (timeoutEnabled) {
-        log(`[${HOOK_NAME10}] Clearing pending fallback due to provider auto-retry signal`, {
+        log(`[${HOOK_NAME11}] Clearing pending fallback due to provider auto-retry signal`, {
           sessionID,
           pendingFallbackModel: state3.pendingFallbackModel
         });
         state3.pendingFallbackModel = undefined;
       } else {
-        log(`[${HOOK_NAME10}] session.status retry skipped (pending fallback in progress)`, {
+        log(`[${HOOK_NAME11}] session.status retry skipped (pending fallback in progress)`, {
           sessionID,
           pendingFallbackModel: state3.pendingFallbackModel
         });
         return;
       }
     }
-    log(`[${HOOK_NAME10}] Detected provider auto-retry signal in session.status`, {
+    log(`[${HOOK_NAME11}] Detected provider auto-retry signal in session.status`, {
       sessionID,
       model: state3.currentModel,
       retryAttempt: status.attempt
@@ -63323,7 +63504,7 @@ function createEventHandler(deps, helpers) {
     const sessionID = sessionInfo?.id;
     const model = sessionInfo?.model;
     if (sessionID && model) {
-      log(`[${HOOK_NAME10}] Session created with model`, { sessionID, model });
+      log(`[${HOOK_NAME11}] Session created with model`, { sessionID, model });
       sessionStates2.set(sessionID, createFallbackState(model));
       sessionLastAccess.set(sessionID, Date.now());
     }
@@ -63332,7 +63513,7 @@ function createEventHandler(deps, helpers) {
     const sessionInfo = props?.info;
     const sessionID = sessionInfo?.id;
     if (sessionID) {
-      log(`[${HOOK_NAME10}] Cleaning up session state`, { sessionID });
+      log(`[${HOOK_NAME11}] Cleaning up session state`, { sessionID });
       cancelledSessions.delete(sessionID);
       sessionStates2.delete(sessionID);
       sessionLastAccess.delete(sessionID);
@@ -63352,7 +63533,7 @@ function createEventHandler(deps, helpers) {
     }
     cancelledSessions.add(sessionID);
     resetRetryState(sessionID);
-    log(`[${HOOK_NAME10}] Cleared fallback retry state on session.stop`, { sessionID });
+    log(`[${HOOK_NAME11}] Cleared fallback retry state on session.stop`, { sessionID });
   };
   const handleMessageUpdated = (props) => {
     const info = props?.info;
@@ -63368,11 +63549,11 @@ function createEventHandler(deps, helpers) {
       return;
     if (cancelledSessions.has(sessionID)) {
       resetRetryState(sessionID);
-      log(`[${HOOK_NAME10}] Cleared fallback retry state for cancelled session on idle`, { sessionID });
+      log(`[${HOOK_NAME11}] Cleared fallback retry state for cancelled session on idle`, { sessionID });
       return;
     }
     if (sessionAwaitingFallbackResult.has(sessionID)) {
-      log(`[${HOOK_NAME10}] session.idle while awaiting fallback result; keeping timeout armed`, { sessionID });
+      log(`[${HOOK_NAME11}] session.idle while awaiting fallback result; keeping timeout armed`, { sessionID });
       return;
     }
     const hadTimeout = sessionFallbackTimeouts.has(sessionID);
@@ -63384,7 +63565,7 @@ function createEventHandler(deps, helpers) {
       state3.pendingFallbackModel = undefined;
     }
     if (hadTimeout) {
-      log(`[${HOOK_NAME10}] Cleared fallback timeout after session completion`, { sessionID });
+      log(`[${HOOK_NAME11}] Cleared fallback timeout after session completion`, { sessionID });
     }
   };
   const handleSessionError = async (props) => {
@@ -63392,18 +63573,18 @@ function createEventHandler(deps, helpers) {
     const error51 = props?.error;
     const agent = props?.agent;
     if (!sessionID) {
-      log(`[${HOOK_NAME10}] session.error without sessionID, skipping`);
+      log(`[${HOOK_NAME11}] session.error without sessionID, skipping`);
       return;
     }
     const resolvedAgent = await helpers.resolveAgentForSessionFromContext(sessionID, agent);
     if (isAbortError(error51)) {
       cancelledSessions.add(sessionID);
       resetRetryState(sessionID);
-      log(`[${HOOK_NAME10}] session.error matched cancellation; cleared retry state`, { sessionID, resolvedAgent });
+      log(`[${HOOK_NAME11}] session.error matched cancellation; cleared retry state`, { sessionID, resolvedAgent });
       return;
     }
     if (sessionRetryInFlight.has(sessionID)) {
-      log(`[${HOOK_NAME10}] session.error skipped - retry in flight`, {
+      log(`[${HOOK_NAME11}] session.error skipped - retry in flight`, {
         sessionID,
         retryInFlight: true
       });
@@ -63411,7 +63592,7 @@ function createEventHandler(deps, helpers) {
     }
     sessionAwaitingFallbackResult.delete(sessionID);
     helpers.clearSessionFallbackTimeout(sessionID);
-    log(`[${HOOK_NAME10}] session.error received`, {
+    log(`[${HOOK_NAME11}] session.error received`, {
       sessionID,
       agent,
       resolvedAgent,
@@ -63420,7 +63601,7 @@ function createEventHandler(deps, helpers) {
       errorType: classifyErrorType(error51)
     });
     if (!isRetryableError(error51, config2.retry_on_errors)) {
-      log(`[${HOOK_NAME10}] Error not retryable, skipping fallback`, {
+      log(`[${HOOK_NAME11}] Error not retryable, skipping fallback`, {
         sessionID,
         retryable: false,
         statusCode: extractStatusCode(error51, config2.retry_on_errors),
@@ -63432,7 +63613,7 @@ function createEventHandler(deps, helpers) {
     let state3 = sessionStates2.get(sessionID);
     const fallbackModels = getFallbackModelsForSession(sessionID, resolvedAgent, pluginConfig);
     if (fallbackModels.length === 0) {
-      log(`[${HOOK_NAME10}] No fallback models configured`, { sessionID, agent });
+      log(`[${HOOK_NAME11}] No fallback models configured`, { sessionID, agent });
       return;
     }
     if (!state3) {
@@ -63444,7 +63625,7 @@ function createEventHandler(deps, helpers) {
         pluginConfig
       });
       if (!initialModel) {
-        log(`[${HOOK_NAME10}] No model info available, cannot fallback`, { sessionID });
+        log(`[${HOOK_NAME11}] No model info available, cannot fallback`, { sessionID });
         return;
       }
       state3 = createFallbackState(initialModel);
@@ -63584,7 +63765,7 @@ function createMessageUpdateHandler(deps, helpers) {
       }
       const hasVisible = await checkVisibleResponse(ctx, sessionID, info);
       if (!hasVisible) {
-        log(`[${HOOK_NAME10}] Assistant update observed without visible final response; keeping fallback timeout`, {
+        log(`[${HOOK_NAME11}] Assistant update observed without visible final response; keeping fallback timeout`, {
           sessionID,
           model
         });
@@ -63597,17 +63778,17 @@ function createMessageUpdateHandler(deps, helpers) {
       if (state3?.pendingFallbackModel) {
         state3.pendingFallbackModel = undefined;
       }
-      log(`[${HOOK_NAME10}] Assistant response observed; cleared fallback timeout`, { sessionID, model });
+      log(`[${HOOK_NAME11}] Assistant response observed; cleared fallback timeout`, { sessionID, model });
       return;
     }
     if (sessionID && role === "assistant" && error51) {
       sessionAwaitingFallbackResult.delete(sessionID);
       if (sessionRetryInFlight.has(sessionID) && !retrySignal) {
-        log(`[${HOOK_NAME10}] message.updated fallback skipped (retry in flight)`, { sessionID });
+        log(`[${HOOK_NAME11}] message.updated fallback skipped (retry in flight)`, { sessionID });
         return;
       }
       if (retrySignal && sessionRetryInFlight.has(sessionID) && timeoutEnabled) {
-        log(`[${HOOK_NAME10}] Overriding in-flight retry due to provider auto-retry signal`, {
+        log(`[${HOOK_NAME11}] Overriding in-flight retry due to provider auto-retry signal`, {
           sessionID,
           model
         });
@@ -63615,12 +63796,12 @@ function createMessageUpdateHandler(deps, helpers) {
         sessionRetryInFlight.delete(sessionID);
       }
       if (retrySignal && timeoutEnabled) {
-        log(`[${HOOK_NAME10}] Detected provider auto-retry signal`, { sessionID, model });
+        log(`[${HOOK_NAME11}] Detected provider auto-retry signal`, { sessionID, model });
       }
       if (!retrySignal) {
         helpers.clearSessionFallbackTimeout(sessionID);
       }
-      log(`[${HOOK_NAME10}] message.updated with assistant error`, {
+      log(`[${HOOK_NAME11}] message.updated with assistant error`, {
         sessionID,
         model,
         statusCode: extractStatusCode(error51, config2.retry_on_errors),
@@ -63628,7 +63809,7 @@ function createMessageUpdateHandler(deps, helpers) {
         errorType: classifyErrorType(error51)
       });
       if (!isRetryableError(error51, config2.retry_on_errors)) {
-        log(`[${HOOK_NAME10}] message.updated error not retryable, skipping fallback`, {
+        log(`[${HOOK_NAME11}] message.updated error not retryable, skipping fallback`, {
           sessionID,
           statusCode: extractStatusCode(error51, config2.retry_on_errors),
           errorName: extractErrorName(error51),
@@ -63652,7 +63833,7 @@ function createMessageUpdateHandler(deps, helpers) {
           pluginConfig
         });
         if (!initialModel) {
-          log(`[${HOOK_NAME10}] message.updated missing model info, cannot fallback`, {
+          log(`[${HOOK_NAME11}] message.updated missing model info, cannot fallback`, {
             sessionID,
             errorName: extractErrorName(error51),
             errorType: classifyErrorType(error51)
@@ -63666,13 +63847,13 @@ function createMessageUpdateHandler(deps, helpers) {
         sessionLastAccess.set(sessionID, Date.now());
         if (state3.pendingFallbackModel) {
           if (retrySignal && timeoutEnabled) {
-            log(`[${HOOK_NAME10}] Clearing pending fallback due to provider auto-retry signal`, {
+            log(`[${HOOK_NAME11}] Clearing pending fallback due to provider auto-retry signal`, {
               sessionID,
               pendingFallbackModel: state3.pendingFallbackModel
             });
             state3.pendingFallbackModel = undefined;
           } else {
-            log(`[${HOOK_NAME10}] message.updated fallback skipped (pending fallback in progress)`, {
+            log(`[${HOOK_NAME11}] message.updated fallback skipped (pending fallback in progress)`, {
               sessionID,
               pendingFallbackModel: state3.pendingFallbackModel
             });
@@ -64678,7 +64859,7 @@ function createSessionRecoveryHook(ctx, options) {
 }
 // src/hooks/start-work/start-work-hook.ts
 init_logger();
-var HOOK_NAME11 = "start-work";
+var HOOK_NAME12 = "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);
@@ -64708,7 +64889,7 @@ function createStartWorkHook(ctx) {
       if (!isStartWorkCommand) {
         return;
       }
-      log(`[${HOOK_NAME11}] Processing start-work command`, {
+      log(`[${HOOK_NAME12}] Processing start-work command`, {
         sessionID: input.sessionID
       });
       updateSessionAgent(input.sessionID, "architect");
@@ -64718,7 +64899,7 @@ function createStartWorkHook(ctx) {
       let contextInfo = "";
       const explicitPlanName = extractUserRequestPlanName(promptText);
       if (explicitPlanName) {
-        log(`[${HOOK_NAME11}] Explicit plan name requested: ${explicitPlanName}`, {
+        log(`[${HOOK_NAME12}] Explicit plan name requested: ${explicitPlanName}`, {
           sessionID: input.sessionID
         });
         const allPlans = findOraclePlans(ctx.directory);
@@ -64859,7 +65040,7 @@ Ask the user which plan to work on. Present the options above and wait for their
 ---
 ${contextInfo}`;
       }
-      log(`[${HOOK_NAME11}] Context injected`, {
+      log(`[${HOOK_NAME12}] Context injected`, {
         sessionID: input.sessionID,
         hasExistingState: !!existingState
       });
@@ -64868,16 +65049,16 @@ ${contextInfo}`;
 }
 // src/hooks/stop-continuation-guard/hook.ts
 init_logger();
-var HOOK_NAME12 = "stop-continuation-guard";
+var HOOK_NAME13 = "stop-continuation-guard";
 function createStopContinuationGuardHook(_ctx, options) {
   const stoppedSessions = new Set;
   const stop = (sessionID) => {
     stoppedSessions.add(sessionID);
-    log(`[${HOOK_NAME12}] Continuation stopped for session`, { sessionID });
+    log(`[${HOOK_NAME13}] Continuation stopped for session`, { sessionID });
     if (options?.backgroundManager) {
       const cancelled = options.backgroundManager.cancelAllForSession(sessionID);
       if (cancelled > 0) {
-        log(`[${HOOK_NAME12}] Cancelled ${cancelled} background task(s) for session`, { sessionID });
+        log(`[${HOOK_NAME13}] Cancelled ${cancelled} background task(s) for session`, { sessionID });
       }
     }
   };
@@ -64886,7 +65067,7 @@ function createStopContinuationGuardHook(_ctx, options) {
   };
   const clear = (sessionID) => {
     stoppedSessions.delete(sessionID);
-    log(`[${HOOK_NAME12}] Continuation guard cleared for session`, { sessionID });
+    log(`[${HOOK_NAME13}] Continuation guard cleared for session`, { sessionID });
   };
   const event = async ({
     event: event2
@@ -64896,7 +65077,7 @@ function createStopContinuationGuardHook(_ctx, options) {
       const sessionInfo = props?.info;
       if (sessionInfo?.id) {
         clear(sessionInfo.id);
-        log(`[${HOOK_NAME12}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
+        log(`[${HOOK_NAME13}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
       }
     }
   };
@@ -64905,7 +65086,7 @@ function createStopContinuationGuardHook(_ctx, options) {
   }) => {
     if (sessionID && stoppedSessions.has(sessionID)) {
       clear(sessionID);
-      log(`[${HOOK_NAME12}] Cleared stop state on new user message`, { sessionID });
+      log(`[${HOOK_NAME13}] Cleared stop state on new user message`, { sessionID });
     }
   };
   return {
@@ -64916,216 +65097,54 @@ function createStopContinuationGuardHook(_ctx, options) {
     clear
   };
 }
-// src/hooks/task-notepad/constants.ts
-var HOOK_NAME13 = "task-notepad";
-var PLAN_DIR_NAME = ".matrixx";
-var PLANS_SUBDIR = "plans";
-var NOTEPAD_DIR_NAME = "notepads";
-var TASKS_SUBDIR = "tasks";
-var PLAN_EXTENSION = ".md";
-var NOTEPAD_EXTENSION = ".md";
-var TODO_TOOL_NAMES = new Set(["todowrite", "TodoWrite"]);
-var TASK_NOTEPAD_FRAGMENT = "task-notepad";
-var TODO_FETCH_ERROR_FRAGMENT = "Failed to fetch todos for task-notepad";
-// src/hooks/task-notepad/hook.ts
+// src/hooks/task-continuation-enforcer/index.ts
 init_logger();
-import { existsSync as existsSync42, mkdirSync as mkdirSync15, readdirSync as readdirSync13, readFileSync as readFileSync32, statSync as statSync8, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname14, join as join51 } from "path";
-function createTaskNotepadHook(ctx) {
-  return {
-    "tool.execute.after": async (input, output) => {
-      if (!output)
-        return;
-      if (!TODO_TOOL_NAMES.has(input.tool))
-        return;
-      const todos = await fetchTodos(ctx, input.sessionID);
-      const inProgress = todos.find((t) => t.status === "in_progress");
-      const completed = todos.filter((t) => t.status === "completed");
-      if (!inProgress && completed.length === 0)
-        return;
-      const plan = resolveActivePlan(ctx.directory);
-      if (inProgress) {
-        if (!plan) {
-          log(`[${HOOK_NAME13}] No active plan, skipping notepad creation`, {
-            sessionID: input.sessionID
-          });
-        } else {
-          ensureNotepad(ctx.directory, plan.name, inProgress);
-        }
-      }
-      if (!plan)
-        return;
-      for (const done of completed) {
-        appendCompletion(ctx.directory, plan.name, done);
-      }
-    }
-  };
-}
-async function fetchTodos(ctx, sessionID) {
-  try {
-    const response = await ctx.client.session.todo({ path: { id: sessionID } });
-    const payload = response;
-    if (Array.isArray(payload?.data)) {
-      return payload.data;
-    }
-    if (Array.isArray(response)) {
-      return response;
-    }
-    return [];
-  } catch (err) {
-    log(`[${HOOK_NAME13}] ${TODO_FETCH_ERROR_FRAGMENT}`, {
-      sessionID,
-      error: String(err)
-    });
-    return [];
-  }
-}
-function resolveActivePlan(directory) {
-  const plansDir = join51(directory, PLAN_DIR_NAME, PLANS_SUBDIR);
-  if (!existsSync42(plansDir))
-    return null;
-  let entries;
-  try {
-    entries = readdirSync13(plansDir);
-  } catch {
-    return null;
-  }
-  let best = null;
-  for (const entry of entries) {
-    if (!entry.endsWith(PLAN_EXTENSION))
-      continue;
-    const fullPath = join51(plansDir, entry);
-    try {
-      const stats = statSync8(fullPath);
-      if (!stats.isFile())
-        continue;
-      const candidate = {
-        name: entry.slice(0, -PLAN_EXTENSION.length),
-        path: fullPath,
-        mtimeMs: stats.mtimeMs
-      };
-      if (!best || candidate.mtimeMs > best.mtimeMs) {
-        best = candidate;
-      }
-    } catch {}
-  }
-  return best;
-}
-function ensureNotepad(directory, planName, todo) {
-  const notepadPath = notepadPathFor(directory, planName, todo.id);
-  if (existsSync42(notepadPath))
-    return;
-  mkdirSync15(dirname14(notepadPath), { recursive: true });
-  const content = renderNotepad(todo);
-  writeFileSync18(notepadPath, content, "utf-8");
-  log(`[${HOOK_NAME13}] Created task notepad`, { plan: planName, taskID: todo.id });
-}
-function appendCompletion(directory, planName, todo) {
-  const notepadPath = notepadPathFor(directory, planName, todo.id);
-  if (!existsSync42(notepadPath))
-    return;
-  const existing = readFileSync32(notepadPath, "utf-8");
-  if (existing.includes("**Status**: completed"))
-    return;
-  const stamp = new Date().toISOString();
-  const updated = `${existing}
-## Completion
-- completed_at: ${stamp}
-- status: completed
-`;
-  writeFileSync18(notepadPath, updated, "utf-8");
-  log(`[${HOOK_NAME13}] Appended completion to notepad`, { plan: planName, taskID: todo.id });
-}
-function notepadPathFor(directory, planName, taskID) {
-  return join51(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
-}
-function renderNotepad(todo) {
-  const priority = todo.priority ?? "medium";
-  return `# Task: ${todo.content}
-
-**Plan**: ${TASK_NOTEPAD_FRAGMENT}
-**Task ID**: ${todo.id}
-**Priority**: ${priority}
-**Status**: ${todo.status}
-**Started**: ${new Date().toISOString()}
-
-## Findings
-
-(Record what you learn about this code as you work \u2014 patterns, conventions, gotchas, useful references.)
-
-## Blockers
-
-(Anything blocking progress. Be specific: file path, line, error, workaround if any.)
 
-## Questions
+// src/hooks/task-continuation-enforcer/constants.ts
+var HOOK_NAME14 = "task-continuation-enforcer";
+var DEFAULT_SKIP_AGENTS = ["oracle", "compaction"];
+var CONTINUATION_PROMPT2 = `${createSystemDirective(SystemDirectiveTypes.TASK_CONTINUATION)}
 
-(Open questions to revisit later. Don't lose them when context compacts.)
+Incomplete Matrixx tasks remain. Continue working on the next pending task.
 
-## Results
+- Proceed without asking for permission
+- Mark each task in_progress before starting, completed immediately after
+- Respect blockedBy dependencies (skip blocked tasks)
+- Do not stop until all tasks are done`;
+var COUNTDOWN_SECONDS = 2;
+var TOAST_DURATION_MS = 900;
+var COUNTDOWN_GRACE_PERIOD_MS = 500;
+var ABORT_WINDOW_MS = 3000;
+var CONTINUATION_COOLDOWN_MS2 = 30000;
+var MAX_CONSECUTIVE_FAILURES = 5;
+var FAILURE_RESET_WINDOW_MS = 5 * 60 * 1000;
 
-(Summary on completion. What changed, what was verified, what remains.)
-`;
-}
-// src/hooks/task-resume-info/hook.ts
-var TARGET_TOOLS2 = ["task", "Task", "task_tool", "delegate_agent"];
-var SESSION_ID_PATTERNS = [
-  /Session ID: (ses_[a-zA-Z0-9_-]+)/,
-  /session_id: (ses_[a-zA-Z0-9_-]+)/,
-  /<task_metadata>\s*session_id: (ses_[a-zA-Z0-9_-]+)/,
-  /sessionId: (ses_[a-zA-Z0-9_-]+)/
-];
-function extractSessionId(output) {
-  for (const pattern of SESSION_ID_PATTERNS) {
-    const match = output.match(pattern);
-    if (match)
-      return match[1] ?? null;
-  }
-  return null;
-}
-function createTaskResumeInfoHook() {
-  const toolExecuteAfter = async (input, output) => {
-    if (!TARGET_TOOLS2.includes(input.tool))
-      return;
-    const outputText = output.output ?? "";
-    if (outputText.startsWith("Error:") || outputText.startsWith("Failed"))
-      return;
-    if (outputText.includes(`
-to continue:`))
-      return;
-    const sessionId = extractSessionId(outputText);
-    if (!sessionId)
-      return;
-    output.output = outputText.trimEnd() + `
+// src/hooks/task-continuation-enforcer/handler.ts
+init_logger();
 
-to continue: task(session_id="${sessionId}", prompt="...")`;
-  };
-  return {
-    "tool.execute.after": toolExecuteAfter
-  };
-}
-// src/hooks/task-todo-mirror/constants.ts
-var HOOK_NAME14 = "task-todo-mirror";
-var TASK_TOOL_NAMES = new Set([
-  "task_create",
-  "task_update"
-]);
-var DEBOUNCE_MS = 300;
-// src/hooks/task-todo-mirror/hook.ts
-import { existsSync as existsSync45, readdirSync as readdirSync15 } from "fs";
+// src/hooks/task-continuation-enforcer/idle-event.ts
+import { existsSync as existsSync44, readdirSync as readdirSync15 } from "fs";
 
 // src/features/task-storage/storage.ts
+init_logger();
 import { randomUUID } from "crypto";
-import { existsSync as existsSync43, mkdirSync as mkdirSync16, readdirSync as readdirSync14, readFileSync as readFileSync33, renameSync as renameSync3, unlinkSync as unlinkSync9, writeFileSync as writeFileSync19 } from "fs";
-import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute3, join as join52 } from "path";
-function getTaskDir(config2 = {}) {
+import { existsSync as existsSync42, mkdirSync as mkdirSync15, readdirSync as readdirSync13, readFileSync as readFileSync32, renameSync as renameSync3, unlinkSync as unlinkSync9, writeFileSync as writeFileSync18 } from "fs";
+import { basename as basename5, dirname as dirname14, isAbsolute as isAbsolute3, join as join51 } from "path";
+function getProjectTaskDir(directory) {
+  return join51(directory, ".matrixx", "tasks");
+}
+function getTaskDir(config2 = {}, directory) {
   const tasksConfig = config2.morpheus?.tasks;
   const storagePath = tasksConfig?.storage_path;
   if (storagePath) {
-    return isAbsolute3(storagePath) ? storagePath : join52(process.cwd(), storagePath);
+    return isAbsolute3(storagePath) ? storagePath : join51(directory ?? process.cwd(), storagePath);
   }
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const listId = resolveTaskListId(config2);
-  return join52(configDir, "tasks", listId);
+  if (tasksConfig?.scope === "global" || !directory) {
+    const configDir = getOpenCodeConfigDir({ binary: "opencode" });
+    const listId = resolveTaskListId(config2);
+    return join51(configDir, "tasks", listId);
+  }
+  return getProjectTaskDir(directory);
 }
 function sanitizePathSegment(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "-") || "default";
@@ -65143,16 +65162,16 @@ function resolveTaskListId(config2 = {}) {
   return sanitizePathSegment(basename5(process.cwd()));
 }
 function ensureDir2(dirPath) {
-  if (!existsSync43(dirPath)) {
-    mkdirSync16(dirPath, { recursive: true });
+  if (!existsSync42(dirPath)) {
+    mkdirSync15(dirPath, { recursive: true });
   }
 }
 function readJsonSafe(filePath, schema) {
   try {
-    if (!existsSync43(filePath)) {
+    if (!existsSync42(filePath)) {
       return null;
     }
-    const content = readFileSync33(filePath, "utf-8");
+    const content = readFileSync32(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = schema.safeParse(parsed);
     if (!result.success) {
@@ -65164,15 +65183,15 @@ function readJsonSafe(filePath, schema) {
   }
 }
 function writeJsonAtomic(filePath, data) {
-  const dir = dirname15(filePath);
+  const dir = dirname14(filePath);
   ensureDir2(dir);
   const tempPath = `${filePath}.tmp.${Date.now()}`;
   try {
-    writeFileSync19(tempPath, JSON.stringify(data, null, 2), "utf-8");
+    writeFileSync18(tempPath, JSON.stringify(data, null, 2), "utf-8");
     renameSync3(tempPath, filePath);
   } catch (error51) {
     try {
-      if (existsSync43(tempPath)) {
+      if (existsSync42(tempPath)) {
         unlinkSync9(tempPath);
       }
     } catch {}
@@ -65180,21 +65199,73 @@ function writeJsonAtomic(filePath, data) {
   }
 }
 var STALE_LOCK_THRESHOLD_MS = 30000;
+async function acquireLockWithRetry(dirPath, retries = 4) {
+  for (let attempt = 0;attempt < retries; attempt++) {
+    const lock = acquireLock(dirPath);
+    if (lock.acquired)
+      return lock;
+    if (attempt < retries - 1) {
+      await new Promise((resolve7) => setTimeout(resolve7, 15 * 2 ** attempt));
+    }
+  }
+  return { acquired: false, release: () => {} };
+}
 function generateTaskId() {
   return `T-${randomUUID()}`;
 }
+function migrateLegacyTasksIfNeeded(config2, directory) {
+  const projectDir = getProjectTaskDir(directory);
+  const legacyDir = join51(getOpenCodeConfigDir({ binary: "opencode" }), "tasks", resolveTaskListId(config2));
+  if (existsSync42(projectDir)) {
+    try {
+      const existing = readdirSync13(projectDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+      if (existing.length > 0) {
+        return { migrated: 0, legacyDir, projectDir };
+      }
+    } catch {}
+  }
+  if (!existsSync42(legacyDir)) {
+    return { migrated: 0, legacyDir, projectDir };
+  }
+  let files = [];
+  try {
+    files = readdirSync13(legacyDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+  } catch {
+    return { migrated: 0, legacyDir, projectDir };
+  }
+  if (files.length === 0) {
+    return { migrated: 0, legacyDir, projectDir };
+  }
+  ensureDir2(projectDir);
+  let migrated = 0;
+  for (const file2 of files) {
+    const src = join51(legacyDir, file2);
+    const dest = join51(projectDir, file2);
+    if (existsSync42(dest))
+      continue;
+    try {
+      const content = readFileSync32(src, "utf-8");
+      writeFileSync18(dest, content, "utf-8");
+      migrated++;
+    } catch {}
+  }
+  if (migrated > 0) {
+    log(`[task-storage] Migrated ${migrated} legacy tasks from ${legacyDir} to ${projectDir}`);
+  }
+  return { migrated, legacyDir, projectDir };
+}
 function acquireLock(dirPath) {
-  const lockPath = join52(dirPath, ".lock");
+  const lockPath = join51(dirPath, ".lock");
   const lockId = randomUUID();
   const createLock = (timestamp) => {
-    writeFileSync19(lockPath, JSON.stringify({ id: lockId, timestamp }), {
+    writeFileSync18(lockPath, JSON.stringify({ id: lockId, timestamp }), {
       encoding: "utf-8",
       flag: "wx"
     });
   };
   const isStale = () => {
     try {
-      const lockContent = readFileSync33(lockPath, "utf-8");
+      const lockContent = readFileSync32(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -65232,9 +65303,9 @@ function acquireLock(dirPath) {
     acquired: true,
     release: () => {
       try {
-        if (!existsSync43(lockPath))
+        if (!existsSync42(lockPath))
           return;
-        const lockContent = readFileSync33(lockPath, "utf-8");
+        const lockContent = readFileSync32(lockPath, "utf-8");
         const lockData = JSON.parse(lockContent);
         if (lockData.id !== lockId)
           return;
@@ -65244,239 +65315,9 @@ function acquireLock(dirPath) {
   };
 }
 
-// src/hooks/task-todo-mirror/hook.ts
+// src/hooks/task-continuation-enforcer/idle-event.ts
 init_logger();
 
-// src/tools/task/todo-sync.ts
-import { existsSync as existsSync44 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join53 } from "path";
-init_logger();
-function mapTaskStatusToTodoStatus(taskStatus) {
-  switch (taskStatus) {
-    case "pending":
-      return "pending";
-    case "in_progress":
-      return "in_progress";
-    case "completed":
-      return "completed";
-    case "deleted":
-      return null;
-    default:
-      return "pending";
-  }
-}
-function extractPriority(metadata) {
-  if (!metadata)
-    return;
-  const priority = metadata.priority;
-  if (typeof priority === "string" && ["low", "medium", "high"].includes(priority)) {
-    return priority;
-  }
-  return;
-}
-function todosMatch(todo1, todo2) {
-  if (todo1.id && todo2.id) {
-    return todo1.id === todo2.id;
-  }
-  return todo1.content === todo2.content;
-}
-function syncTaskToTodo(task) {
-  const todoStatus = mapTaskStatusToTodoStatus(task.status);
-  if (todoStatus === null) {
-    return null;
-  }
-  return {
-    id: task.id,
-    content: task.subject,
-    status: todoStatus,
-    priority: extractPriority(task.metadata)
-  };
-}
-async function resolveTodoWriter2() {
-  const loaders = ["opencode/session/todo", "@opencode-ai/core/session/todo"];
-  for (const loader of loaders) {
-    try {
-      const mod = await import(loader);
-      const update = mod.Todo?.update;
-      if (typeof update === "function") {
-        return update;
-      }
-    } catch (err) {
-      log("[todo-sync] Failed to resolve Todo.update", { loader, error: String(err) });
-    }
-  }
-  return null;
-}
-function getOpencodeDbPath() {
-  const candidates = [];
-  if (process.env.XDG_DATA_HOME) {
-    candidates.push(join53(process.env.XDG_DATA_HOME, "opencode", "opencode.db"));
-  }
-  candidates.push(join53(homedir9(), ".local", "share", "opencode", "opencode.db"));
-  candidates.push(join53(homedir9(), ".config", "opencode", "opencode.db"));
-  for (const p of candidates) {
-    if (existsSync44(p))
-      return p;
-  }
-  return candidates[1] ?? null;
-}
-async function directDbWrite(sessionID, todos) {
-  const dbPath = getOpencodeDbPath();
-  if (!dbPath || !existsSync44(dbPath)) {
-    log("[todo-sync] directDbWrite no db", { dbPath });
-    return false;
-  }
-  try {
-    const mod = await import("bun:sqlite");
-    const Database = mod.Database;
-    const db = new Database(dbPath);
-    const now = Date.now();
-    try {
-      db.exec("BEGIN IMMEDIATE");
-      db.prepare("DELETE FROM todo WHERE session_id = ?").run(sessionID);
-      const stmt = db.prepare("INSERT INTO todo (session_id, content, status, priority, position, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?)");
-      todos.forEach((t, idx) => {
-        stmt.run(sessionID, t.content, t.status, t.priority ?? "medium", idx, now, now);
-      });
-      db.exec("COMMIT");
-    } catch (inner) {
-      try {
-        db.exec("ROLLBACK");
-      } catch {}
-      throw inner;
-    } finally {
-      db.close();
-    }
-    log("[todo-sync] directDbWrite ok", { sessionID, count: todos.length });
-    return true;
-  } catch (err) {
-    log("[todo-sync] directDbWrite failed", { error: String(err) });
-    return false;
-  }
-}
-async function writeTodosWithFallback(sessionID, todos, writer) {
-  if (writer) {
-    try {
-      await writer({ sessionID, todos });
-      return;
-    } catch (err) {
-      log("[todo-sync] writer failed, fallback to direct DB", { error: String(err) });
-    }
-  }
-  const ok = await directDbWrite(sessionID, todos);
-  if (!ok) {
-    log("[todo-sync] fallback also failed", { sessionID });
-  }
-}
-function extractTodos2(response) {
-  const payload = response;
-  if (Array.isArray(payload?.data)) {
-    return payload.data;
-  }
-  if (Array.isArray(response)) {
-    return response;
-  }
-  return [];
-}
-async function syncTaskTodoUpdate(ctx, task, sessionID, writer) {
-  if (!ctx)
-    return;
-  const resolvedWriter = writer ?? await resolveTodoWriter2();
-  await syncSingleSession(ctx, task, sessionID, resolvedWriter);
-  const mainSessionID = safeGetMainSessionID();
-  if (mainSessionID && mainSessionID !== sessionID) {
-    await syncSingleSession(ctx, task, mainSessionID, resolvedWriter);
-  }
-}
-async function syncSingleSession(ctx, task, sessionID, writer) {
-  try {
-    const response = await ctx.client.session.todo({
-      path: { id: sessionID }
-    });
-    const currentTodos = extractTodos2(response);
-    const taskTodo = syncTaskToTodo(task);
-    const nextTodos = currentTodos.filter((todo) => {
-      if (taskTodo) {
-        return !todosMatch(todo, taskTodo);
-      }
-      if (todo.id) {
-        return todo.id !== task.id;
-      }
-      return todo.content !== task.subject;
-    });
-    if (taskTodo) {
-      nextTodos.push(taskTodo);
-    }
-    await writeTodosWithFallback(sessionID, nextTodos, writer);
-  } catch (err) {
-    log("[todo-sync] Failed to sync task todo", {
-      error: String(err),
-      sessionID
-    });
-  }
-}
-function safeGetMainSessionID() {
-  try {
-    return getMainSessionID();
-  } catch {
-    return;
-  }
-}
-async function syncAllTasksToTodos(ctx, tasks, sessionID, writer) {
-  try {
-    let currentTodos = [];
-    try {
-      const response = await ctx.client.session.todo({
-        path: { id: sessionID || "" }
-      });
-      currentTodos = extractTodos2(response);
-    } catch (err) {
-      log("[todo-sync] Failed to fetch current todos", {
-        error: String(err),
-        sessionID
-      });
-    }
-    const newTodos = [];
-    const tasksToRemove = new Set;
-    const allTaskSubjects = new Set;
-    for (const task of tasks) {
-      allTaskSubjects.add(task.subject);
-      const todo = syncTaskToTodo(task);
-      if (todo === null) {
-        tasksToRemove.add(task.id);
-      } else {
-        newTodos.push(todo);
-      }
-    }
-    const finalTodos = [];
-    const removedTaskSubjects = new Set(tasks.filter((t) => t.status === "deleted").map((t) => t.subject));
-    for (const existing of currentTodos) {
-      const isInNewTodos = newTodos.some((newTodo) => todosMatch(existing, newTodo));
-      const isRemovedById = existing.id ? tasksToRemove.has(existing.id) : false;
-      const isRemovedByContent = !existing.id && removedTaskSubjects.has(existing.content);
-      const isReplacedByTask = !existing.id && allTaskSubjects.has(existing.content);
-      if (!isInNewTodos && !isRemovedById && !isRemovedByContent && !isReplacedByTask) {
-        finalTodos.push(existing);
-      }
-    }
-    finalTodos.push(...newTodos);
-    const resolvedWriter = writer ?? await resolveTodoWriter2();
-    if (sessionID) {
-      await writeTodosWithFallback(sessionID, finalTodos, resolvedWriter);
-    }
-    log("[todo-sync] Synced todos", {
-      count: finalTodos.length,
-      sessionID
-    });
-  } catch (err) {
-    log("[todo-sync] Error in syncAllTasksToTodos", {
-      error: String(err),
-      sessionID
-    });
-  }
-}
-
 // src/tools/task/types.ts
 var TaskStatusSchema = exports_external.enum(["pending", "in_progress", "completed", "deleted"]);
 var TaskObjectSchema = exports_external.object({
@@ -65491,7 +65332,8 @@ var TaskObjectSchema = exports_external.object({
   metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
   repoURL: exports_external.string().optional(),
   parentID: exports_external.string().optional(),
-  threadID: exports_external.string()
+  threadID: exports_external.string(),
+  projectRoot: exports_external.string().optional()
 }).strict();
 var TaskCreateInputSchema = exports_external.object({
   subject: exports_external.string(),
@@ -65528,82 +65370,849 @@ var TaskDeleteInputSchema = exports_external.object({
   id: exports_external.string()
 });
 
-// src/hooks/task-todo-mirror/hook.ts
-function loadAllTasks(pluginConfig) {
+// src/hooks/task-continuation-enforcer/abort-detection.ts
+function isLastAssistantMessageAborted(messages) {
+  if (!messages || messages.length === 0)
+    return false;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const info = messages[i].info;
+    if (info?.role !== "assistant")
+      continue;
+    const errorName = info.error?.name;
+    if (!errorName)
+      return false;
+    return errorName === "MessageAbortedError" || errorName === "AbortError";
+  }
+  return false;
+}
+
+// src/hooks/task-continuation-enforcer/countdown.ts
+init_logger();
+
+// src/hooks/task-continuation-enforcer/continuation-injection.ts
+import { existsSync as existsSync43, readdirSync as readdirSync14 } from "fs";
+init_logger();
+// src/hooks/task-continuation-enforcer/todo.ts
+function getIncompleteTaskCount(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  return tasks.filter((task) => {
+    if (task.status !== "pending" && task.status !== "in_progress")
+      return false;
+    if (task.blockedBy.length === 0)
+      return true;
+    return task.blockedBy.every((bid) => byId.get(bid)?.status === "completed");
+  }).length;
+}
+
+// src/hooks/task-continuation-enforcer/continuation-injection.ts
+function hasWritePermission(tools) {
+  const editPermission = tools?.edit;
+  const writePermission = tools?.write;
+  return !tools || editPermission !== false && editPermission !== "deny" && writePermission !== false && writePermission !== "deny";
+}
+async function injectContinuation(args) {
+  const {
+    ctx,
+    sessionID,
+    backgroundManager,
+    skipAgents = DEFAULT_SKIP_AGENTS,
+    resolvedInfo,
+    sessionStateStore
+  } = args;
+  const state3 = sessionStateStore.getExistingState(sessionID);
+  if (state3?.isRecovering) {
+    log(`[${HOOK_NAME14}] Skipped injection: in recovery`, { sessionID });
+    return;
+  }
+  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
+  if (hasRunningBgTasks) {
+    log(`[${HOOK_NAME14}] Skipped injection: background tasks running`, { sessionID });
+    return;
+  }
+  const tasks = [];
+  let total = 0;
   try {
-    const dir = getTaskDir(pluginConfig);
-    if (!existsSync45(dir))
-      return [];
-    const files = readdirSync15(dir).filter((f) => f.endsWith(".json") && f.startsWith("T-"));
-    const tasks = [];
-    for (const file2 of files) {
-      const task = readJsonSafe(`${dir}/${file2}`, TaskObjectSchema);
-      if (task)
-        tasks.push(task);
+    const taskDir = getTaskDir({}, ctx.directory);
+    if (!existsSync43(taskDir)) {
+      log(`[${HOOK_NAME14}] Skipped injection: no task dir`, { sessionID, taskDir });
+      return;
+    }
+    const files = readdirSync14(taskDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+    for (const f of files) {
+      const parsed = readJsonSafe(`${taskDir}/${f}`, TaskObjectSchema);
+      if (parsed)
+        tasks.push(parsed);
+    }
+    total = tasks.length;
+    if (total === 0) {
+      log(`[${HOOK_NAME14}] Skipped injection: no tasks`, { sessionID });
+      return;
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME14}] Failed to fetch tasks`, { sessionID, error: String(error51) });
+    return;
+  }
+  const freshIncompleteCount = getIncompleteTaskCount(tasks);
+  if (freshIncompleteCount === 0) {
+    log(`[${HOOK_NAME14}] Skipped injection: no incomplete tasks`, { sessionID, total });
+    return;
+  }
+  let agentName = resolvedInfo?.agent;
+  let model = resolvedInfo?.model;
+  let tools = resolvedInfo?.tools;
+  if (!agentName || !model) {
+    let previousMessage = null;
+    if (isSqliteBackend()) {
+      previousMessage = await findNearestMessageWithFieldsFromSDK(ctx.client, sessionID);
+    } else {
+      const messageDir = getMessageDir(sessionID);
+      previousMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+    }
+    agentName = agentName ?? previousMessage?.agent;
+    model = model ?? (previousMessage?.model?.providerID && previousMessage?.model?.modelID ? {
+      providerID: previousMessage.model.providerID,
+      modelID: previousMessage.model.modelID,
+      ...previousMessage.model.variant ? { variant: previousMessage.model.variant } : {}
+    } : undefined);
+    tools = tools ?? previousMessage?.tools;
+  }
+  if (agentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(agentName))) {
+    log(`[${HOOK_NAME14}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
+    return;
+  }
+  if (!hasWritePermission(tools)) {
+    log(`[${HOOK_NAME14}] Skipped: agent lacks write permission`, { sessionID, agent: agentName });
+    return;
+  }
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  const incompleteTasks = tasks.filter((task) => {
+    if (task.status !== "pending" && task.status !== "in_progress")
+      return false;
+    if (task.blockedBy.length === 0)
+      return true;
+    return task.blockedBy.every((bid) => byId.get(bid)?.status === "completed");
+  });
+  const taskList = incompleteTasks.map((task) => `- [${task.status}] ${task.subject} (${task.id})`).join(`
+`);
+  const prompt = `${CONTINUATION_PROMPT2}
+
+[Status: ${total - freshIncompleteCount}/${total} completed, ${freshIncompleteCount} remaining]
+
+Remaining Matrixx tasks:
+${taskList}`;
+  const injectionState = sessionStateStore.getExistingState(sessionID);
+  if (injectionState) {
+    injectionState.inFlight = true;
+  }
+  try {
+    log(`[${HOOK_NAME14}] Injecting continuation`, {
+      sessionID,
+      agent: agentName,
+      model,
+      incompleteCount: freshIncompleteCount
+    });
+    await ctx.client.session.promptAsync({
+      path: { id: sessionID },
+      body: {
+        agent: agentName,
+        ...model !== undefined ? { model } : {},
+        parts: [{ type: "text", text: prompt }]
+      },
+      query: { directory: ctx.directory }
+    });
+    log(`[${HOOK_NAME14}] Injection successful`, { sessionID });
+    if (injectionState) {
+      injectionState.inFlight = false;
+      injectionState.lastInjectedAt = Date.now();
+      injectionState.consecutiveFailures = 0;
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME14}] Injection failed`, { sessionID, error: String(error51) });
+    if (injectionState) {
+      injectionState.inFlight = false;
+      injectionState.lastInjectedAt = Date.now();
+      injectionState.consecutiveFailures = (injectionState.consecutiveFailures ?? 0) + 1;
     }
-    return tasks;
-  } catch (err) {
-    log(`[${HOOK_NAME14}] Failed to load tasks`, { error: String(err) });
-    return [];
   }
 }
-function createTaskTodoMirrorHook(ctx, pluginConfig) {
-  const enabled = pluginConfig.experimental?.task_system ?? false;
-  const lastSync = new Map;
-  const syncForSession = async (sessionID) => {
-    if (!enabled)
+
+// src/hooks/task-continuation-enforcer/countdown.ts
+async function showCountdownToast(ctx, seconds, incompleteCount) {
+  await ctx.client.tui.showToast({
+    body: {
+      title: "Task Continuation",
+      message: `Resuming in ${seconds}s... (${incompleteCount} tasks remaining)`,
+      variant: "warning",
+      duration: TOAST_DURATION_MS
+    }
+  }).catch((err) => {
+    log("[task-continuation] Countdown toast failed:", err);
+  });
+}
+function startCountdown(args) {
+  const {
+    ctx,
+    sessionID,
+    incompleteCount,
+    resolvedInfo,
+    backgroundManager,
+    skipAgents,
+    sessionStateStore
+  } = args;
+  const state3 = sessionStateStore.getState(sessionID);
+  if (state3.countdownTimer || state3.countdownInterval) {
+    log(`[${HOOK_NAME14}] Skipped: countdown already active`, { sessionID });
+    return;
+  }
+  let secondsRemaining = COUNTDOWN_SECONDS;
+  showCountdownToast(ctx, secondsRemaining, incompleteCount);
+  state3.countdownStartedAt = Date.now();
+  state3.countdownInterval = setInterval(() => {
+    secondsRemaining--;
+    if (secondsRemaining > 0) {
+      showCountdownToast(ctx, secondsRemaining, incompleteCount);
+    }
+  }, 1000);
+  state3.countdownTimer = setTimeout(() => {
+    sessionStateStore.cancelCountdown(sessionID);
+    injectContinuation({
+      ctx,
+      sessionID,
+      backgroundManager,
+      skipAgents,
+      resolvedInfo,
+      sessionStateStore
+    });
+  }, COUNTDOWN_SECONDS * 1000);
+  log(`[${HOOK_NAME14}] Countdown started`, {
+    sessionID,
+    seconds: COUNTDOWN_SECONDS,
+    incompleteCount
+  });
+}
+
+// src/hooks/task-continuation-enforcer/idle-event.ts
+async function handleSessionIdle(args) {
+  const {
+    ctx,
+    sessionID,
+    sessionStateStore,
+    backgroundManager,
+    skipAgents = DEFAULT_SKIP_AGENTS,
+    isContinuationStopped
+  } = args;
+  log(`[${HOOK_NAME14}] session.idle`, { sessionID });
+  const state3 = sessionStateStore.getState(sessionID);
+  if (state3.countdownTimer || state3.countdownInterval) {
+    log(`[${HOOK_NAME14}] Skipped: countdown already active`, { sessionID });
+    return;
+  }
+  if (state3.isRecovering) {
+    log(`[${HOOK_NAME14}] Skipped: in recovery`, { sessionID });
+    return;
+  }
+  if (state3.abortDetectedAt) {
+    const timeSinceAbort = Date.now() - state3.abortDetectedAt;
+    if (timeSinceAbort < ABORT_WINDOW_MS) {
+      log(`[${HOOK_NAME14}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
+      state3.abortDetectedAt = undefined;
+      return;
+    }
+    state3.abortDetectedAt = undefined;
+  }
+  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
+  if (hasRunningBgTasks) {
+    log(`[${HOOK_NAME14}] Skipped: background tasks running`, { sessionID });
+    return;
+  }
+  try {
+    const messagesResp = await ctx.client.session.messages({
+      path: { id: sessionID },
+      query: { directory: ctx.directory }
+    });
+    const messages = normalizeSDKResponse(messagesResp, []);
+    if (isLastAssistantMessageAborted(messages)) {
+      log(`[${HOOK_NAME14}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
       return;
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME14}] Messages fetch failed, continuing`, { sessionID, error: String(error51) });
+  }
+  let incompleteCount = 0;
+  let total = 0;
+  try {
+    const taskDir = getTaskDir({}, ctx.directory);
+    if (!existsSync44(taskDir)) {
+      log(`[${HOOK_NAME14}] No task dir`, { sessionID, taskDir });
+      return;
+    }
+    const files = readdirSync15(taskDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+    const tasks = [];
+    for (const f of files) {
+      const parsed = readJsonSafe(`${taskDir}/${f}`, TaskObjectSchema);
+      if (parsed)
+        tasks.push(parsed);
+    }
+    total = tasks.length;
+    if (total === 0) {
+      log(`[${HOOK_NAME14}] No tasks`, { sessionID });
+      return;
+    }
+    incompleteCount = getIncompleteTaskCount(tasks);
+  } catch (error51) {
+    log(`[${HOOK_NAME14}] Task fetch failed`, { sessionID, error: String(error51) });
+    return;
+  }
+  if (incompleteCount === 0) {
+    log(`[${HOOK_NAME14}] All tasks complete`, { sessionID, total });
+    return;
+  }
+  if (state3.inFlight) {
+    log(`[${HOOK_NAME14}] Skipped: injection in flight`, { sessionID });
+    return;
+  }
+  if ((state3.consecutiveFailures ?? 0) >= MAX_CONSECUTIVE_FAILURES && state3.lastInjectedAt && Date.now() - state3.lastInjectedAt >= FAILURE_RESET_WINDOW_MS) {
+    state3.consecutiveFailures = 0;
+    log(`[${HOOK_NAME14}] Reset consecutive failures after recovery window`, {
+      sessionID,
+      failureResetWindowMs: FAILURE_RESET_WINDOW_MS
+    });
+  }
+  if ((state3.consecutiveFailures ?? 0) >= MAX_CONSECUTIVE_FAILURES) {
+    log(`[${HOOK_NAME14}] Skipped: max consecutive failures reached`, {
+      sessionID,
+      consecutiveFailures: state3.consecutiveFailures ?? 0,
+      maxConsecutiveFailures: MAX_CONSECUTIVE_FAILURES
+    });
+    return;
+  }
+  const effectiveCooldown = CONTINUATION_COOLDOWN_MS2 * 2 ** Math.min(state3.consecutiveFailures ?? 0, 5);
+  if (state3.lastInjectedAt && Date.now() - state3.lastInjectedAt < effectiveCooldown) {
+    log(`[${HOOK_NAME14}] Skipped: cooldown active`, {
+      sessionID,
+      effectiveCooldown,
+      consecutiveFailures: state3.consecutiveFailures ?? 0
+    });
+    return;
+  }
+  let resolvedInfo;
+  let hasCompactionMessage = false;
+  try {
+    const messagesResp = await ctx.client.session.messages({
+      path: { id: sessionID }
+    });
+    const messages = normalizeSDKResponse(messagesResp, []);
+    for (let i = messages.length - 1;i >= 0; i--) {
+      const info = messages[i].info;
+      if (info?.agent === "compaction") {
+        hasCompactionMessage = true;
+        continue;
+      }
+      if (info?.agent || info?.model || info?.modelID && info?.providerID) {
+        resolvedInfo = {
+          agent: info.agent,
+          model: info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined),
+          tools: info.tools
+        };
+        break;
+      }
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME14}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
+  }
+  log(`[${HOOK_NAME14}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
+  const resolvedAgentName = resolvedInfo?.agent;
+  if (resolvedAgentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(resolvedAgentName))) {
+    log(`[${HOOK_NAME14}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
+    return;
+  }
+  if (hasCompactionMessage && !resolvedInfo?.agent) {
+    log(`[${HOOK_NAME14}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
+    return;
+  }
+  if (isContinuationStopped?.(sessionID)) {
+    log(`[${HOOK_NAME14}] Skipped: continuation stopped for session`, { sessionID });
+    return;
+  }
+  startCountdown({
+    ctx,
+    sessionID,
+    incompleteCount,
+    total,
+    resolvedInfo,
+    backgroundManager,
+    skipAgents,
+    sessionStateStore
+  });
+}
+
+// src/hooks/task-continuation-enforcer/non-idle-events.ts
+init_logger();
+function handleNonIdleEvent(args) {
+  const { eventType, properties, sessionStateStore } = args;
+  if (eventType === "message.updated") {
+    const info = properties?.info;
+    const sessionID = info?.sessionID;
+    const role = info?.role;
     if (!sessionID)
       return;
+    if (role === "user") {
+      const state3 = sessionStateStore.getExistingState(sessionID);
+      if (state3?.countdownStartedAt) {
+        const elapsed = Date.now() - state3.countdownStartedAt;
+        if (elapsed < COUNTDOWN_GRACE_PERIOD_MS) {
+          log(`[${HOOK_NAME14}] Ignoring user message in grace period`, { sessionID, elapsed });
+          return;
+        }
+      }
+      if (state3)
+        state3.abortDetectedAt = undefined;
+      sessionStateStore.cancelCountdown(sessionID);
+      return;
+    }
+    if (role === "assistant") {
+      const state3 = sessionStateStore.getExistingState(sessionID);
+      if (state3)
+        state3.abortDetectedAt = undefined;
+      sessionStateStore.cancelCountdown(sessionID);
+      return;
+    }
+    return;
+  }
+  if (eventType === "message.part.updated") {
+    const info = properties?.info;
+    const sessionID = info?.sessionID;
+    const role = info?.role;
+    if (sessionID && role === "assistant") {
+      const state3 = sessionStateStore.getExistingState(sessionID);
+      if (state3)
+        state3.abortDetectedAt = undefined;
+      sessionStateStore.cancelCountdown(sessionID);
+    }
+    return;
+  }
+  if (eventType === "tool.execute.before" || eventType === "tool.execute.after") {
+    const sessionID = properties?.sessionID;
+    if (sessionID) {
+      const state3 = sessionStateStore.getExistingState(sessionID);
+      if (state3)
+        state3.abortDetectedAt = undefined;
+      sessionStateStore.cancelCountdown(sessionID);
+    }
+    return;
+  }
+  if (eventType === "session.deleted") {
+    const sessionInfo = properties?.info;
+    if (sessionInfo?.id) {
+      sessionStateStore.cleanup(sessionInfo.id);
+      log(`[${HOOK_NAME14}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
+    }
+    return;
+  }
+}
+
+// src/hooks/task-continuation-enforcer/handler.ts
+function createTaskContinuationHandler(args) {
+  const {
+    ctx,
+    sessionStateStore,
+    backgroundManager,
+    skipAgents = DEFAULT_SKIP_AGENTS,
+    isContinuationStopped
+  } = args;
+  return async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.error") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      const error51 = props?.error;
+      if (error51?.name === "MessageAbortedError" || error51?.name === "AbortError") {
+        const state3 = sessionStateStore.getState(sessionID);
+        state3.abortDetectedAt = Date.now();
+        log(`[${HOOK_NAME14}] Abort detected via session.error`, { sessionID, errorName: error51.name });
+      }
+      sessionStateStore.cancelCountdown(sessionID);
+      log(`[${HOOK_NAME14}] session.error`, { sessionID });
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      await handleSessionIdle({
+        ctx,
+        sessionID,
+        sessionStateStore,
+        backgroundManager,
+        skipAgents,
+        isContinuationStopped
+      });
+      return;
+    }
+    handleNonIdleEvent({
+      eventType: event.type,
+      properties: props,
+      sessionStateStore
+    });
+  };
+}
+
+// src/hooks/task-continuation-enforcer/session-state.ts
+var SESSION_STATE_TTL_MS = 10 * 60 * 1000;
+var SESSION_STATE_PRUNE_INTERVAL_MS = 2 * 60 * 1000;
+function createSessionStateStore() {
+  const sessions = new Map;
+  let pruneInterval;
+  pruneInterval = setInterval(() => {
     const now = Date.now();
-    const last = lastSync.get(sessionID) ?? 0;
-    if (now - last < DEBOUNCE_MS)
+    for (const [sessionID, tracked] of sessions.entries()) {
+      if (now - tracked.lastAccessedAt > SESSION_STATE_TTL_MS) {
+        cancelCountdown(sessionID);
+        sessions.delete(sessionID);
+      }
+    }
+  }, SESSION_STATE_PRUNE_INTERVAL_MS);
+  if (typeof pruneInterval === "object" && "unref" in pruneInterval) {
+    pruneInterval.unref();
+  }
+  function getState(sessionID) {
+    const existing = sessions.get(sessionID);
+    if (existing) {
+      existing.lastAccessedAt = Date.now();
+      return existing.state;
+    }
+    const state3 = {
+      consecutiveFailures: 0
+    };
+    sessions.set(sessionID, { state: state3, lastAccessedAt: Date.now() });
+    return state3;
+  }
+  function getExistingState(sessionID) {
+    const existing = sessions.get(sessionID);
+    if (existing) {
+      existing.lastAccessedAt = Date.now();
+      return existing.state;
+    }
+    return;
+  }
+  function cancelCountdown(sessionID) {
+    const tracked = sessions.get(sessionID);
+    if (!tracked)
       return;
-    lastSync.set(sessionID, now);
-    try {
-      const tasks = loadAllTasks(pluginConfig);
-      await syncAllTasksToTodos(ctx, tasks, sessionID);
-      log(`[${HOOK_NAME14}] Synced ${tasks.length} tasks to session`, { sessionID });
-    } catch (err) {
-      log(`[${HOOK_NAME14}] Sync failed`, { sessionID, error: String(err) });
+    const state3 = tracked.state;
+    if (state3.countdownTimer) {
+      clearTimeout(state3.countdownTimer);
+      state3.countdownTimer = undefined;
     }
+    if (state3.countdownInterval) {
+      clearInterval(state3.countdownInterval);
+      state3.countdownInterval = undefined;
+    }
+    state3.inFlight = false;
+    state3.countdownStartedAt = undefined;
+  }
+  function cleanup(sessionID) {
+    cancelCountdown(sessionID);
+    sessions.delete(sessionID);
+  }
+  function cancelAllCountdowns() {
+    for (const sessionID of sessions.keys()) {
+      cancelCountdown(sessionID);
+    }
+  }
+  function shutdown() {
+    clearInterval(pruneInterval);
+    cancelAllCountdowns();
+    sessions.clear();
+  }
+  return {
+    getState,
+    getExistingState,
+    cancelCountdown,
+    cleanup,
+    cancelAllCountdowns,
+    shutdown
+  };
+}
+
+// src/hooks/task-continuation-enforcer/index.ts
+function createTaskContinuationEnforcer(ctx, options = {}) {
+  const {
+    backgroundManager,
+    skipAgents = DEFAULT_SKIP_AGENTS,
+    isContinuationStopped
+  } = options;
+  const sessionStateStore = createSessionStateStore();
+  const markRecovering = (sessionID) => {
+    const state3 = sessionStateStore.getState(sessionID);
+    state3.isRecovering = true;
+    sessionStateStore.cancelCountdown(sessionID);
+    log(`[${HOOK_NAME14}] Session marked as recovering`, { sessionID });
+  };
+  const markRecoveryComplete = (sessionID) => {
+    const state3 = sessionStateStore.getExistingState(sessionID);
+    if (state3) {
+      state3.isRecovering = false;
+      log(`[${HOOK_NAME14}] Session recovery complete`, { sessionID });
+    }
+  };
+  const handler = createTaskContinuationHandler({
+    ctx,
+    sessionStateStore,
+    backgroundManager,
+    skipAgents,
+    isContinuationStopped
+  });
+  const cancelAllCountdowns = () => {
+    sessionStateStore.cancelAllCountdowns();
+    log(`[${HOOK_NAME14}] All countdowns cancelled`);
   };
   return {
-    "tool.execute.after": async (input, _output) => {
-      if (!enabled)
+    handler,
+    markRecovering,
+    markRecoveryComplete,
+    cancelAllCountdowns
+  };
+}
+// src/hooks/task-edit-guard/constants.ts
+var HOOK_NAME15 = "task-edit-guard";
+var BLOCKED_PATTERNS = [
+  /sed\s+.*\.matrixx\/plans/,
+  /sed\s+.*\.matrixx\/tasks/,
+  /python3?\s+.*\.matrixx\/plans/,
+  /python3?\s+.*\.matrixx\/tasks/,
+  /echo\s+.*\.matrixx\/plans/,
+  /echo\s+.*\.matrixx\/tasks/,
+  /cat\s*>.*\.matrixx\/plans/,
+  /cat\s*>.*\.matrixx\/tasks/,
+  /mv\s+.*\.matrixx\/plans/,
+  /mv\s+.*\.matrixx\/tasks/,
+  /rm\s+.*\.matrixx\/tasks\/T-.*\.json/,
+  /printf\s+.*\.matrixx\/plans/,
+  /printf\s+.*\.matrixx\/tasks/
+];
+// src/hooks/task-edit-guard/hook.ts
+function createTaskEditGuardHook(ctx) {
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (input.tool?.toLowerCase() !== "bash")
         return;
-      await syncForSession(input.sessionID);
-    },
-    "chat.message": async (input, _output) => {
-      if (!enabled)
+      const args = output.args;
+      const cmd = args?.command;
+      if (!cmd)
         return;
-      await syncForSession(input.sessionID);
-    },
-    "experimental.chat.messages.transform": async (_input, output) => {
-      if (!enabled)
+      const lower = cmd.toLowerCase();
+      if (lower.includes("grep") && !lower.includes("sed") && !lower.includes("python")) {
+        const isOnlyGrep = BLOCKED_PATTERNS.every((rx) => !rx.test(cmd));
+        if (isOnlyGrep)
+          return;
+      }
+      const hit = BLOCKED_PATTERNS.some((rx) => rx.test(cmd));
+      if (!hit)
         return;
-      let sessionID;
-      for (let i = output.messages.length - 1;i >= 0; i--) {
-        const id = output.messages[i].info.sessionID;
-        if (id) {
-          sessionID = id;
-          break;
+      ctx.directory;
+      log(`[${HOOK_NAME15}] BLOCKED raw bash edit`, {
+        sessionID: input.sessionID,
+        command: cmd.slice(0, 120)
+      });
+      throw new Error("Blocked: raw bash edit to plan/task files. " + "Use Edit (hashline IDs) for .matrixx/plans/*.md and task_create/task_update/task_cleanup for .matrixx/tasks/T-*.json \u2014 raw bash sed/python bypasses project-scoped task system");
+    }
+  };
+}
+// src/hooks/task-notepad/constants.ts
+var HOOK_NAME16 = "task-notepad";
+var PLAN_DIR_NAME = ".matrixx";
+var PLANS_SUBDIR = "plans";
+var NOTEPAD_DIR_NAME = "notepads";
+var TASKS_SUBDIR = "tasks";
+var PLAN_EXTENSION = ".md";
+var NOTEPAD_EXTENSION = ".md";
+var TODO_TOOL_NAMES = new Set(["todowrite", "TodoWrite"]);
+var TASK_NOTEPAD_FRAGMENT = "task-notepad";
+var TODO_FETCH_ERROR_FRAGMENT = "Failed to fetch todos for task-notepad";
+// src/hooks/task-notepad/hook.ts
+init_logger();
+import { existsSync as existsSync45, mkdirSync as mkdirSync16, readdirSync as readdirSync16, readFileSync as readFileSync33, statSync as statSync8, writeFileSync as writeFileSync19 } from "fs";
+import { dirname as dirname15, join as join52 } from "path";
+function createTaskNotepadHook(ctx) {
+  return {
+    "tool.execute.after": async (input, output) => {
+      if (!output)
+        return;
+      if (!TODO_TOOL_NAMES.has(input.tool))
+        return;
+      const todos = await fetchTodos(ctx, input.sessionID);
+      const inProgress = todos.find((t) => t.status === "in_progress");
+      const completed = todos.filter((t) => t.status === "completed");
+      if (!inProgress && completed.length === 0)
+        return;
+      const plan = resolveActivePlan(ctx.directory);
+      if (inProgress) {
+        if (!plan) {
+          log(`[${HOOK_NAME16}] No active plan, skipping notepad creation`, {
+            sessionID: input.sessionID
+          });
+        } else {
+          ensureNotepad(ctx.directory, plan.name, inProgress);
         }
       }
-      await syncForSession(sessionID);
-    },
-    event: async (input) => {
-      if (!enabled)
+      if (!plan)
         return;
-      const props = input.event.properties;
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID && input.event.type === "session.idle") {
-        await syncForSession(sessionID);
+      for (const done of completed) {
+        appendCompletion(ctx.directory, plan.name, done);
       }
-    },
-    _syncForSession: syncForSession
+    }
+  };
+}
+async function fetchTodos(ctx, sessionID) {
+  try {
+    const response = await ctx.client.session.todo({ path: { id: sessionID } });
+    const payload = response;
+    if (Array.isArray(payload?.data)) {
+      return payload.data;
+    }
+    if (Array.isArray(response)) {
+      return response;
+    }
+    return [];
+  } catch (err) {
+    log(`[${HOOK_NAME16}] ${TODO_FETCH_ERROR_FRAGMENT}`, {
+      sessionID,
+      error: String(err)
+    });
+    return [];
+  }
+}
+function resolveActivePlan(directory) {
+  const plansDir = join52(directory, PLAN_DIR_NAME, PLANS_SUBDIR);
+  if (!existsSync45(plansDir))
+    return null;
+  let entries;
+  try {
+    entries = readdirSync16(plansDir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const entry of entries) {
+    if (!entry.endsWith(PLAN_EXTENSION))
+      continue;
+    const fullPath = join52(plansDir, entry);
+    try {
+      const stats = statSync8(fullPath);
+      if (!stats.isFile())
+        continue;
+      const candidate = {
+        name: entry.slice(0, -PLAN_EXTENSION.length),
+        path: fullPath,
+        mtimeMs: stats.mtimeMs
+      };
+      if (!best || candidate.mtimeMs > best.mtimeMs) {
+        best = candidate;
+      }
+    } catch {}
+  }
+  return best;
+}
+function ensureNotepad(directory, planName, todo) {
+  const notepadPath = notepadPathFor(directory, planName, todo.id);
+  if (existsSync45(notepadPath))
+    return;
+  mkdirSync16(dirname15(notepadPath), { recursive: true });
+  const content = renderNotepad(todo);
+  writeFileSync19(notepadPath, content, "utf-8");
+  log(`[${HOOK_NAME16}] Created task notepad`, { plan: planName, taskID: todo.id });
+}
+function appendCompletion(directory, planName, todo) {
+  const notepadPath = notepadPathFor(directory, planName, todo.id);
+  if (!existsSync45(notepadPath))
+    return;
+  const existing = readFileSync33(notepadPath, "utf-8");
+  if (existing.includes("**Status**: completed"))
+    return;
+  const stamp = new Date().toISOString();
+  const updated = `${existing}
+## Completion
+- completed_at: ${stamp}
+- status: completed
+`;
+  writeFileSync19(notepadPath, updated, "utf-8");
+  log(`[${HOOK_NAME16}] Appended completion to notepad`, { plan: planName, taskID: todo.id });
+}
+function notepadPathFor(directory, planName, taskID) {
+  return join52(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
+}
+function renderNotepad(todo) {
+  const priority = todo.priority ?? "medium";
+  return `# Task: ${todo.content}
+
+**Plan**: ${TASK_NOTEPAD_FRAGMENT}
+**Task ID**: ${todo.id}
+**Priority**: ${priority}
+**Status**: ${todo.status}
+**Started**: ${new Date().toISOString()}
+
+## Findings
+
+(Record what you learn about this code as you work \u2014 patterns, conventions, gotchas, useful references.)
+
+## Blockers
+
+(Anything blocking progress. Be specific: file path, line, error, workaround if any.)
+
+## Questions
+
+(Open questions to revisit later. Don't lose them when context compacts.)
+
+## Results
+
+(Summary on completion. What changed, what was verified, what remains.)
+`;
+}
+// src/hooks/task-resume-info/hook.ts
+var TARGET_TOOLS2 = ["task", "Task", "task_tool", "delegate_agent"];
+var SESSION_ID_PATTERNS = [
+  /Session ID: (ses_[a-zA-Z0-9_-]+)/,
+  /session_id: (ses_[a-zA-Z0-9_-]+)/,
+  /<task_metadata>\s*session_id: (ses_[a-zA-Z0-9_-]+)/,
+  /sessionId: (ses_[a-zA-Z0-9_-]+)/
+];
+function extractSessionId(output) {
+  for (const pattern of SESSION_ID_PATTERNS) {
+    const match = output.match(pattern);
+    if (match)
+      return match[1] ?? null;
+  }
+  return null;
+}
+function createTaskResumeInfoHook() {
+  const toolExecuteAfter = async (input, output) => {
+    if (!TARGET_TOOLS2.includes(input.tool))
+      return;
+    const outputText = output.output ?? "";
+    if (outputText.startsWith("Error:") || outputText.startsWith("Failed"))
+      return;
+    if (outputText.includes(`
+to continue:`))
+      return;
+    const sessionId = extractSessionId(outputText);
+    if (!sessionId)
+      return;
+    output.output = outputText.trimEnd() + `
+
+to continue: task(session_id="${sessionId}", prompt="...")`;
+  };
+  return {
+    "tool.execute.after": toolExecuteAfter
   };
 }
+// src/shared/task-system-gating.ts
+var TASK_SYSTEM_DEFAULT = true;
+function isTaskSystemEnabled(config2) {
+  return config2?.experimental?.task_system ?? TASK_SYSTEM_DEFAULT;
+}
+
 // src/hooks/tasks-todowrite-disabler/constants.ts
 var BLOCKED_TOOLS2 = ["TodoWrite", "TodoRead"];
 var REPLACEMENT_MESSAGE = `TodoRead/TodoWrite are DISABLED because experimental.task_system is enabled.
@@ -65637,10 +66246,10 @@ DO NOT retry TodoWrite. Convert to TaskCreate NOW.`;
 
 // src/hooks/tasks-todowrite-disabler/hook.ts
 function createTasksTodowriteDisablerHook(config2) {
-  const isTaskSystemEnabled = config2.experimental?.task_system ?? false;
+  const enabled = isTaskSystemEnabled(config2);
   return {
     "tool.execute.before": async (input, _output) => {
-      if (!isTaskSystemEnabled) {
+      if (!enabled) {
         return;
       }
       const toolName = input.tool;
@@ -66122,22 +66731,22 @@ function createThinkingBlockValidatorHook() {
 init_logger();
 
 // src/hooks/todo-continuation-enforcer/constants.ts
-var HOOK_NAME15 = "todo-continuation-enforcer";
-var DEFAULT_SKIP_AGENTS = ["oracle", "compaction"];
-var CONTINUATION_PROMPT2 = `${createSystemDirective(SystemDirectiveTypes.TODO_CONTINUATION)}
+var HOOK_NAME17 = "todo-continuation-enforcer";
+var DEFAULT_SKIP_AGENTS2 = ["oracle", "compaction"];
+var CONTINUATION_PROMPT3 = `${createSystemDirective(SystemDirectiveTypes.TODO_CONTINUATION)}
 
 Incomplete tasks remain in your todo list. Continue working on the next pending task.
 
 - Proceed without asking for permission
 - Mark each task complete when finished
 - Do not stop until all tasks are done`;
-var COUNTDOWN_SECONDS = 2;
-var TOAST_DURATION_MS = 900;
-var COUNTDOWN_GRACE_PERIOD_MS = 500;
-var ABORT_WINDOW_MS = 3000;
-var CONTINUATION_COOLDOWN_MS2 = 30000;
-var MAX_CONSECUTIVE_FAILURES = 5;
-var FAILURE_RESET_WINDOW_MS = 5 * 60 * 1000;
+var COUNTDOWN_SECONDS2 = 2;
+var TOAST_DURATION_MS2 = 900;
+var COUNTDOWN_GRACE_PERIOD_MS2 = 500;
+var ABORT_WINDOW_MS2 = 3000;
+var CONTINUATION_COOLDOWN_MS3 = 30000;
+var MAX_CONSECUTIVE_FAILURES2 = 5;
+var FAILURE_RESET_WINDOW_MS2 = 5 * 60 * 1000;
 
 // src/hooks/todo-continuation-enforcer/handler.ts
 init_logger();
@@ -66146,7 +66755,7 @@ init_logger();
 init_logger();
 
 // src/hooks/todo-continuation-enforcer/abort-detection.ts
-function isLastAssistantMessageAborted(messages) {
+function isLastAssistantMessageAborted2(messages) {
   if (!messages || messages.length === 0)
     return false;
   for (let i = messages.length - 1;i >= 0; i--) {
@@ -66172,28 +66781,28 @@ function getIncompleteCount(todos) {
 }
 
 // src/hooks/todo-continuation-enforcer/continuation-injection.ts
-function hasWritePermission(tools) {
+function hasWritePermission2(tools) {
   const editPermission = tools?.edit;
   const writePermission = tools?.write;
   return !tools || editPermission !== false && editPermission !== "deny" && writePermission !== false && writePermission !== "deny";
 }
-async function injectContinuation(args) {
+async function injectContinuation2(args) {
   const {
     ctx,
     sessionID,
     backgroundManager,
-    skipAgents = DEFAULT_SKIP_AGENTS,
+    skipAgents = DEFAULT_SKIP_AGENTS2,
     resolvedInfo,
     sessionStateStore
   } = args;
   const state3 = sessionStateStore.getExistingState(sessionID);
   if (state3?.isRecovering) {
-    log(`[${HOOK_NAME15}] Skipped injection: in recovery`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped injection: in recovery`, { sessionID });
     return;
   }
   const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
   if (hasRunningBgTasks) {
-    log(`[${HOOK_NAME15}] Skipped injection: background tasks running`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped injection: background tasks running`, { sessionID });
     return;
   }
   let todos = [];
@@ -66201,12 +66810,12 @@ async function injectContinuation(args) {
     const response = await ctx.client.session.todo({ path: { id: sessionID } });
     todos = normalizeSDKResponse(response, [], { preferResponseOnMissingData: true });
   } catch (error51) {
-    log(`[${HOOK_NAME15}] Failed to fetch todos`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME17}] Failed to fetch todos`, { sessionID, error: String(error51) });
     return;
   }
   const freshIncompleteCount = getIncompleteCount(todos);
   if (freshIncompleteCount === 0) {
-    log(`[${HOOK_NAME15}] Skipped injection: no incomplete todos`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped injection: no incomplete todos`, { sessionID });
     return;
   }
   let agentName = resolvedInfo?.agent;
@@ -66229,17 +66838,17 @@ async function injectContinuation(args) {
     tools = tools ?? previousMessage?.tools;
   }
   if (agentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(agentName))) {
-    log(`[${HOOK_NAME15}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
+    log(`[${HOOK_NAME17}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
     return;
   }
-  if (!hasWritePermission(tools)) {
-    log(`[${HOOK_NAME15}] Skipped: agent lacks write permission`, { sessionID, agent: agentName });
+  if (!hasWritePermission2(tools)) {
+    log(`[${HOOK_NAME17}] Skipped: agent lacks write permission`, { sessionID, agent: agentName });
     return;
   }
   const incompleteTodos = todos.filter((todo) => todo.status !== "completed" && todo.status !== "cancelled");
   const todoList = incompleteTodos.map((todo) => `- [${todo.status}] ${todo.content}`).join(`
 `);
-  const prompt = `${CONTINUATION_PROMPT2}
+  const prompt = `${CONTINUATION_PROMPT3}
 
 [Status: ${todos.length - freshIncompleteCount}/${todos.length} completed, ${freshIncompleteCount} remaining]
 
@@ -66250,7 +66859,7 @@ ${todoList}`;
     injectionState.inFlight = true;
   }
   try {
-    log(`[${HOOK_NAME15}] Injecting continuation`, {
+    log(`[${HOOK_NAME17}] Injecting continuation`, {
       sessionID,
       agent: agentName,
       model,
@@ -66265,14 +66874,14 @@ ${todoList}`;
       },
       query: { directory: ctx.directory }
     });
-    log(`[${HOOK_NAME15}] Injection successful`, { sessionID });
+    log(`[${HOOK_NAME17}] Injection successful`, { sessionID });
     if (injectionState) {
       injectionState.inFlight = false;
       injectionState.lastInjectedAt = Date.now();
       injectionState.consecutiveFailures = 0;
     }
   } catch (error51) {
-    log(`[${HOOK_NAME15}] Injection failed`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME17}] Injection failed`, { sessionID, error: String(error51) });
     if (injectionState) {
       injectionState.inFlight = false;
       injectionState.lastInjectedAt = Date.now();
@@ -66282,19 +66891,19 @@ ${todoList}`;
 }
 
 // src/hooks/todo-continuation-enforcer/countdown.ts
-async function showCountdownToast(ctx, seconds, incompleteCount) {
+async function showCountdownToast2(ctx, seconds, incompleteCount) {
   await ctx.client.tui.showToast({
     body: {
       title: "Todo Continuation",
       message: `Resuming in ${seconds}s... (${incompleteCount} tasks remaining)`,
       variant: "warning",
-      duration: TOAST_DURATION_MS
+      duration: TOAST_DURATION_MS2
     }
   }).catch((err) => {
     log("[todo-continuation] Countdown toast failed:", err);
   });
 }
-function startCountdown(args) {
+function startCountdown2(args) {
   const {
     ctx,
     sessionID,
@@ -66305,19 +66914,22 @@ function startCountdown(args) {
     sessionStateStore
   } = args;
   const state3 = sessionStateStore.getState(sessionID);
-  sessionStateStore.cancelCountdown(sessionID);
-  let secondsRemaining = COUNTDOWN_SECONDS;
-  showCountdownToast(ctx, secondsRemaining, incompleteCount);
+  if (state3.countdownTimer || state3.countdownInterval) {
+    log(`[${HOOK_NAME17}] Skipped: countdown already active`, { sessionID });
+    return;
+  }
+  let secondsRemaining = COUNTDOWN_SECONDS2;
+  showCountdownToast2(ctx, secondsRemaining, incompleteCount);
   state3.countdownStartedAt = Date.now();
   state3.countdownInterval = setInterval(() => {
     secondsRemaining--;
     if (secondsRemaining > 0) {
-      showCountdownToast(ctx, secondsRemaining, incompleteCount);
+      showCountdownToast2(ctx, secondsRemaining, incompleteCount);
     }
   }, 1000);
   state3.countdownTimer = setTimeout(() => {
     sessionStateStore.cancelCountdown(sessionID);
-    injectContinuation({
+    injectContinuation2({
       ctx,
       sessionID,
       backgroundManager,
@@ -66325,34 +66937,38 @@ function startCountdown(args) {
       resolvedInfo,
       sessionStateStore
     });
-  }, COUNTDOWN_SECONDS * 1000);
-  log(`[${HOOK_NAME15}] Countdown started`, {
+  }, COUNTDOWN_SECONDS2 * 1000);
+  log(`[${HOOK_NAME17}] Countdown started`, {
     sessionID,
-    seconds: COUNTDOWN_SECONDS,
+    seconds: COUNTDOWN_SECONDS2,
     incompleteCount
   });
 }
 
 // src/hooks/todo-continuation-enforcer/idle-event.ts
-async function handleSessionIdle(args) {
+async function handleSessionIdle2(args) {
   const {
     ctx,
     sessionID,
     sessionStateStore,
     backgroundManager,
-    skipAgents = DEFAULT_SKIP_AGENTS,
+    skipAgents = DEFAULT_SKIP_AGENTS2,
     isContinuationStopped
   } = args;
-  log(`[${HOOK_NAME15}] session.idle`, { sessionID });
+  log(`[${HOOK_NAME17}] session.idle`, { sessionID });
   const state3 = sessionStateStore.getState(sessionID);
+  if (state3.countdownTimer || state3.countdownInterval) {
+    log(`[${HOOK_NAME17}] Skipped: countdown already active`, { sessionID });
+    return;
+  }
   if (state3.isRecovering) {
-    log(`[${HOOK_NAME15}] Skipped: in recovery`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped: in recovery`, { sessionID });
     return;
   }
   if (state3.abortDetectedAt) {
     const timeSinceAbort = Date.now() - state3.abortDetectedAt;
-    if (timeSinceAbort < ABORT_WINDOW_MS) {
-      log(`[${HOOK_NAME15}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
+    if (timeSinceAbort < ABORT_WINDOW_MS2) {
+      log(`[${HOOK_NAME17}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
       state3.abortDetectedAt = undefined;
       return;
     }
@@ -66360,7 +66976,7 @@ async function handleSessionIdle(args) {
   }
   const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
   if (hasRunningBgTasks) {
-    log(`[${HOOK_NAME15}] Skipped: background tasks running`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped: background tasks running`, { sessionID });
     return;
   }
   try {
@@ -66369,52 +66985,52 @@ async function handleSessionIdle(args) {
       query: { directory: ctx.directory }
     });
     const messages = normalizeSDKResponse(messagesResp, []);
-    if (isLastAssistantMessageAborted(messages)) {
-      log(`[${HOOK_NAME15}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
+    if (isLastAssistantMessageAborted2(messages)) {
+      log(`[${HOOK_NAME17}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
       return;
     }
   } catch (error51) {
-    log(`[${HOOK_NAME15}] Messages fetch failed, continuing`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME17}] 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_NAME15}] Todo fetch failed`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME17}] Todo fetch failed`, { sessionID, error: String(error51) });
     return;
   }
   if (!todos || todos.length === 0) {
-    log(`[${HOOK_NAME15}] No todos`, { sessionID });
+    log(`[${HOOK_NAME17}] No todos`, { sessionID });
     return;
   }
   const incompleteCount = getIncompleteCount(todos);
   if (incompleteCount === 0) {
-    log(`[${HOOK_NAME15}] All todos complete`, { sessionID, total: todos.length });
+    log(`[${HOOK_NAME17}] All todos complete`, { sessionID, total: todos.length });
     return;
   }
   if (state3.inFlight) {
-    log(`[${HOOK_NAME15}] Skipped: injection in flight`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped: injection in flight`, { sessionID });
     return;
   }
-  if (state3.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES && state3.lastInjectedAt && Date.now() - state3.lastInjectedAt >= FAILURE_RESET_WINDOW_MS) {
+  if (state3.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES2 && state3.lastInjectedAt && Date.now() - state3.lastInjectedAt >= FAILURE_RESET_WINDOW_MS2) {
     state3.consecutiveFailures = 0;
-    log(`[${HOOK_NAME15}] Reset consecutive failures after recovery window`, {
+    log(`[${HOOK_NAME17}] Reset consecutive failures after recovery window`, {
       sessionID,
-      failureResetWindowMs: FAILURE_RESET_WINDOW_MS
+      failureResetWindowMs: FAILURE_RESET_WINDOW_MS2
     });
   }
-  if (state3.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
-    log(`[${HOOK_NAME15}] Skipped: max consecutive failures reached`, {
+  if (state3.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES2) {
+    log(`[${HOOK_NAME17}] Skipped: max consecutive failures reached`, {
       sessionID,
       consecutiveFailures: state3.consecutiveFailures,
-      maxConsecutiveFailures: MAX_CONSECUTIVE_FAILURES
+      maxConsecutiveFailures: MAX_CONSECUTIVE_FAILURES2
     });
     return;
   }
-  const effectiveCooldown = CONTINUATION_COOLDOWN_MS2 * 2 ** Math.min(state3.consecutiveFailures, 5);
+  const effectiveCooldown = CONTINUATION_COOLDOWN_MS3 * 2 ** Math.min(state3.consecutiveFailures, 5);
   if (state3.lastInjectedAt && Date.now() - state3.lastInjectedAt < effectiveCooldown) {
-    log(`[${HOOK_NAME15}] Skipped: cooldown active`, {
+    log(`[${HOOK_NAME17}] Skipped: cooldown active`, {
       sessionID,
       effectiveCooldown,
       consecutiveFailures: state3.consecutiveFailures
@@ -66444,23 +67060,23 @@ async function handleSessionIdle(args) {
       }
     }
   } catch (error51) {
-    log(`[${HOOK_NAME15}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME17}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
   }
-  log(`[${HOOK_NAME15}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
+  log(`[${HOOK_NAME17}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
   const resolvedAgentName = resolvedInfo?.agent;
   if (resolvedAgentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(resolvedAgentName))) {
-    log(`[${HOOK_NAME15}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
+    log(`[${HOOK_NAME17}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
     return;
   }
   if (hasCompactionMessage && !resolvedInfo?.agent) {
-    log(`[${HOOK_NAME15}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
     return;
   }
   if (isContinuationStopped?.(sessionID)) {
-    log(`[${HOOK_NAME15}] Skipped: continuation stopped for session`, { sessionID });
+    log(`[${HOOK_NAME17}] Skipped: continuation stopped for session`, { sessionID });
     return;
   }
-  startCountdown({
+  startCountdown2({
     ctx,
     sessionID,
     incompleteCount,
@@ -66474,7 +67090,7 @@ async function handleSessionIdle(args) {
 
 // src/hooks/todo-continuation-enforcer/non-idle-events.ts
 init_logger();
-function handleNonIdleEvent(args) {
+function handleNonIdleEvent2(args) {
   const { eventType, properties, sessionStateStore } = args;
   if (eventType === "message.updated") {
     const info = properties?.info;
@@ -66486,8 +67102,8 @@ function handleNonIdleEvent(args) {
       const state3 = sessionStateStore.getExistingState(sessionID);
       if (state3?.countdownStartedAt) {
         const elapsed = Date.now() - state3.countdownStartedAt;
-        if (elapsed < COUNTDOWN_GRACE_PERIOD_MS) {
-          log(`[${HOOK_NAME15}] Ignoring user message in grace period`, { sessionID, elapsed });
+        if (elapsed < COUNTDOWN_GRACE_PERIOD_MS2) {
+          log(`[${HOOK_NAME17}] Ignoring user message in grace period`, { sessionID, elapsed });
           return;
         }
       }
@@ -66531,7 +67147,7 @@ function handleNonIdleEvent(args) {
     const sessionInfo = properties?.info;
     if (sessionInfo?.id) {
       sessionStateStore.cleanup(sessionInfo.id);
-      log(`[${HOOK_NAME15}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
+      log(`[${HOOK_NAME17}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
     }
     return;
   }
@@ -66543,7 +67159,7 @@ function createTodoContinuationHandler(args) {
     ctx,
     sessionStateStore,
     backgroundManager,
-    skipAgents = DEFAULT_SKIP_AGENTS,
+    skipAgents = DEFAULT_SKIP_AGENTS2,
     isContinuationStopped
   } = args;
   return async ({ event }) => {
@@ -66556,17 +67172,17 @@ function createTodoContinuationHandler(args) {
       if (error51?.name === "MessageAbortedError" || error51?.name === "AbortError") {
         const state3 = sessionStateStore.getState(sessionID);
         state3.abortDetectedAt = Date.now();
-        log(`[${HOOK_NAME15}] Abort detected via session.error`, { sessionID, errorName: error51.name });
+        log(`[${HOOK_NAME17}] Abort detected via session.error`, { sessionID, errorName: error51.name });
       }
       sessionStateStore.cancelCountdown(sessionID);
-      log(`[${HOOK_NAME15}] session.error`, { sessionID });
+      log(`[${HOOK_NAME17}] session.error`, { sessionID });
       return;
     }
     if (event.type === "session.idle") {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
-      await handleSessionIdle({
+      await handleSessionIdle2({
         ctx,
         sessionID,
         sessionStateStore,
@@ -66576,7 +67192,7 @@ function createTodoContinuationHandler(args) {
       });
       return;
     }
-    handleNonIdleEvent({
+    handleNonIdleEvent2({
       eventType: event.type,
       properties: props,
       sessionStateStore
@@ -66585,20 +67201,20 @@ function createTodoContinuationHandler(args) {
 }
 
 // src/hooks/todo-continuation-enforcer/session-state.ts
-var SESSION_STATE_TTL_MS = 10 * 60 * 1000;
-var SESSION_STATE_PRUNE_INTERVAL_MS = 2 * 60 * 1000;
-function createSessionStateStore() {
+var SESSION_STATE_TTL_MS2 = 10 * 60 * 1000;
+var SESSION_STATE_PRUNE_INTERVAL_MS2 = 2 * 60 * 1000;
+function createSessionStateStore2() {
   const sessions = new Map;
   let pruneInterval;
   pruneInterval = setInterval(() => {
     const now = Date.now();
     for (const [sessionID, tracked] of sessions.entries()) {
-      if (now - tracked.lastAccessedAt > SESSION_STATE_TTL_MS) {
+      if (now - tracked.lastAccessedAt > SESSION_STATE_TTL_MS2) {
         cancelCountdown(sessionID);
         sessions.delete(sessionID);
       }
     }
-  }, SESSION_STATE_PRUNE_INTERVAL_MS);
+  }, SESSION_STATE_PRUNE_INTERVAL_MS2);
   if (typeof pruneInterval === "object" && "unref" in pruneInterval) {
     pruneInterval.unref();
   }
@@ -66666,21 +67282,21 @@ function createSessionStateStore() {
 function createTodoContinuationEnforcer(ctx, options = {}) {
   const {
     backgroundManager,
-    skipAgents = DEFAULT_SKIP_AGENTS,
+    skipAgents = DEFAULT_SKIP_AGENTS2,
     isContinuationStopped
   } = options;
-  const sessionStateStore = createSessionStateStore();
+  const sessionStateStore = createSessionStateStore2();
   const markRecovering = (sessionID) => {
     const state3 = sessionStateStore.getState(sessionID);
     state3.isRecovering = true;
     sessionStateStore.cancelCountdown(sessionID);
-    log(`[${HOOK_NAME15}] Session marked as recovering`, { sessionID });
+    log(`[${HOOK_NAME17}] Session marked as recovering`, { sessionID });
   };
   const markRecoveryComplete = (sessionID) => {
     const state3 = sessionStateStore.getExistingState(sessionID);
     if (state3) {
       state3.isRecovering = false;
-      log(`[${HOOK_NAME15}] Session recovery complete`, { sessionID });
+      log(`[${HOOK_NAME17}] Session recovery complete`, { sessionID });
     }
   };
   const handler = createTodoContinuationHandler({
@@ -66692,7 +67308,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
   });
   const cancelAllCountdowns = () => {
     sessionStateStore.cancelAllCountdowns();
-    log(`[${HOOK_NAME15}] All countdowns cancelled`);
+    log(`[${HOOK_NAME17}] All countdowns cancelled`);
   };
   return {
     handler,
@@ -66701,38 +67317,6 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
     cancelAllCountdowns
   };
 }
-// src/hooks/todo-description-override/description.ts
-var TODOWRITE_DESCRIPTION = `Manage your todo list with ATOMIC, single-responsibility items.
-
-RULES:
-- One todo = one specific, verifiable action (not "Update everything" or "Fix issues")
-- Each todo must be completable in isolation \u2014 no vague catch-alls
-- Todos must be nameable with a single precise phrase
-- Mark in_progress BEFORE starting work, completed IMMEDIATELY after finishing
-- Only ONE todo in_progress at a time
-
-ANTI-PATTERNS (will be rejected by reviewers):
-- "Update X and Y and Z" \u2192 SPLIT into 3 separate todos
-- "Fix issues" \u2192 SPECIFY which file, function, or behavior
-- "Refactor" \u2192 SPECIFY what is being refactored and to what end
-- "Improve" \u2192 SPECIFY the measurable outcome
-
-STATUS TRANSITIONS:
-  pending \u2192 in_progress \u2192 completed
-  pending \u2192 cancelled (if no longer needed)
-
-Never batch-complete todos. Mark each one complete the moment it is done.`;
-
-// src/hooks/todo-description-override/hook.ts
-function createTodoDescriptionOverrideHook() {
-  return {
-    "tool.definition": async (input, output) => {
-      if (input.toolID === "todowrite") {
-        output.description = TODOWRITE_DESCRIPTION;
-      }
-    }
-  };
-}
 // src/hooks/tool-output-truncator.ts
 var DEFAULT_MAX_TOKENS = 50000;
 var WEBFETCH_MAX_TOKENS = 1e4;
@@ -66948,8 +67532,8 @@ This is a reminder only. No automatic action was taken.`;
 }
 // src/hooks/unstable-agent-babysitter/unstable-agent-babysitter-hook.ts
 init_logger();
-var HOOK_NAME16 = "unstable-agent-babysitter";
-var DEFAULT_TIMEOUT_MS2 = 120000;
+var HOOK_NAME18 = "unstable-agent-babysitter";
+var DEFAULT_TIMEOUT_MS = 120000;
 var COOLDOWN_MS = 5 * 60 * 1000;
 async function resolveMainSessionTarget(ctx, sessionID) {
   let agent = getSessionAgent(sessionID);
@@ -66968,7 +67552,7 @@ async function resolveMainSessionTarget(ctx, sessionID) {
       }
     }
   } catch (error51) {
-    log(`[${HOOK_NAME16}] Failed to resolve main session agent`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME18}] Failed to resolve main session agent`, { sessionID, error: String(error51) });
   }
   return { agent, model };
 }
@@ -67001,7 +67585,7 @@ async function getThinkingSummary(ctx, sessionID) {
       return combined;
     return `${combined.slice(0, THINKING_SUMMARY_MAX_CHARS)}...`;
   } catch (error51) {
-    log(`[${HOOK_NAME16}] Failed to fetch thinking summary`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME18}] Failed to fetch thinking summary`, { sessionID, error: String(error51) });
     return null;
   }
 }
@@ -67020,7 +67604,7 @@ function createUnstableAgentBabysitterHook(ctx, options) {
     const tasks = options.backgroundManager.getTasksByParentSession(mainSessionID);
     if (tasks.length === 0)
       return;
-    const timeoutMs = options.config?.timeout_ms ?? DEFAULT_TIMEOUT_MS2;
+    const timeoutMs = options.config?.timeout_ms ?? DEFAULT_TIMEOUT_MS;
     const now = Date.now();
     for (const task of tasks) {
       if (task.status !== "running")
@@ -67050,9 +67634,9 @@ function createUnstableAgentBabysitterHook(ctx, options) {
           query: { directory: ctx.directory }
         });
         reminderCooldowns.set(task.id, now);
-        log(`[${HOOK_NAME16}] Reminder injected`, { taskId: task.id, sessionID: mainSessionID });
+        log(`[${HOOK_NAME18}] Reminder injected`, { taskId: task.id, sessionID: mainSessionID });
       } catch (error51) {
-        log(`[${HOOK_NAME16}] Reminder injection failed`, { taskId: task.id, error: String(error51) });
+        log(`[${HOOK_NAME18}] Reminder injection failed`, { taskId: task.id, error: String(error51) });
       }
     }
   };
@@ -67203,7 +67787,7 @@ function createWebFetchRedirectGuardHook(_ctx) {
 }
 // src/hooks/write-existing-file-guard/hook.ts
 import { existsSync as existsSync46 } from "fs";
-import { isAbsolute as isAbsolute4, join as join54, normalize, resolve as resolve7, sep } from "path";
+import { isAbsolute as isAbsolute4, join as join53, normalize, resolve as resolve7, sep } from "path";
 function createWriteExistingFileGuardHook(ctx) {
   return {
     "tool.execute.before": async (input, output) => {
@@ -67218,7 +67802,7 @@ function createWriteExistingFileGuardHook(ctx) {
       }
       const resolvedPath = normalize(isAbsolute4(filePath) ? filePath : resolve7(ctx.directory, filePath));
       if (existsSync46(resolvedPath)) {
-        const matrixxRoot = join54(ctx.directory, ".matrixx") + sep;
+        const matrixxRoot = join53(ctx.directory, ".matrixx") + sep;
         const isMatrixMarkdown = resolvedPath.startsWith(matrixxRoot) && resolvedPath.endsWith(".md");
         if (isMatrixMarkdown) {
           log("[write-existing-file-guard] Allowing .matrixx/*.md overwrite", {
@@ -67281,7 +67865,12 @@ function createContinuationHooks(args) {
   const stopContinuationGuard = isHookEnabled("stop-continuation-guard") ? safeHook("stop-continuation-guard", () => createStopContinuationGuardHook(ctx, { backgroundManager })) : null;
   const compactionContextInjector = isHookEnabled("compaction-context-injector") ? safeHook("compaction-context-injector", () => createCompactionContextInjector(backgroundManager)) : null;
   const compactionTodoPreserver = isHookEnabled("compaction-todo-preserver") ? safeHook("compaction-todo-preserver", () => createCompactionTodoPreserverHook(ctx)) : null;
-  const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? safeHook("todo-continuation-enforcer", () => createTodoContinuationEnforcer(ctx, {
+  const isTaskSystem = isTaskSystemEnabled(pluginConfig);
+  const todoContinuationEnforcer = !isTaskSystem && isHookEnabled("todo-continuation-enforcer") ? safeHook("todo-continuation-enforcer", () => createTodoContinuationEnforcer(ctx, {
+    backgroundManager,
+    isContinuationStopped: stopContinuationGuard?.isStopped
+  })) : null;
+  const taskContinuationEnforcer = isTaskSystem && isHookEnabled("task-continuation-enforcer") ? safeHook("task-continuation-enforcer", () => createTaskContinuationEnforcer(ctx, {
     backgroundManager,
     isContinuationStopped: stopContinuationGuard?.isStopped
   })) : null;
@@ -67293,6 +67882,10 @@ function createContinuationHooks(args) {
       onAbortCallbacks.push(todoContinuationEnforcer.markRecovering);
       onRecoveryCompleteCallbacks.push(todoContinuationEnforcer.markRecoveryComplete);
     }
+    if (taskContinuationEnforcer) {
+      onAbortCallbacks.push(taskContinuationEnforcer.markRecovering);
+      onRecoveryCompleteCallbacks.push(taskContinuationEnforcer.markRecoveryComplete);
+    }
     if (onAbortCallbacks.length > 0) {
       sessionRecovery.setOnAbortCallback((sessionID) => {
         for (const callback of onAbortCallbacks)
@@ -67321,6 +67914,7 @@ function createContinuationHooks(args) {
     compactionContextInjector,
     compactionTodoPreserver,
     todoContinuationEnforcer,
+    taskContinuationEnforcer,
     unstableAgentBabysitter,
     backgroundNotificationHook,
     architectHook,
@@ -67638,7 +68232,7 @@ function getLanguageId(ext) {
 }
 // src/tools/lsp/server-installation.ts
 import { existsSync as existsSync47 } from "fs";
-import { join as join55 } from "path";
+import { join as join54 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
@@ -67666,23 +68260,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync47(join55(p, cmd + suffix))) {
+      if (existsSync47(join54(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join55(getDataDir(), "opencode");
+  const dataDir = join54(getDataDir(), "opencode");
   const additionalBases = [
-    join55(cwd, "node_modules", ".bin"),
-    join55(configDir, "bin"),
-    join55(configDir, "node_modules", ".bin"),
-    join55(dataDir, "bin")
+    join54(cwd, "node_modules", ".bin"),
+    join54(configDir, "bin"),
+    join54(configDir, "node_modules", ".bin"),
+    join54(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync47(join55(base, cmd + suffix))) {
+      if (existsSync47(join54(base, cmd + suffix))) {
         return true;
       }
     }
@@ -67694,7 +68288,7 @@ function isServerInstalled(command) {
 }
 // src/tools/lsp/server-config-loader.ts
 import { existsSync as existsSync48, readFileSync as readFileSync34 } from "fs";
-import { join as join56 } from "path";
+import { join as join55 } from "path";
 function loadJsonFile(path12) {
   if (!existsSync48(path12))
     return null;
@@ -67708,9 +68302,9 @@ function getConfigPaths3() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectConfigFile(join56(cwd, ".opencode", "matrixx")).path,
-    user: detectConfigFile(join56(configDir, "matrixx")).path,
-    opencode: detectConfigFile(join56(configDir, "opencode")).path
+    project: detectConfigFile(join55(cwd, ".opencode", "matrixx")).path,
+    user: detectConfigFile(join55(configDir, "matrixx")).path,
+    opencode: detectConfigFile(join55(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -68559,7 +69153,7 @@ class LSPServerManager {
 var lspManager = LSPServerManager.getInstance();
 // src/tools/lsp/lsp-client-wrapper.ts
 import { existsSync as existsSync50, statSync as statSync10 } from "fs";
-import { dirname as dirname16, extname as extname3, join as join57, resolve as resolve9 } from "path";
+import { dirname as dirname16, extname as extname3, join as join56, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function findWorkspaceRoot(filePath) {
   let dir = resolve9(filePath);
@@ -68575,7 +69169,7 @@ function findWorkspaceRoot(filePath) {
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync50(join57(dir, marker))) {
+      if (existsSync50(join56(dir, marker))) {
         return dir;
       }
     }
@@ -81420,20 +82014,20 @@ var CLI_LANGUAGES = [
   "tsx",
   "yaml"
 ];
-var DEFAULT_TIMEOUT_MS3 = 300000;
+var DEFAULT_TIMEOUT_MS2 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/sg-cli-path.ts
 import { existsSync as existsSync52, statSync as statSync11 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname17, join as join59 } from "path";
+import { dirname as dirname17, join as join58 } from "path";
 
 // src/tools/ast-grep/downloader.ts
 import { existsSync as existsSync51 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import { homedir as homedir10 } from "os";
-import { join as join58 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join57 } from "path";
 init_logger();
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -81458,12 +82052,12 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join58(homedir10(), "AppData", "Local");
-    return join58(base2, "matrixx", "bin");
+    const base2 = localAppData || join57(homedir9(), "AppData", "Local");
+    return join57(base2, "matrixx", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join58(homedir10(), ".cache");
-  return join58(base, "matrixx", "bin");
+  const base = xdgCache || join57(homedir9(), ".cache");
+  return join57(base, "matrixx", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
@@ -81480,7 +82074,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join58(cacheDir, binaryName);
+  const binaryPath = join57(cacheDir, binaryName);
   if (existsSync51(binaryPath)) {
     return binaryPath;
   }
@@ -81489,7 +82083,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version3}/${assetName}`;
   log(`[matrixx] Downloading ast-grep binary...`);
   try {
-    const archivePath = join58(cacheDir, assetName);
+    const archivePath = join57(cacheDir, assetName);
     ensureCacheDir(cacheDir);
     await downloadArchive(downloadUrl, archivePath);
     await extractZipArchive(archivePath, cacheDir);
@@ -81543,7 +82137,7 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDirectory = dirname17(cliPackageJsonPath);
-    const sgPath = join59(cliDirectory, binaryName);
+    const sgPath = join58(cliDirectory, binaryName);
     if (existsSync52(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
@@ -81555,7 +82149,7 @@ function findSgCliPathSync() {
       const packageJsonPath = require2.resolve(`${platformPackage}/package.json`);
       const packageDirectory = dirname17(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join59(packageDirectory, astGrepBinaryName);
+      const binaryPath = join58(packageDirectory, astGrepBinaryName);
       if (existsSync52(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
@@ -81715,7 +82309,7 @@ async function runSg(options) {
       };
     }
   }
-  const timeout = DEFAULT_TIMEOUT_MS3;
+  const timeout = DEFAULT_TIMEOUT_MS2;
   const proc = spawn9([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
@@ -83818,8 +84412,6 @@ function createBddPipelineTool(opts) {
   });
 }
 function makeDeps(args) {
-  const featureName = args.featurePath.split("/").pop()?.replace(/\.feature$/i, "") ?? "feature";
-  const _featureDir = resolvePath2(args.outDir, featureName);
   return {
     parseFeature: async (path12) => {
       const raw = await args.parseTool.execute({ filePath: path12 }, dummyCtx(args));
@@ -83988,17 +84580,17 @@ var {spawn: spawn10 } = globalThis.Bun;
 // src/tools/grep/constants.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync59 } from "fs";
-import { dirname as dirname18, join as join61 } from "path";
+import { dirname as dirname18, join as join60 } from "path";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync58, readdirSync as readdirSync17 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync58, readdirSync as readdirSync18 } from "fs";
+import { join as join59 } from "path";
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync17(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync18(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join60(entry.parentPath ?? dir, entry.name);
+        return join59(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -84019,11 +84611,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join60(homeDir, ".cache", "matrixx", "bin");
+  return join59(homeDir, ".cache", "matrixx", "bin");
 }
 function getRgPath() {
   const isWindows = process.platform === "win32";
-  return join60(getInstallDir(), isWindows ? "rg.exe" : "rg");
+  return join59(getInstallDir(), isWindows ? "rg.exe" : "rg");
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -84040,7 +84632,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join60(destDir, binaryName);
+    const destPath = join59(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync4 } = await import("fs");
       renameSync4(foundPath, destPath);
@@ -84061,7 +84653,7 @@ async function downloadAndInstallRipgrep() {
   ensureCacheDir(installDir);
   const filename = `ripgrep-${RG_VERSION}-${config4.platform}.${config4.extension}`;
   const url3 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join60(installDir, filename);
+  const archivePath = join59(installDir, filename);
   try {
     await downloadArchive(url3, archivePath);
     if (config4.extension === "tar.gz") {
@@ -84106,11 +84698,11 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join61(getDataDir(), "opencode", "bin", rgName),
-    join61(execDir, rgName),
-    join61(execDir, "bin", rgName),
-    join61(execDir, "..", "bin", rgName),
-    join61(execDir, "..", "libexec", rgName)
+    join60(getDataDir(), "opencode", "bin", rgName),
+    join60(execDir, rgName),
+    join60(execDir, "bin", rgName),
+    join60(execDir, "..", "bin", rgName),
+    join60(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
     if (existsSync59(candidate)) {
@@ -84166,7 +84758,7 @@ var DEFAULT_MAX_DEPTH = 20;
 var DEFAULT_MAX_FILESIZE = "10M";
 var DEFAULT_MAX_COUNT = 500;
 var DEFAULT_MAX_COLUMNS = 1000;
-var DEFAULT_TIMEOUT_MS4 = 300000;
+var DEFAULT_TIMEOUT_MS3 = 300000;
 var DEFAULT_MAX_OUTPUT_BYTES2 = 10 * 1024 * 1024;
 var RG_SAFETY_FLAGS = [
   "--no-follow",
@@ -84178,7 +84770,7 @@ var RG_SAFETY_FLAGS = [
 var GREP_SAFETY_FLAGS = ["-n", "-H", "--color=never"];
 
 // src/tools/glob/constants.ts
-var DEFAULT_TIMEOUT_MS5 = 60000;
+var DEFAULT_TIMEOUT_MS4 = 60000;
 var DEFAULT_LIMIT = 100;
 var DEFAULT_MAX_DEPTH2 = 20;
 var DEFAULT_MAX_OUTPUT_BYTES3 = 10 * 1024 * 1024;
@@ -84241,7 +84833,7 @@ async function getFileMtime(filePath) {
 }
 async function runRgFiles(options, resolvedCli) {
   const cli = resolvedCli ?? resolveGrepCli();
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS5, DEFAULT_TIMEOUT_MS5);
+  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS4, DEFAULT_TIMEOUT_MS4);
   const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
   const isRg = cli.backend === "rg";
   const isWindows = process.platform === "win32";
@@ -84463,7 +85055,7 @@ function parseOutput(output) {
 async function runRg(options) {
   const cli = resolveGrepCli();
   const args = buildArgs(options, cli.backend);
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS4, DEFAULT_TIMEOUT_MS4);
+  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
   if (cli.backend === "rg") {
     args.push("--", options.pattern);
   } else {
@@ -84618,12 +85210,12 @@ var HandoffSchema = exports_external.object({
 });
 // src/features/handoff/storage.ts
 import { existsSync as existsSync60, mkdirSync as mkdirSync17, readFileSync as readFileSync39, renameSync as renameSync4, writeFileSync as writeFileSync23 } from "fs";
-import { join as join62 } from "path";
+import { join as join61 } from "path";
 function getHandoffFilePath(directory) {
-  return join62(directory, HANDOFF_FILE_PATH);
+  return join61(directory, HANDOFF_FILE_PATH);
 }
 function getHandoffConsumedFilePath(directory) {
-  return join62(directory, HANDOFF_CONSUMED_FILE_PATH);
+  return join61(directory, HANDOFF_CONSUMED_FILE_PATH);
 }
 function handoffFileExists(directory) {
   try {
@@ -84661,7 +85253,7 @@ function writeHandoffFile(directory, content) {
 }
 function ensureHandoffDir(directory) {
   try {
-    mkdirSync17(join62(directory, ".matrixx"), { recursive: true });
+    mkdirSync17(join61(directory, ".matrixx"), { recursive: true });
     return true;
   } catch {
     return false;
@@ -84816,20 +85408,20 @@ ${body}
 }
 
 // src/tools/handoff/list-handler.ts
-import { existsSync as existsSync61, readdirSync as readdirSync18, statSync as statSync13 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync61, readdirSync as readdirSync19, statSync as statSync13 } from "fs";
+import { join as join62 } from "path";
 var MATRIX_DIR = ".matrixx";
 function isHandoffFile(name) {
   return name === "handoff.md" || name.startsWith("handoff.consumed");
 }
 function handleList(directory) {
-  const matrixxDir = join63(directory, MATRIX_DIR);
+  const matrixxDir = join62(directory, MATRIX_DIR);
   if (!existsSync61(matrixxDir)) {
     return "No handoffs found in .matrixx/";
   }
   let entries;
   try {
-    entries = readdirSync18(matrixxDir);
+    entries = readdirSync19(matrixxDir);
   } catch {
     return "No handoffs found in .matrixx/";
   }
@@ -84841,7 +85433,7 @@ function handleList(directory) {
   lines.push(`Handoff files in ${matrixxDir}:`);
   lines.push("");
   for (const name of handoffs) {
-    const fullPath = join63(matrixxDir, name);
+    const fullPath = join62(matrixxDir, name);
     let size = "?";
     let mtime = "?";
     try {
@@ -84938,7 +85530,7 @@ function createHandoffTools(ctx) {
 init_logger();
 
 // src/tools/interactive-bash/constants.ts
-var DEFAULT_TIMEOUT_MS6 = 60000;
+var DEFAULT_TIMEOUT_MS5 = 60000;
 var BLOCKED_TMUX_SUBCOMMANDS = [
   "capture-pane",
   "capturep",
@@ -85035,7 +85627,7 @@ The Bash tool can execute these commands directly. Do NOT retry with interactive
       });
       const timeoutPromise = new Promise((_, reject) => {
         const id = setTimeout(() => {
-          const timeoutError = new Error(`Timeout after ${DEFAULT_TIMEOUT_MS6}ms`);
+          const timeoutError = new Error(`Timeout after ${DEFAULT_TIMEOUT_MS5}ms`);
           try {
             proc.kill();
             proc.exited.catch((err) => {
@@ -85043,7 +85635,7 @@ The Bash tool can execute these commands directly. Do NOT retry with interactive
             });
           } catch {}
           reject(timeoutError);
-        }, DEFAULT_TIMEOUT_MS6);
+        }, DEFAULT_TIMEOUT_MS5);
         proc.exited.then(() => clearTimeout(id)).catch(() => clearTimeout(id));
       });
       const [stdout, stderr, exitCode] = await Promise.race([
@@ -85067,7 +85659,7 @@ The Bash tool can execute these commands directly. Do NOT retry with interactive
 // src/tools/pdf-extract-figures/tools.ts
 import { existsSync as existsSync62, mkdtempSync, writeFileSync as writeFileSync24 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join64 } from "path";
+import { join as join63 } from "path";
 var PYTHON_SCRIPT = `#!/usr/bin/env python3
 import sys
 import json
@@ -85218,11 +85810,11 @@ async function runExtraction(args) {
   }
   let tmpDir;
   try {
-    tmpDir = mkdtempSync(join64(tmpdir5(), "matrixx-pdf-extract-"));
+    tmpDir = mkdtempSync(join63(tmpdir5(), "matrixx-pdf-extract-"));
   } catch {
     return "Error: Could not create temporary directory.";
   }
-  const scriptPath = join64(tmpDir, "extract_pdf_figures.py");
+  const scriptPath = join63(tmpDir, "extract_pdf_figures.py");
   writeFileSync24(scriptPath, PYTHON_SCRIPT);
   const payload = buildArgsPayload(args);
   log("[pdf_extract_figures] Running extraction", { file_path: args.file_path, payload });
@@ -85270,9 +85862,9 @@ function createPdfExtractFiguresTool() {
   return { pdf_extract_figures };
 }
 // src/tools/session-manager/constants.ts
-import { join as join65 } from "path";
-var TODO_DIR = join65(getOpenCodeConfigDir({ binary: "opencode" }), "todos");
-var TRANSCRIPT_DIR2 = join65(getOpenCodeConfigDir({ binary: "opencode" }), "transcripts");
+import { join as join64 } from "path";
+var TODO_DIR = join64(getOpenCodeConfigDir({ binary: "opencode" }), "todos");
+var TRANSCRIPT_DIR2 = join64(getOpenCodeConfigDir({ binary: "opencode" }), "transcripts");
 var SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
 
 Returns a list of available session IDs with metadata including message count, date range, and agents used.
@@ -85346,7 +85938,7 @@ Has Transcript: Yes (234 entries)`;
 // src/tools/session-manager/storage.ts
 import { existsSync as existsSync63 } from "fs";
 import { readdir, readFile as readFile4 } from "fs/promises";
-import { join as join66 } from "path";
+import { join as join65 } from "path";
 var sdkClient = null;
 function setStorageClient(client2) {
   sdkClient = client2;
@@ -85373,13 +85965,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join66(SESSION_STORAGE, projectDir.name);
+      const projectPath = join65(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file3 of sessionFiles) {
         if (!file3.endsWith(".json"))
           continue;
         try {
-          const content = await readFile4(join66(projectPath, file3), "utf-8");
+          const content = await readFile4(join65(projectPath, file3), "utf-8");
           const meta3 = JSON.parse(content);
           if (meta3.parentID)
             continue;
@@ -85412,7 +86004,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join66(dir, entry.name);
+          const sessionPath = join65(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -85482,7 +86074,7 @@ async function readSessionMessages(sessionID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile4(join66(messageDir, file3), "utf-8");
+        const content = await readFile4(join65(messageDir, file3), "utf-8");
         const meta3 = JSON.parse(content);
         const parts = await readParts2(meta3.id);
         messages2.push({
@@ -85506,7 +86098,7 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join66(PART_STORAGE, messageID);
+  const partDir = join65(PART_STORAGE, messageID);
   if (!existsSync63(partDir))
     return [];
   const parts = [];
@@ -85516,7 +86108,7 @@ async function readParts2(messageID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile4(join66(partDir, file3), "utf-8");
+        const content = await readFile4(join65(partDir, file3), "utf-8");
         parts.push(JSON.parse(content));
       } catch {}
     }
@@ -85547,7 +86139,7 @@ async function readSessionTodos(sessionID) {
     const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
     for (const file3 of todoFiles) {
       try {
-        const content = await readFile4(join66(TODO_DIR, file3), "utf-8");
+        const content = await readFile4(join65(TODO_DIR, file3), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -85567,7 +86159,7 @@ async function readSessionTodos(sessionID) {
 async function readSessionTranscript(sessionID) {
   if (!existsSync63(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join66(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  const transcriptFile = join65(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
   if (!existsSync63(transcriptFile))
     return 0;
   try {
@@ -86078,17 +86670,17 @@ function createSkillTool(options = {}) {
 }
 var skill = createSkillTool();
 // src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync64, readdirSync as readdirSync19, readFileSync as readFileSync40 } from "fs";
-import { basename as basename6, join as join67 } from "path";
+import { existsSync as existsSync64, readdirSync as readdirSync20, readFileSync as readFileSync40 } from "fs";
+import { basename as basename6, join as join66 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
   if (!existsSync64(commandsDir))
     return [];
-  const entries = readdirSync19(commandsDir, { withFileTypes: true });
+  const entries = readdirSync20(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join67(commandsDir, entry.name);
+    const commandPath = join66(commandsDir, entry.name);
     const commandName = basename6(entry.name, ".md");
     try {
       const content = readFileSync40(commandPath, "utf-8");
@@ -86115,8 +86707,8 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync(directory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeGlobalDir = join67(configDir, "command");
-  const opencodeProjectDir = join67(directory ?? process.cwd(), ".opencode", "command");
+  const opencodeGlobalDir = join66(configDir, "command");
+  const opencodeProjectDir = join66(directory ?? process.cwd(), ".opencode", "command");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const opencodeProjectCommands = discoverCommandsFromDir2(opencodeProjectDir, "opencode-project");
   const builtinCommandsMap = loadBuiltinCommands();
@@ -87287,8 +87879,8 @@ function createAssemblyTool(options) {
 }
 // src/tools/dcp-switch-profile/tools.ts
 import { existsSync as existsSync65, writeFileSync as writeFileSync25 } from "fs";
-import { homedir as homedir11 } from "os";
-import { join as join68 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join67 } from "path";
 
 // src/config/schema/dcp.ts
 var DcpCompressOverrideSchema = exports_external.object({
@@ -87461,8 +88053,8 @@ var DcpConfigSchema = exports_external.object({
 });
 
 // src/tools/dcp-switch-profile/tools.ts
-var DCP_PLUGIN_DIR = join68(homedir11(), ".config", "opencode", "node_modules", "@tarquinen", "opencode-dcp");
-var DCP_SYMLINK = join68(homedir11(), ".config", "opencode", "dcp.jsonc");
+var DCP_PLUGIN_DIR = join67(homedir10(), ".config", "opencode", "node_modules", "@tarquinen", "opencode-dcp");
+var DCP_SYMLINK = join67(homedir10(), ".config", "opencode", "dcp.jsonc");
 var VALID_PROFILES = ["economy", "balanced", "performance", "ultimate"];
 function checkDcpInstalled() {
   if (!existsSync65(DCP_PLUGIN_DIR)) {
@@ -87871,6 +88463,11 @@ function createDelegateAgent(ctx, backgroundManager, disabledAgents = []) {
       }
       const normalizedAgent = args.subagent_type.toLowerCase();
       args = { ...args, subagent_type: normalizedAgent };
+      const callerAgent = (toolCtx.agent || "").toLowerCase();
+      const MOUSE_RESEARCH_ONLY = ["trinity", "operator"];
+      if (callerAgent === "mouse" && !MOUSE_RESEARCH_ONLY.includes(normalizedAgent)) {
+        return `Error: Mouse is a leaf executor. delegate_agent with subagent_type="${normalizedAgent}" is BLOCKED. Only trinity/operator allowed for research. Plan files (.matrixx/plans/*.md) must be created via task(subagent_type="oracle") from Morpheus, never via Mouse \u2192 Oracle. Route plan generation directly from Morpheus to oracle.`;
+      }
       if (disabledAgents.some((disabled) => disabled.toLowerCase() === normalizedAgent)) {
         return `Error: Agent "${normalizedAgent}" is disabled via disabled_agents configuration. Remove it from disabled_agents in your matrixx.json to use it.`;
       }
@@ -91338,6 +91935,109 @@ Original error: ${createResult.error}`;
     }
   });
 }
+// src/tools/task/task-cleanup.ts
+import { existsSync as existsSync66, readdirSync as readdirSync21, readFileSync as readFileSync41, unlinkSync as unlinkSync10 } from "fs";
+import { join as join68 } from "path";
+init_logger();
+function parseOlderThan(value) {
+  const match = value.trim().match(/^(\d+)(d|h|m)$/);
+  if (!match)
+    return null;
+  const amount = Number(match[1]);
+  const unit = match[2];
+  if (unit === "d")
+    return amount * 24 * 60 * 60 * 1000;
+  if (unit === "h")
+    return amount * 60 * 60 * 1000;
+  return amount * 60 * 1000;
+}
+function getTaskTimestamp(task) {
+  const raw = task;
+  const candidate = raw.time_updated ?? raw.time_created ?? raw.updatedAt ?? raw.createdAt ?? raw.timeUpdated ?? raw.timeCreated ?? null;
+  if (candidate === null || candidate === undefined)
+    return Date.now();
+  if (typeof candidate === "number")
+    return candidate;
+  if (typeof candidate === "string") {
+    const parsed = Date.parse(candidate);
+    if (!Number.isNaN(parsed))
+      return parsed;
+    const asNum = Number(candidate);
+    if (!Number.isNaN(asNum))
+      return asNum;
+    return Date.now();
+  }
+  return Date.now();
+}
+function createTaskCleanupTool(config4, ctx) {
+  return tool({
+    description: `Delete completed task files from storage.
+
+Scans getTaskDir()/*.json, filters status==="completed" and optionally olderThan.
+olderThan supports "7d", "24h", "30m" format (regex ^(\\d+)(d|h|m)$).
+Returns counts: {deleted, remaining, deletedIds}`,
+    args: {
+      olderThan: tool.schema.string().optional().describe('Only delete completed tasks older than duration (e.g. "7d", "24h", "30m")'),
+      all: tool.schema.boolean().optional().describe("Delete all completed tasks (default true when olderThan not set)")
+    },
+    execute: async (args, context) => {
+      try {
+        const olderThan = args.olderThan;
+        let olderThanMs = null;
+        if (olderThan !== undefined) {
+          const parsed = parseOlderThan(olderThan);
+          if (parsed === null) {
+            return JSON.stringify({
+              error: "validation_error",
+              message: `Invalid olderThan format: "${olderThan}". Expected e.g. "7d", "24h", "30m"`
+            });
+          }
+          olderThanMs = parsed;
+        }
+        const directory = context?.directory ?? ctx?.directory ?? process.cwd();
+        const taskDir = getTaskDir(config4, directory);
+        if (!existsSync66(taskDir)) {
+          return JSON.stringify({ deleted: 0, remaining: 0, deletedIds: [] });
+        }
+        const files = readdirSync21(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-"));
+        const total = files.length;
+        const deletedIds = [];
+        for (const file3 of files) {
+          const filePath = join68(taskDir, file3);
+          let raw;
+          try {
+            const content = readFileSync41(filePath, "utf-8");
+            raw = JSON.parse(content);
+          } catch {
+            continue;
+          }
+          if (raw.status !== "completed")
+            continue;
+          const id = typeof raw.id === "string" ? raw.id : file3.replace(".json", "");
+          if (olderThanMs !== null) {
+            const ts = getTaskTimestamp(raw);
+            const age = Date.now() - ts;
+            if (age <= olderThanMs)
+              continue;
+          }
+          try {
+            unlinkSync10(filePath);
+            deletedIds.push(id);
+          } catch (err) {
+            log("[task-cleanup] Failed to delete", { file: file3, error: String(err) });
+          }
+        }
+        return JSON.stringify({
+          deleted: deletedIds.length,
+          remaining: total - deletedIds.length,
+          deletedIds
+        });
+      } catch (error95) {
+        return JSON.stringify({ error: "internal_error", message: error95 instanceof Error ? error95.message : String(error95) });
+      }
+    }
+  });
+}
 // src/tools/task/task-create.ts
 import { join as join69 } from "path";
 function createTaskCreateTool(config4, ctx) {
@@ -91371,8 +92071,12 @@ Calculate dependencies carefully to maximize parallel execution:
 async function handleCreate2(args, config4, ctx, context) {
   try {
     const validatedArgs = TaskCreateInputSchema.parse(args);
-    const taskDir = getTaskDir(config4);
-    const lock = acquireLock(taskDir);
+    const directory = context?.directory ?? ctx?.directory ?? process.cwd();
+    try {
+      migrateLegacyTasksIfNeeded(config4, directory);
+    } catch {}
+    const taskDir = getTaskDir(config4, directory);
+    const lock = await acquireLockWithRetry(taskDir);
     if (!lock.acquired) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
@@ -91389,11 +92093,11 @@ async function handleCreate2(args, config4, ctx, context) {
         metadata: validatedArgs.metadata,
         repoURL: validatedArgs.repoURL,
         parentID: validatedArgs.parentID,
-        threadID: context.sessionID
+        threadID: context.sessionID,
+        projectRoot: directory
       };
       const validatedTask = TaskObjectSchema.parse(task);
       writeJsonAtomic(join69(taskDir, `${taskId}.json`), validatedTask);
-      await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
       return JSON.stringify({
         task: {
           id: validatedTask.id,
@@ -91425,7 +92129,7 @@ function parseTaskId(id) {
     return null;
   return id;
 }
-function createTaskGetTool(config4) {
+function createTaskGetTool(config4, ctx) {
   return tool({
     description: `Retrieve a task by ID.
 
@@ -91435,14 +92139,15 @@ Returns null if the task does not exist or the file is invalid.`,
     args: {
       id: tool.schema.string().describe("Task ID to retrieve (format: T-{uuid})")
     },
-    execute: async (args) => {
+    execute: async (args, context) => {
       try {
         const validatedArgs = TaskGetInputSchema.parse(args);
         const taskId = parseTaskId(validatedArgs.id);
         if (!taskId) {
           return JSON.stringify({ error: "invalid_task_id" });
         }
-        const taskDir = getTaskDir(config4);
+        const directory = context?.directory ?? ctx?.directory ?? process.cwd();
+        const taskDir = getTaskDir(config4, directory);
         const taskPath = join70(taskDir, `${taskId}.json`);
         const task = readJsonSafe(taskPath, TaskObjectSchema);
         return JSON.stringify({ task: task ?? null });
@@ -91456,9 +92161,9 @@ Returns null if the task does not exist or the file is invalid.`,
   });
 }
 // src/tools/task/task-list.ts
-import { existsSync as existsSync66, readdirSync as readdirSync20 } from "fs";
+import { existsSync as existsSync67, readdirSync as readdirSync22 } from "fs";
 import { join as join71 } from "path";
-function createTaskList(config4) {
+function createTaskList(config4, ctx) {
   return tool({
     description: `List all active tasks with summary information.
     
@@ -91466,12 +92171,13 @@ Returns tasks excluding completed and deleted statuses by default.
 For each task's blockedBy field, filters to only include unresolved (non-completed) blockers.
 Returns summary format: id, subject, status, owner, blockedBy (not full description).`,
     args: {},
-    execute: async () => {
-      const taskDir = getTaskDir(config4);
-      if (!existsSync66(taskDir)) {
+    execute: async (_args, context) => {
+      const directory = context?.directory ?? ctx?.directory ?? process.cwd();
+      const taskDir = getTaskDir(config4, directory);
+      if (!existsSync67(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
-      const files = readdirSync20(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
+      const files = readdirSync22(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
       if (files.length === 0) {
         return JSON.stringify({ tasks: [] });
       }
@@ -91516,8 +92222,6 @@ function createTaskUpdateTool(config4, ctx) {
 
 Supports updating: subject, description, status, activeForm, owner, metadata.
 For blocks/blockedBy: use addBlocks/addBlockedBy to append (additive, not replacement).
-For metadata: merge with existing, set key to null to delete.
-Syncs to OpenCode Todo API after update.
 
 **IMPORTANT - Dependency Management:**
 Use \`addBlockedBy\` to declare dependencies on other tasks.
@@ -91545,8 +92249,9 @@ async function handleUpdate(args, config4, ctx, context) {
     if (!taskId) {
       return JSON.stringify({ error: "invalid_task_id" });
     }
-    const taskDir = getTaskDir(config4);
-    const lock = acquireLock(taskDir);
+    const directory = context?.directory ?? ctx?.directory ?? process.cwd();
+    const taskDir = getTaskDir(config4, directory);
+    const lock = await acquireLockWithRetry(taskDir);
     if (!lock.acquired) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
@@ -91589,7 +92294,6 @@ async function handleUpdate(args, config4, ctx, context) {
       }
       const validatedTask = TaskObjectSchema.parse(task);
       writeJsonAtomic(taskPath, validatedTask);
-      await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
       return JSON.stringify({ task: validatedTask });
     } finally {
       lock.release();
@@ -91722,14 +92426,14 @@ function createToolGuardHooks(args) {
   const envFileWriteGuard = isHookEnabled("env-file-write-guard") ? safeHook("env-file-write-guard", () => createEnvFileWriteGuardHook(pluginConfig.security?.env_file_guard)) : null;
   const jsonErrorRecovery = isHookEnabled("json-error-recovery") ? safeHook("json-error-recovery", () => createJsonErrorRecoveryHook(ctx)) : null;
   const bashFileReadGuard = isHookEnabled("bash-file-read-guard") ? safeHook("bash-file-read-guard", () => createBashFileReadGuardHook()) : null;
-  const todoDescriptionOverride = isHookEnabled("todo-description-override") ? safeHook("todo-description-override", () => createTodoDescriptionOverrideHook()) : null;
+  const contextModeEnforcer = isHookEnabled("context-mode-enforcer") ? safeHook("context-mode-enforcer", () => createContextModeEnforcerHook(pluginConfig)) : null;
   const readImageResizer = isHookEnabled("read-image-resizer") ? safeHook("read-image-resizer", () => createReadImageResizerHook(ctx)) : null;
   const webfetchRedirectGuard = isHookEnabled("webfetch-redirect-guard") ? safeHook("webfetch-redirect-guard", () => createWebFetchRedirectGuardHook(ctx)) : null;
   const hashlineEditDiffEnhancer = isHookEnabled("hashline-edit-diff-enhancer") ? safeHook("hashline-edit-diff-enhancer", () => createHashlineEditDiffEnhancerHook({ hashline_edit: { enabled: pluginConfig.experimental?.hashline_edit ?? false } })) : null;
   const qualityGate = isHookEnabled("quality-gate") ? safeHook("quality-gate", () => createQualityGateHook()) : null;
   const taskNotepad = isHookEnabled("task-notepad") ? safeHook("task-notepad", () => createTaskNotepadHook(ctx)) : null;
+  const taskEditGuard = isHookEnabled("task-edit-guard") ? safeHook("task-edit-guard", () => createTaskEditGuardHook(ctx)) : null;
   const evolutionWatcher = isHookEnabled("evolution-watcher") ? safeHook("evolution-watcher", () => createEvolutionWatcherHook(ctx, pluginConfig.evolution)) : null;
-  const taskTodoMirror = isHookEnabled("task-todo-mirror") ? safeHook("task-todo-mirror", () => createTaskTodoMirrorHook(ctx, pluginConfig)) : null;
   return {
     commentChecker,
     toolOutputTruncator,
@@ -91744,14 +92448,14 @@ function createToolGuardHooks(args) {
     envFileWriteGuard,
     jsonErrorRecovery,
     bashFileReadGuard,
-    todoDescriptionOverride,
+    contextModeEnforcer,
     readImageResizer,
     webfetchRedirectGuard,
     hashlineEditDiffEnhancer,
     qualityGate,
     taskNotepad,
-    evolutionWatcher,
-    taskTodoMirror
+    taskEditGuard,
+    evolutionWatcher
   };
 }
 
@@ -92205,19 +92909,19 @@ function detectRepetitiveToolUse(window2) {
 }
 
 // src/features/background-agent/message-dir.ts
-import { existsSync as existsSync67, readdirSync as readdirSync21, readFileSync as readFileSync41 } from "fs";
+import { existsSync as existsSync68, readdirSync as readdirSync23, readFileSync as readFileSync42 } from "fs";
 import { join as join73 } from "path";
 var MESSAGE_DIR_CACHE_CAP = 1000;
 var messageDirCache = new Map;
 function computeMessageDir(sessionID) {
-  if (!existsSync67(MESSAGE_STORAGE))
+  if (!existsSync68(MESSAGE_STORAGE))
     return null;
   const directPath = join73(MESSAGE_STORAGE, sessionID);
-  if (existsSync67(directPath))
+  if (existsSync68(directPath))
     return directPath;
-  for (const dir of readdirSync21(MESSAGE_STORAGE)) {
+  for (const dir of readdirSync23(MESSAGE_STORAGE)) {
     const sessionPath = join73(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync67(sessionPath))
+    if (existsSync68(sessionPath))
       return sessionPath;
   }
   return null;
@@ -92251,11 +92955,11 @@ function hasPartialAgentOrModel(message) {
 }
 function findNearestMessageExcludingCompaction(messageDir) {
   try {
-    const files = readdirSync21(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
+    const files = readdirSync23(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
     const parsedByFile = new Map;
     for (const file3 of files) {
       try {
-        const content = readFileSync41(join73(messageDir, file3), "utf-8");
+        const content = readFileSync42(join73(messageDir, file3), "utf-8");
         const parsed = JSON.parse(content);
         parsedByFile.set(file3, parsed);
         if (hasFullAgentAndModel(parsed)) {
@@ -94695,6 +95399,12 @@ ${useWhen.map((w) => `| ${w} | Oracle FIRST, then implement |`).join(`
 ${avoidWhen.map((w) => `- ${w}`).join(`
 `)}
 
+### HARD ROUTING RULE \u2014 Plan File Creation (NON-NEGOTIABLE):
+- ANY task that creates or edits \`.matrixx/plans/*.md\` MUST use \`task(subagent_type='oracle')\` \u2014 NEVER \`task(category='...')\` / Mouse
+- ANY prompt containing \`Oracle plan\`, \`work plan\`, \`proposal\`, \`TL;DR\`, \`root cause\`, \`pure-host\`, \`fix options\` or similar planning language MUST route to \`oracle\`
+- Mouse is a leaf executor and CANNOT produce plans. Oracle owns all plan generation. Mouse \u2192 Oracle is a violation (extra hop, diluted context).
+- If you already created tasks for research + drafting, the drafting task MUST still be \`oracle\`, not \`mouse\`.
+
 ### Usage Pattern:
 Oracle creates plans, not code. Invoke oracle to decompose complex requests into structured work plans with clear steps, then execute the plan yourself or delegate to workers.
 
@@ -94772,14 +95482,14 @@ function buildCompactContextDisciplineSection(hasContextMode = false) {
 | Docs / Web | ctx_fetch_and_index -> ctx_search |
 | Compression | compress when ctx_stats > 40% or 10+ tool calls |
 
-Edits need prior read for LINE#ID \u2014 read\u2192edit chain exempt. When in doubt, use ctx_*.`;
+Edits need prior read for LINE#ID \u2014 read\u2192edit chain exempt. MUST use ctx_* when available \u2014 raw grep/read is forbidden for analysis.`;
 }
 function buildExploreDisciplineSection(hasContextMode = false, hasHeadroom = false) {
   if (!hasContextMode && !hasHeadroom)
     return "";
   const parts = [];
   if (hasContextMode) {
-    parts.push("Prefer ctx_search for indexed hits \u2192 grep/glob fallback for raw FS; use ctx_batch_execute / ctx_execute for multi-file analysis; use ctx_fetch_and_index for docs/web \u2192 ctx_search.");
+    parts.push("MUST use ctx_search for indexed hits \u2192 grep/glob fallback ONLY when ctx_* unavailable; use ctx_batch_execute / ctx_execute for multi-file analysis; use ctx_fetch_and_index for docs/web \u2192 ctx_search. Raw grep/read/glob for analysis is forbidden when ctx_* is available.");
   }
   if (hasHeadroom) {
     parts.push("Use headroom_retrieve / headroom_search for compressed history \u2014 NEVER re-read full history.");
@@ -95823,8 +96533,8 @@ function createBddContractAgent(model) {
 createBddContractAgent.mode = MODE2;
 
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync68, readFileSync as readFileSync42 } from "fs";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync69, readFileSync as readFileSync43 } from "fs";
+import { homedir as homedir11 } from "os";
 import { isAbsolute as isAbsolute5, resolve as resolve10 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
   if (!promptAppend.startsWith("file://"))
@@ -95833,16 +96543,16 @@ function resolvePromptAppend(promptAppend, configDir) {
   let filePath;
   try {
     const decoded = decodeURIComponent(encoded);
-    const expanded = decoded.startsWith("~/") ? decoded.replace(/^~\//, `${homedir12()}/`) : decoded;
+    const expanded = decoded.startsWith("~/") ? decoded.replace(/^~\//, `${homedir11()}/`) : decoded;
     filePath = isAbsolute5(expanded) ? expanded : resolve10(configDir ?? process.cwd(), expanded);
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
-  if (!existsSync68(filePath)) {
+  if (!existsSync69(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync42(filePath, "utf8");
+    return readFileSync43(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -97557,7 +98267,8 @@ var ORACLE_PLAN_BUILDER_METADATA = {
     { domain: "Architecture decisions", trigger: "Multi-system tradeoffs, unfamiliar patterns" },
     { domain: "Work planning", trigger: "Complex feature implementation, refactoring" },
     { domain: "Complex task breakdown", trigger: "Large ambiguous requests needing decomposition" },
-    { domain: "Self-review", trigger: "After completing significant implementation" }
+    { domain: "Self-review", trigger: "After completing significant implementation" },
+    { domain: "Plan generation", trigger: "ANY .matrixx/plans/*.md creation or planning doc \u2192 oracle ONLY, never Mouse" }
   ],
   useWhen: [
     "Complex architecture design",
@@ -100589,20 +101300,22 @@ function buildConstraintsSection(useTaskSystem) {
     return `<Critical_Constraints>
 BLOCKED ACTIONS (will fail if attempted):
 - task (agent delegation tool): BLOCKED \u2014 you cannot delegate work to other agents
+- delegate_agent with subagent_type=oracle/construct/merovingian/smith/sentinel/cipher: BLOCKED \u2014 Mouse is a leaf executor
 
 ALLOWED tools:
-- delegate_agent: You CAN spawn explore/librarian agents for research
+- delegate_agent with subagent_type=trinity/operator ONLY: You MAY spawn explore/librarian agents for research
 - task_create, task_update, task_list, task_get: ALLOWED \u2014 use these for tracking your work
 
-You work ALONE for implementation. No delegation of implementation tasks.
+You work ALONE for implementation. No delegation of implementation or planning tasks. Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.
 </Critical_Constraints>`;
   }
   return `<Critical_Constraints>
 BLOCKED ACTIONS (will fail if attempted):
 - task (agent delegation tool): BLOCKED \u2014 you cannot delegate work to other agents
+- delegate_agent with subagent_type=oracle/construct/merovingian/smith/sentinel/cipher: BLOCKED \u2014 Mouse is a leaf executor
 
-ALLOWED: delegate_agent - You CAN spawn explore/librarian agents for research.
-You work ALONE for implementation. No delegation of implementation tasks.
+ALLOWED: delegate_agent with subagent_type=trinity/operator ONLY - You MAY spawn explore/librarian agents for research.
+You work ALONE for implementation. No delegation of implementation or planning tasks. Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.
 </Critical_Constraints>`;
 }
 function buildTodoDisciplineSection2(useTaskSystem) {
@@ -100707,20 +101420,22 @@ function buildConstraintsSection2(useTaskSystem) {
     return `<Critical_Constraints>
 BLOCKED ACTIONS (will fail if attempted):
 - task (agent delegation tool): BLOCKED \u2014 you cannot delegate work to other agents
+- delegate_agent with subagent_type=oracle/construct/merovingian/smith/sentinel/cipher: BLOCKED \u2014 Mouse is a leaf executor
 
 ALLOWED tools:
-- delegate_agent: You CAN spawn explore/librarian agents for research
+- delegate_agent with subagent_type=trinity/operator ONLY: You MAY spawn explore/librarian agents for research
 - task_create, task_update, task_list, task_get: ALLOWED \u2014 use these for tracking your work
 
-You work ALONE for implementation. No delegation of implementation tasks.
+You work ALONE for implementation. No delegation of implementation or planning tasks. Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.
 </Critical_Constraints>`;
   }
   return `<Critical_Constraints>
 BLOCKED ACTIONS (will fail if attempted):
 - task (agent delegation tool): BLOCKED \u2014 you cannot delegate work to other agents
+- delegate_agent with subagent_type=oracle/construct/merovingian/smith/sentinel/cipher: BLOCKED \u2014 Mouse is a leaf executor
 
-ALLOWED: delegate_agent - You CAN spawn explore/librarian agents for research.
-You work ALONE for implementation. No delegation of implementation tasks.
+ALLOWED: delegate_agent with subagent_type=trinity/operator ONLY - You MAY spawn explore/librarian agents for research.
+You work ALONE for implementation. No delegation of implementation or planning tasks. Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.
 </Critical_Constraints>`;
 }
 function buildTodoDisciplineSection3(useTaskSystem) {
@@ -100821,17 +101536,18 @@ BLOCKED (will fail if attempted):
 | Tool | Status | Description |
 |------|--------|-------------|
 | task | BLOCKED | Agent delegation tool \u2014 you cannot spawn other agents |
+| delegate_agent with oracle/construct/merovingian/smith/sentinel/cipher | BLOCKED | Mouse is leaf \u2014 only trinity/operator allowed |
 
 ALLOWED:
 | Tool | Usage |
 |------|-------|
-| delegate_agent | Spawn explore/librarian for research ONLY |
+| delegate_agent with trinity/operator ONLY | Spawn explore/librarian for research ONLY |
 | task_create | Create tasks to track your work |
 | task_update | Update task status (in_progress, completed) |
 | task_list | List active tasks |
 | task_get | Get task details by ID |
 
-You work ALONE for implementation. No delegation.
+You work ALONE for implementation. No delegation. Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.
 </blocked_actions>`;
   }
   return `<blocked_actions>
@@ -100839,13 +101555,14 @@ BLOCKED (will fail if attempted):
 | Tool | Status | Description |
 |------|--------|-------------|
 | task | BLOCKED | Agent delegation tool \u2014 you cannot spawn other agents |
+| delegate_agent with oracle/construct/merovingian/smith/sentinel/cipher | BLOCKED | Mouse is leaf \u2014 only trinity/operator allowed |
 
 ALLOWED:
 | Tool | Usage |
 |------|-------|
-| delegate_agent | Spawn explore/librarian for research ONLY |
+| delegate_agent with trinity/operator ONLY | Spawn explore/librarian for research ONLY |
 
-You work ALONE for implementation. No delegation.
+You work ALONE for implementation. No delegation. Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.
 </blocked_actions>`;
 }
 function buildGptTaskDisciplineSection(useTaskSystem) {
@@ -100885,11 +101602,12 @@ Execute tasks directly. You NEVER delegate.
 
 <rules>
 - task tool: BLOCKED \u2014 cannot delegate to other agents
-- delegate_agent: ALLOWED \u2014 only for research (explore/librarian)
+- delegate_agent with oracle/construct/merovingian/smith/sentinel/cipher: BLOCKED \u2014 Mouse is leaf, only trinity/operator allowed
+- delegate_agent with trinity/operator ONLY: ALLOWED for research (explore/librarian)
 - ${useTaskSystem ? "task_create/task_update" : "todowrite/todoread"}: REQUIRED for tracking
 - Implement ONLY what is requested \u2014 no scope creep
+- Plan files (.matrixx/plans/*.md): OWNED by oracle \u2014 never create via Mouse
 </rules>
-
 ${taskDiscipline}
 
 <verify>
@@ -100981,15 +101699,21 @@ function buildQwenBlockedActions(useTaskSystem) {
     return `| Tool | Status | Notes |
 |------|--------|-------|
 | task | BLOCKED | Cannot delegate implementation |
-| delegate_agent | ALLOWED | Research only (explore/librarian) |
+| delegate_agent with oracle/construct/merovingian/smith/sentinel/cipher | BLOCKED | Mouse is leaf \u2014 only trinity/operator allowed |
+| delegate_agent with trinity/operator ONLY | ALLOWED | Research only (explore/librarian) |
 | task_create | ALLOWED | Track your work |
 | task_update | ALLOWED | Update status |
-| task_list / task_get | ALLOWED | View tasks |`;
+| task_list / task_get | ALLOWED | View tasks |
+
+Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.`;
   }
   return `| Tool | Status | Notes |
 |------|--------|-------|
 | task | BLOCKED | Cannot delegate implementation |
-| delegate_agent | ALLOWED | Research only (explore/librarian) |`;
+| delegate_agent with oracle/construct/merovingian/smith/sentinel/cipher | BLOCKED | Mouse is leaf \u2014 only trinity/operator allowed |
+| delegate_agent with trinity/operator ONLY | ALLOWED | Research only (explore/librarian) |
+
+Plan files (.matrixx/plans/*.md) are OWNED by oracle \u2014 never create them via Mouse.`;
 }
 function buildQwenDisciplineSection(useTaskSystem) {
   if (useTaskSystem) {
@@ -101256,7 +101980,7 @@ async function applyAgentConfig(params) {
   if (!params.pluginConfig.tdd_enforcer?.enabled) {
     disabledSkills.add("tdd-enforcer");
   }
-  const useTaskSystem = params.pluginConfig.experimental?.task_system ?? false;
+  const useTaskSystem = isTaskSystemEnabled(params.pluginConfig);
   const availableToolNames = getAvailableToolNames();
   const builtinAgents = await createBuiltinAgents(migratedDisabledAgents, params.pluginConfig.agents, params.ctx.directory, undefined, params.pluginConfig.categories, allDiscoveredSkills, params.ctx.client, browserProvider, currentModel, disabledSkills, useTaskSystem, params.pluginConfig.global_model, availableToolNames);
   const rawPluginAgents = params.pluginComponents.agents;
@@ -101562,7 +102286,9 @@ function agentByKey(agentResult, key) {
   return agentResult[key];
 }
 function applyToolConfig(params) {
-  const denyTodoTools = params.pluginConfig.experimental?.task_system ? { todowrite: "deny", todoread: "deny" } : {};
+  const isTaskSystem = isTaskSystemEnabled(params.pluginConfig);
+  const denyTodoTools = isTaskSystem ? { todowrite: "deny", todoread: "deny" } : {};
+  const denyTaskTools = !isTaskSystem ? { "task_*": "deny", task: "deny" } : {};
   params.config.tools = {
     ...params.config.tools,
     "grep_app_*": false,
@@ -101571,7 +102297,7 @@ function applyToolConfig(params) {
     LspCodeActionResolve: false,
     "task_*": false,
     teammate: false,
-    ...params.pluginConfig.experimental?.task_system ? { todowrite: false, todoread: false } : {}
+    ...isTaskSystem ? { todowrite: false, todoread: false } : { "task_*": false, task: false }
   };
   const isCliRunMode = process.env.OPENCODE_CLI_RUN_MODE === "true";
   const questionPermission = isCliRunMode ? "deny" : "allow";
@@ -101587,11 +102313,8 @@ function applyToolConfig(params) {
   if (architect) {
     architect.permission = {
       ...architect.permission,
-      task: "allow",
       delegate_agent: "deny",
-      "task_*": "allow",
-      teammate: "allow",
-      ...denyTodoTools
+      ...isTaskSystem ? { task: "allow", "task_*": "allow", teammate: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools }
     };
   }
   const morpheus = agentByKey(params.agentResult, "morpheus");
@@ -101599,11 +102322,8 @@ function applyToolConfig(params) {
     morpheus.permission = {
       ...morpheus.permission,
       delegate_agent: "deny",
-      task: "allow",
       question: questionPermission,
-      "task_*": "allow",
-      teammate: "allow",
-      ...denyTodoTools
+      ...isTaskSystem ? { task: "allow", "task_*": "allow", teammate: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools }
     };
   }
   const keymaker = agentByKey(params.agentResult, "keymaker");
@@ -101611,9 +102331,8 @@ function applyToolConfig(params) {
     keymaker.permission = {
       ...keymaker.permission,
       delegate_agent: "deny",
-      task: "allow",
       question: questionPermission,
-      ...denyTodoTools
+      ...isTaskSystem ? { task: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools }
     };
   }
   const oracle = agentByKey(params.agentResult, "oracle");
@@ -101621,21 +102340,15 @@ function applyToolConfig(params) {
     oracle.permission = {
       ...oracle.permission,
       delegate_agent: "deny",
-      task: "allow",
       question: questionPermission,
-      "task_*": "allow",
-      teammate: "allow",
-      ...denyTodoTools
+      ...isTaskSystem ? { task: "allow", "task_*": "allow", teammate: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools }
     };
   }
   const mouse = agentByKey(params.agentResult, "mouse");
   if (mouse) {
     mouse.permission = {
       ...mouse.permission,
-      task: "allow",
-      "task_*": "allow",
-      teammate: "allow",
-      ...denyTodoTools
+      ...isTaskSystem ? { task: "allow", "task_*": "allow", teammate: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools }
     };
   }
   params.config.permission = {
@@ -101811,12 +102524,13 @@ function createToolRegistry(args) {
     skills: skillContext.builtinSkills,
     client: ctx.client
   });
-  const taskSystemEnabled = pluginConfig.experimental?.task_system ?? false;
+  const taskSystemEnabled = isTaskSystemEnabled(pluginConfig);
   const taskToolsRecord = taskSystemEnabled ? {
     task_create: createTaskCreateTool(pluginConfig, ctx),
-    task_get: createTaskGetTool(pluginConfig),
-    task_list: createTaskList(pluginConfig),
-    task_update: createTaskUpdateTool(pluginConfig, ctx)
+    task_get: createTaskGetTool(pluginConfig, ctx),
+    task_list: createTaskList(pluginConfig, ctx),
+    task_update: createTaskUpdateTool(pluginConfig, ctx),
+    task_cleanup: createTaskCleanupTool(pluginConfig, ctx)
   } : {};
   const hashlineEnabled = pluginConfig.experimental?.hashline_edit ?? false;
   const hashlineToolsRecord = hashlineEnabled ? { edit: createHashlineEditTool(ctx) } : {};
@@ -102109,6 +102823,12 @@ var BuiltinCommandNameSchema = exports_external.enum([
 var CommentCheckerConfigSchema = exports_external.object({
   custom_prompt: exports_external.string().optional()
 });
+// src/config/schema/context-mode.ts
+var ContextModeConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  enforce: exports_external.boolean().default(false),
+  blocked_tools: exports_external.array(exports_external.string()).default(["read", "grep", "glob"])
+});
 // src/config/schema/evolution.ts
 var EvolutionWatcherConfigSchema = exports_external.object({
   maxArgChars: exports_external.number().int().min(1).default(4000),
@@ -102182,7 +102902,7 @@ var ExperimentalConfigSchema = exports_external.object({
   auto_resume: exports_external.boolean().optional(),
   preemptive_compaction: exports_external.boolean().optional(),
   truncate_all_tool_outputs: exports_external.boolean().optional(),
-  task_system: exports_external.boolean().optional(),
+  task_system: exports_external.boolean().optional().default(true),
   plugin_load_timeout_ms: exports_external.number().min(1000).optional(),
   safe_hook_creation: exports_external.boolean().optional(),
   hashline_edit: exports_external.boolean().optional()
@@ -102196,6 +102916,7 @@ var HeadroomConfigSchema = exports_external.object({
 });
 // src/config/schema/hooks.ts
 var HookNameSchema = exports_external.enum([
+  "task-continuation-enforcer",
   "todo-continuation-enforcer",
   "context-window-monitor",
   "session-recovery",
@@ -102243,7 +102964,6 @@ var HookNameSchema = exports_external.enum([
   "env-file-write-guard",
   "json-error-recovery",
   "bash-file-read-guard",
-  "todo-description-override",
   "runtime-fallback",
   "read-image-resizer",
   "webfetch-redirect-guard",
@@ -102251,14 +102971,16 @@ var HookNameSchema = exports_external.enum([
   "tool-pair-validator",
   "quality-gate",
   "task-notepad",
-  "task-todo-mirror",
   "design-intent-preserver",
   "rtk-bash-rewriter",
   "mcp-startup-notification",
   "evolution-watcher",
   "evolution-compressor",
   "evolution-quality-gate",
-  "evolution-hitl"
+  "evolution-hitl",
+  "context-mode-enforcer",
+  "task-edit-guard",
+  "task-edit-guard"
 ]);
 // src/config/schema/matrix-loop.ts
 var MatrixLoopConfigSchema = exports_external.object({
@@ -102276,7 +102998,8 @@ var MatrixxSelfConfigSkillConfigSchema = exports_external.object({
 var MorpheusTasksConfigSchema = exports_external.object({
   storage_path: exports_external.string().optional(),
   task_list_id: exports_external.string().optional(),
-  claude_code_compat: exports_external.boolean().default(false)
+  claude_code_compat: exports_external.boolean().default(false),
+  scope: exports_external.enum(["global", "project"]).default("project").optional().describe("Task storage scope: project \u2192 .matrixx/tasks per project (default), global \u2192 ~/.config/opencode/tasks/{listId}")
 });
 var MorpheusConfigSchema = exports_external.object({
   tasks: MorpheusTasksConfigSchema.optional()
@@ -102446,6 +103169,7 @@ var MatrixxConfigSchema = exports_external.object({
   agent_definitions: AgentDefinitionsConfigSchema.optional(),
   matrixx_self_config: MatrixxSelfConfigSkillConfigSchema.optional(),
   headroom: HeadroomConfigSchema.optional(),
+  context_mode: ContextModeConfigSchema.optional(),
   rtk: RtkConfigSchema.optional(),
   evolution: EvolutionConfigSchema.optional(),
   _migrations: exports_external.array(exports_external.string()).optional()
@@ -102637,7 +103361,6 @@ function createChatMessageHandler2(args) {
         applyAgentVariant(pluginConfig, input.agent, message);
       }
     }
-    await hooks2.taskTodoMirror?.["chat.message"]?.(input, output);
     await hooks2.stopContinuationGuard?.["chat.message"]?.(input);
     await hooks2.keywordDetector?.["chat.message"]?.(input, output);
     await hooks2.autoSlashCommand?.["chat.message"]?.(input, output);
@@ -102787,8 +103510,8 @@ function createEventHandler2(args) {
     await Promise.resolve(hooks2.autoUpdateChecker?.event?.(input));
     await Promise.resolve(hooks2.backgroundNotificationHook?.event?.(input));
     await Promise.resolve(hooks2.sessionNotification?.(input));
-    await Promise.resolve(hooks2.taskTodoMirror?.event?.(input));
     await Promise.resolve(hooks2.todoContinuationEnforcer?.handler?.(input));
+    await Promise.resolve(hooks2.taskContinuationEnforcer?.handler?.(input));
     await Promise.resolve(hooks2.unstableAgentBabysitter?.event?.(input));
     await Promise.resolve(hooks2.contextWindowMonitor?.event?.(input));
     await Promise.resolve(hooks2.directoryAgentsInjector?.event?.(input));
@@ -102938,7 +103661,6 @@ function setCachedTransform(sessionID, messagesHash, messages2) {
 }
 function createMessagesTransformHandler(args) {
   return async (input, output) => {
-    await args.hooks.taskTodoMirror?.["experimental.chat.messages.transform"]?.(input, output);
     const sessionID = extractSessionID(output.messages);
     if (!sessionID) {
       await args.hooks.contextInjectorMessagesTransform?.["experimental.chat.messages.transform"]?.(input, output);
@@ -102962,9 +103684,7 @@ function createMessagesTransformHandler(args) {
 // src/plugin/tool-definition.ts
 function createToolDefinitionHandler(args) {
   const { hooks: hooks2 } = args;
-  return async (input, output) => {
-    await hooks2.todoDescriptionOverride?.["tool.definition"]?.(input, output);
-  };
+  return async (input, output) => {};
 }
 
 // src/plugin/tool-execute-after.ts
@@ -103001,7 +103721,6 @@ function createToolExecuteAfterHandler2(args) {
       await hooks2.jsonErrorRecovery?.["tool.execute.after"]?.(input, output);
       await hooks2.readImageResizer?.["tool.execute.after"]?.(input, output);
       await hooks2.taskNotepad?.["tool.execute.after"]?.(input, output);
-      await hooks2.taskTodoMirror?.["tool.execute.after"]?.(input, output);
     };
     await Promise.all([
       hooks2.preemptiveCompaction?.["tool.execute.after"]?.(input, output),
@@ -103013,22 +103732,22 @@ function createToolExecuteAfterHandler2(args) {
 
 // src/features/assembly-state/manager.ts
 init_logger();
-var HOOK_NAME17 = "assembly-state";
+var HOOK_NAME19 = "assembly-state";
 var disabledSessions = new Set;
 function isAssemblyDisabled(sessionID) {
   return disabledSessions.has(sessionID);
 }
 function disableAssembly(sessionID) {
   disabledSessions.add(sessionID);
-  log(`[${HOOK_NAME17}] Assembly disabled for session`, { sessionID });
+  log(`[${HOOK_NAME19}] Assembly disabled for session`, { sessionID });
   disabledSessions.add(sessionID);
-  log(`[${HOOK_NAME17}] Consensus disabled for session`, { sessionID });
+  log(`[${HOOK_NAME19}] Consensus disabled for session`, { sessionID });
 }
 function enableAssembly(sessionID) {
   disabledSessions.delete(sessionID);
-  log(`[${HOOK_NAME17}] Assembly enabled for session`, { sessionID });
+  log(`[${HOOK_NAME19}] Assembly enabled for session`, { sessionID });
   disabledSessions.delete(sessionID);
-  log(`[${HOOK_NAME17}] Consensus enabled for session`, { sessionID });
+  log(`[${HOOK_NAME19}] Consensus enabled for session`, { sessionID });
 }
 // src/plugin/session-agent-resolver.ts
 async function resolveSessionAgent(client2, sessionId, timeoutMs = 5000) {
@@ -103071,6 +103790,7 @@ function createToolExecuteBeforeHandler2(args) {
   const writeExistingFileGuardHook = hooks2.writeExistingFileGuard?.["tool.execute.before"];
   const tasksTodowriteDisablerHook = hooks2.tasksTodowriteDisabler?.["tool.execute.before"];
   const oracleMdOnlyHook = hooks2.oracleMdOnly?.["tool.execute.before"];
+  const contextModeEnforcerHook = hooks2.contextModeEnforcer?.["tool.execute.before"];
   const nonInteractiveEnvHook = hooks2.nonInteractiveEnv?.["tool.execute.before"];
   const bashFileReadGuardHook = hooks2.bashFileReadGuard?.["tool.execute.before"];
   const questionLabelTruncatorHook = hooks2.questionLabelTruncator?.["tool.execute.before"];
@@ -103090,7 +103810,8 @@ function createToolExecuteBeforeHandler2(args) {
       envFileWriteGuardHook?.(input, output),
       writeExistingFileGuardHook?.(input, output),
       tasksTodowriteDisablerHook?.(input, output),
-      oracleMdOnlyHook?.(input, output)
+      oracleMdOnlyHook?.(input, output),
+      contextModeEnforcerHook?.(input, output)
     ]);
     let resolvePromise;
     if (input.tool === "task") {