opencode-matrixx 2.6.0 → 2.6.1

package/dist/index.js

@@ -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 }) => {
@@ -61823,13 +61937,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) {
@@ -64916,216 +65028,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_NAME13 = "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 +65093,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 +65114,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 +65130,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 +65234,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 +65246,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 +65263,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 +65301,842 @@ 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_NAME13}] Skipped injection: in recovery`, { sessionID });
+    return;
+  }
+  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
+  if (hasRunningBgTasks) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] 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_NAME13}] Skipped injection: no tasks`, { sessionID });
+      return;
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME13}] Failed to fetch tasks`, { sessionID, error: String(error51) });
+    return;
+  }
+  const freshIncompleteCount = getIncompleteTaskCount(tasks);
+  if (freshIncompleteCount === 0) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] Skipped: agent in skipAgents list`, { sessionID, agent: agentName });
+    return;
+  }
+  if (!hasWritePermission(tools)) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] 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_NAME13}] Injection successful`, { sessionID });
+    if (injectionState) {
+      injectionState.inFlight = false;
+      injectionState.lastInjectedAt = Date.now();
+      injectionState.consecutiveFailures = 0;
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME13}] 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);
+  sessionStateStore.cancelCountdown(sessionID);
+  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_NAME13}] 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_NAME13}] session.idle`, { sessionID });
+  const state3 = sessionStateStore.getState(sessionID);
+  if (state3.isRecovering) {
+    log(`[${HOOK_NAME13}] Skipped: in recovery`, { sessionID });
+    return;
+  }
+  if (state3.abortDetectedAt) {
+    const timeSinceAbort = Date.now() - state3.abortDetectedAt;
+    if (timeSinceAbort < ABORT_WINDOW_MS) {
+      log(`[${HOOK_NAME13}] 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_NAME13}] 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_NAME13}] Skipped: last assistant message was aborted (API fallback)`, { sessionID });
+      return;
+    }
+  } catch (error51) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] 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_NAME13}] No tasks`, { sessionID });
       return;
+    }
+    incompleteCount = getIncompleteTaskCount(tasks);
+  } catch (error51) {
+    log(`[${HOOK_NAME13}] Task fetch failed`, { sessionID, error: String(error51) });
+    return;
+  }
+  if (incompleteCount === 0) {
+    log(`[${HOOK_NAME13}] All tasks complete`, { sessionID, total });
+    return;
+  }
+  if (state3.inFlight) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] Reset consecutive failures after recovery window`, {
+      sessionID,
+      failureResetWindowMs: FAILURE_RESET_WINDOW_MS
+    });
+  }
+  if ((state3.consecutiveFailures ?? 0) >= MAX_CONSECUTIVE_FAILURES) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] 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_NAME13}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
+  }
+  log(`[${HOOK_NAME13}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
+  const resolvedAgentName = resolvedInfo?.agent;
+  if (resolvedAgentName && skipAgents.some((s) => getAgentConfigKey(s) === getAgentConfigKey(resolvedAgentName))) {
+    log(`[${HOOK_NAME13}] Skipped: agent in skipAgents list`, { sessionID, agent: resolvedAgentName });
+    return;
+  }
+  if (hasCompactionMessage && !resolvedInfo?.agent) {
+    log(`[${HOOK_NAME13}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
+    return;
+  }
+  if (isContinuationStopped?.(sessionID)) {
+    log(`[${HOOK_NAME13}] 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_NAME13}] 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_NAME13}] 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_NAME13}] Abort detected via session.error`, { sessionID, errorName: error51.name });
+      }
+      sessionStateStore.cancelCountdown(sessionID);
+      log(`[${HOOK_NAME13}] 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_NAME13}] Session marked as recovering`, { sessionID });
+  };
+  const markRecoveryComplete = (sessionID) => {
+    const state3 = sessionStateStore.getExistingState(sessionID);
+    if (state3) {
+      state3.isRecovering = false;
+      log(`[${HOOK_NAME13}] Session recovery complete`, { sessionID });
     }
   };
+  const handler = createTaskContinuationHandler({
+    ctx,
+    sessionStateStore,
+    backgroundManager,
+    skipAgents,
+    isContinuationStopped
+  });
+  const cancelAllCountdowns = () => {
+    sessionStateStore.cancelAllCountdowns();
+    log(`[${HOOK_NAME13}] 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_NAME14 = "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_NAME14}] 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_NAME15 = "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_NAME15}] 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_NAME15}] ${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_NAME15}] 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_NAME15}] 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 +66170,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 +66655,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_NAME16 = "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 +66679,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 +66705,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_NAME16}] 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_NAME16}] Skipped injection: background tasks running`, { sessionID });
     return;
   }
   let todos = [];
