opencode-matrixx 2.6.4 → 2.6.6

package/dist/index.js

@@ -29560,7 +29560,7 @@ var init_ulw_research = __esm(() => {
       "look_at",
       "delegate_agent",
       "websearch_web_search_exa",
-      "grep_app_searchGitHub",
+      "white_rabbit_searchGitHub",
       "context7_resolve-library-id",
       "context7_query-docs"
     ],
@@ -29671,7 +29671,7 @@ task(
   prompt="""
 Search open source repositories for implementations related to: <CURRENT_LEAD>
 
-Use grep_app_searchGitHub to find real-world code patterns.
+Use white_rabbit_searchGitHub to find real-world code patterns.
 Focus on:
 - Production implementations in similar projects
 - Reference implementations or canonical examples
@@ -44410,31 +44410,16 @@ var ModelFallbackEntrySchema = exports_external.object({
   model: exports_external.string().min(1),
   variant: exports_external.string().optional()
 });
-var TierSpecSchema = exports_external.object({
-  providerPriority: exports_external.array(exports_external.string()),
-  modelPattern: exports_external.string().refine((s) => {
-    try {
-      new RegExp(s);
-      return true;
-    } catch {
-      return false;
-    }
-  }, { message: "Invalid regex pattern" }),
-  fallbackTier: exports_external.string().optional(),
-  fallback: exports_external.array(ModelFallbackEntrySchema).optional()
-});
-var TiersSchema = exports_external.record(exports_external.string(), TierSpecSchema);
 var complexityDowngradeValueSchema = exports_external.string().refine((s) => {
-  if (s.startsWith("tier:")) {
-    const name = s.slice(5);
-    return name.length > 0;
-  }
-  if (s.includes("/")) {
-    const parts = s.split("/");
-    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
-  }
-  return false;
-}, { message: "Must be tier:<name> or <provider>/<model>" });
+  if (!s.includes("/"))
+    return false;
+  if (s.startsWith("/") || s.endsWith("/"))
+    return false;
+  if (s.includes("//"))
+    return false;
+  const parts = s.split("/");
+  return parts.length >= 2 && parts.every((p) => p.length > 0);
+}, { message: "Must be <provider>/<model>" });
 var ComplexityDowngradesSchema = exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), complexityDowngradeValueSchema));
 var AgentModelRequirementsSchema = exports_external.object({
   fallbackChain: exports_external.array(ModelFallbackEntrySchema),
@@ -44861,6 +44846,12 @@ async function resolveCommandsInText(text, depth = 0, maxDepth = 3) {
   return resolved;
 }
 // src/shared/config-errors.ts
+class ConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}
 var configLoadErrors = [];
 function getConfigLoadErrors() {
   return configLoadErrors;
@@ -48112,7 +48103,7 @@ var TARGET_TOOLS = new Set([
   "context7_query-docs",
   "websearch_web_search_exa",
   "context7_get-library-docs",
-  "grep_app_searchgithub"
+  "white_rabbit_searchgithub"
 ]);
 var AGENT_TOOLS = new Set([
   "task",
@@ -48425,8 +48416,11 @@ function getPlanProgress(planPath) {
     const content = readFileSync10(planPath, "utf-8");
     const uncheckedMatches = content.match(/^[-*]\s*\[\s*\]/gm) || [];
     const checkedMatches = content.match(/^[-*]\s*\[[xX]\]/gm) || [];
-    const total = uncheckedMatches.length + checkedMatches.length;
-    const completed = checkedMatches.length;
+    const numberedUnchecked = content.match(/^[-*]\s*\[\s*\]\s*\d+\./gm) || [];
+    const numberedChecked = content.match(/^[-*]\s*\[[xX]\]\s*\d+\./gm) || [];
+    const useNumbered = numberedUnchecked.length + numberedChecked.length > 0;
+    const total = useNumbered ? numberedUnchecked.length + numberedChecked.length : uncheckedMatches.length + checkedMatches.length;
+    const completed = useNumbered ? numberedChecked.length : checkedMatches.length;
     return {
       total,
       completed,
@@ -48498,10 +48492,14 @@ function registerSubagentSession(sessionID, parentSessionID) {
   subagentSessions.add(sessionID);
   subagentParentMap.set(sessionID, parentSessionID);
 }
+function unregisterSubagentSession(sessionID) {
+  subagentSessions.delete(sessionID);
+  subagentParentMap.delete(sessionID);
+}
 function getSubagentSessionIDs(parentSessionID) {
   const ids = [];
-  for (const [subID, parentID] of subagentParentMap) {
-    if (parentID === parentSessionID)
+  for (const subID of subagentSessions) {
+    if (subagentParentMap.get(subID) === parentSessionID)
       ids.push(subID);
   }
   return ids;
@@ -50255,79 +50253,49 @@ This prevents it from being picked up again.
 - DO begin working immediately if the user included a task with /pickup
 `;
 
-// src/features/builtin-commands/templates/profile.ts
-var PROFILE_TEMPLATE = `# /profile Command
+// src/features/builtin-commands/templates/preset.ts
+var PRESET_TEMPLATE = `You are managing the active model preset.
+
+This command is provided by the Matrixx plugin. It uses the built-in \`preset\` tool to list, show, or switch model presets \u2014 no external scripts or direct config edits needed.
 
 ## Usage
 
 \`\`\`
-/profile                  \u2192 List available profiles and show current
-/profile list            \u2192 List available profiles
-/profile show            \u2192 Show currently active profile
-/profile set <name>      \u2192 Change profile (edits project config, instructs to start new session)
-/profile set <name> --global  \u2192 Change profile globally (~/.config/opencode/matrixx.jsonc)
-/profile set <name> --project \u2192 Change profile project-scoped (.opencode/matrixx.jsonc)
+/preset                  \u2192 List available presets and mark the active one
+/preset list             \u2192 List available presets
+/preset show [<name>]    \u2192 Show a preset's agent/category model assignments (defaults to active)
+/preset set <name>       \u2192 Switch the active preset for the current session (live)
+/preset set <name> --save [--global|--project] \u2192 Also persist active_preset to config
 \`\`\`
 
-## Available Profiles
-
-| Profile | Description | Key Characteristic |
-|---------|-------------|-------------------|
-| free | Zero-cost, uses only free/open models | Kimi K2.5 Free, Grok (free), GLM |
-| budget | Cost-optimized for tight budgets | Sonnet/Haiku mix, no Opus |
-| economy | Balanced cost and capability | Primarily Sonnet/Haiku |
-| balanced | Default \u2014 best overall value | Opus/Sonnet/Haiku tiered |
-| performance | Maximum quality, no compromises | Opus for all heavy agents |
-| go | Premium OpenCode Go subscription | Kimi K2.6, DeepSeek V4 Pro, GLM 5.1 |
-
-## How It Works
-
-Each profile sets the \`model\` field on every agent and category in Matrixx's configuration. When you switch profiles, the agent models are swapped accordingly.
-
-The profile name is stored in your \`matrixx.json\` or \`matrixx.jsonc\` config file. On the next session, Matrixx reads it and applies the profile's model mapping, merging it with any explicit per-agent overrides you may have set.
-
-## Task: Change the Profile
-
-Follow these steps:
-
-### Step 1: Know the Current Config Location
-
-Matrixx reads config from two locations (user config wins over project config):
-- **Project**: \`.opencode/matrixx.json\` or \`.opencode/matrixx.jsonc\`
-- **Global**: \`~/.config/opencode/matrixx.json\` or \`~/.config/opencode/matrixx.jsonc\`
-
-### Step 2: Determine Which Config File to Edit
+## Step 1: Determine the action
 
-- \`--global\` \u2192 Edit \`~/.config/opencode/matrixx.jsonc\`
-- \`--project\` (default) \u2192 Edit \`.opencode/matrixx.jsonc\`
-- If no flag and neither file exists, use \`--project\`
+Parse the arguments passed to this command:
 
-### Step 3: Read the Target Config File
+- No arguments or \`list\` \u2192 call \`preset\` with \`action: "list"\`.
+- \`show\` \u2192 call \`preset\` with \`action: "show"\` (optionally \`name\`).
+- \`set <name>\` \u2192 call \`preset\` with \`action: "set"\`, \`name: "<name>"\`.
+- \`set <name> --save\` \u2192 also pass \`save: true\`; \`--global\` \u2192 \`scope: "global"\`, \`--project\` (default) \u2192 \`scope: "project"\`.
 
-Use the \`read\` tool to read the config file.
+## Step 2: Call the built-in \`preset\` tool
 
-### Step 4: Validate the Requested Profile
+Use the \`preset\` tool with the resolved arguments. The tool validates the preset name, applies the session overlay (delegate-task categories switch immediately), and \u2014 with \`--save\` \u2014 persists \`active_preset\` to the project (\`.opencode/matrixx.jsonc\`) or global (\`~/.config/opencode/matrixx.jsonc\`) config.
 
-If the user asked for \`/profile set <name>\`, verify \`<name>\` is in the table above. If not, report the valid profiles and stop.
+The tool handles all validation and file operations \u2014 do NOT edit config files directly.
 
-### Step 5: Update the \`profile\` Key
+## Step 3: Confirm and instruct
 
-Set \`"profile": "<name>"\` in the config JSON. If the \`profile\` key already exists, update it. If it doesn't exist, add it at the top level. Do NOT modify any other keys.
-
-### Step 6: Write the Config File Back
-
-Use the \`write\` tool (or \`edit\` tool for minimal changes) to save the updated config.
-
-### Step 7: Confirm and Advise
+After a successful switch:
 
-Tell the user:
-1. The profile has been changed to \`<name>\`
-2. For the change to take effect, they MUST start a new session (\`/new\` or restart OpenCode)
-3. If they want session-level switching without restarting, suggest using the profile with \`--global\` or \`--project\` as appropriate
+1. Report the tool's output to the user.
+2. Note that delegate-task categories use the new preset immediately (session-scoped live switch).
+3. If \`--save\` was used, tell the user the persisted \`active_preset\` takes effect for builtin agents on the next session.
 
-### Step 8: If \`/profile\` Was Called Without Arguments
+## Important constraints
 
-Just list the available profiles and show the current configuration's profile value.`;
+- Use the built-in \`preset\` tool. Do NOT bypass it by editing config files directly.
+- Do not invent preset names \u2014 if the requested name is unknown, report the available presets and stop.
+- \`--save\` without a scope defaults to project scope.`;
 
 // src/features/builtin-commands/templates/refactor.ts
 var REFACTOR_TEMPLATE = `# Intelligent Refactor Command
@@ -51596,16 +51564,16 @@ ${REMOVE_DEADCODE_TEMPLATE}
 </command-instruction>`,
     argumentHint: "[target-path] [--scope=<file|module|project>] [--dry-run]"
   },
-  profile: {
-    description: '(builtin) View recommended tier configurations (replaces the v2.x profile system; use `tier: "..."` in matrixx.jsonc instead)',
+  preset: {
+    description: "(builtin) Switch the active model preset (session-scoped live switch; --save persists to config)",
     template: `<command-instruction>
-${PROFILE_TEMPLATE}
+${PRESET_TEMPLATE}
 </command-instruction>
 
 <user-request>
 $ARGUMENTS
 </user-request>`,
-    argumentHint: "[list|show|set <name> [--global|--project]]"
+    argumentHint: "[list|show|set <name> [--save [--global|--project]]]"
   },
   "end-ultrawork": {
     description: "(builtin) Deactivate ultrawork mode and return to default Matrixx behavior for the current session",
@@ -52670,6 +52638,16 @@ function createBackgroundNotificationHook(manager) {
     event: eventHandler
   };
 }
+// src/hooks/background-task-blocker/hook.ts
+function createBackgroundTaskBlockerHook() {
+  return {
+    "tool.execute.before": async (input, _output) => {
+      if (input.tool === "background_task") {
+        throw new Error('Tool "background_task" is disabled. Use the "task" tool with category/subagent_type and run_in_background=true for agent delegation.');
+      }
+    }
+  };
+}
 // src/hooks/bash-file-read-guard.ts
 var WARNING_MESSAGE = "Prefer the Read tool over `cat`/`head`/`tail` for reading file contents. " + "The Read tool provides line numbers and hash anchors for precise editing.";
 var FILE_READ_PATTERNS = [
@@ -59099,7 +59077,7 @@ var JSON_ERROR_TOOL_EXCLUDE_LIST = [
   "grep",
   "webfetch",
   "look_at",
-  "grep_app_searchgithub",
+  "white_rabbit_searchgithub",
   "websearch_web_search_exa"
 ];
 var JSON_ERROR_PATTERNS = [
@@ -60125,16 +60103,38 @@ init_logger();
 import { randomUUID } from "crypto";
 import { existsSync as existsSync36, mkdirSync as mkdirSync14, readdirSync as readdirSync11, readFileSync as readFileSync30, renameSync as renameSync3, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
 import { basename as basename5, dirname as dirname10, isAbsolute as isAbsolute3, join as join44 } from "path";
+
+// src/shared/task-system-gating.ts
+var TASK_SYSTEM_DEFAULT = true;
+function resolveTasksConfig(config2) {
+  const canonical = config2?.tasks;
+  const legacyTasks = config2?.morpheus?.tasks;
+  const legacyPoll = config2?.task?.pollTimeoutMs;
+  return {
+    enabled: canonical?.enabled ?? config2?.experimental?.task_system ?? config2?.new_task_system_enabled ?? TASK_SYSTEM_DEFAULT,
+    scope: canonical?.scope ?? legacyTasks?.scope ?? "project",
+    storage_path: canonical?.storage_path ?? legacyTasks?.storage_path,
+    task_list_id: canonical?.task_list_id ?? legacyTasks?.task_list_id,
+    stale_after_hours: canonical?.stale_after_hours ?? legacyTasks?.stale_after_hours,
+    session_scoped: canonical?.session_scoped ?? legacyTasks?.session_scoped ?? true,
+    pollTimeoutMs: canonical?.pollTimeoutMs ?? legacyPoll
+  };
+}
+function isTaskSystemEnabled(config2) {
+  return resolveTasksConfig(config2).enabled;
+}
+
+// src/features/task-storage/storage.ts
 function getProjectTaskDir(directory) {
   return join44(directory, ".matrixx", "tasks");
 }
 function getTaskDir(config2 = {}, directory) {
-  const tasksConfig = config2.morpheus?.tasks;
-  const storagePath = tasksConfig?.storage_path;
+  const tasksConfig = resolveTasksConfig(config2);
+  const storagePath = tasksConfig.storage_path;
   if (storagePath) {
     return isAbsolute3(storagePath) ? storagePath : join44(directory ?? process.cwd(), storagePath);
   }
-  if (tasksConfig?.scope === "global" || !directory) {
+  if (tasksConfig.scope === "global" || !directory) {
     const configDir = getOpenCodeConfigDir({ binary: "opencode" });
     const listId = resolveTaskListId(config2);
     return join44(configDir, "tasks", listId);
@@ -60148,7 +60148,7 @@ function resolveTaskListId(config2 = {}) {
   const envId = process.env.ULTRAWORK_TASK_LIST_ID?.trim();
   if (envId)
     return sanitizePathSegment(envId);
-  const configId = config2.morpheus?.tasks?.task_list_id?.trim();
+  const configId = resolveTasksConfig(config2).task_list_id?.trim();
   if (configId)
     return sanitizePathSegment(configId);
   return sanitizePathSegment(basename5(process.cwd()));
@@ -60369,6 +60369,7 @@ async function getGitHead(directory) {
 
 // src/tools/task/constants.ts
 var TASK_ID_PATTERN = /^T-[A-Za-z0-9]+(-[A-Za-z0-9]+)*$/;
+var DEDUP_WINDOW_MS = 10 * 60 * 1000;
 
 // src/tools/task/types.ts
 var TaskStatusSchema = exports_external.enum(["pending", "in_progress", "completed", "deleted"]);
@@ -64921,7 +64922,7 @@ init_logger();
 
 // src/hooks/task-continuation-enforcer/idle-event.ts
 import { existsSync as existsSync43, readdirSync as readdirSync15 } from "fs";
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 init_logger();
 
 // src/hooks/task-continuation-enforcer/abort-detection.ts
@@ -64945,14 +64946,15 @@ init_logger();
 
 // src/hooks/task-continuation-enforcer/continuation-injection.ts
 import { existsSync as existsSync42, readdirSync as readdirSync14 } from "fs";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 init_logger();
 // src/hooks/task-continuation-enforcer/staleness.ts
 import { statSync as statSync8 } from "fs";
+import { join as join50 } from "path";
 var DEFAULT_STALE_AFTER_HOURS = 24;
 var HOUR_MS = 60 * 60 * 1000;
 function getStaleAfterMs(config2) {
-  const hours = config2?.morpheus?.tasks?.stale_after_hours ?? DEFAULT_STALE_AFTER_HOURS;
+  const hours = resolveTasksConfig(config2).stale_after_hours ?? DEFAULT_STALE_AFTER_HOURS;
   return hours * HOUR_MS;
 }
 function getTaskAgeMs(taskPath) {
@@ -64967,6 +64969,9 @@ function isTaskStale(taskPath, staleAfterMs) {
   const ageMs = getTaskAgeMs(taskPath);
   return ageMs !== null && ageMs > staleAfterMs;
 }
+function filterFreshIncompleteTasks(tasks, taskDir, staleAfterMs) {
+  return tasks.filter((t) => !isTaskStale(join50(taskDir, `${t.id}.json`), staleAfterMs));
+}
 function formatTaskAge(ageMs) {
   const hours = Math.floor(ageMs / HOUR_MS);
   if (hours >= 24) {
@@ -64987,6 +64992,17 @@ function getIncompleteTasks(tasks) {
     return task.blockedBy.every((bid) => byId.get(bid)?.status === "completed");
   });
 }
+function dropSubtasksWithResolvedParent(tasks) {
+  const byId = new Map(tasks.map((t) => [t.id, t]));
+  return tasks.filter((task) => {
+    if (!task.parentID)
+      return true;
+    const parent = byId.get(task.parentID);
+    if (!parent)
+      return true;
+    return parent.status !== "completed" && parent.status !== "deleted";
+  });
+}
 function filterTasksBySession(tasks, options) {
   if (options.sessionScoped === false)
     return tasks;
@@ -65059,10 +65075,10 @@ async function injectContinuation(args) {
         if (parsed)
           tasks.push(parsed);
       }
-      filteredTasks = filterTasksBySession(tasks, {
+      filteredTasks = filterTasksBySession(dropSubtasksWithResolvedParent(tasks), {
         sessionID,
         subagentIDs: getSubagentSessionIDs(sessionID),
-        sessionScoped: config2?.morpheus?.tasks?.session_scoped !== false
+        sessionScoped: resolveTasksConfig(config2).session_scoped
       });
       total = filteredTasks.length;
       if (total === 0) {
@@ -65085,9 +65101,10 @@ async function injectContinuation(args) {
     isBootstrap = true;
     stateForBootstrap._bootstrap = undefined;
   }
-  const freshIncompleteCount = isBootstrap ? 1 : getIncompleteTasks(filteredTasks).length;
+  const staleAfterMs = getStaleAfterMs(config2);
+  const freshIncompleteCount = isBootstrap ? 1 : filterFreshIncompleteTasks(getIncompleteTasks(filteredTasks), taskDir, staleAfterMs).length;
   if (!isBootstrap && freshIncompleteCount === 0) {
-    log(`[${HOOK_NAME14}] Skipped injection: no incomplete tasks`, { sessionID, total });
+    log(`[${HOOK_NAME14}] Skipped injection: only stale tasks remain`, { sessionID, total });
     return;
   }
   let agentName = resolvedInfo?.agent;
@@ -65122,14 +65139,14 @@ async function injectContinuation(args) {
     prompt = BOOTSTRAP_PROMPT;
   } else {
     const incompleteTasks = getIncompleteTasks(filteredTasks);
-    const staleAfterMs = getStaleAfterMs(config2);
+    const freshIncompleteTasks = filterFreshIncompleteTasks(incompleteTasks, taskDir, staleAfterMs);
     const taskList = incompleteTasks.map((task) => {
-      const ageMs = getTaskAgeMs(join50(taskDir, `${task.id}.json`));
+      const ageMs = getTaskAgeMs(join51(taskDir, `${task.id}.json`));
       const staleSuffix = ageMs !== null && ageMs > staleAfterMs ? ` (stale: ${formatTaskAge(ageMs)})` : "";
       return `- [${task.status}] ${task.subject} (${task.id})${staleSuffix}`;
     }).join(`
 `);
-    const staleCount = incompleteTasks.filter((t) => isTaskStale(join50(taskDir, `${t.id}.json`), staleAfterMs)).length;
+    const staleCount = incompleteTasks.length - freshIncompleteTasks.length;
     const staleNote = staleCount > 0 ? `
 
 Note: ${staleCount} remaining task(s) have had no activity for >${Math.round(staleAfterMs / 3600000)}h and may be orphaned. Mark them completed/deleted if superseded.` : "";
@@ -65322,10 +65339,10 @@ async function handleSessionIdle(args) {
         if (parsed)
           tasks.push(parsed);
       }
-      const filteredTasks = filterTasksBySession(tasks, {
+      const filteredTasks = filterTasksBySession(dropSubtasksWithResolvedParent(tasks), {
         sessionID,
         subagentIDs: getSubagentSessionIDs(sessionID),
-        sessionScoped: config2?.morpheus?.tasks?.session_scoped !== false
+        sessionScoped: resolveTasksConfig(config2).session_scoped
       });
       total = filteredTasks.length;
       if (total === 0) {
@@ -65342,7 +65359,7 @@ async function handleSessionIdle(args) {
         const incompleteTasks = getIncompleteTasks(filteredTasks);
         incompleteCount = incompleteTasks.length;
         const staleAfterMs = getStaleAfterMs(config2);
-        const staleIncompleteCount = incompleteTasks.filter((t) => isTaskStale(join51(taskDir, `${t.id}.json`), staleAfterMs)).length;
+        const staleIncompleteCount = incompleteTasks.filter((t) => isTaskStale(join52(taskDir, `${t.id}.json`), staleAfterMs)).length;
         const activeIncompleteCount = incompleteCount - staleIncompleteCount;
         if (activeIncompleteCount === 0 && staleIncompleteCount > 0) {
           log(`[${HOOK_NAME14}] Skipped: only stale tasks remain`, {
@@ -65790,7 +65807,7 @@ var TODO_FETCH_ERROR_FRAGMENT = "Failed to fetch todos for task-notepad";
 // src/hooks/task-notepad/hook.ts
 init_logger();
 import { existsSync as existsSync44, mkdirSync as mkdirSync16, readdirSync as readdirSync16, readFileSync as readFileSync33, statSync as statSync9, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname13, join as join52 } from "path";
+import { dirname as dirname13, join as join53 } from "path";
 function createTaskNotepadHook(ctx) {
   return {
     "tool.execute.after": async (input, output) => {
@@ -65841,7 +65858,7 @@ async function fetchTodos(ctx, sessionID) {
   }
 }
 function resolveActivePlan(directory) {
-  const plansDir = join52(directory, PLAN_DIR_NAME, PLANS_SUBDIR);
+  const plansDir = join53(directory, PLAN_DIR_NAME, PLANS_SUBDIR);
   if (!existsSync44(plansDir))
     return null;
   let entries;
@@ -65854,7 +65871,7 @@ function resolveActivePlan(directory) {
   for (const entry of entries) {
     if (!entry.endsWith(PLAN_EXTENSION))
       continue;
-    const fullPath = join52(plansDir, entry);
+    const fullPath = join53(plansDir, entry);
     try {
       const stats = statSync9(fullPath);
       if (!stats.isFile())
@@ -65897,7 +65914,7 @@ function appendCompletion(directory, planName, todo) {
   log(`[${HOOK_NAME16}] Appended completion to notepad`, { plan: planName, taskID: todo.id });
 }
 function notepadPathFor(directory, planName, taskID) {
-  return join52(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
+  return join53(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
 }
 function renderNotepad(todo) {
   const priority = todo.priority ?? "medium";
@@ -65963,15 +65980,9 @@ to continue: task(session_id="${sessionId}", prompt="...")`;
     "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.
+var REPLACEMENT_MESSAGE = `TodoRead/TodoWrite are DISABLED because tasks.enabled is true.
 
 **ACTION REQUIRED**: RE-REGISTER what you were about to write as Todo using Task tools NOW. Then ASSIGN yourself and START WORKING immediately.
 
@@ -67579,7 +67590,7 @@ function createWebFetchRedirectGuardHook(_ctx) {
 }
 // src/hooks/write-existing-file-guard/hook.ts
 import { existsSync as existsSync45 } from "fs";
-import { isAbsolute as isAbsolute4, join as join53, normalize, resolve as resolve6, sep } from "path";
+import { isAbsolute as isAbsolute4, join as join54, normalize, resolve as resolve6, sep } from "path";
 function createWriteExistingFileGuardHook(ctx) {
   return {
     "tool.execute.before": async (input, output) => {
@@ -67594,7 +67605,7 @@ function createWriteExistingFileGuardHook(ctx) {
       }
       const resolvedPath = normalize(isAbsolute4(filePath) ? filePath : resolve6(ctx.directory, filePath));
       if (existsSync45(resolvedPath)) {
-        const matrixxRoot = join53(ctx.directory, ".matrixx") + sep;
+        const matrixxRoot = join54(ctx.directory, ".matrixx") + sep;
         const isMatrixMarkdown = resolvedPath.startsWith(matrixxRoot) && resolvedPath.endsWith(".md");
         const normalizedPath = resolvedPath.replace(/\\/g, "/");
         const isPlansPath = normalizedPath.includes(".matrixx/plans");
@@ -68040,7 +68051,7 @@ function getLanguageId(ext) {
 }
 // src/tools/lsp/server-installation.ts
 import { existsSync as existsSync46 } from "fs";
-import { join as join54 } from "path";
+import { join as join55 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
@@ -68068,23 +68079,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync46(join54(p, cmd + suffix))) {
+      if (existsSync46(join55(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join54(getDataDir(), "opencode");
+  const dataDir = join55(getDataDir(), "opencode");
   const additionalBases = [
-    join54(cwd, "node_modules", ".bin"),
-    join54(configDir, "bin"),
-    join54(configDir, "node_modules", ".bin"),
-    join54(dataDir, "bin")
+    join55(cwd, "node_modules", ".bin"),
+    join55(configDir, "bin"),
+    join55(configDir, "node_modules", ".bin"),
+    join55(dataDir, "bin")
   ];
   for (const base of additionalBases) {
     for (const suffix of exts) {
-      if (existsSync46(join54(base, cmd + suffix))) {
+      if (existsSync46(join55(base, cmd + suffix))) {
         return true;
       }
     }
@@ -68096,7 +68107,7 @@ function isServerInstalled(command) {
 }
 // src/tools/lsp/server-config-loader.ts
 import { existsSync as existsSync47, readFileSync as readFileSync34 } from "fs";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 function loadJsonFile(path12) {
   if (!existsSync47(path12))
     return null;
@@ -68110,9 +68121,9 @@ function getConfigPaths3() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectConfigFile(join55(cwd, ".opencode", "matrixx")).path,
-    user: detectConfigFile(join55(configDir, "matrixx")).path,
-    opencode: detectConfigFile(join55(configDir, "opencode")).path
+    project: detectConfigFile(join56(cwd, ".opencode", "matrixx")).path,
+    user: detectConfigFile(join56(configDir, "matrixx")).path,
+    opencode: detectConfigFile(join56(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -68961,7 +68972,7 @@ class LSPServerManager {
 var lspManager = LSPServerManager.getInstance();
 // src/tools/lsp/lsp-client-wrapper.ts
 import { existsSync as existsSync49, statSync as statSync11 } from "fs";
-import { dirname as dirname14, extname as extname3, join as join56, resolve as resolve8 } from "path";
+import { dirname as dirname14, extname as extname3, join as join57, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function findWorkspaceRoot(filePath) {
   let dir = resolve8(filePath);
@@ -68977,7 +68988,7 @@ function findWorkspaceRoot(filePath) {
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync49(join56(dir, marker))) {
+      if (existsSync49(join57(dir, marker))) {
         return dir;
       }
     }
@@ -81829,13 +81840,13 @@ var DEFAULT_MAX_MATCHES = 500;
 // src/tools/ast-grep/sg-cli-path.ts
 import { existsSync as existsSync51, statSync as statSync12 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname15, join as join58 } from "path";
+import { dirname as dirname15, join as join59 } from "path";
 
 // src/tools/ast-grep/downloader.ts
 import { existsSync as existsSync50 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import { homedir as homedir8 } from "os";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 init_logger();
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -81860,12 +81871,12 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join57(homedir8(), "AppData", "Local");
-    return join57(base2, "matrixx", "bin");
+    const base2 = localAppData || join58(homedir8(), "AppData", "Local");
+    return join58(base2, "matrixx", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join57(homedir8(), ".cache");
-  return join57(base, "matrixx", "bin");
+  const base = xdgCache || join58(homedir8(), ".cache");
+  return join58(base, "matrixx", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
@@ -81882,7 +81893,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join57(cacheDir, binaryName);
+  const binaryPath = join58(cacheDir, binaryName);
   if (existsSync50(binaryPath)) {
     return binaryPath;
   }
@@ -81891,7 +81902,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 = join57(cacheDir, assetName);
+    const archivePath = join58(cacheDir, assetName);
     ensureCacheDir(cacheDir);
     await downloadArchive(downloadUrl, archivePath);
     await extractZipArchive(archivePath, cacheDir);
@@ -81945,7 +81956,7 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDirectory = dirname15(cliPackageJsonPath);
-    const sgPath = join58(cliDirectory, binaryName);
+    const sgPath = join59(cliDirectory, binaryName);
     if (existsSync51(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
@@ -81957,7 +81968,7 @@ function findSgCliPathSync() {
       const packageJsonPath = require2.resolve(`${platformPackage}/package.json`);
       const packageDirectory = dirname15(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join58(packageDirectory, astGrepBinaryName);
+      const binaryPath = join59(packageDirectory, astGrepBinaryName);
       if (existsSync51(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
@@ -84388,17 +84399,17 @@ var {spawn: spawn10 } = globalThis.Bun;
 // src/tools/grep/constants.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync58 } from "fs";
-import { dirname as dirname16, join as join60 } from "path";
+import { dirname as dirname16, join as join61 } from "path";
 
 // src/tools/grep/downloader.ts
 import { existsSync as existsSync57, readdirSync as readdirSync18 } from "fs";
-import { join as join59 } from "path";
+import { join as join60 } from "path";
 function findFileRecursive(dir, filename) {
   try {
     const entries = readdirSync18(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join59(entry.parentPath ?? dir, entry.name);
+        return join60(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -84419,11 +84430,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join59(homeDir, ".cache", "matrixx", "bin");
+  return join60(homeDir, ".cache", "matrixx", "bin");
 }
 function getRgPath() {
   const isWindows = process.platform === "win32";
-  return join59(getInstallDir(), isWindows ? "rg.exe" : "rg");
+  return join60(getInstallDir(), isWindows ? "rg.exe" : "rg");
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -84440,7 +84451,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join59(destDir, binaryName);
+    const destPath = join60(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync4 } = await import("fs");
       renameSync4(foundPath, destPath);
@@ -84461,7 +84472,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 = join59(installDir, filename);
+  const archivePath = join60(installDir, filename);
   try {
     await downloadArchive(url3, archivePath);
     if (config4.extension === "tar.gz") {
@@ -84506,11 +84517,11 @@ function getOpenCodeBundledRg() {
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join60(getDataDir(), "opencode", "bin", rgName),
-    join60(execDir, rgName),
-    join60(execDir, "bin", rgName),
-    join60(execDir, "..", "bin", rgName),
-    join60(execDir, "..", "libexec", rgName)
+    join61(getDataDir(), "opencode", "bin", rgName),
+    join61(execDir, rgName),
+    join61(execDir, "bin", rgName),
+    join61(execDir, "..", "bin", rgName),
+    join61(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
     if (existsSync58(candidate)) {
@@ -85018,12 +85029,12 @@ var HandoffSchema = exports_external.object({
 });
 // src/features/handoff/storage.ts
 import { existsSync as existsSync59, mkdirSync as mkdirSync17, readFileSync as readFileSync39, renameSync as renameSync4, writeFileSync as writeFileSync22 } from "fs";
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 function getHandoffFilePath(directory) {
-  return join61(directory, HANDOFF_FILE_PATH);
+  return join62(directory, HANDOFF_FILE_PATH);
 }
 function getHandoffConsumedFilePath(directory) {
-  return join61(directory, HANDOFF_CONSUMED_FILE_PATH);
+  return join62(directory, HANDOFF_CONSUMED_FILE_PATH);
 }
 function handoffFileExists(directory) {
   try {
@@ -85061,7 +85072,7 @@ function writeHandoffFile(directory, content) {
 }
 function ensureHandoffDir(directory) {
   try {
-    mkdirSync17(join61(directory, ".matrixx"), { recursive: true });
+    mkdirSync17(join62(directory, ".matrixx"), { recursive: true });
     return true;
   } catch {
     return false;
@@ -85217,13 +85228,13 @@ ${body}
 
 // src/tools/handoff/list-handler.ts
 import { existsSync as existsSync60, readdirSync as readdirSync19, statSync as statSync14 } from "fs";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 var MATRIX_DIR = ".matrixx";
 function isHandoffFile(name) {
   return name === "handoff.md" || name.startsWith("handoff.consumed");
 }
 function handleList(directory) {
-  const matrixxDir = join62(directory, MATRIX_DIR);
+  const matrixxDir = join63(directory, MATRIX_DIR);
   if (!existsSync60(matrixxDir)) {
     return "No handoffs found in .matrixx/";
   }
@@ -85241,7 +85252,7 @@ function handleList(directory) {
   lines.push(`Handoff files in ${matrixxDir}:`);
   lines.push("");
   for (const name of handoffs) {
-    const fullPath = join62(matrixxDir, name);
+    const fullPath = join63(matrixxDir, name);
     let size = "?";
     let mtime = "?";
     try {
@@ -85467,7 +85478,7 @@ The Bash tool can execute these commands directly. Do NOT retry with interactive
 // src/tools/pdf-extract-figures/tools.ts
 import { existsSync as existsSync61, mkdtempSync, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join63 } from "path";
+import { join as join64 } from "path";
 var PYTHON_SCRIPT = `#!/usr/bin/env python3
 import sys
 import json
@@ -85618,11 +85629,11 @@ async function runExtraction(args) {
   }
   let tmpDir;
   try {
-    tmpDir = mkdtempSync(join63(tmpdir5(), "matrixx-pdf-extract-"));
+    tmpDir = mkdtempSync(join64(tmpdir5(), "matrixx-pdf-extract-"));
   } catch {
     return "Error: Could not create temporary directory.";
   }
-  const scriptPath = join63(tmpDir, "extract_pdf_figures.py");
+  const scriptPath = join64(tmpDir, "extract_pdf_figures.py");
   writeFileSync23(scriptPath, PYTHON_SCRIPT);
   const payload = buildArgsPayload(args);
   log("[pdf_extract_figures] Running extraction", { file_path: args.file_path, payload });
@@ -85674,7 +85685,7 @@ import { existsSync as existsSync62 } from "fs";
 import { basename as basename7 } from "path";
 
 // src/tools/plan/types.ts
-import { basename as basename6, isAbsolute as isAbsolute5, join as join64, relative as relative4, resolve as resolve9 } from "path";
+import { basename as basename6, isAbsolute as isAbsolute5, join as join65, relative as relative4, resolve as resolve9 } from "path";
 
 // src/tools/plan/constants.ts
 var PLANS_DIR3 = ".matrixx/plans";
@@ -85700,8 +85711,8 @@ function validatePlanFilePath(filePath, directory) {
   if (!PLAN_FILENAME_KEBAB_REGEX.test(base)) {
     return { error: `fileName must match kebab-case ^[a-z0-9-]+\\.md$: ${base}` };
   }
-  const resolved = isAbsolute5(filePath) ? resolve9(filePath) : resolve9(join64(directory, filePath));
-  const plansDir = resolve9(join64(directory, PLANS_DIR3));
+  const resolved = isAbsolute5(filePath) ? resolve9(filePath) : resolve9(join65(directory, filePath));
+  const plansDir = resolve9(join65(directory, PLANS_DIR3));
   const relToPlans = relative4(plansDir, resolved);
   if (relToPlans.startsWith("..") || isAbsolute5(relToPlans)) {
     return { error: `filePath must be inside ${PLANS_DIR3}: ${filePath}` };
@@ -85805,7 +85816,7 @@ function createPlanDeleteTool(ctx) {
 }
 // src/tools/plan/plan-list.ts
 import { existsSync as existsSync64, readdirSync as readdirSync20, statSync as statSync15 } from "fs";
-import { join as join65 } from "path";
+import { join as join66 } from "path";
 function createPlanListTool(ctx) {
   return tool({
     description: `List plan files under .matrixx/plans/*.md. Filters *.md with kebab-case, sorts by mtime.`,
@@ -85813,13 +85824,13 @@ function createPlanListTool(ctx) {
     execute: async (_args, context) => {
       try {
         const directory = resolveDirectory(context?.directory, ctx?.directory);
-        const plansDir = join65(directory, PLANS_DIR3);
+        const plansDir = join66(directory, PLANS_DIR3);
         if (!existsSync64(plansDir)) {
           return JSON.stringify({ plans: [] });
         }
         const entries = readdirSync20(plansDir).filter((f) => f.endsWith(".md") && PLAN_FILENAME_KEBAB_REGEX.test(f));
         const plans = entries.map((fileName) => {
-          const filePath = join65(plansDir, fileName);
+          const filePath = join66(plansDir, fileName);
           try {
             const stat2 = statSync15(filePath);
             return {
@@ -86965,10 +86976,152 @@ function createPlanUpdateTool(ctx) {
     }
   });
 }
+// src/tools/preset/tools.ts
+import { existsSync as existsSync67, mkdirSync as mkdirSync18, readFileSync as readFileSync40, writeFileSync as writeFileSync24 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname17, join as join67 } from "path";
+
+// src/features/preset-state/manager.ts
+init_logger();
+var HOOK_NAME19 = "preset-state";
+var presetBySession = new Map;
+function setSessionPreset(sessionID, presetName) {
+  presetBySession.set(sessionID, presetName);
+  log(`[${HOOK_NAME19}] Preset set for session`, { sessionID, presetName });
+}
+function getSessionPreset(sessionID) {
+  return presetBySession.get(sessionID);
+}
+// src/tools/preset/tools.ts
+init_logger();
+var ACTIONS = ["list", "show", "set"];
+var SCOPES = ["global", "project"];
+function resolveConfigPath(scope, directory) {
+  if (scope === "global") {
+    return join67(homedir9(), ".config", "opencode", "matrixx.jsonc");
+  }
+  return join67(directory ?? process.cwd(), ".opencode", "matrixx.jsonc");
+}
+function persistActivePreset(presetName, scope, directory) {
+  const configPath = resolveConfigPath(scope, directory);
+  let raw = {};
+  if (existsSync67(configPath)) {
+    const content = readFileSync40(configPath, "utf-8");
+    const parsed = parseJsoncSafe(content);
+    if (parsed.errors.length > 0) {
+      return {
+        ok: false,
+        error: `Cannot parse existing config at ${configPath}: ${parsed.errors[0]?.message}`
+      };
+    }
+    raw = parsed.data ?? {};
+  } else {
+    mkdirSync18(dirname17(configPath), { recursive: true });
+  }
+  raw.active_preset = presetName;
+  writeFileSync24(configPath, `${JSON.stringify(raw, null, 2)}
+`);
+  log("[preset] persisted active_preset", { presetName, scope, configPath });
+  return { ok: true, path: configPath };
+}
+function unknownPresetError(name, presetNames) {
+  const available = presetNames.length > 0 ? presetNames.join(", ") : "(none defined)";
+  return `Error: Unknown preset "${name}". Available presets: ${available}`;
+}
+function formatPreset(name, preset) {
+  const lines = [`Preset "${name}":`];
+  if (preset.default_model) {
+    lines.push(`  default_model: ${preset.default_model}`);
+  }
+  const agentEntries = Object.entries(preset.agents ?? {});
+  if (agentEntries.length > 0) {
+    lines.push("  agents:");
+    for (const [agent, entry] of agentEntries) {
+      lines.push(`    - ${agent}: ${entry.model}${entry.variant ? ` (variant: ${entry.variant})` : ""}`);
+    }
+  }
+  const categoryEntries = Object.entries(preset.categories ?? {});
+  if (categoryEntries.length > 0) {
+    lines.push("  categories:");
+    for (const [category, entry] of categoryEntries) {
+      lines.push(`    - ${category}: ${entry.model}${entry.variant ? ` (variant: ${entry.variant})` : ""}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function runPresetCommand(input) {
+  const { action, name, save, scope, sessionID, options } = input;
+  const presets = options?.pluginConfig?.model_presets ?? {};
+  const presetNames = Object.keys(presets);
+  const activePreset = options?.pluginConfig?.active_preset;
+  const sessionPreset = getSessionPreset(sessionID);
+  const effective = sessionPreset ?? activePreset;
+  if (action === "list") {
+    if (presetNames.length === 0) {
+      return "No model presets defined. Add a `model_presets` section to your matrixx config.";
+    }
+    const lines = presetNames.map((p) => `- ${p}${p === effective ? " (active)" : ""}`);
+    const activeLine = effective ? `Active: ${effective}${sessionPreset ? ` (session overlay for ${sessionID})` : ""}` : "Active: (none)";
+    return `Available presets:
+${lines.join(`
+`)}
+
+${activeLine}`;
+  }
+  if (action === "show") {
+    const target = name ?? effective;
+    if (!target) {
+      return "No preset specified and no active preset set. Usage: preset show <name>";
+    }
+    const preset = presets[target];
+    if (!preset)
+      return unknownPresetError(target, presetNames);
+    return formatPreset(target, preset);
+  }
+  if (!name) {
+    return "Error: `preset set` requires a preset name. Usage: preset set <name> [--save [--global|--project]]";
+  }
+  if (!presets[name])
+    return unknownPresetError(name, presetNames);
+  setSessionPreset(sessionID, name);
+  let message = `\u2713 Active preset set to "${name}" for this session.
+
+` + `- delegate-task categories switch immediately
+` + `- builtin agents apply on next session`;
+  if (save) {
+    const result = persistActivePreset(name, scope, options?.directory);
+    if (!result.ok)
+      return `Error: ${result.error}`;
+    message += `
+
+Persisted active_preset to ${result.path} (scope: ${scope}). Next session starts on "${name}".`;
+  }
+  return message;
+}
+function createPresetTool(options) {
+  const preset = tool({
+    description: "Manage model presets: list available presets, show a preset's model assignments, " + "or set the active preset for the current session. `set <name>` switches delegate-task " + "categories immediately and applies to builtin agents on the next session; " + "`set <name> --save [--global|--project]` additionally persists `active_preset` to config.",
+    args: {
+      action: tool.schema.enum(ACTIONS).describe("Operation: list available presets, show a preset's details, or set the active preset"),
+      name: tool.schema.string().optional().describe("Preset name (required for set; optional for show \u2014 defaults to the active preset)"),
+      save: tool.schema.boolean().optional().describe("Persist the active preset to config (default: false \u2014 session-only overlay)"),
+      scope: tool.schema.enum(SCOPES).optional().describe("Where to persist when --save: project (.opencode/matrixx.jsonc, default) or global (~/.config/opencode/matrixx.jsonc)")
+    },
+    async execute(args, context) {
+      const action = args.action;
+      const name = args.name;
+      const save = args.save;
+      const scope = args.scope ?? "project";
+      return runPresetCommand({ action, name, save, scope, sessionID: context.sessionID, options });
+    }
+  });
+  return { preset };
+}
 // src/tools/session-manager/constants.ts
-import { join as join66 } from "path";
-var TODO_DIR = join66(getOpenCodeConfigDir({ binary: "opencode" }), "todos");
-var TRANSCRIPT_DIR2 = join66(getOpenCodeConfigDir({ binary: "opencode" }), "transcripts");
+import { join as join68 } from "path";
+var TODO_DIR = join68(getOpenCodeConfigDir({ binary: "opencode" }), "todos");
+var TRANSCRIPT_DIR2 = join68(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.
@@ -87040,9 +87193,9 @@ Agents Used: build, oracle, librarian
 Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import { readdir, readFile as readFile3 } from "fs/promises";
-import { join as join67 } from "path";
+import { join as join69 } from "path";
 var sdkClient = null;
 function setStorageClient(client2) {
   sdkClient = client2;
@@ -87061,7 +87214,7 @@ async function getMainSessions(options) {
       return [];
     }
   }
-  if (!existsSync67(SESSION_STORAGE))
+  if (!existsSync68(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -87069,13 +87222,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join67(SESSION_STORAGE, projectDir.name);
+      const projectPath = join69(SESSION_STORAGE, projectDir.name);
       const sessionFiles = await readdir(projectPath);
       for (const file3 of sessionFiles) {
         if (!file3.endsWith(".json"))
           continue;
         try {
-          const content = await readFile3(join67(projectPath, file3), "utf-8");
+          const content = await readFile3(join69(projectPath, file3), "utf-8");
           const meta3 = JSON.parse(content);
           if (meta3.parentID)
             continue;
@@ -87100,7 +87253,7 @@ async function getAllSessions() {
       return [];
     }
   }
-  if (!existsSync67(MESSAGE_STORAGE))
+  if (!existsSync68(MESSAGE_STORAGE))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -87108,7 +87261,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join67(dir, entry.name);
+          const sessionPath = join69(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -87169,7 +87322,7 @@ async function readSessionMessages(sessionID) {
     }
   }
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync67(messageDir))
+  if (!messageDir || !existsSync68(messageDir))
     return [];
   const messages2 = [];
   try {
@@ -87178,7 +87331,7 @@ async function readSessionMessages(sessionID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile3(join67(messageDir, file3), "utf-8");
+        const content = await readFile3(join69(messageDir, file3), "utf-8");
         const meta3 = JSON.parse(content);
         const parts = await readParts2(meta3.id);
         messages2.push({
@@ -87202,8 +87355,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join67(PART_STORAGE, messageID);
-  if (!existsSync67(partDir))
+  const partDir = join69(PART_STORAGE, messageID);
+  if (!existsSync68(partDir))
     return [];
   const parts = [];
   try {
@@ -87212,7 +87365,7 @@ async function readParts2(messageID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile3(join67(partDir, file3), "utf-8");
+        const content = await readFile3(join69(partDir, file3), "utf-8");
         parts.push(JSON.parse(content));
       } catch {}
     }
@@ -87236,14 +87389,14 @@ async function readSessionTodos(sessionID) {
       return [];
     }
   }
-  if (!existsSync67(TODO_DIR))
+  if (!existsSync68(TODO_DIR))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR);
     const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
     for (const file3 of todoFiles) {
       try {
-        const content = await readFile3(join67(TODO_DIR, file3), "utf-8");
+        const content = await readFile3(join69(TODO_DIR, file3), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -87261,10 +87414,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync67(TRANSCRIPT_DIR2))
+  if (!existsSync68(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join67(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync67(transcriptFile))
+  const transcriptFile = join69(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync68(transcriptFile))
     return 0;
   try {
     const content = await readFile3(transcriptFile, "utf-8");
@@ -87774,20 +87927,20 @@ function createSkillTool(options = {}) {
 }
 var skill = createSkillTool();
 // src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync68, readdirSync as readdirSync21, readFileSync as readFileSync40 } from "fs";
-import { basename as basename8, join as join68 } from "path";
+import { existsSync as existsSync69, readdirSync as readdirSync21, readFileSync as readFileSync41 } from "fs";
+import { basename as basename8, join as join70 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync68(commandsDir))
+  if (!existsSync69(commandsDir))
     return [];
   const entries = readdirSync21(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join68(commandsDir, entry.name);
+    const commandPath = join70(commandsDir, entry.name);
     const commandName = basename8(entry.name, ".md");
     try {
-      const content = readFileSync40(commandPath, "utf-8");
+      const content = readFileSync41(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -87811,8 +87964,8 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync(directory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeGlobalDir = join68(configDir, "command");
-  const opencodeProjectDir = join68(directory ?? process.cwd(), ".opencode", "command");
+  const opencodeGlobalDir = join70(configDir, "command");
+  const opencodeProjectDir = join70(directory ?? process.cwd(), ".opencode", "command");
   const opencodeGlobalCommands = discoverCommandsFromDir2(opencodeGlobalDir, "opencode");
   const opencodeProjectCommands = discoverCommandsFromDir2(opencodeProjectDir, "opencode-project");
   const builtinCommandsMap = loadBuiltinCommands();
@@ -87836,7 +87989,7 @@ function discoverCommandsSync(directory) {
   ];
 }
 // src/tools/slashcommand/command-output-formatter.ts
-import { dirname as dirname17 } from "path";
+import { dirname as dirname18 } from "path";
 async function formatLoadedCommand(command, userMessage) {
   const sections = [];
   sections.push(`# /${command.name} Command
@@ -87875,7 +88028,7 @@ async function formatLoadedCommand(command, userMessage) {
   if (!content && command.lazyContentLoader) {
     content = await command.lazyContentLoader.load();
   }
-  const commandDir = command.path ? dirname17(command.path) : process.cwd();
+  const commandDir = command.path ? dirname18(command.path) : process.cwd();
   const withFileReferences = await resolveFileReferencesInText(content, commandDir);
   const resolvedContent = await resolveCommandsInText(withFileReferences);
   let finalContent = resolvedContent.trim();
@@ -88587,8 +88740,6 @@ function createBackgroundOutput(manager, client2) {
     }
   });
 }
-// src/tools/background-task/create-background-task.ts
-init_logger();
 // src/tools/assembly/constants.ts
 var DEFAULT_VOTERS = 3;
 var DEFAULT_ROUNDS = 2;
@@ -88954,9 +89105,9 @@ function createAssemblyTool(options) {
   });
 }
 // src/tools/dcp-switch-profile/tools.ts
-import { existsSync as existsSync69, writeFileSync as writeFileSync24 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join69 } from "path";
+import { existsSync as existsSync70, writeFileSync as writeFileSync25 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join71 } from "path";
 
 // src/config/schema/dcp.ts
 var DcpCompressOverrideSchema = exports_external.object({
@@ -89129,11 +89280,11 @@ var DcpConfigSchema = exports_external.object({
 });
 
 // src/tools/dcp-switch-profile/tools.ts
-var DCP_PLUGIN_DIR = join69(homedir9(), ".config", "opencode", "node_modules", "@tarquinen", "opencode-dcp");
-var DCP_SYMLINK = join69(homedir9(), ".config", "opencode", "dcp.jsonc");
+var DCP_PLUGIN_DIR = join71(homedir10(), ".config", "opencode", "node_modules", "@tarquinen", "opencode-dcp");
+var DCP_SYMLINK = join71(homedir10(), ".config", "opencode", "dcp.jsonc");
 var VALID_PROFILES = ["economy", "balanced", "performance", "ultimate"];
 function checkDcpInstalled() {
-  if (!existsSync69(DCP_PLUGIN_DIR)) {
+  if (!existsSync70(DCP_PLUGIN_DIR)) {
     return `DCP is not installed at ${DCP_PLUGIN_DIR}. Install it with: npm install --prefix ~/.config/opencode @tarquinen/opencode-dcp`;
   }
   return null;
@@ -89211,7 +89362,7 @@ function switchProfile(profile, options) {
   if (dcpError)
     return dcpError;
   const inlineConfig = buildInlineConfig(profile, options);
-  writeFileSync24(DCP_SYMLINK, `${JSON.stringify(inlineConfig, null, 2)}
+  writeFileSync25(DCP_SYMLINK, `${JSON.stringify(inlineConfig, null, 2)}
 `);
   return `\u2713 Switched to DCP profile: ${profile}
 
@@ -89557,149 +89708,23 @@ function createDelegateAgent(ctx, backgroundManager, disabledAgents = []) {
     }
   });
 }
-// src/shared/tier-resolver.ts
-init_logger();
-
-// src/shared/model-tiers.ts
-function compilePattern(pattern) {
-  try {
-    return new RegExp(pattern);
-  } catch {
-    return /(?!)/;
-  }
-}
-var DEFAULT_TIER_SPECS = {
-  free: {
-    name: "free",
-    providerPriority: ["opencode", "xai", "opencode-go", "zai-coding-plan"],
-    modelPattern: /-free$|kimi-k2\.5-free|minimax-m2\.5-free|grok-code-fast/,
-    fallback: [
-      { providers: ["opencode"], model: "kimi-k2.5-free" },
-      { providers: ["xai"], model: "grok-code-fast-1" }
-    ]
-  },
-  fast: {
-    name: "fast",
-    providerPriority: ["anthropic", "openai", "google", "opencode-go"],
-    modelPattern: /claude-haiku|gpt-5-nano|gemini-2\.5-flash|deepseek-v4-flash/,
-    fallback: [{ providers: ["anthropic"], model: "claude-haiku-4-5" }],
-    fallbackTier: "free"
-  },
-  standard: {
-    name: "standard",
-    providerPriority: ["anthropic", "openai", "google", "opencode-go"],
-    modelPattern: /claude-sonnet|gpt-5\.2|gemini-2\.5-pro/,
-    fallback: [{ providers: ["anthropic"], model: "claude-sonnet-4-6" }],
-    fallbackTier: "fast"
-  },
-  premium: {
-    name: "premium",
-    providerPriority: ["anthropic", "openai", "google", "opencode-go"],
-    modelPattern: /claude-opus|gpt-5\.3-codex|gemini-3-pro/,
-    fallback: [{ providers: ["anthropic"], model: "claude-opus-4-6" }],
-    fallbackTier: "standard"
-  },
-  frontier: {
-    name: "frontier",
-    providerPriority: ["anthropic", "openai", "google", "opencode-go"],
-    modelPattern: /claude-opus|gpt-5\.3-codex|gemini-3\.1-pro/,
-    fallback: [{ providers: ["anthropic"], model: "claude-opus-4-6" }],
-    fallbackTier: "premium"
-  }
-};
-function buildTierSpecs(config4) {
-  if (!config4?.tiers)
-    return DEFAULT_TIER_SPECS;
-  const result = {};
-  for (const [name, raw] of Object.entries(config4.tiers)) {
-    if (!raw || typeof raw !== "object")
-      continue;
-    const providerPriority = Array.isArray(raw.providerPriority) ? raw.providerPriority : [];
-    const rawPattern = raw.modelPattern;
-    const patternString = typeof rawPattern === "string" ? rawPattern : "";
-    result[name] = {
-      name,
-      providerPriority,
-      modelPattern: compilePattern(patternString),
-      fallbackTier: raw.fallbackTier,
-      fallback: raw.fallback
-    };
-  }
-  return result;
-}
-function getTierSpec(tierName, config4) {
-  if (!tierName)
-    return;
-  const specs = buildTierSpecs(config4);
-  return specs[tierName];
-}
-
-// src/shared/tier-resolver.ts
-function resolveTier(tier, ctx, config4) {
-  const spec = getTierSpec(tier, config4);
-  if (!spec)
-    return null;
-  if (ctx.availableModels.size > 0) {
-    for (const provider of spec.providerPriority) {
-      const match = findRegexMatch(spec.modelPattern, provider, ctx.availableModels);
-      if (match) {
-        log("[tier-resolver] resolved via regex", { tier, provider, match });
-        return { model: match, provenance: "tier-resolved", tier };
-      }
-    }
-    log("[tier-resolver] no live match found, recursing to fallback tier", { tier });
-  } else if (ctx.connectedProviders) {
-    const connectedSet = new Set(ctx.connectedProviders);
-    const fallback = spec.fallback ?? [];
-    for (const entry of fallback) {
-      for (const provider of entry.providers) {
-        if (connectedSet.has(provider)) {
-          const model = `${provider}/${entry.model}`;
-          log("[tier-resolver] using config fallback (cold cache)", { tier, provider, model });
-          return { model, provenance: "tier-static-fallback", tier };
-        }
-      }
-    }
-    log("[tier-resolver] no config fallback provider is connected", { tier });
-  } else {
-    log("[tier-resolver] no live models and no connected providers cache", { tier });
-  }
-  if (spec.fallbackTier) {
-    return resolveTier(spec.fallbackTier, ctx, config4);
-  }
-  return null;
-}
-function findRegexMatch(pattern, provider, available) {
-  for (const candidate of available) {
-    if (!candidate.startsWith(`${provider}/`))
-      continue;
-    if (pattern.test(candidate))
-      return candidate;
-  }
-  return null;
-}
-
 // src/tools/delegate-task/complexity-types.ts
 function isDowngradable(level) {
   return level === 1 || level === 2;
 }
 
 // src/tools/delegate-task/complexity-constants.ts
-function resolveComplexityModel(category, complexity, originalModel, userDowngrades, config4, tierContext) {
+function resolveComplexityModel(category, complexity, originalModel, userDowngrades, config4) {
   if (!isDowngradable(complexity)) {
     return { model: originalModel, downgraded: false };
   }
   let complexityDowngrades;
-  let tiersConfig;
   if (config4) {
     const maybe = config4;
-    const hasHolderKeys = "complexityDowngrades" in maybe || "tiers" in maybe;
+    const hasHolderKeys = "complexityDowngrades" in maybe;
     if (hasHolderKeys) {
       const holder = config4;
       complexityDowngrades = holder.complexityDowngrades;
-      if (holder.tiers) {
-        tiersConfig = holder;
-      }
     } else {
       complexityDowngrades = config4;
     }
@@ -89709,20 +89734,6 @@ function resolveComplexityModel(category, complexity, originalModel, userDowngra
   if (!rawDowngrade) {
     return { model: originalModel, downgraded: false };
   }
-  if (rawDowngrade.startsWith("tier:")) {
-    const tierName = rawDowngrade.slice(5).trim();
-    if (!tierName) {
-      return { model: originalModel, downgraded: false };
-    }
-    if (!tierContext || !tiersConfig) {
-      return { model: originalModel, downgraded: false };
-    }
-    const resolved = resolveTier(tierName, tierContext, tiersConfig);
-    if (!resolved) {
-      return { model: originalModel, downgraded: false };
-    }
-    return { model: resolved.model, downgraded: true };
-  }
   return { model: rawDowngrade, downgraded: true };
 }
 // src/tools/delegate-task/complexity-scorer.ts
@@ -89999,14 +90010,14 @@ You are NOT an interactive assistant. You are an autonomous problem-solver.
 - Report completion with summary of changes made
 </Category_Context>`;
 var DEFAULT_CATEGORIES = {
-  construct: { tier: "standard" },
-  source: { tier: "premium", variant: "max" },
-  "deep-jack": { tier: "premium", variant: "max" },
-  "matrix-bend": { tier: "standard" },
-  "bullet-time": { tier: "fast" },
-  "blue-pill": { tier: "standard" },
-  "red-pill": { tier: "premium", variant: "max" },
-  broadcast: { tier: "standard" }
+  construct: {},
+  source: { variant: "max" },
+  "deep-jack": { variant: "max" },
+  "matrix-bend": {},
+  "bullet-time": {},
+  "blue-pill": {},
+  "red-pill": { variant: "max" },
+  broadcast: {}
 };
 var CATEGORY_PROMPT_APPENDS = {
   construct: VISUAL_CATEGORY_PROMPT_APPEND,
@@ -90339,93 +90350,10 @@ function isPlanFamily(category) {
 // src/tools/delegate-task/tools.ts
 init_logger();
 
-// src/config/resolve-tiers.ts
-init_logger();
-function resolveTiersInConfig(config4, ctx) {
-  const defaultTier = config4.default_tier;
-  const agents = walkAgentOverrides(config4.agents, defaultTier, ctx, config4);
-  const categories = walkCategoryOverrides(config4.categories, defaultTier, ctx, config4);
-  const { default_tier: _drop, ...rest } = config4;
-  return { ...rest, agents, categories };
-}
-function resolveTiersInCategoryRegistry(registry4, ctx, config4) {
-  const result = {};
-  for (const [name, entry] of Object.entries(registry4)) {
-    if (!entry)
-      continue;
-    result[name] = resolveEntry(entry, undefined, ctx, config4);
-  }
-  return result;
-}
-function walkAgentOverrides(agents, defaultTier, ctx, config4) {
-  if (!agents)
-    return agents;
-  const result = {};
-  for (const [name, entry] of Object.entries(agents)) {
-    if (!entry) {
-      result[name] = entry;
-      continue;
-    }
-    result[name] = resolveEntry(entry, defaultTier, ctx, config4);
-  }
-  return result;
-}
-function walkCategoryOverrides(categories, defaultTier, ctx, config4) {
-  if (!categories)
-    return categories;
-  const result = {};
-  for (const [name, entry] of Object.entries(categories)) {
-    if (!entry) {
-      result[name] = entry;
-      continue;
-    }
-    result[name] = resolveEntry(entry, defaultTier, ctx, config4);
-  }
-  return result;
-}
-function resolveEntry(entry, defaultTier, ctx, config4) {
-  if (entry.model) {
-    const { tier: _t2, ...rest2 } = entry;
-    return rest2;
-  }
-  const tier = entry.tier ?? defaultTier;
-  if (!tier)
-    return entry;
-  const resolved = resolveTier(tier, ctx, config4);
-  if (!resolved) {
-    log("[resolveTiersInConfig] tier could not be resolved", { tier });
-    return entry;
-  }
-  const { tier: _t, ...rest } = entry;
-  return { ...rest, model: resolved.model };
-}
-
 // src/shared/merge-categories.ts
-function mergeCategories(userCategories, config4) {
-  const resolvedDefaults = resolveDefaultCategories(config4);
-  const merged = userCategories ? { ...resolvedDefaults, ...userCategories } : { ...resolvedDefaults };
-  return Object.fromEntries(Object.entries(merged).filter(([, config5]) => !config5.disable));
-}
-function resolveDefaultCategories(config4) {
-  const providerCache = readProviderModelsCache();
-  const availableModels = new Set;
-  if (providerCache) {
-    const connected = new Set(providerCache.connected);
-    for (const [providerId, models] of Object.entries(providerCache.models)) {
-      if (!connected.has(providerId))
-        continue;
-      for (const item of models) {
-        const modelID = typeof item === "string" ? item : item?.id;
-        if (modelID)
-          availableModels.add(`${providerId}/${modelID}`);
-      }
-    }
-  }
-  const ctx = {
-    availableModels,
-    connectedProviders: readConnectedProvidersCache()
-  };
-  return resolveTiersInCategoryRegistry(DEFAULT_CATEGORIES, ctx, config4);
+function mergeCategories(userCategories) {
+  const merged = userCategories ? { ...DEFAULT_CATEGORIES, ...userCategories } : { ...DEFAULT_CATEGORIES };
+  return Object.fromEntries(Object.entries(merged).filter(([, config4]) => !config4.disable));
 }
 // src/tools/delegate-task/background-continuation.ts
 async function executeBackgroundContinuation(args, ctx, executorCtx, parentContext) {
@@ -90500,6 +90428,9 @@ function getTimingConfig() {
     SESSION_CONTINUATION_STABILITY_MS
   };
 }
+function setPollTimeoutMs(ms) {
+  MAX_POLL_TIME_MS = ms;
+}
 
 // src/tools/delegate-task/background-task.ts
 async function executeBackgroundTask(args, ctx, executorCtx, parentContext, agentToUse, categoryModel, systemContent) {
@@ -90578,6 +90509,67 @@ session_id: ${sessionId}
     });
   }
 }
+// src/config/preset-applier.ts
+init_logger();
+function resolvePresetModel(preset, key) {
+  const entry = preset.agents?.[key] ?? preset.categories?.[key];
+  if (entry)
+    return entry;
+  if (preset.default_model)
+    return { model: preset.default_model };
+  return;
+}
+function applyActivePreset(config4, presetName) {
+  const name = presetName ?? config4.active_preset;
+  if (!name)
+    return config4;
+  const preset = config4.model_presets?.[name];
+  if (!preset) {
+    log("[applyActivePreset] unknown active_preset", { active_preset: name });
+    return config4;
+  }
+  const agents = fillRegistry(config4.agents, preset.agents, preset.default_model);
+  const categories = fillRegistry(config4.categories, preset.categories, preset.default_model);
+  const result = { ...config4 };
+  if (agents !== config4.agents)
+    result.agents = agents;
+  if (categories !== config4.categories) {
+    result.categories = categories;
+  }
+  return result;
+}
+function fillRegistry(registry4, presetEntries, defaultModel) {
+  if (!registry4)
+    return registry4;
+  let changed = false;
+  const result = {};
+  for (const [name, entry] of Object.entries(registry4)) {
+    if (!entry) {
+      result[name] = entry;
+      continue;
+    }
+    const filled = applyEntry(entry, presetEntries?.[name], defaultModel);
+    if (filled) {
+      changed = true;
+      result[name] = filled;
+    } else {
+      result[name] = entry;
+    }
+  }
+  return changed ? result : registry4;
+}
+function applyEntry(entry, presetEntry, defaultModel) {
+  if (entry.model)
+    return null;
+  const model = presetEntry?.model ?? defaultModel;
+  if (!model)
+    return null;
+  const variant = entry.variant ?? presetEntry?.variant;
+  if (variant === undefined)
+    return { ...entry, model };
+  return { ...entry, model, variant };
+}
+
 // src/tools/delegate-task/category-resolver.ts
 init_logger();
 
@@ -90635,7 +90627,7 @@ async function getAvailableModelsForDelegateTask(client2) {
 // src/tools/delegate-task/categories.ts
 init_logger();
 function resolveCategoryConfig(categoryName, options) {
-  const { userCategories, inheritedModel: _inheritedModel, systemDefaultModel, availableModels, tierContext, modelRequirements, tiers } = options;
+  const { userCategories, inheritedModel: _inheritedModel, systemDefaultModel, availableModels, modelRequirements, presetEntry } = options;
   const defaultConfig = DEFAULT_CATEGORIES[categoryName];
   const userConfig = userCategories?.[categoryName];
   const hasExplicitUserConfig = userConfig !== undefined;
@@ -90654,16 +90646,13 @@ function resolveCategoryConfig(categoryName, options) {
   if (!defaultConfig && !userConfig) {
     return null;
   }
-  const tierConfig = tiers ? { tiers } : undefined;
-  const effectiveUserModel = resolveTierOnEntry(userConfig, tierContext, tierConfig);
-  const effectiveDefaultModel = resolveTierOnEntry(defaultConfig, tierContext, tierConfig);
-  const model = normalizeModel(effectiveUserModel ?? userConfig?.model) ?? normalizeModel(effectiveDefaultModel ?? defaultConfig?.model) ?? systemDefaultModel;
-  const hasUserModelOverride = (effectiveUserModel ?? userConfig?.model) !== undefined;
+  const model = normalizeModel(userConfig?.model) ?? normalizeModel(presetEntry?.model) ?? normalizeModel(defaultConfig?.model) ?? systemDefaultModel;
+  const hasUserModelOverride = (userConfig?.model ?? presetEntry?.model) !== undefined;
   const config4 = {
     ...defaultConfig,
     ...userConfig,
     model,
-    variant: userConfig?.variant ?? (hasUserModelOverride ? undefined : defaultConfig?.variant)
+    variant: userConfig?.variant ?? presetEntry?.variant ?? (hasUserModelOverride ? undefined : defaultConfig?.variant)
   };
   let promptAppend = defaultPromptAppend;
   if (userConfig?.prompt_append) {
@@ -90673,12 +90662,6 @@ ${userConfig.prompt_append}` : userConfig.prompt_append;
   }
   return { config: config4, promptAppend, model, temperature: config4.temperature };
 }
-function resolveTierOnEntry(entry, ctx, tiersConfig) {
-  if (!entry || entry.model || !entry.tier || !ctx)
-    return;
-  const resolved = resolveTier(entry.tier, ctx, tiersConfig);
-  return resolved?.model;
-}
 
 // src/tools/delegate-task/model-selection.ts
 function normalizeModel2(model) {
@@ -90737,11 +90720,33 @@ function resolveModelForDelegateTask(input) {
 var MOUSE_AGENT2 = "mouse";
 
 // src/tools/delegate-task/category-resolver.ts
+function resolveCategoryPresetEntry(categoryName, ctx) {
+  const { sessionID, modelPresets, activePreset } = ctx;
+  if (!modelPresets)
+    return;
+  const overlayName = sessionID ? getSessionPreset(sessionID) : undefined;
+  let result;
+  if (overlayName) {
+    const overlayPreset = modelPresets[overlayName];
+    if (overlayPreset) {
+      const entry = resolvePresetModel(overlayPreset, categoryName);
+      if (entry)
+        result = entry;
+    } else {
+      log("[preset] unknown session overlay preset, ignoring", { sessionID, presetName: overlayName });
+    }
+  }
+  if (!result && activePreset) {
+    const preset = modelPresets[activePreset];
+    if (preset)
+      result = resolvePresetModel(preset, categoryName);
+  }
+  return result;
+}
 async function resolveCategoryExecution(args, executorCtx, inheritedModel, systemDefaultModel) {
-  const { client: client2, userCategories, mouseModel, globalModel, modelRequirements, complexityDowngrades, tiers } = executorCtx;
+  const { client: client2, userCategories, mouseModel, globalModel, modelRequirements, complexityDowngrades } = executorCtx;
   const categoryRequirements = getCategoryModelRequirements(modelRequirements ? { modelRequirements } : undefined);
   const availableModels = await getAvailableModelsForDelegateTask(client2);
-  const connectedProviders = readConnectedProvidersCache();
   const categoryName = args.category;
   const enabledCategories = mergeCategories(userCategories);
   const categoryExists = enabledCategories[categoryName] !== undefined;
@@ -90750,8 +90755,8 @@ async function resolveCategoryExecution(args, executorCtx, inheritedModel, syste
     inheritedModel,
     systemDefaultModel,
     availableModels,
-    tierContext: { availableModels, connectedProviders },
-    modelRequirements
+    modelRequirements,
+    presetEntry: resolveCategoryPresetEntry(categoryName, executorCtx)
   });
   if (!resolved) {
     const requirement2 = categoryRequirements[categoryName];
@@ -90847,9 +90852,7 @@ Available categories: ${allCategoryNames}`
   }
   if (actualModel && (complexityLevel === 1 || complexityLevel === 2)) {
     const userDowngrades = userCategories?.[args.category]?.complexity_downgrades;
-    const holder = complexityDowngrades || tiers ? { complexityDowngrades, tiers } : undefined;
-    const tierCtx = { availableModels, connectedProviders };
-    const resolvedDowngrade = resolveComplexityModel(args.category, complexityLevel, actualModel, userDowngrades, holder, tierCtx);
+    const resolvedDowngrade = resolveComplexityModel(args.category, complexityLevel, actualModel, userDowngrades, complexityDowngrades);
     if (resolvedDowngrade.downgraded) {
       complexityDowngraded = true;
       log("[complexity] Auto-downgraded model", {
@@ -91365,7 +91368,7 @@ async function pollSyncSession(ctx, client2, input) {
   let idleStallCount = 0;
   let lastMsgCount = 0;
   let stableIdlePolls = 0;
-  log("[task] Starting poll loop", { sessionID: input.sessionID, agentToUse: input.agentToUse });
+  log("[task] Starting poll loop", { sessionID: input.sessionID, agentToUse: input.agentToUse, maxPollTimeMs });
   while (Date.now() - pollStart < maxPollTimeMs) {
     if (ctx.abort?.aborted) {
       log("[task] Aborted by user", { sessionID: input.sessionID });
@@ -91743,6 +91746,7 @@ async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse
   const toastManager = getTaskToastManager();
   let taskId;
   let syncSessionID;
+  let pollTimedOut = false;
   try {
     const createSessionResult = await deps.createSyncSession(client2, {
       parentSessionID: parentContext.sessionID,
@@ -91825,6 +91829,7 @@ async function executeSyncTask(args, ctx, executorCtx, parentContext, agentToUse
         }
       });
       if (pollError) {
+        pollTimedOut = pollError.startsWith("Poll timeout reached");
         return pollError;
       }
       const result = await deps.fetchSyncResult(client2, sessionID, undefined, {
@@ -91861,10 +91866,12 @@ session_id: ${sessionID}
     });
   } finally {
     if (syncSessionID) {
-      subagentSessions.delete(syncSessionID);
-      client2.session.abort({ path: { id: syncSessionID } }).catch((err) => {
-        log("[delegate-task] Sync session abort failed:", err);
-      });
+      unregisterSubagentSession(syncSessionID);
+      if (!pollTimedOut) {
+        client2.session.abort({ path: { id: syncSessionID } }).catch((err) => {
+          log("[delegate-task] Sync session abort failed:", err);
+        });
+      }
     }
   }
 }
@@ -92190,7 +92197,7 @@ Prompts MUST be in English.`;
       let actualModel;
       let isUnstableAgent = false;
       if (args.category) {
-        const resolution = await resolveCategoryExecution(args, options, inheritedModel, systemDefaultModel);
+        const resolution = await resolveCategoryExecution(args, { ...options, sessionID: ctx.sessionID }, inheritedModel, systemDefaultModel);
         if (resolution.error) {
           return resolution.error;
         }
@@ -92591,8 +92598,8 @@ Original error: ${createResult.error}`;
   });
 }
 // src/tools/task/task-cleanup.ts
-import { existsSync as existsSync70, readdirSync as readdirSync22, readFileSync as readFileSync41, unlinkSync as unlinkSync11 } from "fs";
-import { join as join70 } from "path";
+import { existsSync as existsSync71, readdirSync as readdirSync22, readFileSync as readFileSync42, unlinkSync as unlinkSync11 } from "fs";
+import { join as join72 } from "path";
 init_logger();
 function parseOlderThan(value) {
   const match = value.trim().match(/^(\d+)(d|h|m)$/);
@@ -92651,17 +92658,17 @@ Returns counts: {deleted, remaining, deletedIds}`,
         }
         const directory = context?.directory ?? ctx?.directory ?? process.cwd();
         const taskDir = getTaskDir(config4, directory);
-        if (!existsSync70(taskDir)) {
+        if (!existsSync71(taskDir)) {
           return JSON.stringify({ deleted: 0, remaining: 0, deletedIds: [] });
         }
         const files = readdirSync22(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-"));
         const total = files.length;
         const deletedIds = [];
         for (const file3 of files) {
-          const filePath = join70(taskDir, file3);
+          const filePath = join72(taskDir, file3);
           let raw;
           try {
-            const content = readFileSync41(filePath, "utf-8");
+            const content = readFileSync42(filePath, "utf-8");
             raw = JSON.parse(content);
           } catch {
             continue;
@@ -92694,7 +92701,9 @@ Returns counts: {deleted, remaining, deletedIds}`,
   });
 }
 // src/tools/task/task-create.ts
-import { join as join71 } from "path";
+import { readdirSync as readdirSync23, statSync as statSync17 } from "fs";
+import { join as join73 } from "path";
+init_logger();
 function createTaskCreateTool(config4, ctx) {
   return tool({
     description: `Create a new task with auto-generated ID and threadID recording.
@@ -92736,6 +92745,13 @@ async function handleCreate2(args, config4, ctx, context) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
     try {
+      const existingTask = findDuplicateTask(taskDir, validatedArgs.subject, directory);
+      if (existingTask) {
+        return JSON.stringify({
+          task: { id: existingTask.id, subject: existingTask.subject },
+          deduplicated: true
+        });
+      }
       const taskId = generateTaskId();
       const task = {
         id: taskId,
@@ -92752,7 +92768,7 @@ async function handleCreate2(args, config4, ctx, context) {
         projectRoot: directory
       };
       const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(join71(taskDir, `${taskId}.json`), validatedTask);
+      writeJsonAtomic(join73(taskDir, `${taskId}.json`), validatedTask);
       return JSON.stringify({
         task: {
           id: validatedTask.id,
@@ -92772,8 +92788,47 @@ async function handleCreate2(args, config4, ctx, context) {
     return JSON.stringify({ error: "internal_error" });
   }
 }
+function findDuplicateTask(taskDir, subject, directory) {
+  let files;
+  try {
+    files = readdirSync23(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-"));
+  } catch (error95) {
+    log(`[task-create] Failed to list task dir ${taskDir} during dedup scan`, error95);
+    return null;
+  }
+  for (const file3 of files) {
+    const filePath = join73(taskDir, file3);
+    let existing;
+    try {
+      existing = readJsonSafe(filePath, TaskObjectSchema);
+    } catch (error95) {
+      log(`[task-create] Failed to read task file ${filePath} during dedup scan`, error95);
+      continue;
+    }
+    if (!existing)
+      continue;
+    const isActive = existing.status === "pending" || existing.status === "in_progress";
+    if (!isActive)
+      continue;
+    if (existing.subject.trim() !== subject.trim())
+      continue;
+    if (existing.projectRoot !== directory)
+      continue;
+    let mtimeMs;
+    try {
+      mtimeMs = statSync17(filePath).mtimeMs;
+    } catch (error95) {
+      log(`[task-create] Failed to stat task file ${filePath} during dedup scan`, error95);
+      continue;
+    }
+    if (Date.now() - mtimeMs > DEDUP_WINDOW_MS)
+      continue;
+    return existing;
+  }
+  return null;
+}
 // src/tools/task/task-get.ts
-import { join as join72 } from "path";
+import { join as join74 } from "path";
 function parseTaskId(id) {
   if (!TASK_ID_PATTERN.test(id))
     return null;
@@ -92798,7 +92853,7 @@ Returns null if the task does not exist or the file is invalid.`,
         }
         const directory = context?.directory ?? ctx?.directory ?? process.cwd();
         const taskDir = getTaskDir(config4, directory);
-        const taskPath = join72(taskDir, `${taskId}.json`);
+        const taskPath = join74(taskDir, `${taskId}.json`);
         const task = readJsonSafe(taskPath, TaskObjectSchema);
         return JSON.stringify({ task: task ?? null });
       } catch (error95) {
@@ -92811,35 +92866,42 @@ Returns null if the task does not exist or the file is invalid.`,
   });
 }
 // src/tools/task/task-list.ts
-import { existsSync as existsSync71, readdirSync as readdirSync23 } from "fs";
-import { join as join73 } from "path";
+import { existsSync as existsSync72, readdirSync as readdirSync24 } from "fs";
+import { join as join75 } from "path";
 function createTaskList(config4, ctx) {
   return tool({
     description: `List all active tasks with summary information.
     
 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 (_args, context) => {
+Returns summary format: id, subject, status, owner, blockedBy (not full description).
+
+Optional \`parentID\` filter: when provided, returns only tasks whose parentID matches
+(i.e. the subtasks of that parent task).`,
+    args: {
+      parentID: tool.schema.string().optional().describe("Filter to subtasks of this parent task ID")
+    },
+    execute: async (args, context) => {
+      const parentID = args.parentID;
       const directory = context?.directory ?? ctx?.directory ?? process.cwd();
       const taskDir = getTaskDir(config4, directory);
-      if (!existsSync71(taskDir)) {
+      if (!existsSync72(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
-      const files = readdirSync23(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
+      const files = readdirSync24(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
       if (files.length === 0) {
         return JSON.stringify({ tasks: [] });
       }
       const allTasks = [];
       for (const fileId of files) {
-        const task = readJsonSafe(join73(taskDir, `${fileId}.json`), TaskObjectSchema);
+        const task = readJsonSafe(join75(taskDir, `${fileId}.json`), TaskObjectSchema);
         if (task) {
           allTasks.push(task);
         }
       }
       const activeTasks = allTasks.filter((task) => task.status !== "completed" && task.status !== "deleted");
-      const summaries = activeTasks.map((task) => {
+      const filteredTasks = parentID ? activeTasks.filter((task) => task.parentID === parentID) : activeTasks;
+      const summaries = filteredTasks.map((task) => {
         const unresolvedBlockers = task.blockedBy.filter((blockerId) => {
           const blockerTask = allTasks.find((t) => t.id === blockerId);
           return blockerTask?.status !== "completed";
@@ -92849,7 +92911,8 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
           subject: task.subject,
           status: task.status,
           owner: task.owner,
-          blockedBy: unresolvedBlockers
+          blockedBy: unresolvedBlockers,
+          parentID: task.parentID
         };
       });
       return JSON.stringify({
@@ -92860,7 +92923,7 @@ Returns summary format: id, subject, status, owner, blockedBy (not full descript
   });
 }
 // src/tools/task/task-update.ts
-import { join as join74 } from "path";
+import { join as join76 } from "path";
 function parseTaskId2(id) {
   if (!TASK_ID_PATTERN.test(id))
     return null;
@@ -92906,7 +92969,7 @@ async function handleUpdate(args, config4, ctx, context) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
     try {
-      const taskPath = join74(taskDir, `${taskId}.json`);
+      const taskPath = join76(taskDir, `${taskId}.json`);
       const task = readJsonSafe(taskPath, TaskObjectSchema);
       if (!task) {
         return JSON.stringify({ error: "task_not_found" });
@@ -93051,6 +93114,7 @@ function createToolGuardHooks(args) {
   const { ctx, pluginConfig, isHookEnabled, safeHookEnabled } = args;
   const evolutionEnabled = pluginConfig.evolution?.enabled === true;
   const safeHook = (hookName, factory) => safeCreateHook(hookName, factory, { enabled: safeHookEnabled });
+  const backgroundTaskBlocker = isHookEnabled("background-task-blocker") ? safeHook("background-task-blocker", () => createBackgroundTaskBlockerHook()) : null;
   const commentChecker = isHookEnabled("comment-checker") ? safeHook("comment-checker", () => createCommentCheckerHooks(pluginConfig.comment_checker)) : null;
   const toolOutputTruncator = isHookEnabled("tool-output-truncator") ? safeHook("tool-output-truncator", () => createToolOutputTruncatorHook(ctx, { experimental: pluginConfig.experimental })) : null;
   let directoryAgentsInjector = null;
@@ -93084,6 +93148,7 @@ function createToolGuardHooks(args) {
   const taskEditGuard = isHookEnabled("task-edit-guard") ? safeHook("task-edit-guard", () => createTaskEditGuardHook(ctx)) : null;
   const evolutionWatcher = evolutionEnabled && isHookEnabled("evolution-watcher") ? safeHook("evolution-watcher", () => createEvolutionWatcherHook(ctx, pluginConfig.evolution)) : null;
   return {
+    backgroundTaskBlocker,
     commentChecker,
     toolOutputTruncator,
     directoryAgentsInjector,
@@ -93443,6 +93508,10 @@ class ConcurrencyManager {
     return this.queues.get(model)?.length ?? 0;
   }
 }
+// src/features/background-agent/handle-index.ts
+import { existsSync as existsSync73, mkdirSync as mkdirSync19, readdirSync as readdirSync25, readFileSync as readFileSync43, renameSync as renameSync5, unlinkSync as unlinkSync12, writeFileSync as writeFileSync26 } from "fs";
+import { dirname as dirname19, join as join77 } from "path";
+
 // src/features/background-agent/constants.ts
 var TASK_TTL_MS = 30 * 60 * 1000;
 var MIN_STABILITY_TIME_MS2 = 10 * 1000;
@@ -93457,6 +93526,126 @@ var POLLING_INTERVAL_MS = 3000;
 var PRUNE_THROTTLE_MS = 30000;
 var TASK_CLEANUP_DELAY_MS = 10 * 60 * 1000;
 
+// src/features/background-agent/handle-index.ts
+var BG_HANDLE_DIR_NAME = "bg-handles";
+var BG_HANDLE_FILE_PREFIX = "bg_";
+var BgHandleSchema = exports_external.object({
+  taskId: exports_external.string(),
+  parentSessionID: exports_external.string(),
+  parentMessageID: exports_external.string(),
+  description: exports_external.string(),
+  agent: exports_external.string(),
+  status: exports_external.enum(["pending", "running", "completed", "error", "cancelled", "interrupt"]),
+  model: exports_external.object({
+    providerID: exports_external.string(),
+    modelID: exports_external.string(),
+    variant: exports_external.string().optional(),
+    temperature: exports_external.number().optional()
+  }).optional(),
+  category: exports_external.string().optional(),
+  concurrencyGroup: exports_external.string().optional(),
+  queuedAt: exports_external.number().optional(),
+  startedAt: exports_external.number().optional(),
+  completedAt: exports_external.number().optional()
+}).strict();
+function getBgHandleDir(directory) {
+  return join77(directory, ".matrixx", BG_HANDLE_DIR_NAME);
+}
+function getHandlePath(directory, taskId) {
+  return join77(getBgHandleDir(directory), `${taskId}.json`);
+}
+function ensureDir3(dirPath) {
+  if (!existsSync73(dirPath)) {
+    mkdirSync19(dirPath, { recursive: true });
+  }
+}
+function toHandle(task) {
+  return {
+    taskId: task.id,
+    parentSessionID: task.parentSessionID,
+    parentMessageID: task.parentMessageID,
+    description: task.description,
+    agent: task.agent,
+    status: task.status,
+    model: task.model,
+    category: task.category,
+    concurrencyGroup: task.concurrencyGroup,
+    queuedAt: task.queuedAt?.getTime(),
+    startedAt: task.startedAt?.getTime(),
+    completedAt: task.completedAt?.getTime()
+  };
+}
+function writeHandle(directory, task) {
+  const filePath = getHandlePath(directory, task.id);
+  ensureDir3(dirname19(filePath));
+  const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+  try {
+    writeFileSync26(tempPath, JSON.stringify(toHandle(task), null, 2), "utf-8");
+    renameSync5(tempPath, filePath);
+  } catch (error95) {
+    try {
+      if (existsSync73(tempPath)) {
+        unlinkSync12(tempPath);
+      }
+    } catch {}
+    throw error95;
+  }
+}
+function readHandleFile(filePath) {
+  try {
+    if (!existsSync73(filePath)) {
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync43(filePath, "utf-8"));
+    const result = BgHandleSchema.safeParse(parsed);
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+function readHandles(directory) {
+  const dir = getBgHandleDir(directory);
+  if (!existsSync73(dir)) {
+    return [];
+  }
+  const handles = [];
+  for (const name of readdirSync25(dir)) {
+    if (!name.startsWith(BG_HANDLE_FILE_PREFIX) || !name.endsWith(".json")) {
+      continue;
+    }
+    const handle = readHandleFile(join77(dir, name));
+    if (handle) {
+      handles.push(handle);
+    }
+  }
+  return handles;
+}
+function sweepStaleHandles(directory, ttlMs = TASK_TTL_MS, now = Date.now()) {
+  const dir = getBgHandleDir(directory);
+  if (!existsSync73(dir)) {
+    return 0;
+  }
+  let removed = 0;
+  for (const name of readdirSync25(dir)) {
+    if (!name.startsWith(BG_HANDLE_FILE_PREFIX) || !name.endsWith(".json")) {
+      continue;
+    }
+    const filePath = join77(dir, name);
+    const handle = readHandleFile(filePath);
+    const timestamp = handle?.completedAt ?? handle?.startedAt ?? handle?.queuedAt;
+    if (handle && timestamp !== undefined && now - timestamp <= ttlMs) {
+      continue;
+    }
+    try {
+      unlinkSync12(filePath);
+      removed++;
+    } catch {}
+  }
+  if (removed > 0) {
+    log(`[bg-handles] Swept ${removed} stale handle file(s) from ${dir}`);
+  }
+  return removed;
+}
 // src/features/background-agent/error-helpers.ts
 function getErrorText(error95) {
   if (!error95)
@@ -93559,19 +93748,19 @@ function detectRepetitiveToolUse(window2) {
 }
 
 // src/features/background-agent/message-dir.ts
-import { existsSync as existsSync72, readdirSync as readdirSync24, readFileSync as readFileSync42 } from "fs";
-import { join as join75 } from "path";
+import { existsSync as existsSync74, readdirSync as readdirSync26, readFileSync as readFileSync44 } from "fs";
+import { join as join78 } from "path";
 var MESSAGE_DIR_CACHE_CAP = 1000;
 var messageDirCache = new Map;
 function computeMessageDir(sessionID) {
-  if (!existsSync72(MESSAGE_STORAGE))
+  if (!existsSync74(MESSAGE_STORAGE))
     return null;
-  const directPath = join75(MESSAGE_STORAGE, sessionID);
-  if (existsSync72(directPath))
+  const directPath = join78(MESSAGE_STORAGE, sessionID);
+  if (existsSync74(directPath))
     return directPath;
-  for (const dir of readdirSync24(MESSAGE_STORAGE)) {
-    const sessionPath = join75(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync72(sessionPath))
+  for (const dir of readdirSync26(MESSAGE_STORAGE)) {
+    const sessionPath = join78(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync74(sessionPath))
       return sessionPath;
   }
   return null;
@@ -93605,11 +93794,11 @@ function hasPartialAgentOrModel(message) {
 }
 function findNearestMessageExcludingCompaction(messageDir) {
   try {
-    const files = readdirSync24(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
+    const files = readdirSync26(messageDir).filter((name) => name.endsWith(".json")).sort().reverse();
     const parsedByFile = new Map;
     for (const file3 of files) {
       try {
-        const content = readFileSync42(join75(messageDir, file3), "utf-8");
+        const content = readFileSync44(join78(messageDir, file3), "utf-8");
         const parsed = JSON.parse(content);
         parsedByFile.set(file3, parsed);
         if (hasFullAgentAndModel(parsed)) {
@@ -93757,6 +93946,25 @@ class TaskHistory {
 }
 
 // src/features/background-agent/manager.ts
+function restoreTaskFromHandle(handle) {
+  const interrupted = handle.status === "running" || handle.status === "pending";
+  return {
+    id: handle.taskId,
+    parentSessionID: handle.parentSessionID,
+    parentMessageID: handle.parentMessageID,
+    description: handle.description,
+    prompt: "",
+    agent: handle.agent,
+    status: interrupted ? "interrupt" : handle.status,
+    queuedAt: handle.queuedAt !== undefined ? new Date(handle.queuedAt) : undefined,
+    startedAt: handle.startedAt !== undefined ? new Date(handle.startedAt) : undefined,
+    completedAt: handle.completedAt !== undefined ? new Date(handle.completedAt) : undefined,
+    model: handle.model,
+    category: handle.category,
+    concurrencyGroup: handle.concurrencyGroup
+  };
+}
+
 class BackgroundManager {
   static cleanupManagers = new Set;
   static cleanupRegistered = false;
@@ -93797,6 +94005,28 @@ class BackgroundManager {
     this.enableParentSessionNotifications = options?.enableParentSessionNotifications ?? true;
     this.registerProcessCleanup();
   }
+  persistHandle(task) {
+    try {
+      writeHandle(this.directory, task);
+    } catch (error95) {
+      log("[background-agent] Failed to persist background handle:", { taskId: task.id, error: error95 });
+    }
+  }
+  async restoreHandles() {
+    const swept = sweepStaleHandles(this.directory);
+    const handles = readHandles(this.directory);
+    let restored = 0;
+    for (const handle of handles) {
+      if (this.tasks.has(handle.taskId)) {
+        continue;
+      }
+      this.tasks.set(handle.taskId, restoreTaskFromHandle(handle));
+      restored++;
+    }
+    if (restored > 0 || swept > 0) {
+      log("[background-agent] Restored background handles:", { restored, swept });
+    }
+  }
   async launch(input) {
     log("[background-agent] launch() called with:", {
       agent: input.agent,
@@ -93948,6 +94178,7 @@ class BackgroundManager {
     };
     task.concurrencyKey = concurrencyKey;
     task.concurrencyGroup = concurrencyKey;
+    this.persistHandle(task);
     this.taskHistory.record(input.parentSessionID, { id: task.id, sessionID, agent: input.agent, description: input.description, status: "running", category: input.category, startedAt: task.startedAt });
     this.startPolling();
     log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent });
@@ -93999,6 +94230,7 @@ class BackgroundManager {
           existingTask.error = errorMessage;
         }
         existingTask.completedAt = new Date;
+        this.persistHandle(existingTask);
         if (existingTask.concurrencyKey) {
           this.concurrencyManager.release(existingTask.concurrencyKey);
           existingTask.concurrencyKey = undefined;
@@ -94101,6 +94333,7 @@ class BackgroundManager {
       concurrencyGroup
     };
     this.tasks.set(task.id, task);
+    this.persistHandle(task);
     registerSubagentSession(input.sessionID, input.parentSessionID);
     this.startPolling();
     this.taskHistory.record(input.parentSessionID, { id: task.id, sessionID: input.sessionID, agent: input.agent || "task", description: input.description, status: "running", startedAt: task.startedAt });
@@ -94147,6 +94380,7 @@ class BackgroundManager {
       existingTask.parentTools = input.parentTools;
     }
     existingTask.startedAt = new Date;
+    this.persistHandle(existingTask);
     existingTask.progress = {
       toolCalls: existingTask.progress?.toolCalls ?? 0,
       lastUpdate: new Date
@@ -94202,6 +94436,7 @@ class BackgroundManager {
       const errorMessage = error95 instanceof Error ? error95.message : String(error95);
       existingTask.error = errorMessage;
       existingTask.completedAt = new Date;
+      this.persistHandle(existingTask);
       if (existingTask.concurrencyKey) {
         this.concurrencyManager.release(existingTask.concurrencyKey);
         existingTask.concurrencyKey = undefined;
@@ -94366,6 +94601,7 @@ class BackgroundManager {
       task.status = "error";
       task.error = errorMessage ?? "Session error";
       task.completedAt = new Date;
+      this.persistHandle(task);
       this.taskHistory.record(task.parentSessionID, { id: task.id, sessionID: task.sessionID, agent: task.agent, description: task.description, status: "error", category: task.category, startedAt: task.startedAt, completedAt: task.completedAt });
       if (task.concurrencyKey) {
         this.concurrencyManager.release(task.concurrencyKey);
@@ -94534,6 +94770,7 @@ class BackgroundManager {
     }
     task.status = "cancelled";
     task.completedAt = new Date;
+    this.persistHandle(task);
     if (reason) {
       task.error = reason;
     }
@@ -94656,6 +94893,7 @@ class BackgroundManager {
     }
     task.status = "completed";
     task.completedAt = new Date;
+    this.persistHandle(task);
     this.taskHistory.record(task.parentSessionID, { id: task.id, sessionID: task.sessionID, agent: task.agent, description: task.description, status: "completed", category: task.category, startedAt: task.startedAt, completedAt: task.completedAt });
     if (task.concurrencyKey) {
       this.concurrencyManager.release(task.concurrencyKey);
@@ -94788,6 +95026,7 @@ class BackgroundManager {
         task.status = "error";
         task.error = errorMessage;
         task.completedAt = new Date;
+        this.persistHandle(task);
         if (task.concurrencyKey) {
           this.concurrencyManager.release(task.concurrencyKey);
           task.concurrencyKey = undefined;
@@ -94813,7 +95052,7 @@ class BackgroundManager {
         }
         this.tasks.delete(taskId);
         if (task.sessionID) {
-          subagentSessions.delete(task.sessionID);
+          unregisterSubagentSession(task.sessionID);
         }
       }
     }
@@ -94872,6 +95111,7 @@ class BackgroundManager {
         task.status = "cancelled";
         task.error = `Stale timeout (no activity for ${staleMinutes2}min since start)`;
         task.completedAt = new Date;
+        this.persistHandle(task);
         if (task.concurrencyKey) {
           this.concurrencyManager.release(task.concurrencyKey);
           task.concurrencyKey = undefined;
@@ -94900,6 +95140,7 @@ class BackgroundManager {
       task.status = "cancelled";
       task.error = `Stale timeout (no activity for ${staleMinutes}min)`;
       task.completedAt = new Date;
+      this.persistHandle(task);
       if (task.concurrencyKey) {
         this.concurrencyManager.release(task.concurrencyKey);
         task.concurrencyKey = undefined;
@@ -95791,9 +96032,9 @@ class TmuxSessionManager {
 var SESSION_TIMEOUT_MS3 = 10 * 60 * 1000;
 var MIN_STABILITY_TIME_MS4 = 10 * 1000;
 // src/agents/dynamic-agent-prompt-builder.ts
-import { existsSync as existsSync73, readFileSync as readFileSync43 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join76 } from "path";
+import { existsSync as existsSync75, readFileSync as readFileSync45 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join79 } from "path";
 init_logger();
 function categorizeTools(toolNames) {
   return toolNames.map((name) => {
@@ -96155,24 +96396,24 @@ function exploreCtxPart(hasGrepGlob) {
 function resolveContextModeDisciplinePath() {
   try {
     const resolved = __require.resolve("context-mode/configs/opencode/AGENTS.md");
-    if (existsSync73(resolved))
+    if (existsSync75(resolved))
       return resolved;
   } catch {}
   try {
     const cacheDir = getOpenCodeCacheDir();
-    const p = join76(cacheDir, "packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md");
-    if (existsSync73(p))
+    const p = join79(cacheDir, "packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md");
+    if (existsSync75(p))
       return p;
   } catch {}
   try {
-    const base = process.env.XDG_CACHE_HOME ?? join76(homedir10(), ".cache");
-    const p = join76(base, "opencode/packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md");
-    if (existsSync73(p))
+    const base = process.env.XDG_CACHE_HOME ?? join79(homedir11(), ".cache");
+    const p = join79(base, "opencode/packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md");
+    if (existsSync75(p))
       return p;
   } catch {}
   try {
-    const p2 = join76(homedir10(), ".cache/opencode/packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md");
-    if (existsSync73(p2))
+    const p2 = join79(homedir11(), ".cache/opencode/packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md");
+    if (existsSync75(p2))
       return p2;
   } catch {}
   return null;
@@ -96190,11 +96431,11 @@ function loadContextModeDiscipline(hasGrepGlob = true) {
     const p = resolveContextModeDisciplinePath();
     if (!p)
       throw new Error("discipline file not found");
-    const raw = readFileSync43(p, "utf8");
+    const raw = readFileSync45(p, "utf8");
     let version4 = "1.0.169";
     try {
       const pkgResolved = __require.resolve("context-mode/package.json");
-      const pkgRaw = readFileSync43(pkgResolved, "utf8");
+      const pkgRaw = readFileSync45(pkgResolved, "utf8");
       const pkg = JSON.parse(pkgRaw);
       if (pkg.version)
         version4 = pkg.version;
@@ -96241,11 +96482,11 @@ function loadCompactContextDiscipline(hasGrepGlob = true) {
     const p = resolveContextModeDisciplinePath();
     if (!p)
       throw new Error("discipline file not found");
-    const raw = readFileSync43(p, "utf8");
+    const raw = readFileSync45(p, "utf8");
     let version4 = "1.0.169";
     try {
       const pkgResolved = __require.resolve("context-mode/package.json");
-      const pkgRaw = readFileSync43(pkgResolved, "utf8");
+      const pkgRaw = readFileSync45(pkgResolved, "utf8");
       const pkg = JSON.parse(pkgRaw);
       if (pkg.version)
         version4 = pkg.version;
@@ -97314,8 +97555,8 @@ function createBddContractAgent(model) {
 createBddContractAgent.mode = MODE2;
 
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync74, readFileSync as readFileSync44 } from "fs";
-import { homedir as homedir11 } from "os";
+import { existsSync as existsSync76, readFileSync as readFileSync46 } from "fs";
+import { homedir as homedir12 } from "os";
 import { isAbsolute as isAbsolute6, resolve as resolve10 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
   if (!promptAppend.startsWith("file://"))
@@ -97324,16 +97565,16 @@ function resolvePromptAppend(promptAppend, configDir) {
   let filePath;
   try {
     const decoded = decodeURIComponent(encoded);
-    const expanded = decoded.startsWith("~/") ? decoded.replace(/^~\//, `${homedir11()}/`) : decoded;
+    const expanded = decoded.startsWith("~/") ? decoded.replace(/^~\//, `${homedir12()}/`) : decoded;
     filePath = isAbsolute6(expanded) ? expanded : resolve10(configDir ?? process.cwd(), expanded);
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
-  if (!existsSync74(filePath)) {
+  if (!existsSync76(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync44(filePath, "utf8");
+    return readFileSync46(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -99217,16 +99458,19 @@ var OPERATOR_PROMPT_METADATA = {
   category: "exploration",
   cost: "CHEAP",
   promptAlias: "Librarian",
-  keyTrigger: "External library/source mentioned \u2192 fire `librarian` background",
+  keyTrigger: "External library/source mentioned or code search needed \u2192 fire `librarian` background",
   triggers: [
-    { domain: "Librarian", trigger: "Unfamiliar packages / libraries, struggles at weird behaviour (to find existing implementation of opensource)" }
+    { domain: "Librarian", trigger: "Unfamiliar packages / libraries, struggles at weird behaviour (to find existing implementation of opensource)" },
+    { domain: "Code Search", trigger: "Find real-world code examples, search GitHub repos for patterns, or need OSS implementation references" }
   ],
   useWhen: [
     "How do I use [library]?",
     "What's the best practice for [framework feature]?",
     "Why does [external dependency] behave this way?",
     "Find examples of [library] usage",
-    "Working with unfamiliar npm/pip/cargo packages"
+    "Working with unfamiliar npm/pip/cargo packages",
+    "Show me real-world code examples of [pattern]",
+    "Search GitHub for implementations of [feature]"
   ]
 };
 function createOperatorAgent(model) {
@@ -99327,7 +99571,7 @@ context7_query-docs(libraryId: id, query: "specific topic")
 Tool 1: context7_resolve-library-id("library-name")
         \u2192 then context7_query-docs(libraryId: id, query: "specific-topic")
 Tool 2: webfetch(relevant_pages_from_sitemap)  // Targeted, not random
-Tool 3: grep_app_searchGitHub(query: "usage pattern", language: ["TypeScript"])
+Tool 3: white_rabbit_searchGitHub(query: "usage pattern", language: ["TypeScript"])
 \`\`\`
 
 **Output**: Summarize findings with links to official docs (versioned if applicable) and real-world examples.
@@ -99346,8 +99590,8 @@ Step 2: Get commit SHA for permalinks
         cd \${TMPDIR:-/tmp}/repo-name && git rev-parse HEAD
 
 Step 3: Find the implementation
-        - grep/ast_grep_search for function/class
-        - read the specific file
+        - ctx_search / ast_grep_search for function/class \u2014 NOT grep (blocked under enforce:true)
+        - ctx_execute_file for analysis (or read for targeted sections)
         - git blame for context if needed
 
 Step 4: Construct permalink
@@ -99357,7 +99601,7 @@ Step 4: Construct permalink
 **Parallel acceleration (4+ calls)**:
 \`\`\`
 Tool 1: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
-Tool 2: grep_app_searchGitHub(query: "function_name", repo: "owner/repo")
+Tool 2: white_rabbit_searchGitHub(query: "function_name", repo: "owner/repo")
 Tool 3: gh api repos/owner/repo/commits/HEAD --jq '.sha'
 Tool 4: context7_get-library-docs(id, topic: "relevant-api")
 \`\`\`
@@ -99396,8 +99640,8 @@ Tool 1: context7_resolve-library-id \u2192 context7_query-docs
 Tool 2: webfetch(targeted_doc_pages_from_sitemap)
 
 // Code Search
-Tool 3: grep_app_searchGitHub(query: "pattern1", language: [...])
-Tool 4: grep_app_searchGitHub(query: "pattern2", useRegexp: true)
+Tool 3: white_rabbit_searchGitHub(query: "pattern1", language: [...])
+Tool 4: white_rabbit_searchGitHub(query: "pattern2", useRegexp: true)
 
 // Source Analysis
 Tool 5: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
@@ -99453,7 +99697,7 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 | **Sitemap Discovery** | webfetch | \`webfetch(docs_url + "/sitemap.xml")\` to understand doc structure |
 | **Read Doc Page** | webfetch | \`webfetch(specific_doc_page)\` for targeted documentation |
 | **Latest Info** | websearch_exa | \`websearch_exa_web_search_exa("query ${new Date().getFullYear()}")\` |
-| **Fast Code Search** | grep_app | \`grep_app_searchGitHub(query, language, useRegexp)\` |
+| **Fast Code Search** | white_rabbit | \`white_rabbit_searchGitHub(query, language, useRegexp)\` |
 | **Deep Code Search** | gh CLI | \`gh search code "query" --repo owner/repo\` |
 | **Clone Repo** | gh CLI | \`gh repo clone owner/repo \${TMPDIR:-/tmp}/name -- --depth 1\` |
 | **Issues/PRs** | gh CLI | \`gh search issues/prs "query" --repo owner/repo\` |
@@ -99489,16 +99733,16 @@ Use OS-appropriate temp directory:
 **Doc Discovery is SEQUENTIAL** (websearch \u2192 version check \u2192 sitemap \u2192 investigate).
 **Main phase is PARALLEL** once you know where to look.
 
-**Always vary queries** when using grep_app:
+**Always vary queries** when using white_rabbit:
 \`\`\`
 // GOOD: Different angles
-grep_app_searchGitHub(query: "useQuery(", language: ["TypeScript"])
-grep_app_searchGitHub(query: "queryOptions", language: ["TypeScript"])
-grep_app_searchGitHub(query: "staleTime:", language: ["TypeScript"])
+white_rabbit_searchGitHub(query: "useQuery(", language: ["TypeScript"])
+white_rabbit_searchGitHub(query: "queryOptions", language: ["TypeScript"])
+white_rabbit_searchGitHub(query: "staleTime:", language: ["TypeScript"])
 
 // BAD: Same pattern
-grep_app_searchGitHub(query: "useQuery")
-grep_app_searchGitHub(query: "useQuery")
+white_rabbit_searchGitHub(query: "useQuery")
+white_rabbit_searchGitHub(query: "useQuery")
 \`\`\`
 
 ---
@@ -99508,7 +99752,7 @@ grep_app_searchGitHub(query: "useQuery")
 | Failure | Recovery Action |
 |---------|-----------------|
 | context7 not found | Clone repo, read source + README directly |
-| grep_app no results | Broaden query, try concept instead of exact name |
+| white_rabbit no results | Broaden query, try concept instead of exact name |
 | gh API rate limit | Use cloned repo in temp directory |
 | Repo not found | Search for forks or mirrors |
 | Sitemap not found | Try \`/sitemap-0.xml\`, \`/sitemap_index.xml\`, or fetch docs index page and parse navigation |
@@ -99519,7 +99763,7 @@ grep_app_searchGitHub(query: "useQuery")
 
 ## COMMUNICATION RULES
 
-1. **NO TOOL NAMES**: Say "I'll search the codebase" not "I'll use grep_app"
+1. **NO TOOL NAMES**: Say "I'll search the codebase" not "I'll use white_rabbit"
 2. **NO PREAMBLE**: Answer directly, skip "I'll help you with..."
 3. **ALWAYS CITE**: Every code claim needs a permalink
 4. **USE MARKDOWN**: Code blocks with language identifiers
@@ -100496,8 +100740,8 @@ Your response has **FAILED** if:
 Use the right tool for the job:
 - **Semantic search** (definitions, references): LSP tools
 - **Structural patterns** (function shapes, class structures): ast_grep_search  
-- **Text patterns** (strings, comments, logs): grep (if available; otherwise ctx_search / ast_grep_search)
-- **File patterns** (find by name/extension): glob (if available; otherwise ctx_search / LSP)
+- **Text patterns** (strings, comments, logs): ctx_search (indexed KB) -> ctx_batch_execute / ctx_execute for multi-file analysis. ast_grep_search for structural patterns. grep/glob only as fallback when ctx_* unavailable.
+- **File patterns** (find by name/extension): ctx_search (indexed KB) -> LSP / ast_grep_search. glob only as fallback when ctx_* unavailable.
 - **History/evolution** (when added, who changed): git commands
 
 Flood with parallel calls. Cross-validate findings across multiple tools.`
@@ -100695,6 +100939,13 @@ This will:
 5. **Seraph Before Plan** - Always catch gaps before committing to plan
 6. **Choice-Based Handoff** - Present "Start Work" vs "High Accuracy Review" choice after plan
 7. **Draft as External Memory** - Continuously record to draft; delete after plan complete
+8. **Background-First Delegation** - Default to \`run_in_background=true\` for every delegation; never nest a blocking subagent call inside an already-blocking session
+
+### Delegation Policy (MANDATORY)
+
+- **Default to background mode**: every Oracle delegation passes \`run_in_background=true\`.
+- **Never nest a blocking subagent call** (\`run_in_background=false\`) inside an already-blocking session. Oracle may itself run under a fixed poll budget (default 600s); a nested blocking call consumes that budget and stalls at the timeout.
+- **Use sequential top-level calls instead**: fire the delegation in background, return to your work, then collect the result with \`background_output(task_id=...)\`.
 
 ---
 
@@ -100728,12 +100979,14 @@ var ORACLE_HIGH_ACCURACY_MODE = `# PHASE 3: PLAN GENERATION
 \`\`\`typescript
 // After generating initial plan
 while (true) {
-  const result = task(
+  // Fire Smith in background (never a blocking nested call), then collect its verdict.
+  const smithTask = task(
     subagent_type="smith",
     load_skills=[],
     prompt=".matrixx/plans/{name}.md",
-    run_in_background=false
+    run_in_background=true
   )
+  const result = background_output(task_id=smithTask.task_id)
 
   if (result.verdict === "OKAY") {
     break // Plan approved - exit loop
@@ -101338,7 +101591,7 @@ task(subagent_type="operator", load_skills=[], prompt="I'm designing architectur
 
 **Oracle Consultation** (recommend when stakes are high):
 \`\`\`typescript
-task(subagent_type="oracle", load_skills=[], prompt="Architecture consultation needed: [context]...", run_in_background=false)
+task(subagent_type="oracle", load_skills=[], prompt="Architecture consultation needed: [context]...", run_in_background=true)
 \`\`\`
 
 **Interview Focus:**
@@ -101500,12 +101753,14 @@ todoWrite([
 
 > **Edge \u2014 Trivial/Simple bypass:** If complexity is 1-2 (Trivial/Simple) and the request is ambiguous but single-scope (one domain, no architectural keywords), **bypass Seraph** and ask directly per Morpheus Phase 0 (ask ONE clarifying question).
 
-If gate **passes**, summon Seraph:
+If gate **passes**, summon Seraph in **background mode** (never blocking \u2014 see policy below):
 
 \`\`\`typescript
-task(
+// Fire Seraph in background \u2014 NEVER run_in_background=false from this session.
+const seraphTask = task(
   subagent_type="seraph",
   load_skills=[],
+  run_in_background=true,
   prompt=\`Review this planning session before I generate the work plan:
 
   **User's Goal**: {summarize what user wants}
@@ -101525,11 +101780,18 @@ task(
   3. Potential scope creep areas to lock down
   4. Assumptions I'm making that need validation
   5. Missing acceptance criteria
-  6. Edge cases not addressed\`,
-  run_in_background=false
+  6. Edge cases not addressed\`
 )
+
+// Continue drafting/other work, then collect once when needed:
+const seraphReview = background_output(task_id=seraphTask.task_id)
 \`\`\`
 
+> **NO-BLOCKING-NESTING POLICY (MANDATORY \u2014 applies to EVERY Oracle delegation):**
+> - **Default to background mode**: always pass \`run_in_background=true\`. Oracle's own invocations default to background; blocking is never the default.
+> - **Never nest a blocking subagent call** (\`run_in_background=false\`) inside your own session. Oracle may itself be running inside a fixed poll budget (default 600s); a blocking nested call consumes that same budget and stalls at the timeout.
+> - **Use sequential top-level calls instead**: fire the delegation in background, return to your work, then collect the result with \`background_output(task_id=...)\`. If a result is required before proceeding, collect it once and continue \u2014 never block on a nested subagent.
+
 If gate **does NOT pass**, skip Seraph and proceed directly to plan generation (note \`Seraph bypassed: complexity=X / no multi-component signal\` in summary).
 
 ## Post-Seraph: Auto-Generate Plan and Summarize
@@ -101875,7 +102137,7 @@ Parallel Speedup: ~40% faster than sequential
 
 | Wave | Tasks | Recommended Agents |
 |------|-------|-------------------|
-| 1 | 1, 5 | task(category="...", load_skills=[...], run_in_background=false) |
+| 1 | 1, 5 | task(category="...", load_skills=[...], run_in_background=true) |
 | 2 | 2, 3, 6 | dispatch parallel after Wave 1 completes |
 | 3 | 4 | final integration task |
 
@@ -102891,14 +103153,6 @@ var document_reader = {
   enabled: true
 };
 
-// src/mcp/grep-app.ts
-var grep_app = {
-  type: "remote",
-  url: "https://mcp.grep.app",
-  enabled: true,
-  oauth: false
-};
-
 // src/mcp/mcp-validator.ts
 function validateWebsearchConfig(config4) {
   const provider = config4?.provider || "exa";
@@ -102947,8 +103201,16 @@ function createWebsearchConfig(config4) {
 }
 var websearch = createWebsearchConfig();
 
+// src/mcp/white-rabbit.ts
+var white_rabbit = {
+  type: "remote",
+  url: "https://mcp.grep.app",
+  enabled: true,
+  oauth: false
+};
+
 // src/mcp/types.ts
-var McpNameSchema = exports_external.enum(["websearch", "context7", "grep_app", "document_reader"]);
+var McpNameSchema = exports_external.enum(["websearch", "context7", "white_rabbit", "document_reader"]);
 var AnyMcpNameSchema = exports_external.string().min(1);
 
 // src/mcp/index.ts
@@ -102997,8 +103259,8 @@ function createBuiltinMcps(disabledMcps = [], config4, options = {}) {
   if (!disabledMcps.includes("context7")) {
     mcps.context7 = context7;
   }
-  if (!disabledMcps.includes("grep_app")) {
-    mcps.grep_app = grep_app;
+  if (!disabledMcps.includes("white_rabbit")) {
+    mcps.white_rabbit = white_rabbit;
   }
   if (!disabledMcps.includes("document_reader")) {
     if (commandAvailable("uvx")) {
@@ -103100,7 +103362,7 @@ function applyToolConfig(params) {
   const denyTaskTools = !isTaskSystem ? { "task_*": "deny", task: "deny" } : {};
   params.config.tools = {
     ...params.config.tools,
-    "grep_app_*": false,
+    "white_rabbit_*": false,
     LspHover: false,
     LspCodeActions: false,
     LspCodeActionResolve: false,
@@ -103112,7 +103374,7 @@ function applyToolConfig(params) {
   const questionPermission = isCliRunMode ? "deny" : "allow";
   const operator = agentByKey(params.agentResult, "operator");
   if (operator) {
-    operator.permission = { ...operator.permission, "grep_app_*": "allow" };
+    operator.permission = { ...operator.permission, "white_rabbit_*": "allow" };
   }
   const construct = agentByKey(params.agentResult, "construct");
   if (construct) {
@@ -103220,6 +103482,9 @@ function createManagers(args) {
     },
     enableParentSessionNotifications: backgroundNotificationHookEnabled
   });
+  backgroundManager.restoreHandles().catch((error95) => {
+    log("[index] Failed to restore background handles:", error95);
+  });
   initTaskToastManager(ctx.client);
   const configHandler = createConfigHandler({
     ctx: { directory: ctx.directory, client: ctx.client },
@@ -103306,7 +103571,8 @@ function createToolRegistry(args) {
     availableSkills: skillContext.availableSkills,
     modelRequirements: pluginConfig.modelRequirements,
     complexityDowngrades: pluginConfig.complexityDowngrades,
-    tiers: pluginConfig.tiers,
+    modelPresets: pluginConfig.model_presets,
+    activePreset: pluginConfig.active_preset,
     agentOverrides: pluginConfig.agents,
     onSyncSessionCreated: async (event) => {
       log("[index] onSyncSessionCreated callback", {
@@ -103367,6 +103633,7 @@ function createToolRegistry(args) {
     ...createHandoffTools(ctx),
     ...createPdfExtractFiguresTool(),
     ...createDcpSwitchProfileTool({ pluginConfig }),
+    ...createPresetTool({ pluginConfig, directory: ctx.directory }),
     ...backgroundTools,
     delegate_agent: delegateAgent,
     ...lookAt ? { look_at: lookAt } : {},
@@ -103393,6 +103660,10 @@ function createToolRegistry(args) {
 // src/create-tools.ts
 async function createTools(args) {
   const { ctx, pluginConfig, managers } = args;
+  const pollTimeout = resolveTasksConfig(pluginConfig).pollTimeoutMs;
+  if (pollTimeout !== undefined) {
+    setPollTimeoutMs(pollTimeout);
+  }
   const skillContext = await createSkillContext({
     directory: ctx.directory,
     pluginConfig
@@ -103494,10 +103765,8 @@ var AgentPermissionSchema = exports_external.object({
 });
 
 // src/config/schema/agent-overrides.ts
-var TierNameSchema = exports_external.enum(["free", "fast", "standard", "premium", "frontier"]);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
-  tier: TierNameSchema.optional(),
   variant: exports_external.string().optional(),
   category: exports_external.string().optional(),
   skills: exports_external.array(exports_external.string()).optional(),
@@ -103588,7 +103857,6 @@ var BrowserAutomationConfigSchema = exports_external.object({
 var CategoryConfigSchema = exports_external.object({
   description: exports_external.string().optional(),
   model: exports_external.string().optional(),
-  tier: TierNameSchema.optional(),
   variant: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
   top_p: exports_external.number().min(0).max(1).optional(),
@@ -103626,7 +103894,7 @@ var BuiltinCommandNameSchema = exports_external.enum([
   "refactor",
   "start-work",
   "stop-continuation",
-  "profile",
+  "preset",
   "end-ultrawork",
   "handoff",
   "research",
@@ -103758,6 +104026,7 @@ var HookNameEnum = exports_external.enum([
   "preemptive-compaction",
   "rules-injector",
   "background-notification",
+  "background-task-blocker",
   "auto-update-checker",
   "startup-toast",
   "keyword-detector",
@@ -103823,6 +104092,29 @@ var MatrixxSelfConfigSkillConfigSchema = exports_external.object({
   proactive: exports_external.boolean().default(false)
 });
 
+// src/config/schema/model-presets.ts
+var providerModelSchema = exports_external.string().refine((s) => {
+  if (!s.includes("/"))
+    return false;
+  if (s.startsWith("/") || s.endsWith("/"))
+    return false;
+  if (s.includes("//"))
+    return false;
+  const parts = s.split("/");
+  return parts.length >= 2 && parts.every((p) => p.length > 0);
+}, { message: "Must be <provider>/<model>" });
+var ModelPresetEntrySchema = exports_external.object({
+  model: providerModelSchema,
+  variant: exports_external.string().optional()
+});
+var ModelPresetSchema = exports_external.object({
+  default_model: providerModelSchema.optional(),
+  agents: exports_external.record(exports_external.string(), ModelPresetEntrySchema).optional(),
+  categories: exports_external.record(exports_external.string(), ModelPresetEntrySchema).optional()
+});
+var ModelPresetsSchema = exports_external.record(exports_external.string(), ModelPresetSchema);
+var ActivePresetSchema = exports_external.string().min(1);
+
 // src/config/schema/morpheus.ts
 var MorpheusTasksConfigSchema = exports_external.object({
   storage_path: exports_external.string().optional(),
@@ -103949,6 +104241,22 @@ var SkillsConfigSchema = exports_external.union([
   }).catchall(SkillEntrySchema)
 ]);
 
+// src/config/schema/task.ts
+var TaskConfigSchema = exports_external.object({
+  pollTimeoutMs: exports_external.number().min(60000).optional()
+});
+
+// src/config/schema/tasks.ts
+var TasksConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().optional().default(true),
+  scope: exports_external.enum(["global", "project"]).default("project").optional().describe("Task storage scope: project \u2192 .matrixx/tasks per project (default), global \u2192 <opencode-config>/tasks/{listId}"),
+  storage_path: exports_external.string().optional(),
+  task_list_id: exports_external.string().optional(),
+  stale_after_hours: exports_external.number().int().min(1).optional().describe("Pending tasks with no file activity for this many hours are considered stale (default: 24). Stale tasks are excluded from task-continuation directives."),
+  session_scoped: exports_external.boolean().default(true).optional().describe("When true, the task-continuation-enforcer only considers tasks created by the current session (or its subagent sessions). When false, all project tasks are considered regardless of session origin."),
+  pollTimeoutMs: exports_external.number().min(60000).optional()
+});
+
 // src/config/schema/tdd-enforcer.ts
 var TddEnforcerConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false)
@@ -103980,7 +104288,8 @@ var WebsearchConfigSchema = exports_external.object({
 var MatrixxConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   global_model: exports_external.string().optional(),
-  default_tier: TierNameSchema.optional(),
+  model_presets: ModelPresetsSchema.optional(),
+  active_preset: ActivePresetSchema.optional(),
   new_task_system_enabled: exports_external.boolean().optional(),
   default_run_agent: exports_external.string().optional(),
   disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
@@ -104002,6 +104311,8 @@ var MatrixxConfigSchema = exports_external.object({
   background_task: BackgroundTaskConfigSchema.optional(),
   notification: NotificationConfigSchema.optional(),
   babysitting: BabysittingConfigSchema.optional(),
+  tasks: TasksConfigSchema.optional(),
+  task: TaskConfigSchema.optional(),
   tdd_enforcer: TddEnforcerConfigSchema.optional(),
   browser_automation_engine: BrowserAutomationConfigSchema.optional(),
   websearch: WebsearchConfigSchema.optional(),
@@ -104017,7 +104328,6 @@ var MatrixxConfigSchema = exports_external.object({
   rtk: RtkConfigSchema.optional(),
   evolution: EvolutionConfigSchema.optional(),
   _migrations: exports_external.array(exports_external.string()).optional(),
-  tiers: TiersSchema.optional(),
   modelRequirements: ModelRequirementsSchema.optional(),
   complexityDowngrades: ComplexityDowngradesSchema.optional()
 });
@@ -104025,11 +104335,8 @@ var MatrixxConfigSchema = exports_external.object({
 init_logger();
 var MIGRATION_KEY = "model-migration";
 function normalizeModelInput(value) {
-  if (value.startsWith("tier:")) {
-    return value;
-  }
   if (value.includes("/")) {
-    log(`[migration] prefixed model '${value}' is deprecated, use 'tier:<name>' or bare '<model>'`);
+    log(`[migration] prefixed model '${value}' is deprecated, use bare '<model>'`);
   }
   return value;
 }
@@ -104041,26 +104348,6 @@ function migrateMatrixxConfig(raw) {
   if (typeof migrated.global_model === "string") {
     migrated = { ...migrated, global_model: normalizeModelInput(migrated.global_model) };
   }
-  if (migrated.tiers) {
-    const nextTiers = {};
-    for (const [tierName, spec] of Object.entries(migrated.tiers)) {
-      if (!spec || typeof spec !== "object") {
-        nextTiers[tierName] = spec;
-        continue;
-      }
-      const typed = spec;
-      if (!typed.fallback) {
-        nextTiers[tierName] = spec;
-        continue;
-      }
-      const nextFallback = typed.fallback.map((entry) => ({
-        ...entry,
-        model: normalizeModelInput(entry.model)
-      }));
-      nextTiers[tierName] = { ...spec, fallback: nextFallback };
-    }
-    migrated = { ...migrated, tiers: nextTiers };
-  }
   if (migrated.modelRequirements) {
     const nextMR = { ...migrated.modelRequirements };
     for (const scope of ["agents", "categories"]) {
@@ -104205,7 +104492,7 @@ function mergeConfigs(base, override) {
   });
   return merged;
 }
-function resolveConfigPath(baseDir, configName) {
+function resolveConfigPath2(baseDir, configName) {
   const newBase = path13.join(baseDir, "matrixx");
   const newDetected = detectConfigFile(newBase);
   if (newDetected.format !== "none") {
@@ -104219,29 +104506,39 @@ function resolveConfigPath(baseDir, configName) {
   }
   return `${newBase}.json`;
 }
+function assertModelsResolvable(config4) {
+  const globalModel = config4.global_model;
+  const unresolved = [];
+  for (const [name, entry] of Object.entries(config4.agents ?? {})) {
+    if (entry && !entry.disable && !entry.model && !globalModel) {
+      unresolved.push(`agent "${name}"`);
+    }
+  }
+  for (const [name, entry] of Object.entries(config4.categories ?? {})) {
+    if (entry && !entry.disable && !entry.model && !globalModel) {
+      unresolved.push(`category "${name}"`);
+    }
+  }
+  if (unresolved.length > 0) {
+    throw new ConfigError(`Matrixx config error: no model resolved for ${unresolved.join(", ")}. ` + `Set an explicit "model" on the entry, define model_presets with an active_preset, ` + `or run "bunx opencode-matrixx setup" to generate a preset from your connected providers.`);
+  }
+}
 async function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const userConfigPath = resolveConfigPath(configDir, "matrixx");
+  const userConfigPath = resolveConfigPath2(configDir, "matrixx");
   const projectDir = path13.join(directory, ".opencode");
-  const projectConfigPath = resolveConfigPath(projectDir, "matrixx");
+  const projectConfigPath = resolveConfigPath2(projectDir, "matrixx");
   let config4 = loadConfigFromPath(userConfigPath, ctx) ?? {};
   const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
   if (projectConfig) {
     config4 = mergeConfigs(config4, projectConfig);
   }
   config4 = migrateMatrixxConfig(config4);
-  const connectedProviders = readConnectedProvidersCache();
-  const availableModels = await fetchAvailableModels(undefined, { connectedProviders });
-  const tierCtx = {
-    availableModels: availableModels ?? new Set,
-    connectedProviders
-  };
-  config4 = resolveTiersInConfig(config4, tierCtx);
-  const resolvedDefaults = resolveTiersInCategoryRegistry(DEFAULT_CATEGORIES, tierCtx, config4);
-  config4 = {
-    ...config4,
-    categories: { ...resolvedDefaults, ...config4.categories ?? {} }
-  };
+  config4 = applyActivePreset(config4, config4.active_preset);
+  if (config4.active_preset && config4.model_presets?.[config4.active_preset]) {
+    log("Active model preset applied", { active_preset: config4.active_preset });
+  }
+  assertModelsResolvable(config4);
   log("Final merged config", {
     agents: config4.agents,
     disabled_agents: config4.disabled_agents,
@@ -104461,19 +104758,19 @@ function createEventHandler2(args) {
   };
   const recentSyntheticIdles = new Map;
   const recentRealIdles = new Map;
-  const DEDUP_WINDOW_MS = 500;
+  const DEDUP_WINDOW_MS2 = 500;
   return async (input) => {
     pruneRecentSyntheticIdles({
       recentSyntheticIdles,
       recentRealIdles,
       now: Date.now(),
-      dedupWindowMs: DEDUP_WINDOW_MS
+      dedupWindowMs: DEDUP_WINDOW_MS2
     });
     if (input.event.type === "session.idle") {
       const sessionID = input.event.properties?.sessionID;
       if (sessionID) {
         const emittedAt = recentSyntheticIdles.get(sessionID);
-        if (emittedAt && Date.now() - emittedAt < DEDUP_WINDOW_MS) {
+        if (emittedAt && Date.now() - emittedAt < DEDUP_WINDOW_MS2) {
           recentSyntheticIdles.delete(sessionID);
           return;
         }
@@ -104485,7 +104782,7 @@ function createEventHandler2(args) {
     if (syntheticIdle) {
       const sessionID = syntheticIdle.event.properties?.sessionID;
       const emittedAt = recentRealIdles.get(sessionID);
-      if (emittedAt && Date.now() - emittedAt < DEDUP_WINDOW_MS) {
+      if (emittedAt && Date.now() - emittedAt < DEDUP_WINDOW_MS2) {
         recentRealIdles.delete(sessionID);
         return;
       }
@@ -104661,22 +104958,22 @@ function createToolExecuteAfterHandler2(args) {
 
 // src/features/assembly-state/manager.ts
 init_logger();
-var HOOK_NAME19 = "assembly-state";
+var HOOK_NAME20 = "assembly-state";
 var disabledSessions = new Set;
 function isAssemblyDisabled(sessionID) {
   return disabledSessions.has(sessionID);
 }
 function disableAssembly(sessionID) {
   disabledSessions.add(sessionID);
-  log(`[${HOOK_NAME19}] Assembly disabled for session`, { sessionID });
+  log(`[${HOOK_NAME20}] Assembly disabled for session`, { sessionID });
   disabledSessions.add(sessionID);
-  log(`[${HOOK_NAME19}] Consensus disabled for session`, { sessionID });
+  log(`[${HOOK_NAME20}] Consensus disabled for session`, { sessionID });
 }
 function enableAssembly(sessionID) {
   disabledSessions.delete(sessionID);
-  log(`[${HOOK_NAME19}] Assembly enabled for session`, { sessionID });
+  log(`[${HOOK_NAME20}] Assembly enabled for session`, { sessionID });
   disabledSessions.delete(sessionID);
-  log(`[${HOOK_NAME19}] Consensus enabled for session`, { sessionID });
+  log(`[${HOOK_NAME20}] Consensus enabled for session`, { sessionID });
 }
 // src/plugin/session-agent-resolver.ts
 async function resolveSessionAgent(client2, sessionId, timeoutMs = 5000) {
@@ -104719,6 +105016,7 @@ function createToolExecuteBeforeHandler2(args) {
   const taskEditGuardHook = hooks2.taskEditGuard?.["tool.execute.before"];
   const tasksTodowriteDisablerHook = hooks2.tasksTodowriteDisabler?.["tool.execute.before"];
   const oracleMdOnlyHook = hooks2.oracleMdOnly?.["tool.execute.before"];
+  const backgroundTaskBlockerHook = hooks2.backgroundTaskBlocker?.["tool.execute.before"];
   const contextModeEnforcerHook = hooks2.contextModeEnforcer?.["tool.execute.before"];
   const nonInteractiveEnvHook = hooks2.nonInteractiveEnv?.["tool.execute.before"];
   const bashFileReadGuardHook = hooks2.bashFileReadGuard?.["tool.execute.before"];
@@ -104739,7 +105037,8 @@ function createToolExecuteBeforeHandler2(args) {
       taskEditGuardHook?.(input, output),
       tasksTodowriteDisablerHook?.(input, output),
       oracleMdOnlyHook?.(input, output),
-      contextModeEnforcerHook?.(input, output)
+      contextModeEnforcerHook?.(input, output),
+      backgroundTaskBlockerHook?.(input, output)
     ]);
     let resolvePromise;
     if (input.tool === "task") {