@@ -66201,12 +66734,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_NAME16}] 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_NAME16}] Skipped injection: no incomplete todos`, { sessionID });
     return;
   }
   let agentName = resolvedInfo?.agent;
@@ -66229,17 +66762,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_NAME16}] 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_NAME16}] 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 +66783,7 @@ ${todoList}`;
     injectionState.inFlight = true;
   }
   try {
-    log(`[${HOOK_NAME15}] Injecting continuation`, {
+    log(`[${HOOK_NAME16}] Injecting continuation`, {
       sessionID,
       agent: agentName,
       model,
@@ -66265,14 +66798,14 @@ ${todoList}`;
       },
       query: { directory: ctx.directory }
     });
-    log(`[${HOOK_NAME15}] Injection successful`, { sessionID });
+    log(`[${HOOK_NAME16}] 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_NAME16}] Injection failed`, { sessionID, error: String(error51) });
     if (injectionState) {
       injectionState.inFlight = false;
       injectionState.lastInjectedAt = Date.now();
@@ -66282,19 +66815,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,
@@ -66306,18 +66839,18 @@ function startCountdown(args) {
   } = args;
   const state3 = sessionStateStore.getState(sessionID);
   sessionStateStore.cancelCountdown(sessionID);
-  let secondsRemaining = COUNTDOWN_SECONDS;
-  showCountdownToast(ctx, secondsRemaining, incompleteCount);
+  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 +66858,34 @@ function startCountdown(args) {
       resolvedInfo,
       sessionStateStore
     });
-  }, COUNTDOWN_SECONDS * 1000);
-  log(`[${HOOK_NAME15}] Countdown started`, {
+  }, COUNTDOWN_SECONDS2 * 1000);
+  log(`[${HOOK_NAME16}] 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_NAME16}] session.idle`, { sessionID });
   const state3 = sessionStateStore.getState(sessionID);
   if (state3.isRecovering) {
-    log(`[${HOOK_NAME15}] Skipped: in recovery`, { sessionID });
+    log(`[${HOOK_NAME16}] 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_NAME16}] Skipped: abort detected via event ${timeSinceAbort}ms ago`, { sessionID });
       state3.abortDetectedAt = undefined;
       return;
     }
@@ -66360,7 +66893,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_NAME16}] Skipped: background tasks running`, { sessionID });
     return;
   }
   try {
@@ -66369,52 +66902,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_NAME16}] 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_NAME16}] 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_NAME16}] Todo fetch failed`, { sessionID, error: String(error51) });
     return;
   }
   if (!todos || todos.length === 0) {
-    log(`[${HOOK_NAME15}] No todos`, { sessionID });
+    log(`[${HOOK_NAME16}] No todos`, { sessionID });
     return;
   }
   const incompleteCount = getIncompleteCount(todos);
   if (incompleteCount === 0) {
-    log(`[${HOOK_NAME15}] All todos complete`, { sessionID, total: todos.length });
+    log(`[${HOOK_NAME16}] All todos complete`, { sessionID, total: todos.length });
     return;
   }
   if (state3.inFlight) {
-    log(`[${HOOK_NAME15}] Skipped: injection in flight`, { sessionID });
+    log(`[${HOOK_NAME16}] 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_NAME16}] 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_NAME16}] 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_NAME16}] Skipped: cooldown active`, {
       sessionID,
       effectiveCooldown,
       consecutiveFailures: state3.consecutiveFailures
@@ -66444,23 +66977,23 @@ async function handleSessionIdle(args) {
       }
     }
   } catch (error51) {
-    log(`[${HOOK_NAME15}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME16}] Failed to fetch messages for agent check`, { sessionID, error: String(error51) });
   }
-  log(`[${HOOK_NAME15}] Agent check`, { sessionID, agentName: resolvedInfo?.agent, skipAgents, hasCompactionMessage });
+  log(`[${HOOK_NAME16}] 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_NAME16}] 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_NAME16}] Skipped: compaction occurred but no agent info resolved`, { sessionID });
     return;
   }
   if (isContinuationStopped?.(sessionID)) {
-    log(`[${HOOK_NAME15}] Skipped: continuation stopped for session`, { sessionID });
+    log(`[${HOOK_NAME16}] Skipped: continuation stopped for session`, { sessionID });
     return;
   }
-  startCountdown({
+  startCountdown2({
     ctx,
     sessionID,
     incompleteCount,
@@ -66474,7 +67007,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 +67019,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_NAME16}] Ignoring user message in grace period`, { sessionID, elapsed });
           return;
         }
       }
@@ -66531,7 +67064,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_NAME16}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
     }
     return;
   }
@@ -66543,7 +67076,7 @@ function createTodoContinuationHandler(args) {
     ctx,
     sessionStateStore,
     backgroundManager,
-    skipAgents = DEFAULT_SKIP_AGENTS,
+    skipAgents = DEFAULT_SKIP_AGENTS2,
     isContinuationStopped
   } = args;
   return async ({ event }) => {
@@ -66556,17 +67089,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_NAME16}] Abort detected via session.error`, { sessionID, errorName: error51.name });
       }
       sessionStateStore.cancelCountdown(sessionID);
-      log(`[${HOOK_NAME15}] session.error`, { sessionID });
+      log(`[${HOOK_NAME16}] 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 +67109,7 @@ function createTodoContinuationHandler(args) {
       });
       return;
     }
-    handleNonIdleEvent({
+    handleNonIdleEvent2({
       eventType: event.type,
       properties: props,
       sessionStateStore
@@ -66585,20 +67118,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 +67199,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_NAME16}] 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_NAME16}] Session recovery complete`, { sessionID });
     }
   };
   const handler = createTodoContinuationHandler({
@@ -66692,7 +67225,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
   });
   const cancelAllCountdowns = () => {
     sessionStateStore.cancelAllCountdowns();
-    log(`[${HOOK_NAME15}] All countdowns cancelled`);
+    log(`[${HOOK_NAME16}] All countdowns cancelled`);
   };
   return {
     handler,
@@ -66701,38 +67234,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 +67449,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_NAME17 = "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 +67469,7 @@ async function resolveMainSessionTarget(ctx, sessionID) {
       }
     }
   } catch (error51) {
-    log(`[${HOOK_NAME16}] Failed to resolve main session agent`, { sessionID, error: String(error51) });
+    log(`[${HOOK_NAME17}] Failed to resolve main session agent`, { sessionID, error: String(error51) });
   }
   return { agent, model };
 }
@@ -67001,7 +67502,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_NAME17}] Failed to fetch thinking summary`, { sessionID, error: String(error51) });
     return null;
   }
 }
@@ -67020,7 +67521,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 +67551,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_NAME17}] Reminder injected`, { taskId: task.id, sessionID: mainSessionID });
       } catch (error51) {
-        log(`[${HOOK_NAME16}] Reminder injection failed`, { taskId: task.id, error: String(error51) });
+        log(`[${HOOK_NAME17}] Reminder injection failed`, { taskId: task.id, error: String(error51) });
       }
     }
   };
@@ -67203,7 +67704,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 +67719,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 +67782,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 +67799,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 +67831,7 @@ function createContinuationHooks(args) {
     compactionContextInjector,
     compactionTodoPreserver,
     todoContinuationEnforcer,
+    taskContinuationEnforcer,
     unstableAgentBabysitter,
     backgroundNotificationHook,
     architectHook,
@@ -67638,7 +68149,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 +68177,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 +68205,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 +68219,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 +69070,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 +69086,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 +81931,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 +81969,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 +81991,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 +82000,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 +82054,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 +82066,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 +82226,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 +84329,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 +84497,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 +84528,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 +84549,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 +84570,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 +84615,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 +84675,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 +84687,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 +84750,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 +84972,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 +85127,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 +85170,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 +85325,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 +85350,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 +85447,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 +85544,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 +85552,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 +85576,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 +85727,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 +85779,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 +85855,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 +85882,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 +85921,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 +85991,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 +86015,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 +86025,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 +86056,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 +86076,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 +86587,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 +86624,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 +87796,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 +87970,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 +88380,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 +91852,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 +91988,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 +92010,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 +92046,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 +92056,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 +92078,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 +92088,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 +92139,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 +92166,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 +92211,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 +92343,13 @@ 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 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 +92364,13 @@ function createToolGuardHooks(args) {
     envFileWriteGuard,
     jsonErrorRecovery,
     bashFileReadGuard,
-    todoDescriptionOverride,
     readImageResizer,
     webfetchRedirectGuard,
     hashlineEditDiffEnhancer,
     qualityGate,
     taskNotepad,
-    evolutionWatcher,
-    taskTodoMirror
+    taskEditGuard,
+    evolutionWatcher
   };
 }
 
@@ -92205,19 +92824,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 +92870,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 +95314,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.
 
@@ -95823,8 +96448,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 +96458,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 +98182,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 +101215,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 +101335,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 +101451,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 +101470,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 +101517,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 +101614,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 +101895,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 +102201,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 +102212,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 +102228,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 +102237,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 +102246,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 +102255,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 +102439,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) } : {};
@@ -102182,7 +102811,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 +102825,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 +102873,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 +102880,14 @@ 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",
+  "task-edit-guard"
 ]);
 // src/config/schema/matrix-loop.ts
 var MatrixLoopConfigSchema = exports_external.object({
@@ -102276,7 +102905,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()
@@ -102637,7 +103267,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 +103416,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 +103567,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 +103590,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 +103627,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 +103638,22 @@ function createToolExecuteAfterHandler2(args) {
 
 // src/features/assembly-state/manager.ts
 init_logger();
-var HOOK_NAME17 = "assembly-state";
+var HOOK_NAME18 = "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_NAME18}] Assembly disabled for session`, { sessionID });
   disabledSessions.add(sessionID);
-  log(`[${HOOK_NAME17}] Consensus disabled for session`, { sessionID });
+  log(`[${HOOK_NAME18}] Consensus disabled for session`, { sessionID });
 }
 function enableAssembly(sessionID) {
   disabledSessions.delete(sessionID);
-  log(`[${HOOK_NAME17}] Assembly enabled for session`, { sessionID });
+  log(`[${HOOK_NAME18}] Assembly enabled for session`, { sessionID });
   disabledSessions.delete(sessionID);
-  log(`[${HOOK_NAME17}] Consensus enabled for session`, { sessionID });
+  log(`[${HOOK_NAME18}] Consensus enabled for session`, { sessionID });
 }
 // src/plugin/session-agent-resolver.ts
 async function resolveSessionAgent(client2, sessionId, timeoutMs = 5000) {