opencode-matrixx 2.6.8 → 2.6.9

package/dist/index.js

@@ -4550,18 +4550,18 @@ __export(exports_storage, {
   readState: () => readState,
   writeState: () => writeState
 });
-import { existsSync as existsSync35, mkdirSync as mkdirSync13, readFileSync as readFileSync28, unlinkSync as unlinkSync7, writeFileSync as writeFileSync15 } from "fs";
-import { dirname as dirname9, join as join44 } from "path";
+import { existsSync as existsSync38, mkdirSync as mkdirSync14, readFileSync as readFileSync31, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
+import { dirname as dirname9, join as join48 } from "path";
 function getStateFilePath(directory, customPath) {
-  return customPath ? join44(directory, customPath) : join44(directory, DEFAULT_STATE_FILE);
+  return customPath ? join48(directory, customPath) : join48(directory, DEFAULT_STATE_FILE);
 }
 function readState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
-  if (!existsSync35(filePath)) {
+  if (!existsSync38(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync28(filePath, "utf-8");
+    const content = readFileSync31(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     const active = data.active;
     const iteration = data.iteration;
@@ -4597,8 +4597,8 @@ function writeState(directory, state3, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
     const dir = dirname9(filePath);
-    if (!existsSync35(dir)) {
-      mkdirSync13(dir, { recursive: true });
+    if (!existsSync38(dir)) {
+      mkdirSync14(dir, { recursive: true });
     }
     const sessionIdLine = state3.session_id ? `session_id: "${state3.session_id}"
 ` : "";
@@ -4615,7 +4615,7 @@ started_at: "${state3.started_at}"
 ${sessionIdLine}${ultraworkLine}${verificationLine}---
 ${state3.prompt}
 `;
-    writeFileSync15(filePath, content, "utf-8");
+    writeFileSync16(filePath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -4624,8 +4624,8 @@ ${state3.prompt}
 function clearState(directory, customPath) {
   const filePath = getStateFilePath(directory, customPath);
   try {
-    if (existsSync35(filePath)) {
-      unlinkSync7(filePath);
+    if (existsSync38(filePath)) {
+      unlinkSync8(filePath);
     }
     return true;
   } catch {
@@ -5645,8 +5645,8 @@ var require_semaphore = __commonJS(function(exports) {
       this._waiting = [];
     }
     lock(thunk) {
-      return new Promise((resolve7, reject) => {
-        this._waiting.push({ thunk, resolve: resolve7, reject });
+      return new Promise((resolve6, reject) => {
+        this._waiting.push({ thunk, resolve: resolve6, reject });
         this.runNext();
       });
     }
@@ -7137,9 +7137,9 @@ ${JSON.stringify(message, null, 4)}`);
         if (typeof cancellationStrategy.sender.enableCancellation === "function") {
           cancellationStrategy.sender.enableCancellation(requestMessage);
         }
-        return new Promise(async (resolve7, reject) => {
+        return new Promise(async (resolve6, reject) => {
           const resolveWithCleanup = (r) => {
-            resolve7(r);
+            resolve6(r);
             cancellationStrategy.sender.cleanup(id);
             disposable?.dispose();
           };
@@ -7548,10 +7548,10 @@ var require_ril = __commonJS(function(exports) {
       return api_1.Disposable.create(() => this.stream.off("end", listener));
     }
     write(data, encoding) {
-      return new Promise((resolve7, reject) => {
+      return new Promise((resolve6, reject) => {
         const callback = (error51) => {
           if (error51 === undefined || error51 === null) {
-            resolve7();
+            resolve6();
           } else {
             reject(error51);
           }
@@ -7810,10 +7810,10 @@ var require_main = __commonJS(function(exports) {
   exports.generateRandomPipeName = generateRandomPipeName;
   function createClientPipeTransport(pipeName, encoding = "utf-8") {
     let connectResolve;
-    const connected = new Promise((resolve7, _reject) => {
-      connectResolve = resolve7;
+    const connected = new Promise((resolve6, _reject) => {
+      connectResolve = resolve6;
     });
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve6, reject) => {
       let server = (0, net_1.createServer)((socket) => {
         server.close();
         connectResolve([
@@ -7824,7 +7824,7 @@ var require_main = __commonJS(function(exports) {
       server.on("error", reject);
       server.listen(pipeName, () => {
         server.removeListener("error", reject);
-        resolve7({
+        resolve6({
           onConnected: () => {
             return connected;
           }
@@ -7843,10 +7843,10 @@ var require_main = __commonJS(function(exports) {
   exports.createServerPipeTransport = createServerPipeTransport;
   function createClientSocketTransport(port, encoding = "utf-8") {
     let connectResolve;
-    const connected = new Promise((resolve7, _reject) => {
-      connectResolve = resolve7;
+    const connected = new Promise((resolve6, _reject) => {
+      connectResolve = resolve6;
     });
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve6, reject) => {
       const server = (0, net_1.createServer)((socket) => {
         server.close();
         connectResolve([
@@ -7857,7 +7857,7 @@ var require_main = __commonJS(function(exports) {
       server.on("error", reject);
       server.listen(port, "127.0.0.1", () => {
         server.removeListener("error", reject);
-        resolve7({
+        resolve6({
           onConnected: () => {
             return connected;
           }
@@ -16061,8 +16061,8 @@ var require_TransformOperationExecutor = __commonJS(function(exports) {
           return value;
         return Buffer.from(value);
       } else if ((0, utils_1.isPromise)(value) && !isMap) {
-        return new Promise((resolve9, reject) => {
-          value.then((data) => resolve9(this.transform(undefined, data, targetType, undefined, undefined, level + 1)), reject);
+        return new Promise((resolve8, reject) => {
+          value.then((data) => resolve8(this.transform(undefined, data, targetType, undefined, undefined, level + 1)), reject);
         });
       } else if (!isMap && value !== null && typeof value === "object" && typeof value.then === "function") {
         return value;
@@ -55027,7 +55027,7 @@ var DELEGATE_TASK_ERROR_PATTERNS = [
   {
     pattern: "Cannot call primary agent",
     errorType: "primary_agent",
-    fixHint: "Primary agents cannot be called via task. Use a subagent like 'explore', 'oracle', or 'librarian'"
+    fixHint: "Primary agents cannot be called via task. Use a subagent like 'explore', 'oracle', or 'librarian'. For 'architect', use /start-work to run Architect as session agent"
   },
   {
     pattern: "Operation timed out",
@@ -55228,93 +55228,6 @@ ${originalText}`;
     }
   };
 }
-// src/hooks/directory-injector/factory.ts
-function createDirectoryInjectorHook(ctx, processFile, clearInjectedPaths) {
-  const sessionCaches = new Map;
-  const truncator = createDynamicTruncator(ctx);
-  const toolExecuteAfter = async (input, output) => {
-    const toolName = input.tool.toLowerCase();
-    if (toolName === "read") {
-      await processFile({
-        ctx,
-        truncator,
-        sessionCaches,
-        filePath: output.title,
-        sessionID: input.sessionID,
-        output
-      });
-      return;
-    }
-  };
-  const toolExecuteBefore = async (input, output) => {};
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        sessionCaches.delete(sessionInfo.id);
-        clearInjectedPaths(sessionInfo.id);
-      }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        sessionCaches.delete(sessionID);
-        clearInjectedPaths(sessionID);
-      }
-    }
-  };
-  return {
-    "tool.execute.before": toolExecuteBefore,
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
-}
-// src/hooks/directory-agents-injector/injector.ts
-import { readFile } from "fs/promises";
-import { dirname as dirname7 } from "path";
-
-// src/hooks/directory-agents-injector/finder.ts
-import { access } from "fs/promises";
-import { dirname as dirname6, join as join38, resolve as resolve2 } from "path";
-
-// src/hooks/directory-agents-injector/constants.ts
-import { join as join37 } from "path";
-var AGENTS_INJECTOR_STORAGE = join37(OPENCODE_STORAGE, "directory-agents");
-var AGENTS_FILENAME = "AGENTS.md";
-
-// src/hooks/directory-agents-injector/finder.ts
-function resolveFilePath2(rootDirectory, path10) {
-  if (!path10)
-    return null;
-  if (path10.startsWith("/"))
-    return path10;
-  return resolve2(rootDirectory, path10);
-}
-async function findAgentsMdUp(input) {
-  const found = [];
-  let current = input.startDir;
-  while (true) {
-    const isRootDir = current === input.rootDir;
-    if (!isRootDir) {
-      const agentsPath = join38(current, AGENTS_FILENAME);
-      const exists = await access(agentsPath).then(() => true).catch(() => false);
-      if (exists) {
-        found.push(agentsPath);
-      }
-    }
-    if (isRootDir)
-      break;
-    const parent = dirname6(current);
-    if (parent === current)
-      break;
-    if (!parent.startsWith(input.rootDir))
-      break;
-    current = parent;
-  }
-  return found.reverse();
-}
-
 // src/shared/session-injected-paths.ts
 import {
   existsSync as existsSync32,
@@ -55323,9 +55236,9 @@ import {
   unlinkSync as unlinkSync4,
   writeFileSync as writeFileSync12
 } from "fs";
-import { join as join39 } from "path";
+import { join as join37 } from "path";
 function createInjectedPathsStorage(storageDir) {
-  const getStoragePath2 = (sessionID) => join39(storageDir, `${sessionID}.json`);
+  const getStoragePath2 = (sessionID) => join37(storageDir, `${sessionID}.json`);
   const loadInjectedPaths = (sessionID) => {
     const filePath = getStoragePath2(sessionID);
     if (!existsSync32(filePath))
@@ -55362,6 +55275,11 @@ function createInjectedPathsStorage(storageDir) {
   };
 }
 
+// src/hooks/directory-agents-injector/constants.ts
+import { join as join38 } from "path";
+var AGENTS_INJECTOR_STORAGE = join38(OPENCODE_STORAGE, "directory-agents");
+var AGENTS_FILENAME = "AGENTS.md";
+
 // src/hooks/directory-agents-injector/storage.ts
 var {
   loadInjectedPaths,
@@ -55369,47 +55287,581 @@ var {
   clearInjectedPaths
 } = createInjectedPathsStorage(AGENTS_INJECTOR_STORAGE);
 
-// src/hooks/directory-agents-injector/injector.ts
-function getSessionCache(sessionCaches, sessionID) {
-  if (!sessionCaches.has(sessionID)) {
-    sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
+// src/hooks/rules-injector/output-path.ts
+function getRuleInjectionFilePath(output) {
+  const metadata = output.metadata;
+  const metadataFilePath = metadata && typeof metadata === "object" ? metadata.filePath : undefined;
+  if (typeof metadataFilePath === "string" && metadataFilePath.length > 0) {
+    return metadataFilePath;
   }
-  return sessionCaches.get(sessionID);
+  if (typeof output.title === "string" && output.title.length > 0) {
+    return output.title;
+  }
+  return null;
 }
-async function processFilePathForAgentsInjection(input) {
-  const resolved = resolveFilePath2(input.ctx.directory, input.filePath);
-  if (!resolved)
-    return;
-  const dir = dirname7(resolved);
-  const cache2 = getSessionCache(input.sessionCaches, input.sessionID);
-  const agentsPaths = await findAgentsMdUp({ startDir: dir, rootDir: input.ctx.directory });
-  let dirty = false;
-  for (const agentsPath of agentsPaths) {
-    const agentsDir = dirname7(agentsPath);
-    if (cache2.has(agentsDir))
+
+// src/hooks/rules-injector/storage.ts
+import {
+  existsSync as existsSync33,
+  mkdirSync as mkdirSync10,
+  readFileSync as readFileSync26,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync13
+} from "fs";
+import { join as join40 } from "path";
+
+// src/hooks/rules-injector/constants.ts
+import { join as join39 } from "path";
+var RULES_INJECTOR_STORAGE = join39(OPENCODE_STORAGE, "rules-injector");
+var PROJECT_MARKERS = [
+  ".git",
+  "pyproject.toml",
+  "package.json",
+  "Cargo.toml",
+  "go.mod",
+  ".venv"
+];
+var PROJECT_RULE_SUBDIRS = [
+  [".github", "instructions"],
+  [".cursor", "rules"],
+  [".matrixx", "rules"]
+];
+var PROJECT_RULE_FILES = [
+  ".github/copilot-instructions.md"
+];
+var GITHUB_INSTRUCTIONS_PATTERN = /\.instructions\.md$/;
+var RULE_EXTENSIONS = [".md", ".mdc"];
+
+// src/hooks/rules-injector/storage.ts
+function getStoragePath2(sessionID) {
+  return join40(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+}
+function loadInjectedRules(sessionID) {
+  const filePath = getStoragePath2(sessionID);
+  if (!existsSync33(filePath))
+    return { contentHashes: new Set, realPaths: new Set };
+  try {
+    const content = readFileSync26(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return {
+      contentHashes: new Set(data.injectedHashes),
+      realPaths: new Set(data.injectedRealPaths ?? [])
+    };
+  } catch {
+    return { contentHashes: new Set, realPaths: new Set };
+  }
+}
+function saveInjectedRules(sessionID, data) {
+  if (!existsSync33(RULES_INJECTOR_STORAGE)) {
+    mkdirSync10(RULES_INJECTOR_STORAGE, { recursive: true });
+  }
+  const storageData = {
+    sessionID,
+    injectedHashes: [...data.contentHashes],
+    injectedRealPaths: [...data.realPaths],
+    updatedAt: Date.now()
+  };
+  writeFileSync13(getStoragePath2(sessionID), JSON.stringify(storageData, null, 2));
+}
+function clearInjectedRules(sessionID) {
+  const filePath = getStoragePath2(sessionID);
+  if (existsSync33(filePath)) {
+    unlinkSync5(filePath);
+  }
+}
+
+// src/hooks/post-read-injector/injector.ts
+import { readFileSync as readFileSync28 } from "fs";
+import { join as join43, relative as relative2, resolve as resolve2 } from "path";
+
+// src/hooks/rules-injector/matcher.ts
+var import_picomatch = __toESM(require_picomatch2(), 1);
+import { createHash } from "crypto";
+import { relative } from "path";
+function shouldApplyRule(metadata, currentFilePath, projectRoot) {
+  if (metadata.alwaysApply === true) {
+    return { applies: true, reason: "alwaysApply" };
+  }
+  const globs = metadata.globs;
+  if (!globs) {
+    return { applies: false };
+  }
+  const patterns = Array.isArray(globs) ? globs : [globs];
+  if (patterns.length === 0) {
+    return { applies: false };
+  }
+  const relativePath = projectRoot ? relative(projectRoot, currentFilePath) : currentFilePath;
+  for (const pattern of patterns) {
+    if (import_picomatch.default.isMatch(relativePath, pattern, { dot: true, bash: true })) {
+      return { applies: true, reason: `glob: ${pattern}` };
+    }
+  }
+  return { applies: false };
+}
+function isDuplicateByRealPath(realPath, cache2) {
+  return cache2.has(realPath);
+}
+function createContentHash(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function isDuplicateByContentHash(hash2, cache2) {
+  return cache2.has(hash2);
+}
+
+// src/hooks/rules-injector/parser.ts
+function parseRuleFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { metadata: {}, body: content };
+  }
+  const yamlContent = match[1];
+  const body = match[2];
+  try {
+    const metadata = parseYamlContent(yamlContent);
+    return { metadata, body };
+  } catch {
+    return { metadata: {}, body: content };
+  }
+}
+function parseYamlContent(yamlContent) {
+  const lines = yamlContent.split(`
+`);
+  const metadata = {};
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      i++;
       continue;
-    try {
-      const content = await readFile(agentsPath, "utf-8");
-      const { result, truncated } = await input.truncator.truncate(input.sessionID, content);
-      const truncationNotice = truncated ? `
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const rawValue = line.slice(colonIndex + 1).trim();
+    if (key === "description") {
+      metadata.description = parseStringValue(rawValue);
+    } else if (key === "alwaysApply") {
+      metadata.alwaysApply = rawValue === "true";
+    } else if (key === "globs" || key === "applyTo") {
+      const { value, consumed } = parseArrayOrStringValue(rawValue, lines, i);
+      metadata.globs = mergeGlobs(metadata.globs, value);
+      i += consumed;
+      continue;
+    }
+    i++;
+  }
+  return metadata;
+}
+function parseStringValue(value) {
+  if (!value)
+    return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseArrayOrStringValue(rawValue, lines, currentIndex) {
+  if (rawValue.startsWith("[")) {
+    return { value: parseInlineArray(rawValue), consumed: 1 };
+  }
+  if (!rawValue || rawValue === "") {
+    const arrayItems = [];
+    let consumed = 1;
+    for (let j = currentIndex + 1;j < lines.length; j++) {
+      const nextLine = lines[j];
+      const arrayMatch = nextLine.match(/^\s+-\s*(.*)$/);
+      if (arrayMatch) {
+        const itemValue = parseStringValue(arrayMatch[1].trim());
+        if (itemValue) {
+          arrayItems.push(itemValue);
+        }
+        consumed++;
+      } else if (nextLine.trim() === "") {
+        consumed++;
+      } else {
+        break;
+      }
+    }
+    if (arrayItems.length > 0) {
+      return { value: arrayItems, consumed };
+    }
+  }
+  const stringValue = parseStringValue(rawValue);
+  if (stringValue.includes(",")) {
+    const items = stringValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    return { value: items, consumed: 1 };
+  }
+  return { value: stringValue, consumed: 1 };
+}
+function parseInlineArray(value) {
+  const content = value.slice(1, value.lastIndexOf("]")).trim();
+  if (!content)
+    return [];
+  const items = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  for (let i = 0;i < content.length; i++) {
+    const char = content[i];
+    if (!inQuote && (char === '"' || char === "'")) {
+      inQuote = true;
+      quoteChar = char;
+    } else if (inQuote && char === quoteChar) {
+      inQuote = false;
+      quoteChar = "";
+    } else if (!inQuote && char === ",") {
+      const trimmed2 = current.trim();
+      if (trimmed2) {
+        items.push(parseStringValue(trimmed2));
+      }
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed) {
+    items.push(parseStringValue(trimmed));
+  }
+  return items;
+}
+function mergeGlobs(existing, newValue) {
+  if (!existing)
+    return newValue;
+  const existingArray = Array.isArray(existing) ? existing : [existing];
+  const newArray = Array.isArray(newValue) ? newValue : [newValue];
+  return [...existingArray, ...newArray];
+}
+
+// src/hooks/rules-injector/project-root-finder.ts
+import { existsSync as existsSync34, statSync as statSync4 } from "fs";
+import { dirname as dirname6, join as join41 } from "path";
+function findProjectRoot(startPath) {
+  let current;
+  try {
+    const stat = statSync4(startPath);
+    current = stat.isDirectory() ? startPath : dirname6(startPath);
+  } catch {
+    current = dirname6(startPath);
+  }
+  while (true) {
+    for (const marker of PROJECT_MARKERS) {
+      const markerPath = join41(current, marker);
+      if (existsSync34(markerPath)) {
+        return current;
+      }
+    }
+    const parent = dirname6(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/hooks/rules-injector/rule-file-scanner.ts
+import { existsSync as existsSync35, readdirSync as readdirSync11, realpathSync as realpathSync2 } from "fs";
+import { join as join42 } from "path";
+function isGitHubInstructionsDir(dir) {
+  return dir.includes(".github/instructions") || dir.endsWith(".github/instructions");
+}
+function isValidRuleFile(fileName, dir) {
+  if (isGitHubInstructionsDir(dir)) {
+    return GITHUB_INSTRUCTIONS_PATTERN.test(fileName);
+  }
+  return RULE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
+}
+function findRuleFilesRecursive(dir, results) {
+  if (!existsSync35(dir))
+    return;
+  try {
+    const entries = readdirSync11(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join42(dir, entry.name);
+      if (entry.isDirectory()) {
+        findRuleFilesRecursive(fullPath, results);
+      } else if (entry.isFile()) {
+        if (isValidRuleFile(entry.name, dir)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {}
+}
+function safeRealpathSync(filePath) {
+  try {
+    return realpathSync2(filePath);
+  } catch {
+    return filePath;
+  }
+}
+
+// src/hooks/post-read-injector/constants.ts
+var MAX_DIRECTORY_CONTEXT_BYTES = 6144;
+var DIRECTORY_CONTEXT_HEADER = "Directory Context";
+var DIRECTORY_CONTEXT_SEPARATOR = `
+---
+`;
+function buildTruncationMarker(omittedChars) {
+  return `
+[${DIRECTORY_CONTEXT_HEADER} truncated: ${omittedChars} chars omitted]`;
+}
+
+// src/hooks/post-read-injector/block.ts
+function buildDirectoryContextBlock(sections) {
+  const header = `
+
+[${DIRECTORY_CONTEXT_HEADER}]
+`;
+  const fullBody = sections.join(DIRECTORY_CONTEXT_SEPARATOR);
+  const full = `${header}${fullBody}`;
+  if (full.length <= MAX_DIRECTORY_CONTEXT_BYTES)
+    return full;
+  const probeMarker = buildTruncationMarker(fullBody.length);
+  const allowedBody = MAX_DIRECTORY_CONTEXT_BYTES - header.length - probeMarker.length;
+  const sliced = fullBody.slice(0, Math.max(0, allowedBody));
+  const omitted = fullBody.length - sliced.length;
+  const marker = buildTruncationMarker(omitted);
+  const block = `${header}${sliced}${marker}`;
+  if (block.length <= MAX_DIRECTORY_CONTEXT_BYTES)
+    return block;
+  const overflow = block.length - MAX_DIRECTORY_CONTEXT_BYTES;
+  return `${header}${sliced.slice(0, Math.max(0, sliced.length - overflow))}${marker}`;
+}
+
+// src/hooks/post-read-injector/sections.ts
+import { readFileSync as readFileSync27 } from "fs";
+import { access, readFile } from "fs/promises";
+async function readAgentsSection(agentsPath, sessionID, truncator) {
+  const exists = await access(agentsPath).then(() => true).catch(() => false);
+  if (!exists)
+    return null;
+  try {
+    const content = await readFile(agentsPath, "utf-8");
+    const { result, truncated } = await truncator.truncate(sessionID, content);
+    const notice = truncated ? `
 
 [Note: Content was truncated to save context window space. For full context, please read the file directly: ${agentsPath}]` : "";
-      input.output.output += `
+    return `[Directory Context: ${agentsPath}]
+${result}${notice}`;
+  } catch {
+    return null;
+  }
+}
+async function readRuleSection(candidate, rel, reason, sessionID, truncator, rulesCache) {
+  try {
+    const raw = readFileSync27(candidate, "utf-8");
+    const { body } = parseRuleFrontmatter(raw);
+    const hash2 = createContentHash(body);
+    if (isDuplicateByContentHash(hash2, rulesCache.contentHashes))
+      return null;
+    const { result, truncated } = await truncator.truncate(sessionID, body);
+    const notice = truncated ? `
+
+[Note: Content was truncated to save context window space. For full context, please read the file directly: ${rel}]` : "";
+    rulesCache.contentHashes.add(hash2);
+    return `[Rule: ${rel}]
+[Match: ${reason}]
+${result}${notice}`;
+  } catch {
+    return null;
+  }
+}
 
-[Directory Context: ${agentsPath}]
-${result}${truncationNotice}`;
-      cache2.add(agentsDir);
-      dirty = true;
-    } catch {}
+// src/hooks/post-read-injector/unified-walk.ts
+import { dirname as dirname7 } from "path";
+function normalize(dir) {
+  return dir.endsWith("/") && dir.length > 1 ? dir.slice(0, -1) : dir;
+}
+function collectAncestorDirs(filePath, rootDir, projectRoot, onVisit) {
+  let visit2;
+  if (typeof rootDir === "function")
+    visit2 = rootDir;
+  else if (typeof projectRoot === "function")
+    visit2 = projectRoot;
+  if (typeof onVisit === "function")
+    visit2 = onVisit;
+  let current;
+  try {
+    current = normalize(dirname7(filePath));
+  } catch {
+    return [];
   }
-  if (dirty) {
-    saveInjectedPaths(input.sessionID, cache2);
+  const dirs = [];
+  const seen = new Set;
+  while (true) {
+    if (!seen.has(current)) {
+      seen.add(current);
+      dirs.push(current);
+      visit2?.(current);
+    }
+    const parent = normalize(dirname7(current));
+    if (parent === current)
+      break;
+    current = parent;
   }
+  return dirs;
+}
+
+// src/hooks/post-read-injector/injector.ts
+function resolveUnifiedFilePath(rootDirectory, filePath) {
+  if (!filePath)
+    return null;
+  if (filePath.startsWith("/"))
+    return filePath;
+  return resolve2(rootDirectory, filePath);
+}
+function createUnifiedPostReadProcessor(deps) {
+  const { workspaceDirectory, truncator, onVisitDir } = deps;
+  const agentsCaches = new Map;
+  const rulesCaches = new Map;
+  function getAgentsCache(sessionID) {
+    let cache2 = agentsCaches.get(sessionID);
+    if (!cache2) {
+      cache2 = loadInjectedPaths(sessionID);
+      agentsCaches.set(sessionID, cache2);
+    }
+    return cache2;
+  }
+  function getRulesCache(sessionID) {
+    let cache2 = rulesCaches.get(sessionID);
+    if (!cache2) {
+      cache2 = loadInjectedRules(sessionID);
+      rulesCaches.set(sessionID, cache2);
+    }
+    return cache2;
+  }
+  function clearSessionCache(sessionID) {
+    agentsCaches.delete(sessionID);
+    rulesCaches.delete(sessionID);
+  }
+  async function processFilePathForInjection(filePath, sessionID, output) {
+    if (output.output.includes(`[${DIRECTORY_CONTEXT_HEADER}]`))
+      return;
+    const resolved = resolveUnifiedFilePath(workspaceDirectory, filePath);
+    if (!resolved)
+      return;
+    const projectRoot = findProjectRoot(resolved);
+    const agentsCache = getAgentsCache(sessionID);
+    const rulesCache = getRulesCache(sessionID);
+    const dirs = collectAncestorDirs(resolved, workspaceDirectory, projectRoot, onVisitDir);
+    const sections = [];
+    const seenRulePaths = new Set;
+    let agentsDirty = false;
+    let rulesDirty = false;
+    for (const dir of dirs) {
+      if (dir !== workspaceDirectory && (dir === workspaceDirectory || dir.startsWith(`${workspaceDirectory}/`))) {
+        if (!agentsCache.has(dir)) {
+          const section = await readAgentsSection(join43(dir, AGENTS_FILENAME), sessionID, truncator);
+          if (section) {
+            sections.push(section);
+            agentsCache.add(dir);
+            agentsDirty = true;
+          }
+        }
+      }
+      const inScope = !projectRoot || dir === projectRoot || dir.startsWith(`${projectRoot}/`) || projectRoot.startsWith(`${dir}/`);
+      if (!inScope)
+        continue;
+      for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
+        const files = [];
+        findRuleFilesRecursive(join43(dir, parent, subdir), files);
+        for (const candidate of files) {
+          const realPath = safeRealpathSync(candidate);
+          if (seenRulePaths.has(realPath))
+            continue;
+          seenRulePaths.add(realPath);
+          if (isDuplicateByRealPath(realPath, rulesCache.realPaths))
+            continue;
+          const { metadata } = parseRuleFrontmatter(readFileSync28(candidate, "utf-8"));
+          const match = shouldApplyRule(metadata, resolved, projectRoot);
+          if (!match.applies)
+            continue;
+          const rel = projectRoot ? relative2(projectRoot, candidate) : candidate;
+          const section = await readRuleSection(candidate, rel, match.reason ?? "matched", sessionID, truncator, rulesCache);
+          if (section) {
+            sections.push(section);
+            rulesCache.realPaths.add(realPath);
+            rulesDirty = true;
+          }
+        }
+      }
+      if (projectRoot && dir === projectRoot) {
+        for (const single of PROJECT_RULE_FILES) {
+          const candidate = join43(projectRoot, single);
+          const realPath = safeRealpathSync(candidate);
+          if (seenRulePaths.has(realPath))
+            continue;
+          seenRulePaths.add(realPath);
+          if (isDuplicateByRealPath(realPath, rulesCache.realPaths))
+            continue;
+          const section = await readRuleSection(candidate, single, "copilot-instructions (always apply)", sessionID, truncator, rulesCache);
+          if (section) {
+            sections.push(section);
+            rulesCache.realPaths.add(realPath);
+            rulesDirty = true;
+          }
+        }
+      }
+    }
+    if (sections.length === 0)
+      return;
+    output.output += buildDirectoryContextBlock(sections);
+    if (agentsDirty)
+      saveInjectedPaths(sessionID, agentsCache);
+    if (rulesDirty)
+      saveInjectedRules(sessionID, rulesCache);
+  }
+  return { processFilePathForInjection, clearSessionCache };
+}
+
+// src/hooks/post-read-injector/hook.ts
+var DEFAULT_TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
+function createPostReadInjectorHook(ctx, options) {
+  const truncator = createDynamicTruncator(ctx);
+  const { processFilePathForInjection, clearSessionCache } = createUnifiedPostReadProcessor({
+    workspaceDirectory: ctx.directory,
+    truncator
+  });
+  const tracked = (options?.trackedTools ?? DEFAULT_TRACKED_TOOLS).map((tool) => tool.toLowerCase());
+  const toolExecuteAfter = async (input, output) => {
+    if (!tracked.includes(input.tool.toLowerCase()))
+      return;
+    const filePath = getRuleInjectionFilePath({ title: output.title, metadata: output.metadata });
+    if (!filePath)
+      return;
+    await processFilePathForInjection(filePath, input.sessionID, output);
+  };
+  const toolExecuteBefore = async (input, output) => {};
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const info = props?.info;
+      if (info?.id) {
+        clearSessionCache(info.id);
+        clearInjectedPaths(info.id);
+        clearInjectedRules(info.id);
+      }
+    }
+    if (event.type === "session.compacted") {
+      const sessionID = props?.sessionID ?? props?.info?.id;
+      if (sessionID) {
+        clearSessionCache(sessionID);
+        clearInjectedPaths(sessionID);
+        clearInjectedRules(sessionID);
+      }
+    }
+  };
+  return {
+    "tool.execute.before": toolExecuteBefore,
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler
+  };
 }
 
 // src/hooks/directory-agents-injector/hook.ts
 function createDirectoryAgentsInjectorHook(ctx) {
-  return createDirectoryInjectorHook(ctx, processFilePathForAgentsInjection, clearInjectedPaths);
+  return createPostReadInjectorHook(ctx, { trackedTools: ["read"] });
 }
 // src/hooks/edit-error-recovery/hook.ts
 var EDIT_ERROR_PATTERNS = [
@@ -55531,7 +55983,7 @@ ${envContext}`;
   };
 }
 // src/hooks/env-file-write-guard/sensitive-file-matcher.ts
-var import_picomatch = __toESM(require_picomatch2(), 1);
+var import_picomatch2 = __toESM(require_picomatch2(), 1);
 import { basename as basename3 } from "path";
 var DEFAULT_BLOCKED_PATTERNS = [
   ".env",
@@ -55551,7 +56003,7 @@ var DEFAULT_BLOCKED_PATTERNS = [
 ];
 function createSensitiveFileMatcher(blockedPatterns, allowedPaths) {
   const patterns = blockedPatterns ?? DEFAULT_BLOCKED_PATTERNS;
-  const isBlocked = import_picomatch.default(patterns, { dot: true, bash: true });
+  const isBlocked = import_picomatch2.default(patterns, { dot: true, bash: true });
   const allowSet = new Set(allowedPaths ?? []);
   return function isSensitiveFile(filePath) {
     if (allowSet.has(filePath))
@@ -58864,8 +59316,8 @@ ${originalText}`;
 init_logger();
 
 // src/hooks/interactive-bash-session/constants.ts
-import { join as join42 } from "path";
-var INTERACTIVE_BASH_SESSION_STORAGE = join42(OPENCODE_STORAGE, "interactive-bash-session");
+import { join as join46 } from "path";
+var INTERACTIVE_BASH_SESSION_STORAGE = join46(OPENCODE_STORAGE, "interactive-bash-session");
 var MATRIXX_SESSION_PREFIX = "matrixx-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -58960,22 +59412,22 @@ function findSubcommand(tokens) {
 
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync34,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync27,
-  unlinkSync as unlinkSync6,
-  writeFileSync as writeFileSync14
+  existsSync as existsSync37,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync30,
+  unlinkSync as unlinkSync7,
+  writeFileSync as writeFileSync15
 } from "fs";
-import { join as join43 } from "path";
-function getStoragePath2(sessionID) {
-  return join43(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+import { join as join47 } from "path";
+function getStoragePath3(sessionID) {
+  return join47(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
-  const filePath = getStoragePath2(sessionID);
-  if (!existsSync34(filePath))
+  const filePath = getStoragePath3(sessionID);
+  if (!existsSync37(filePath))
     return null;
   try {
-    const content = readFileSync27(filePath, "utf-8");
+    const content = readFileSync30(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -58987,21 +59439,21 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state3) {
-  if (!existsSync34(INTERACTIVE_BASH_SESSION_STORAGE)) {
-    mkdirSync12(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  if (!existsSync37(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync13(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
-  const filePath = getStoragePath2(state3.sessionID);
+  const filePath = getStoragePath3(state3.sessionID);
   const serialized = {
     sessionID: state3.sessionID,
     tmuxSessions: Array.from(state3.tmuxSessions),
     updatedAt: state3.updatedAt
   };
-  writeFileSync14(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync15(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
-  const filePath = getStoragePath2(sessionID);
-  if (existsSync34(filePath)) {
-    unlinkSync6(filePath);
+  const filePath = getStoragePath3(sessionID);
+  if (existsSync37(filePath)) {
+    unlinkSync7(filePath);
   }
 }
 
@@ -59344,7 +59796,7 @@ init_logger();
 
 // src/hooks/matrix-loop/completion-promise-detector.ts
 init_logger();
-import { existsSync as existsSync36, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync32 } from "fs";
 function escapeRegex2(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -59355,9 +59807,9 @@ function detectCompletionInTranscript(transcriptPath, promise2) {
   if (!transcriptPath)
     return false;
   try {
-    if (!existsSync36(transcriptPath))
+    if (!existsSync39(transcriptPath))
       return false;
-    const content = readFileSync29(transcriptPath, "utf-8");
+    const content = readFileSync32(transcriptPath, "utf-8");
     const pattern = buildPromisePattern(promise2);
     const lines = content.split(`
 `).filter((line) => line.trim());
@@ -60063,10 +60515,10 @@ async function getAgentFromSession(sessionID, directory, client) {
 }
 
 // src/hooks/oracle-md-only/path-policy.ts
-import { isAbsolute as isAbsolute2, relative, resolve as resolve4 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative3, resolve as resolve4 } from "path";
 function isAllowedFile(filePath, workspaceRoot) {
   const resolved = resolve4(workspaceRoot, filePath);
-  const rel = relative(workspaceRoot, resolved);
+  const rel = relative3(workspaceRoot, resolved);
   if (rel.startsWith("..") || isAbsolute2(rel)) {
     return false;
   }
@@ -60138,13 +60590,13 @@ function createOracleMdOnlyHook(ctx) {
   };
 }
 // src/hooks/plan-persister/hook.ts
-import { existsSync as existsSync38, readdirSync as readdirSync12 } from "fs";
+import { existsSync as existsSync41, readdirSync as readdirSync13 } from "fs";
 
 // src/features/task-storage/storage.ts
 init_logger();
 import { randomUUID } from "crypto";
-import { existsSync as existsSync37, 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 join45 } from "path";
+import { existsSync as existsSync40, mkdirSync as mkdirSync15, readdirSync as readdirSync12, readFileSync as readFileSync33, renameSync as renameSync3, unlinkSync as unlinkSync9, writeFileSync as writeFileSync17 } from "fs";
+import { basename as basename5, dirname as dirname10, isAbsolute as isAbsolute3, join as join49 } from "path";
 
 // src/shared/task-system-gating.ts
 var TASK_SYSTEM_DEFAULT = true;
@@ -60168,18 +60620,18 @@ function isTaskSystemEnabled(config2) {
 
 // src/features/task-storage/storage.ts
 function getProjectTaskDir(directory) {
-  return join45(directory, ".matrixx", "tasks");
+  return join49(directory, ".matrixx", "tasks");
 }
 function getTaskDir(config2 = {}, directory) {
   const tasksConfig = resolveTasksConfig(config2);
   const storagePath = tasksConfig.storage_path;
   if (storagePath) {
-    return isAbsolute3(storagePath) ? storagePath : join45(directory ?? process.cwd(), storagePath);
+    return isAbsolute3(storagePath) ? storagePath : join49(directory ?? process.cwd(), storagePath);
   }
   if (tasksConfig.scope === "global" || !directory) {
     const configDir = getOpenCodeConfigDir({ binary: "opencode" });
     const listId = resolveTaskListId(config2);
-    return join45(configDir, "tasks", listId);
+    return join49(configDir, "tasks", listId);
   }
   return getProjectTaskDir(directory);
 }
@@ -60196,16 +60648,16 @@ function resolveTaskListId(config2 = {}) {
   return sanitizePathSegment(basename5(process.cwd()));
 }
 function ensureDir2(dirPath) {
-  if (!existsSync37(dirPath)) {
-    mkdirSync14(dirPath, { recursive: true });
+  if (!existsSync40(dirPath)) {
+    mkdirSync15(dirPath, { recursive: true });
   }
 }
 function readJsonSafe(filePath, schema) {
   try {
-    if (!existsSync37(filePath)) {
+    if (!existsSync40(filePath)) {
       return null;
     }
-    const content = readFileSync30(filePath, "utf-8");
+    const content = readFileSync33(filePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = schema.safeParse(parsed);
     if (!result.success) {
@@ -60221,12 +60673,12 @@ function writeJsonAtomic(filePath, data) {
   ensureDir2(dir);
   const tempPath = `${filePath}.tmp.${Date.now()}`;
   try {
-    writeFileSync16(tempPath, JSON.stringify(data, null, 2), "utf-8");
+    writeFileSync17(tempPath, JSON.stringify(data, null, 2), "utf-8");
     renameSync3(tempPath, filePath);
   } catch (error51) {
     try {
-      if (existsSync37(tempPath)) {
-        unlinkSync8(tempPath);
+      if (existsSync40(tempPath)) {
+        unlinkSync9(tempPath);
       }
     } catch {}
     throw error51;
@@ -60249,21 +60701,21 @@ function generateTaskId() {
 }
 function migrateLegacyTasksIfNeeded(config2, directory) {
   const projectDir = getProjectTaskDir(directory);
-  const legacyDir = join45(getOpenCodeConfigDir({ binary: "opencode" }), "tasks", resolveTaskListId(config2));
-  if (existsSync37(projectDir)) {
+  const legacyDir = join49(getOpenCodeConfigDir({ binary: "opencode" }), "tasks", resolveTaskListId(config2));
+  if (existsSync40(projectDir)) {
     try {
-      const existing = readdirSync11(projectDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+      const existing = readdirSync12(projectDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
       if (existing.length > 0) {
         return { migrated: 0, legacyDir, projectDir };
       }
     } catch {}
   }
-  if (!existsSync37(legacyDir)) {
+  if (!existsSync40(legacyDir)) {
     return { migrated: 0, legacyDir, projectDir };
   }
   let files = [];
   try {
-    files = readdirSync11(legacyDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+    files = readdirSync12(legacyDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
   } catch {
     return { migrated: 0, legacyDir, projectDir };
   }
@@ -60273,13 +60725,13 @@ function migrateLegacyTasksIfNeeded(config2, directory) {
   ensureDir2(projectDir);
   let migrated = 0;
   for (const file2 of files) {
-    const src = join45(legacyDir, file2);
-    const dest = join45(projectDir, file2);
-    if (existsSync37(dest))
+    const src = join49(legacyDir, file2);
+    const dest = join49(projectDir, file2);
+    if (existsSync40(dest))
       continue;
     try {
-      const content = readFileSync30(src, "utf-8");
-      writeFileSync16(dest, content, "utf-8");
+      const content = readFileSync33(src, "utf-8");
+      writeFileSync17(dest, content, "utf-8");
       migrated++;
     } catch {}
   }
@@ -60289,17 +60741,17 @@ function migrateLegacyTasksIfNeeded(config2, directory) {
   return { migrated, legacyDir, projectDir };
 }
 function acquireLock(dirPath) {
-  const lockPath = join45(dirPath, ".lock");
+  const lockPath = join49(dirPath, ".lock");
   const lockId = randomUUID();
   const createLock = (timestamp) => {
-    writeFileSync16(lockPath, JSON.stringify({ id: lockId, timestamp }), {
+    writeFileSync17(lockPath, JSON.stringify({ id: lockId, timestamp }), {
       encoding: "utf-8",
       flag: "wx"
     });
   };
   const isStale = () => {
     try {
-      const lockContent = readFileSync30(lockPath, "utf-8");
+      const lockContent = readFileSync33(lockPath, "utf-8");
       const lockData = JSON.parse(lockContent);
       const lockAge = Date.now() - lockData.timestamp;
       return lockAge > STALE_LOCK_THRESHOLD_MS;
@@ -60323,7 +60775,7 @@ function acquireLock(dirPath) {
   let acquired = tryAcquire();
   if (!acquired && isStale()) {
     try {
-      unlinkSync8(lockPath);
+      unlinkSync9(lockPath);
     } catch {}
     acquired = tryAcquire();
   }
@@ -60337,13 +60789,13 @@ function acquireLock(dirPath) {
     acquired: true,
     release: () => {
       try {
-        if (!existsSync37(lockPath))
+        if (!existsSync40(lockPath))
           return;
-        const lockContent = readFileSync30(lockPath, "utf-8");
+        const lockContent = readFileSync33(lockPath, "utf-8");
         const lockData = JSON.parse(lockContent);
         if (lockData.id !== lockId)
           return;
-        unlinkSync8(lockPath);
+        unlinkSync9(lockPath);
       } catch {}
     }
   };
@@ -60479,13 +60931,13 @@ function createPlanPersister(ctx, options) {
     if (!mission.session_ids?.includes(sessionID))
       return;
     const planPath = mission.active_plan;
-    if (!existsSync38(planPath))
+    if (!existsSync41(planPath))
       return;
     let todos = [];
     try {
       const taskDir = getTaskDir({}, directory);
-      if (existsSync38(taskDir)) {
-        const files = readdirSync12(taskDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
+      if (existsSync41(taskDir)) {
+        const files = readdirSync13(taskDir).filter((f) => f.startsWith("T-") && f.endsWith(".json"));
         const tasks = [];
         for (const f of files) {
           const parsed = readJsonSafe(`${taskDir}/${f}`, TaskObjectSchema);
@@ -61811,568 +62263,9 @@ function createRtkBashRewriterHook(_ctx, config2) {
     }
   };
 }
-// src/hooks/rules-injector/project-root-finder.ts
-import { existsSync as existsSync39, statSync as statSync5 } from "fs";
-import { dirname as dirname11, join as join47 } from "path";
-
-// src/hooks/rules-injector/constants.ts
-import { join as join46 } from "path";
-var RULES_INJECTOR_STORAGE = join46(OPENCODE_STORAGE, "rules-injector");
-var PROJECT_MARKERS = [
-  ".git",
-  "pyproject.toml",
-  "package.json",
-  "Cargo.toml",
-  "go.mod",
-  ".venv"
-];
-var PROJECT_RULE_SUBDIRS = [
-  [".github", "instructions"],
-  [".cursor", "rules"],
-  [".matrixx", "rules"]
-];
-var PROJECT_RULE_FILES = [
-  ".github/copilot-instructions.md"
-];
-var GITHUB_INSTRUCTIONS_PATTERN = /\.instructions\.md$/;
-var RULE_EXTENSIONS = [".md", ".mdc"];
-
-// src/hooks/rules-injector/project-root-finder.ts
-function findProjectRoot(startPath) {
-  let current;
-  try {
-    const stat = statSync5(startPath);
-    current = stat.isDirectory() ? startPath : dirname11(startPath);
-  } catch {
-    current = dirname11(startPath);
-  }
-  while (true) {
-    for (const marker of PROJECT_MARKERS) {
-      const markerPath = join47(current, marker);
-      if (existsSync39(markerPath)) {
-        return current;
-      }
-    }
-    const parent = dirname11(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-// src/hooks/rules-injector/rule-file-finder.ts
-import { existsSync as existsSync41, statSync as statSync6 } from "fs";
-import { dirname as dirname12, join as join49 } from "path";
-
-// src/hooks/rules-injector/rule-file-scanner.ts
-import { existsSync as existsSync40, readdirSync as readdirSync13, realpathSync as realpathSync2 } from "fs";
-import { join as join48 } from "path";
-function isGitHubInstructionsDir(dir) {
-  return dir.includes(".github/instructions") || dir.endsWith(".github/instructions");
-}
-function isValidRuleFile(fileName, dir) {
-  if (isGitHubInstructionsDir(dir)) {
-    return GITHUB_INSTRUCTIONS_PATTERN.test(fileName);
-  }
-  return RULE_EXTENSIONS.some((ext) => fileName.endsWith(ext));
-}
-function findRuleFilesRecursive(dir, results) {
-  if (!existsSync40(dir))
-    return;
-  try {
-    const entries = readdirSync13(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join48(dir, entry.name);
-      if (entry.isDirectory()) {
-        findRuleFilesRecursive(fullPath, results);
-      } else if (entry.isFile()) {
-        if (isValidRuleFile(entry.name, dir)) {
-          results.push(fullPath);
-        }
-      }
-    }
-  } catch {}
-}
-function safeRealpathSync(filePath) {
-  try {
-    return realpathSync2(filePath);
-  } catch {
-    return filePath;
-  }
-}
-
-// src/hooks/rules-injector/rule-file-finder.ts
-function findRuleFiles(projectRoot, currentFile) {
-  const candidates = [];
-  const seenRealPaths = new Set;
-  let currentDir = dirname12(currentFile);
-  let distance = 0;
-  while (true) {
-    for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join49(currentDir, parent, subdir);
-      const files = [];
-      findRuleFilesRecursive(ruleDir, files);
-      for (const filePath of files) {
-        const realPath = safeRealpathSync(filePath);
-        if (seenRealPaths.has(realPath))
-          continue;
-        seenRealPaths.add(realPath);
-        candidates.push({
-          path: filePath,
-          realPath,
-          isGlobal: false,
-          distance
-        });
-      }
-    }
-    if (projectRoot && currentDir === projectRoot)
-      break;
-    const parentDir = dirname12(currentDir);
-    if (parentDir === currentDir)
-      break;
-    currentDir = parentDir;
-    distance++;
-  }
-  if (projectRoot) {
-    for (const ruleFile of PROJECT_RULE_FILES) {
-      const filePath = join49(projectRoot, ruleFile);
-      if (existsSync41(filePath)) {
-        try {
-          const stat = statSync6(filePath);
-          if (stat.isFile()) {
-            const realPath = safeRealpathSync(filePath);
-            if (!seenRealPaths.has(realPath)) {
-              seenRealPaths.add(realPath);
-              candidates.push({
-                path: filePath,
-                realPath,
-                isGlobal: false,
-                distance: 0,
-                isSingleFile: true
-              });
-            }
-          }
-        } catch {}
-      }
-    }
-  }
-  candidates.sort((a, b) => {
-    if (a.isGlobal !== b.isGlobal) {
-      return a.isGlobal ? 1 : -1;
-    }
-    return a.distance - b.distance;
-  });
-  return candidates;
-}
-// src/hooks/rules-injector/storage.ts
-import {
-  existsSync as existsSync42,
-  mkdirSync as mkdirSync15,
-  readFileSync as readFileSync31,
-  unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync17
-} from "fs";
-import { join as join50 } from "path";
-function getStoragePath3(sessionID) {
-  return join50(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
-}
-function loadInjectedRules(sessionID) {
-  const filePath = getStoragePath3(sessionID);
-  if (!existsSync42(filePath))
-    return { contentHashes: new Set, realPaths: new Set };
-  try {
-    const content = readFileSync31(filePath, "utf-8");
-    const data = JSON.parse(content);
-    return {
-      contentHashes: new Set(data.injectedHashes),
-      realPaths: new Set(data.injectedRealPaths ?? [])
-    };
-  } catch {
-    return { contentHashes: new Set, realPaths: new Set };
-  }
-}
-function saveInjectedRules(sessionID, data) {
-  if (!existsSync42(RULES_INJECTOR_STORAGE)) {
-    mkdirSync15(RULES_INJECTOR_STORAGE, { recursive: true });
-  }
-  const storageData = {
-    sessionID,
-    injectedHashes: [...data.contentHashes],
-    injectedRealPaths: [...data.realPaths],
-    updatedAt: Date.now()
-  };
-  writeFileSync17(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
-}
-function clearInjectedRules(sessionID) {
-  const filePath = getStoragePath3(sessionID);
-  if (existsSync42(filePath)) {
-    unlinkSync9(filePath);
-  }
-}
-
-// src/hooks/rules-injector/cache.ts
-function createSessionCacheStore() {
-  const sessionCaches = new Map;
-  function getSessionCache2(sessionID) {
-    if (!sessionCaches.has(sessionID)) {
-      sessionCaches.set(sessionID, loadInjectedRules(sessionID));
-    }
-    return sessionCaches.get(sessionID);
-  }
-  function clearSessionCache(sessionID) {
-    sessionCaches.delete(sessionID);
-    clearInjectedRules(sessionID);
-  }
-  return { getSessionCache: getSessionCache2, clearSessionCache };
-}
-
-// src/hooks/rules-injector/injector.ts
-import { readFileSync as readFileSync32, statSync as statSync7, watch } from "fs";
-import { relative as relative3, resolve as resolve5 } from "path";
-
-// src/hooks/rules-injector/matcher.ts
-var import_picomatch2 = __toESM(require_picomatch2(), 1);
-import { createHash } from "crypto";
-import { relative as relative2 } from "path";
-function shouldApplyRule(metadata, currentFilePath, projectRoot) {
-  if (metadata.alwaysApply === true) {
-    return { applies: true, reason: "alwaysApply" };
-  }
-  const globs = metadata.globs;
-  if (!globs) {
-    return { applies: false };
-  }
-  const patterns2 = Array.isArray(globs) ? globs : [globs];
-  if (patterns2.length === 0) {
-    return { applies: false };
-  }
-  const relativePath = projectRoot ? relative2(projectRoot, currentFilePath) : currentFilePath;
-  for (const pattern of patterns2) {
-    if (import_picomatch2.default.isMatch(relativePath, pattern, { dot: true, bash: true })) {
-      return { applies: true, reason: `glob: ${pattern}` };
-    }
-  }
-  return { applies: false };
-}
-function isDuplicateByRealPath(realPath, cache2) {
-  return cache2.has(realPath);
-}
-function createContentHash(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-function isDuplicateByContentHash(hash2, cache2) {
-  return cache2.has(hash2);
-}
-
-// src/hooks/rules-injector/parser.ts
-function parseRuleFrontmatter(content) {
-  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-  const match = content.match(frontmatterRegex);
-  if (!match) {
-    return { metadata: {}, body: content };
-  }
-  const yamlContent = match[1];
-  const body = match[2];
-  try {
-    const metadata = parseYamlContent(yamlContent);
-    return { metadata, body };
-  } catch {
-    return { metadata: {}, body: content };
-  }
-}
-function parseYamlContent(yamlContent) {
-  const lines = yamlContent.split(`
-`);
-  const metadata = {};
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) {
-      i++;
-      continue;
-    }
-    const key = line.slice(0, colonIndex).trim();
-    const rawValue = line.slice(colonIndex + 1).trim();
-    if (key === "description") {
-      metadata.description = parseStringValue(rawValue);
-    } else if (key === "alwaysApply") {
-      metadata.alwaysApply = rawValue === "true";
-    } else if (key === "globs" || key === "applyTo") {
-      const { value, consumed } = parseArrayOrStringValue(rawValue, lines, i);
-      metadata.globs = mergeGlobs(metadata.globs, value);
-      i += consumed;
-      continue;
-    }
-    i++;
-  }
-  return metadata;
-}
-function parseStringValue(value) {
-  if (!value)
-    return "";
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function parseArrayOrStringValue(rawValue, lines, currentIndex) {
-  if (rawValue.startsWith("[")) {
-    return { value: parseInlineArray(rawValue), consumed: 1 };
-  }
-  if (!rawValue || rawValue === "") {
-    const arrayItems = [];
-    let consumed = 1;
-    for (let j = currentIndex + 1;j < lines.length; j++) {
-      const nextLine = lines[j];
-      const arrayMatch = nextLine.match(/^\s+-\s*(.*)$/);
-      if (arrayMatch) {
-        const itemValue = parseStringValue(arrayMatch[1].trim());
-        if (itemValue) {
-          arrayItems.push(itemValue);
-        }
-        consumed++;
-      } else if (nextLine.trim() === "") {
-        consumed++;
-      } else {
-        break;
-      }
-    }
-    if (arrayItems.length > 0) {
-      return { value: arrayItems, consumed };
-    }
-  }
-  const stringValue = parseStringValue(rawValue);
-  if (stringValue.includes(",")) {
-    const items = stringValue.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-    return { value: items, consumed: 1 };
-  }
-  return { value: stringValue, consumed: 1 };
-}
-function parseInlineArray(value) {
-  const content = value.slice(1, value.lastIndexOf("]")).trim();
-  if (!content)
-    return [];
-  const items = [];
-  let current = "";
-  let inQuote = false;
-  let quoteChar = "";
-  for (let i = 0;i < content.length; i++) {
-    const char = content[i];
-    if (!inQuote && (char === '"' || char === "'")) {
-      inQuote = true;
-      quoteChar = char;
-    } else if (inQuote && char === quoteChar) {
-      inQuote = false;
-      quoteChar = "";
-    } else if (!inQuote && char === ",") {
-      const trimmed2 = current.trim();
-      if (trimmed2) {
-        items.push(parseStringValue(trimmed2));
-      }
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  const trimmed = current.trim();
-  if (trimmed) {
-    items.push(parseStringValue(trimmed));
-  }
-  return items;
-}
-function mergeGlobs(existing, newValue) {
-  if (!existing)
-    return newValue;
-  const existingArray = Array.isArray(existing) ? existing : [existing];
-  const newArray = Array.isArray(newValue) ? newValue : [newValue];
-  return [...existingArray, ...newArray];
-}
-
-// src/hooks/rules-injector/injector.ts
-var parsedRuleCache = new Map;
-var RULE_WATCHER_DEBOUNCE_MS = 1000;
-var ruleWatchers = new Map;
-var ruleWatcherDebounceTimers = new Map;
-function makeRuleCacheKey(realPath, cwd, mtimeMs) {
-  return `${realPath}\x00${cwd}\x00${mtimeMs}`;
-}
-function invalidateRuleCacheForPath(realPath) {
-  const prefix = `${realPath}\x00`;
-  for (const key of parsedRuleCache.keys()) {
-    if (key.startsWith(prefix)) {
-      parsedRuleCache.delete(key);
-    }
-  }
-}
-function setupRuleWatcher(realPath) {
-  if (ruleWatchers.has(realPath))
-    return;
-  try {
-    const watcher = watch(realPath, () => {
-      const existing = ruleWatcherDebounceTimers.get(realPath);
-      if (existing)
-        clearTimeout(existing);
-      const timer = setTimeout(() => {
-        ruleWatcherDebounceTimers.delete(realPath);
-        invalidateRuleCacheForPath(realPath);
-      }, RULE_WATCHER_DEBOUNCE_MS);
-      if (typeof timer.unref === "function") {
-        timer.unref?.();
-      }
-      ruleWatcherDebounceTimers.set(realPath, timer);
-    });
-    watcher.on("error", () => {
-      ruleWatchers.delete(realPath);
-    });
-    ruleWatchers.set(realPath, watcher);
-  } catch {}
-}
-function getCachedParsedRule(filePath, realPath, cwd) {
-  try {
-    const stat = statSync7(filePath);
-    const key = makeRuleCacheKey(realPath, cwd, stat.mtimeMs);
-    const cached2 = parsedRuleCache.get(key);
-    if (cached2 && cached2.size === stat.size) {
-      return { metadata: cached2.metadata, body: cached2.body };
-    }
-    const rawContent = readFileSync32(filePath, "utf-8");
-    const { metadata, body } = parseRuleFrontmatter(rawContent);
-    parsedRuleCache.set(key, {
-      mtimeMs: stat.mtimeMs,
-      size: stat.size,
-      metadata,
-      body
-    });
-    setupRuleWatcher(realPath);
-    return { metadata, body };
-  } catch {
-    const rawContent = readFileSync32(filePath, "utf-8");
-    return parseRuleFrontmatter(rawContent);
-  }
-}
-function resolveFilePath3(workspaceDirectory, path12) {
-  if (!path12)
-    return null;
-  if (path12.startsWith("/"))
-    return path12;
-  return resolve5(workspaceDirectory, path12);
-}
-function createRuleInjectionProcessor(deps) {
-  const { workspaceDirectory, truncator, getSessionCache: getSessionCache2 } = deps;
-  async function processFilePathForInjection(filePath, sessionID, output) {
-    const resolved = resolveFilePath3(workspaceDirectory, filePath);
-    if (!resolved)
-      return;
-    const projectRoot = findProjectRoot(resolved);
-    const cache2 = getSessionCache2(sessionID);
-    const ruleFileCandidates = findRuleFiles(projectRoot, resolved);
-    const toInject = [];
-    let dirty = false;
-    for (const candidate of ruleFileCandidates) {
-      if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
-        continue;
-      try {
-        const { metadata, body } = getCachedParsedRule(candidate.path, candidate.realPath, workspaceDirectory);
-        let matchReason;
-        if (candidate.isSingleFile) {
-          matchReason = "copilot-instructions (always apply)";
-        } else {
-          const matchResult = shouldApplyRule(metadata, resolved, projectRoot);
-          if (!matchResult.applies)
-            continue;
-          matchReason = matchResult.reason ?? "matched";
-        }
-        const contentHash = createContentHash(body);
-        if (isDuplicateByContentHash(contentHash, cache2.contentHashes))
-          continue;
-        const relativePath = projectRoot ? relative3(projectRoot, candidate.path) : candidate.path;
-        toInject.push({
-          relativePath,
-          matchReason,
-          content: body,
-          distance: candidate.distance
-        });
-        cache2.realPaths.add(candidate.realPath);
-        cache2.contentHashes.add(contentHash);
-        dirty = true;
-      } catch {}
-    }
-    if (toInject.length === 0)
-      return;
-    toInject.sort((a, b) => a.distance - b.distance);
-    for (const rule of toInject) {
-      const { result, truncated } = await truncator.truncate(sessionID, rule.content);
-      const truncationNotice = truncated ? `
-
-[Note: Content was truncated to save context window space. For full context, please read the file directly: ${rule.relativePath}]` : "";
-      output.output += `
-
-[Rule: ${rule.relativePath}]
-[Match: ${rule.matchReason}]
-${result}${truncationNotice}`;
-    }
-    if (dirty) {
-      saveInjectedRules(sessionID, cache2);
-    }
-  }
-  return { processFilePathForInjection };
-}
-
-// src/hooks/rules-injector/output-path.ts
-function getRuleInjectionFilePath(output) {
-  const metadata = output.metadata;
-  const metadataFilePath = metadata && typeof metadata === "object" ? metadata.filePath : undefined;
-  if (typeof metadataFilePath === "string" && metadataFilePath.length > 0) {
-    return metadataFilePath;
-  }
-  if (typeof output.title === "string" && output.title.length > 0) {
-    return output.title;
-  }
-  return null;
-}
-
 // src/hooks/rules-injector/hook.ts
-var TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
 function createRulesInjectorHook(ctx) {
-  const truncator = createDynamicTruncator(ctx);
-  const { getSessionCache: getSessionCache2, clearSessionCache } = createSessionCacheStore();
-  const { processFilePathForInjection } = createRuleInjectionProcessor({
-    workspaceDirectory: ctx.directory,
-    truncator,
-    getSessionCache: getSessionCache2
-  });
-  const toolExecuteAfter = async (input, output) => {
-    const toolName = input.tool.toLowerCase();
-    if (TRACKED_TOOLS.includes(toolName)) {
-      const filePath = getRuleInjectionFilePath(output);
-      if (!filePath)
-        return;
-      await processFilePathForInjection(filePath, input.sessionID, output);
-      return;
-    }
-  };
-  const toolExecuteBefore = async (input, output) => {};
-  const eventHandler = async ({ event }) => {
-    const props = event.properties;
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info;
-      if (sessionInfo?.id) {
-        clearSessionCache(sessionInfo.id);
-      }
-    }
-    if (event.type === "session.compacted") {
-      const sessionID = props?.sessionID ?? props?.info?.id;
-      if (sessionID) {
-        clearSessionCache(sessionID);
-      }
-    }
-  };
-  return {
-    "tool.execute.before": toolExecuteBefore,
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler
-  };
+  return createPostReadInjectorHook(ctx, { trackedTools: ["read", "write", "edit", "multiedit"] });
 }
 // src/hooks/runtime-fallback/auto-retry.ts
 init_logger();
@@ -64967,8 +64860,8 @@ var FAILURE_RESET_WINDOW_MS = 5 * 60 * 1000;
 init_logger();
 
 // src/hooks/task-continuation-enforcer/idle-event.ts
-import { existsSync as existsSync44, readdirSync as readdirSync15 } from "fs";
-import { join as join53 } from "path";
+import { existsSync as existsSync43, readdirSync as readdirSync15 } from "fs";
+import { join as join52 } from "path";
 init_logger();
 
 // src/hooks/task-continuation-enforcer/abort-detection.ts
@@ -64991,12 +64884,12 @@ function isLastAssistantMessageAborted(messages) {
 init_logger();
 
 // src/hooks/task-continuation-enforcer/continuation-injection.ts
-import { existsSync as existsSync43, readdirSync as readdirSync14 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync42, readdirSync as readdirSync14 } from "fs";
+import { join as join51 } from "path";
 init_logger();
 // src/hooks/task-continuation-enforcer/staleness.ts
-import { statSync as statSync8 } from "fs";
-import { join as join51 } from "path";
+import { statSync as statSync6 } from "fs";
+import { join as join50 } from "path";
 var DEFAULT_STALE_AFTER_HOURS = 24;
 var HOUR_MS = 60 * 60 * 1000;
 function getStaleAfterMs(config2) {
@@ -65005,7 +64898,7 @@ function getStaleAfterMs(config2) {
 }
 function getTaskAgeMs(taskPath) {
   try {
-    const stat = statSync8(taskPath);
+    const stat = statSync6(taskPath);
     return Date.now() - stat.mtimeMs;
   } catch {
     return null;
@@ -65016,7 +64909,7 @@ function isTaskStale(taskPath, staleAfterMs) {
   return ageMs !== null && ageMs > staleAfterMs;
 }
 function filterFreshIncompleteTasks(tasks, taskDir, staleAfterMs) {
-  return tasks.filter((t) => !isTaskStale(join51(taskDir, `${t.id}.json`), staleAfterMs));
+  return tasks.filter((t) => !isTaskStale(join50(taskDir, `${t.id}.json`), staleAfterMs));
 }
 function formatTaskAge(ageMs) {
   const hours = Math.floor(ageMs / HOUR_MS);
@@ -65117,7 +65010,7 @@ async function injectContinuation(args) {
   let taskDir = "";
   try {
     taskDir = getTaskDir(config2, ctx.directory);
-    if (!existsSync43(taskDir)) {
+    if (!existsSync42(taskDir)) {
       const hadNonExplorerBgTasks = backgroundManager ? hasNonExplorerBgTasks(backgroundManager.getTasksByParentSession(sessionID)) : false;
       if (hadNonExplorerBgTasks) {
         log(`[${HOOK_NAME14}] Bootstrap injection: no task dir (hadNonExplorerBgTasks)`, { sessionID, taskDir });
@@ -65200,7 +65093,7 @@ async function injectContinuation(args) {
     const incompleteTasks = getIncompleteTasks(filteredTasks);
     const freshIncompleteTasks = filterFreshIncompleteTasks(incompleteTasks, taskDir, staleAfterMs);
     const taskList = incompleteTasks.map((task) => {
-      const ageMs = getTaskAgeMs(join52(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(`
@@ -65382,7 +65275,7 @@ async function handleSessionIdle(args) {
   let taskDir = "";
   try {
     taskDir = getTaskDir(config2, ctx.directory);
-    if (!existsSync44(taskDir)) {
+    if (!existsSync43(taskDir)) {
       const hadNonExplorerBgTasks = backgroundManager ? hasNonExplorerBgTasks(backgroundManager.getTasksByParentSession(sessionID)) : false;
       if (hadNonExplorerBgTasks) {
         log(`[${HOOK_NAME14}] No task dir \u2014 bootstrap (hadBgTasks)`, { sessionID, taskDir });
@@ -65421,7 +65314,7 @@ async function handleSessionIdle(args) {
         const incompleteTasks = getIncompleteTasks(filteredTasks);
         incompleteCount = incompleteTasks.length;
         const staleAfterMs = getStaleAfterMs(config2);
-        const staleIncompleteCount = incompleteTasks.filter((t) => isTaskStale(join53(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`, {
@@ -65868,8 +65761,8 @@ var TASK_NOTEPAD_FRAGMENT = "task-notepad";
 var TODO_FETCH_ERROR_FRAGMENT = "Failed to fetch todos for task-notepad";
 // src/hooks/task-notepad/hook.ts
 init_logger();
-import { existsSync as existsSync45, mkdirSync as mkdirSync16, readdirSync as readdirSync16, readFileSync as readFileSync33, statSync as statSync9, writeFileSync as writeFileSync18 } from "fs";
-import { dirname as dirname13, join as join54 } from "path";
+import { existsSync as existsSync44, mkdirSync as mkdirSync16, readdirSync as readdirSync16, readFileSync as readFileSync34, statSync as statSync7, writeFileSync as writeFileSync18 } from "fs";
+import { dirname as dirname11, join as join53 } from "path";
 function createTaskNotepadHook(ctx) {
   return {
     "tool.execute.after": async (input, output) => {
@@ -65920,8 +65813,8 @@ async function fetchTodos(ctx, sessionID) {
   }
 }
 function resolveActivePlan(directory) {
-  const plansDir = join54(directory, PLAN_DIR_NAME, PLANS_SUBDIR);
-  if (!existsSync45(plansDir))
+  const plansDir = join53(directory, PLAN_DIR_NAME, PLANS_SUBDIR);
+  if (!existsSync44(plansDir))
     return null;
   let entries;
   try {
@@ -65933,9 +65826,9 @@ function resolveActivePlan(directory) {
   for (const entry of entries) {
     if (!entry.endsWith(PLAN_EXTENSION))
       continue;
-    const fullPath = join54(plansDir, entry);
+    const fullPath = join53(plansDir, entry);
     try {
-      const stats = statSync9(fullPath);
+      const stats = statSync7(fullPath);
       if (!stats.isFile())
         continue;
       const candidate = {
@@ -65952,18 +65845,18 @@ function resolveActivePlan(directory) {
 }
 function ensureNotepad(directory, planName, todo) {
   const notepadPath = notepadPathFor(directory, planName, todo.id);
-  if (existsSync45(notepadPath))
+  if (existsSync44(notepadPath))
     return;
-  mkdirSync16(dirname13(notepadPath), { recursive: true });
+  mkdirSync16(dirname11(notepadPath), { recursive: true });
   const content = renderNotepad(todo);
   writeFileSync18(notepadPath, content, "utf-8");
   log(`[${HOOK_NAME16}] Created task notepad`, { plan: planName, taskID: todo.id });
 }
 function appendCompletion(directory, planName, todo) {
   const notepadPath = notepadPathFor(directory, planName, todo.id);
-  if (!existsSync45(notepadPath))
+  if (!existsSync44(notepadPath))
     return;
-  const existing = readFileSync33(notepadPath, "utf-8");
+  const existing = readFileSync34(notepadPath, "utf-8");
   if (existing.includes("**Status**: completed"))
     return;
   const stamp = new Date().toISOString();
@@ -65976,7 +65869,7 @@ function appendCompletion(directory, planName, todo) {
   log(`[${HOOK_NAME16}] Appended completion to notepad`, { plan: planName, taskID: todo.id });
 }
 function notepadPathFor(directory, planName, taskID) {
-  return join54(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
+  return join53(directory, PLAN_DIR_NAME, NOTEPAD_DIR_NAME, planName, TASKS_SUBDIR, `${taskID}${NOTEPAD_EXTENSION}`);
 }
 function renderNotepad(todo) {
   const priority = todo.priority ?? "medium";
@@ -67185,6 +67078,7 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
 // src/hooks/tool-output-truncator.ts
 var DEFAULT_MAX_TOKENS = 50000;
 var WEBFETCH_MAX_TOKENS = 1e4;
+var READ_MAX_TOKENS = 1e4;
 var TRUNCATABLE_TOOLS = [
   "grep",
   "Grep",
@@ -67197,11 +67091,19 @@ var TRUNCATABLE_TOOLS = [
   "interactive_bash",
   "Interactive_bash",
   "webfetch",
-  "WebFetch"
+  "WebFetch",
+  "read",
+  "Read",
+  "lookup_type",
+  "list_types"
 ];
 var TOOL_SPECIFIC_MAX_TOKENS = {
   webfetch: WEBFETCH_MAX_TOKENS,
-  WebFetch: WEBFETCH_MAX_TOKENS
+  WebFetch: WEBFETCH_MAX_TOKENS,
+  read: READ_MAX_TOKENS,
+  Read: READ_MAX_TOKENS,
+  lookup_type: READ_MAX_TOKENS,
+  list_types: READ_MAX_TOKENS
 };
 function createToolOutputTruncatorHook(ctx, options) {
   const truncator = createDynamicTruncator(ctx);
@@ -67651,8 +67553,8 @@ function createWebFetchRedirectGuardHook(_ctx) {
   };
 }
 // src/hooks/write-existing-file-guard/hook.ts
-import { existsSync as existsSync46 } from "fs";
-import { isAbsolute as isAbsolute4, join as join55, normalize, resolve as resolve6, sep } from "path";
+import { existsSync as existsSync45 } from "fs";
+import { isAbsolute as isAbsolute4, join as join54, normalize as normalize2, resolve as resolve5, sep } from "path";
 function createWriteExistingFileGuardHook(ctx) {
   return {
     "tool.execute.before": async (input, output) => {
@@ -67665,9 +67567,9 @@ function createWriteExistingFileGuardHook(ctx) {
       if (!filePath) {
         return;
       }
-      const resolvedPath = normalize(isAbsolute4(filePath) ? filePath : resolve6(ctx.directory, filePath));
-      if (existsSync46(resolvedPath)) {
-        const matrixxRoot = join55(ctx.directory, ".matrixx") + sep;
+      const resolvedPath = normalize2(isAbsolute4(filePath) ? filePath : resolve5(ctx.directory, filePath));
+      if (existsSync45(resolvedPath)) {
+        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");
@@ -67845,8 +67747,8 @@ function createAnthropicEffortHook() {
   };
 }
 // src/tools/lsp/lsp-client.ts
-import { readFileSync as readFileSync35 } from "fs";
-import { extname as extname2, resolve as resolve7 } from "path";
+import { readFileSync as readFileSync36 } from "fs";
+import { extname as extname2, resolve as resolve6 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
 // src/tools/lsp/language-mappings.ts
@@ -68112,14 +68014,14 @@ function getLanguageId(ext) {
   return EXT_TO_LANG[ext] || "plaintext";
 }
 // src/tools/lsp/server-installation.ts
-import { existsSync as existsSync47 } from "fs";
-import { join as join56 } from "path";
+import { existsSync as existsSync46 } from "fs";
+import { join as join55 } from "path";
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync47(cmd))
+    if (existsSync46(cmd))
       return true;
   }
   const isWindows = process.platform === "win32";
@@ -68141,23 +68043,23 @@ function isServerInstalled(command) {
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
     for (const suffix of exts) {
-      if (existsSync47(join56(p, cmd + suffix))) {
+      if (existsSync46(join55(p, cmd + suffix))) {
         return true;
       }
     }
   }
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const dataDir = join56(getDataDir(), "opencode");
+  const dataDir = join55(getDataDir(), "opencode");
   const additionalBases = [
-    join56(cwd, "node_modules", ".bin"),
-    join56(configDir, "bin"),
-    join56(configDir, "node_modules", ".bin"),
-    join56(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 (existsSync47(join56(base, cmd + suffix))) {
+      if (existsSync46(join55(base, cmd + suffix))) {
         return true;
       }
     }
@@ -68168,13 +68070,13 @@ function isServerInstalled(command) {
   return false;
 }
 // src/tools/lsp/server-config-loader.ts
-import { existsSync as existsSync48, readFileSync as readFileSync34 } from "fs";
-import { join as join57 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync35 } from "fs";
+import { join as join56 } from "path";
 function loadJsonFile(path12) {
-  if (!existsSync48(path12))
+  if (!existsSync47(path12))
     return null;
   try {
-    return parseJsonc(readFileSync34(path12, "utf-8"));
+    return parseJsonc(readFileSync35(path12, "utf-8"));
   } catch {
     return null;
   }
@@ -68183,9 +68085,9 @@ function getConfigPaths3() {
   const cwd = process.cwd();
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   return {
-    project: detectConfigFile(join57(cwd, ".opencode", "matrixx")).path,
-    user: detectConfigFile(join57(configDir, "matrixx")).path,
-    opencode: detectConfigFile(join57(configDir, "opencode")).path
+    project: detectConfigFile(join56(cwd, ".opencode", "matrixx")).path,
+    user: detectConfigFile(join56(configDir, "matrixx")).path,
+    opencode: detectConfigFile(join56(configDir, "opencode")).path
   };
 }
 function loadAllConfigs() {
@@ -68303,17 +68205,17 @@ import { Readable, Writable } from "stream";
 // src/tools/lsp/lsp-process.ts
 init_logger();
 import { spawn as nodeSpawn } from "child_process";
-import { existsSync as existsSync49, statSync as statSync10 } from "fs";
+import { existsSync as existsSync48, statSync as statSync8 } from "fs";
 var {spawn: bunSpawn } = globalThis.Bun;
 function shouldUseNodeSpawn() {
   return process.platform === "win32";
 }
 function validateCwd(cwd) {
   try {
-    if (!existsSync49(cwd)) {
+    if (!existsSync48(cwd)) {
       return { valid: false, error: `Working directory does not exist: ${cwd}` };
     }
-    const stats = statSync10(cwd);
+    const stats = statSync8(cwd);
     if (!stats.isDirectory()) {
       return { valid: false, error: `Path is not a directory: ${cwd}` };
     }
@@ -68325,8 +68227,8 @@ function validateCwd(cwd) {
 function wrapNodeProcess(proc) {
   let resolveExited;
   let exitCode = null;
-  const exitedPromise = new Promise((resolve7) => {
-    resolveExited = resolve7;
+  const exitedPromise = new Promise((resolve6) => {
+    resolveExited = resolve6;
   });
   proc.on("exit", (code) => {
     exitCode = code ?? 1;
@@ -68346,9 +68248,9 @@ function wrapNodeProcess(proc) {
       nodeStream.on("data", (chunk) => {
         const uint8 = new Uint8Array(chunk);
         if (waitingResolve) {
-          const resolve7 = waitingResolve;
+          const resolve6 = waitingResolve;
           waitingResolve = null;
-          resolve7({ done: false, value: uint8 });
+          resolve6({ done: false, value: uint8 });
         } else {
           chunks.push(uint8);
         }
@@ -68356,17 +68258,17 @@ function wrapNodeProcess(proc) {
       nodeStream.on("end", () => {
         streamEnded = true;
         if (waitingResolve) {
-          const resolve7 = waitingResolve;
+          const resolve6 = waitingResolve;
           waitingResolve = null;
-          resolve7({ done: true, value: undefined });
+          resolve6({ done: true, value: undefined });
         }
       });
       nodeStream.on("error", () => {
         streamEnded = true;
         if (waitingResolve) {
-          const resolve7 = waitingResolve;
+          const resolve6 = waitingResolve;
           waitingResolve = null;
-          resolve7({ done: true, value: undefined });
+          resolve6({ done: true, value: undefined });
         }
       });
     } else {
@@ -68374,13 +68276,13 @@ function wrapNodeProcess(proc) {
     }
     return {
       read() {
-        return new Promise((resolve7) => {
+        return new Promise((resolve6) => {
           if (chunks.length > 0) {
-            resolve7({ done: false, value: chunks.shift() });
+            resolve6({ done: false, value: chunks.shift() });
           } else if (streamEnded) {
-            resolve7({ done: true, value: undefined });
+            resolve6({ done: true, value: undefined });
           } else {
-            waitingResolve = resolve7;
+            waitingResolve = resolve6;
           }
         });
       }
@@ -68468,7 +68370,7 @@ class LSPClientTransport {
       throw new Error(`Failed to spawn LSP server: ${this.server.command.join(" ")}`);
     }
     this.startStderrReading();
-    await new Promise((resolve7) => setTimeout(resolve7, 100));
+    await new Promise((resolve6) => setTimeout(resolve6, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -68600,8 +68502,8 @@ recent stderr: ${stderr}` : ""}`));
       try {
         proc.kill();
         let timeoutId;
-        const timeoutPromise = new Promise((resolve7) => {
-          timeoutId = setTimeout(resolve7, 5000);
+        const timeoutPromise = new Promise((resolve6) => {
+          timeoutId = setTimeout(resolve6, 5000);
         });
         await Promise.race([
           proc.exited.then(() => {
@@ -68613,7 +68515,7 @@ recent stderr: ${stderr}` : ""}`));
           log("[LSPClient] Process did not exit within timeout, escalating to SIGKILL");
           try {
             proc.kill("SIGKILL");
-            await Promise.race([proc.exited, new Promise((resolve7) => setTimeout(resolve7, 1000))]);
+            await Promise.race([proc.exited, new Promise((resolve6) => setTimeout(resolve6, 1000))]);
           } catch {}
         }
       } catch {}
@@ -68693,9 +68595,9 @@ class LSPClient extends LSPClientConnection {
   documentVersions = new Map;
   lastSyncedText = new Map;
   async openFile(filePath) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     const uri = pathToFileURL2(absPath).href;
-    const text = readFileSync35(absPath, "utf-8");
+    const text = readFileSync36(absPath, "utf-8");
     if (!this.openedFiles.has(absPath)) {
       const ext = extname2(absPath);
       const languageId = getLanguageId(ext);
@@ -68731,7 +68633,7 @@ class LSPClient extends LSPClientConnection {
     });
   }
   async definition(filePath, line, character) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.sendRequest("textDocument/definition", {
       textDocument: { uri: pathToFileURL2(absPath).href },
@@ -68739,7 +68641,7 @@ class LSPClient extends LSPClientConnection {
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.sendRequest("textDocument/references", {
       textDocument: { uri: pathToFileURL2(absPath).href },
@@ -68748,7 +68650,7 @@ class LSPClient extends LSPClientConnection {
     });
   }
   async documentSymbols(filePath) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.sendRequest("textDocument/documentSymbol", {
       textDocument: { uri: pathToFileURL2(absPath).href }
@@ -68758,7 +68660,7 @@ class LSPClient extends LSPClientConnection {
     return this.sendRequest("workspace/symbol", { query });
   }
   async diagnostics(filePath) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     const uri = pathToFileURL2(absPath).href;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
@@ -68773,7 +68675,7 @@ class LSPClient extends LSPClientConnection {
     return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async prepareRename(filePath, line, character) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.sendRequest("textDocument/prepareRename", {
       textDocument: { uri: pathToFileURL2(absPath).href },
@@ -68781,7 +68683,7 @@ class LSPClient extends LSPClientConnection {
     });
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve7(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.sendRequest("textDocument/rename", {
       textDocument: { uri: pathToFileURL2(absPath).href },
@@ -69033,31 +68935,31 @@ class LSPServerManager {
 }
 var lspManager = LSPServerManager.getInstance();
 // src/tools/lsp/lsp-client-wrapper.ts
-import { existsSync as existsSync50, statSync as statSync11 } from "fs";
-import { dirname as dirname14, extname as extname3, join as join58, resolve as resolve8 } from "path";
+import { existsSync as existsSync49, statSync as statSync9 } from "fs";
+import { dirname as dirname12, extname as extname3, join as join57, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function findWorkspaceRoot(filePath) {
-  let dir = resolve8(filePath);
+  let dir = resolve7(filePath);
   try {
-    const stat = statSync11(dir);
+    const stat = statSync9(dir);
     if (!stat.isDirectory()) {
-      dir = dirname14(dir);
+      dir = dirname12(dir);
     }
   } catch {
-    dir = dirname14(dir);
+    dir = dirname12(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   let prevDir = "";
   while (dir !== prevDir) {
     for (const marker of markers) {
-      if (existsSync50(join58(dir, marker))) {
+      if (existsSync49(join57(dir, marker))) {
         return dir;
       }
     }
     prevDir = dir;
-    dir = dirname14(dir);
+    dir = dirname12(dir);
   }
-  return dirname14(resolve8(filePath));
+  return dirname12(resolve7(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath3(uri);
@@ -69098,7 +69000,7 @@ function formatServerLookupError(result) {
 `);
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve8(filePath);
+  const absPath = resolve7(filePath);
   const ext = extname3(absPath);
   const result = findServerForExtension(ext);
   if (result.status !== "found") {
@@ -81652,10 +81554,10 @@ var lsp_goto_definition = tool({
   }
 });
 // src/tools/lsp/workspace-edit.ts
-import { readFileSync as readFileSync36, writeFileSync as writeFileSync19 } from "fs";
+import { readFileSync as readFileSync37, writeFileSync as writeFileSync19 } from "fs";
 function applyTextEditsToFile(filePath, edits) {
   try {
-    const content = readFileSync36(filePath, "utf-8");
+    const content = readFileSync37(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -81721,7 +81623,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync36(oldPath, "utf-8");
+            const content = readFileSync37(oldPath, "utf-8");
             writeFileSync19(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
@@ -81860,12 +81762,12 @@ var lsp_symbols = tool({
   }
 });
 // src/tools/ast-grep/cli.ts
-import { existsSync as existsSync54 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/ast-grep/cli-binary-path-resolution.ts
 init_logger();
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync52 } from "fs";
 
 // src/tools/ast-grep/language-support.ts
 var CLI_LANGUAGES = [
@@ -81900,15 +81802,15 @@ var DEFAULT_MAX_OUTPUT_BYTES = 1 * 1024 * 1024;
 var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/sg-cli-path.ts
-import { existsSync as existsSync52, statSync as statSync12 } from "fs";
+import { existsSync as existsSync51, statSync as statSync10 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname15, join as join60 } from "path";
+import { dirname as dirname13, join as join59 } from "path";
 
 // src/tools/ast-grep/downloader.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync50 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import { homedir as homedir9 } from "os";
-import { join as join59 } from "path";
+import { join as join58 } from "path";
 init_logger();
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -81933,12 +81835,12 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join59(homedir9(), "AppData", "Local");
-    return join59(base2, "matrixx", "bin");
+    const base2 = localAppData || join58(homedir9(), "AppData", "Local");
+    return join58(base2, "matrixx", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join59(homedir9(), ".cache");
-  return join59(base, "matrixx", "bin");
+  const base = xdgCache || join58(homedir9(), ".cache");
+  return join58(base, "matrixx", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
@@ -81955,8 +81857,8 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join59(cacheDir, binaryName);
-  if (existsSync51(binaryPath)) {
+  const binaryPath = join58(cacheDir, binaryName);
+  if (existsSync50(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os7 } = platformInfo;
@@ -81964,7 +81866,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 = join59(cacheDir, assetName);
+    const archivePath = join58(cacheDir, assetName);
     ensureCacheDir(cacheDir);
     await downloadArchive(downloadUrl, archivePath);
     await extractZipArchive(archivePath, cacheDir);
@@ -81989,7 +81891,7 @@ async function ensureAstGrepBinary() {
 // src/tools/ast-grep/sg-cli-path.ts
 function isValidBinary(filePath) {
   try {
-    return statSync12(filePath).size > 1e4;
+    return statSync10(filePath).size > 1e4;
   } catch {
     return false;
   }
@@ -82017,9 +81919,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire4(import.meta.url);
     const cliPackageJsonPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDirectory = dirname15(cliPackageJsonPath);
-    const sgPath = join60(cliDirectory, binaryName);
-    if (existsSync52(sgPath) && isValidBinary(sgPath)) {
+    const cliDirectory = dirname13(cliPackageJsonPath);
+    const sgPath = join59(cliDirectory, binaryName);
+    if (existsSync51(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -82028,10 +81930,10 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire4(import.meta.url);
       const packageJsonPath = require2.resolve(`${platformPackage}/package.json`);
-      const packageDirectory = dirname15(packageJsonPath);
+      const packageDirectory = dirname13(packageJsonPath);
       const astGrepBinaryName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join60(packageDirectory, astGrepBinaryName);
-      if (existsSync52(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join59(packageDirectory, astGrepBinaryName);
+      if (existsSync51(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -82039,7 +81941,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path12 of homebrewPaths) {
-      if (existsSync52(path12) && isValidBinary(path12)) {
+      if (existsSync51(path12) && isValidBinary(path12)) {
         return path12;
       }
     }
@@ -82065,7 +81967,7 @@ function setSgCliPath(path12) {
 var resolvedCliPath3 = null;
 var initPromise3 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync53(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync52(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise3) {
@@ -82073,7 +81975,7 @@ async function getAstGrepPath() {
   }
   initPromise3 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync53(syncPath)) {
+    if (syncPath && existsSync52(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -82172,7 +82074,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!cliPath || !existsSync54(cliPath)) {
+  if (!cliPath || !existsSync53(cliPath)) {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -84460,18 +84362,18 @@ var {spawn: spawn10 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync59 } from "fs";
-import { dirname as dirname16, join as join62 } from "path";
+import { existsSync as existsSync58 } from "fs";
+import { dirname as dirname14, join as join61 } from "path";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync58, readdirSync as readdirSync18 } from "fs";
-import { join as join61 } from "path";
+import { existsSync as existsSync57, readdirSync as readdirSync18 } from "fs";
+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 join61(entry.parentPath ?? dir, entry.name);
+        return join60(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -84492,11 +84394,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join61(homeDir, ".cache", "matrixx", "bin");
+  return join60(homeDir, ".cache", "matrixx", "bin");
 }
 function getRgPath() {
   const isWindows = process.platform === "win32";
-  return join61(getInstallDir(), isWindows ? "rg.exe" : "rg");
+  return join60(getInstallDir(), isWindows ? "rg.exe" : "rg");
 }
 async function extractTarGz2(archivePath, destDir) {
   const platformKey = getPlatformKey();
@@ -84513,7 +84415,7 @@ async function extractZip2(archivePath, destDir) {
   const binaryName = process.platform === "win32" ? "rg.exe" : "rg";
   const foundPath = findFileRecursive(destDir, binaryName);
   if (foundPath) {
-    const destPath = join61(destDir, binaryName);
+    const destPath = join60(destDir, binaryName);
     if (foundPath !== destPath) {
       const { renameSync: renameSync4 } = await import("fs");
       renameSync4(foundPath, destPath);
@@ -84528,13 +84430,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync58(rgPath)) {
+  if (existsSync57(rgPath)) {
     return rgPath;
   }
   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 = join61(installDir, filename);
+  const archivePath = join60(installDir, filename);
   try {
     await downloadArchive(url3, archivePath);
     if (config4.extension === "tar.gz") {
@@ -84543,7 +84445,7 @@ async function downloadAndInstallRipgrep() {
       await extractZip2(archivePath, installDir);
     }
     ensureExecutable(rgPath);
-    if (!existsSync58(rgPath)) {
+    if (!existsSync57(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
@@ -84555,7 +84457,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync58(rgPath) ? rgPath : null;
+  return existsSync57(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -84575,18 +84477,18 @@ function findExecutable(name) {
 }
 function getOpenCodeBundledRg() {
   const execPath = process.execPath;
-  const execDir = dirname16(execPath);
+  const execDir = dirname14(execPath);
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join62(getDataDir(), "opencode", "bin", rgName),
-    join62(execDir, rgName),
-    join62(execDir, "bin", rgName),
-    join62(execDir, "..", "bin", rgName),
-    join62(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 (existsSync59(candidate)) {
+    if (existsSync58(candidate)) {
       return candidate;
     }
   }
@@ -85090,17 +84992,17 @@ var HandoffSchema = exports_external.object({
   sections: HandoffSectionSchema
 });
 // src/features/handoff/storage.ts
-import { existsSync as existsSync60, mkdirSync as mkdirSync17, readFileSync as readFileSync39, renameSync as renameSync4, writeFileSync as writeFileSync22 } from "fs";
-import { join as join63 } from "path";
+import { existsSync as existsSync59, mkdirSync as mkdirSync17, readFileSync as readFileSync40, renameSync as renameSync4, writeFileSync as writeFileSync22 } from "fs";
+import { join as join62 } from "path";
 function getHandoffFilePath(directory) {
-  return join63(directory, HANDOFF_FILE_PATH);
+  return join62(directory, HANDOFF_FILE_PATH);
 }
 function getHandoffConsumedFilePath(directory) {
-  return join63(directory, HANDOFF_CONSUMED_FILE_PATH);
+  return join62(directory, HANDOFF_CONSUMED_FILE_PATH);
 }
 function handoffFileExists(directory) {
   try {
-    return existsSync60(getHandoffFilePath(directory));
+    return existsSync59(getHandoffFilePath(directory));
   } catch {
     return false;
   }
@@ -85108,9 +85010,9 @@ function handoffFileExists(directory) {
 function readHandoffFile(directory) {
   const filePath = getHandoffFilePath(directory);
   try {
-    if (!existsSync60(filePath))
+    if (!existsSync59(filePath))
       return null;
-    return readFileSync39(filePath, "utf-8");
+    return readFileSync40(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -85134,7 +85036,7 @@ function writeHandoffFile(directory, content) {
 }
 function ensureHandoffDir(directory) {
   try {
-    mkdirSync17(join63(directory, ".matrixx"), { recursive: true });
+    mkdirSync17(join62(directory, ".matrixx"), { recursive: true });
     return true;
   } catch {
     return false;
@@ -85289,15 +85191,15 @@ ${body}
 }
 
 // src/tools/handoff/list-handler.ts
-import { existsSync as existsSync61, readdirSync as readdirSync19, statSync as statSync14 } from "fs";
-import { join as join64 } from "path";
+import { existsSync as existsSync60, readdirSync as readdirSync19, statSync as statSync12 } from "fs";
+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 = join64(directory, MATRIX_DIR);
-  if (!existsSync61(matrixxDir)) {
+  const matrixxDir = join63(directory, MATRIX_DIR);
+  if (!existsSync60(matrixxDir)) {
     return "No handoffs found in .matrixx/";
   }
   let entries;
@@ -85314,11 +85216,11 @@ function handleList(directory) {
   lines.push(`Handoff files in ${matrixxDir}:`);
   lines.push("");
   for (const name of handoffs) {
-    const fullPath = join64(matrixxDir, name);
+    const fullPath = join63(matrixxDir, name);
     let size = "?";
     let mtime = "?";
     try {
-      const stat2 = statSync14(fullPath);
+      const stat2 = statSync12(fullPath);
       size = `${stat2.size}B`;
       mtime = stat2.mtime.toISOString();
     } catch {}
@@ -85538,9 +85440,9 @@ The Bash tool can execute these commands directly. Do NOT retry with interactive
   }
 });
 // src/tools/pdf-extract-figures/tools.ts
-import { existsSync as existsSync62, mkdtempSync, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync61, mkdtempSync, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join65 } from "path";
+import { join as join64 } from "path";
 var PYTHON_SCRIPT = `#!/usr/bin/env python3
 import sys
 import json
@@ -85642,7 +85544,7 @@ function validateArgs(args) {
   if (!args.file_path) {
     return "Error: 'file_path' is required.";
   }
-  if (!existsSync62(args.file_path)) {
+  if (!existsSync61(args.file_path)) {
     return `Error: File not found: ${args.file_path}`;
   }
   if (!args.file_path.toLowerCase().endsWith(".pdf")) {
@@ -85691,11 +85593,11 @@ async function runExtraction(args) {
   }
   let tmpDir;
   try {
-    tmpDir = mkdtempSync(join65(tmpdir5(), "matrixx-pdf-extract-"));
+    tmpDir = mkdtempSync(join64(tmpdir5(), "matrixx-pdf-extract-"));
   } catch {
     return "Error: Could not create temporary directory.";
   }
-  const scriptPath = join65(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 });
@@ -85743,11 +85645,11 @@ function createPdfExtractFiguresTool() {
   return { pdf_extract_figures };
 }
 // src/tools/plan/plan-create.ts
-import { existsSync as existsSync63 } from "fs";
+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 join66, relative as relative4, resolve as resolve9 } from "path";
+import { basename as basename6, isAbsolute as isAbsolute5, join as join65, relative as relative4, resolve as resolve8 } from "path";
 
 // src/tools/plan/constants.ts
 var PLANS_DIR3 = ".matrixx/plans";
@@ -85773,8 +85675,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(join66(directory, filePath));
-  const plansDir = resolve9(join66(directory, PLANS_DIR3));
+  const resolved = isAbsolute5(filePath) ? resolve8(filePath) : resolve8(join65(directory, filePath));
+  const plansDir = resolve8(join65(directory, PLANS_DIR3));
   const relToPlans = relative4(plansDir, resolved);
   if (relToPlans.startsWith("..") || isAbsolute5(relToPlans)) {
     return { error: `filePath must be inside ${PLANS_DIR3}: ${filePath}` };
@@ -85817,7 +85719,7 @@ Uses atomicWrite (.tmp.pid+rename) + upsertMetadataComment. Warns if file alread
         }
         const resolved = validation.resolved;
         ensurePlanDir(directory);
-        if (existsSync63(resolved)) {
+        if (existsSync62(resolved)) {
           return JSON.stringify({
             error: "file_exists",
             message: `Plan file already exists: ${resolved}. Use plan_read + plan_update to modify.`,
@@ -85848,7 +85750,7 @@ Uses atomicWrite (.tmp.pid+rename) + upsertMetadataComment. Warns if file alread
   });
 }
 // src/tools/plan/plan-delete.ts
-import { existsSync as existsSync64, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync63, unlinkSync as unlinkSync10 } from "fs";
 function createPlanDeleteTool(ctx) {
   return tool({
     description: `Delete a plan file under .matrixx/plans/*.md. Scoped unlink inside PLANS_DIR, refuses outside paths.`,
@@ -85864,7 +85766,7 @@ function createPlanDeleteTool(ctx) {
           return JSON.stringify({ error: "invalid_file_path", message: validation.error });
         }
         const resolved = validation.resolved;
-        if (!existsSync64(resolved)) {
+        if (!existsSync63(resolved)) {
           return JSON.stringify({ error: "file_not_found", message: `File not found: ${resolved}` });
         }
         unlinkSync10(resolved);
@@ -85877,8 +85779,8 @@ function createPlanDeleteTool(ctx) {
   });
 }
 // src/tools/plan/plan-list.ts
-import { existsSync as existsSync65, readdirSync as readdirSync20, statSync as statSync15 } from "fs";
-import { join as join67 } from "path";
+import { existsSync as existsSync64, readdirSync as readdirSync20, statSync as statSync13 } from "fs";
+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.`,
@@ -85886,15 +85788,15 @@ function createPlanListTool(ctx) {
     execute: async (_args, context) => {
       try {
         const directory = resolveDirectory(context?.directory, ctx?.directory);
-        const plansDir = join67(directory, PLANS_DIR3);
-        if (!existsSync65(plansDir)) {
+        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 = join67(plansDir, fileName);
+          const filePath = join66(plansDir, fileName);
           try {
-            const stat2 = statSync15(filePath);
+            const stat2 = statSync13(filePath);
             return {
               fileName,
               filePath,
@@ -85915,7 +85817,7 @@ function createPlanListTool(ctx) {
   });
 }
 // src/tools/plan/plan-read.ts
-import { existsSync as existsSync66, statSync as statSync16 } from "fs";
+import { existsSync as existsSync65, statSync as statSync14 } from "fs";
 function createPlanReadTool(ctx) {
   return tool({
     description: `Read a plan file from .matrixx/plans/*.md with hashline-tagged output (1#AB|content) + lsp-style. Enforces scoping and ${MAX_PLAN_FILE_BYTES2} byte cap.`,
@@ -85931,11 +85833,11 @@ function createPlanReadTool(ctx) {
           return JSON.stringify({ error: "invalid_file_path", message: validation.error });
         }
         const resolved = validation.resolved;
-        if (!existsSync66(resolved)) {
+        if (!existsSync65(resolved)) {
           return JSON.stringify({ error: "file_not_found", message: `File not found: ${resolved}` });
         }
         try {
-          const stat2 = statSync16(resolved);
+          const stat2 = statSync14(resolved);
           if (stat2.size > MAX_PLAN_FILE_BYTES2) {
             return JSON.stringify({
               error: "file_too_large",
@@ -85963,7 +85865,7 @@ function createPlanReadTool(ctx) {
   });
 }
 // src/tools/plan/plan-update.ts
-import { existsSync as existsSync67 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 
 // src/features/tool-metadata-store/store.ts
 var pendingStore = new Map;
@@ -87026,7 +86928,7 @@ function createPlanUpdateTool(ctx) {
           return JSON.stringify({ error: "invalid_file_path", message: validation.error });
         }
         const resolved = validation.resolved;
-        if (!existsSync67(resolved)) {
+        if (!existsSync66(resolved)) {
           return JSON.stringify({ error: "file_not_found", message: `File not found: ${resolved}` });
         }
         const result = await executeHashlineEditTool({ filePath: resolved, edits }, context, ctx);
@@ -87039,9 +86941,9 @@ function createPlanUpdateTool(ctx) {
   });
 }
 // src/tools/preset/tools.ts
-import { existsSync as existsSync68, mkdirSync as mkdirSync18, readFileSync as readFileSync40, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync67, mkdirSync as mkdirSync18, readFileSync as readFileSync41, writeFileSync as writeFileSync24 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname17, join as join68 } from "path";
+import { dirname as dirname15, join as join67 } from "path";
 
 // src/features/preset-state/manager.ts
 init_logger();
@@ -87060,15 +86962,15 @@ var ACTIONS = ["list", "show", "set"];
 var SCOPES = ["global", "project"];
 function resolveConfigPath(scope, directory) {
   if (scope === "global") {
-    return join68(homedir10(), ".config", "opencode", "matrixx.jsonc");
+    return join67(homedir10(), ".config", "opencode", "matrixx.jsonc");
   }
-  return join68(directory ?? process.cwd(), ".opencode", "matrixx.jsonc");
+  return join67(directory ?? process.cwd(), ".opencode", "matrixx.jsonc");
 }
 function persistActivePreset(presetName, scope, directory) {
   const configPath = resolveConfigPath(scope, directory);
   let raw = {};
-  if (existsSync68(configPath)) {
-    const content = readFileSync40(configPath, "utf-8");
+  if (existsSync67(configPath)) {
+    const content = readFileSync41(configPath, "utf-8");
     const parsed = parseJsoncSafe(content);
     if (parsed.errors.length > 0) {
       return {
@@ -87078,7 +86980,7 @@ function persistActivePreset(presetName, scope, directory) {
     }
     raw = parsed.data ?? {};
   } else {
-    mkdirSync18(dirname17(configPath), { recursive: true });
+    mkdirSync18(dirname15(configPath), { recursive: true });
   }
   raw.active_preset = presetName;
   writeFileSync24(configPath, `${JSON.stringify(raw, null, 2)}
@@ -87181,9 +87083,9 @@ function createPresetTool(options) {
   return { preset };
 }
 // src/tools/session-manager/constants.ts
-import { join as join69 } from "path";
-var TODO_DIR = join69(getOpenCodeConfigDir({ binary: "opencode" }), "todos");
-var TRANSCRIPT_DIR2 = join69(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.
@@ -87255,9 +87157,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 existsSync69 } from "fs";
+import { existsSync as existsSync68 } from "fs";
 import { readdir, readFile as readFile3 } from "fs/promises";
-import { join as join70 } from "path";
+import { join as join69 } from "path";
 var sdkClient = null;
 function setStorageClient(client2) {
   sdkClient = client2;
@@ -87276,7 +87178,7 @@ async function getMainSessions(options) {
       return [];
     }
   }
-  if (!existsSync69(SESSION_STORAGE))
+  if (!existsSync68(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -87284,13 +87186,13 @@ async function getMainSessions(options) {
     for (const projectDir of projectDirs) {
       if (!projectDir.isDirectory())
         continue;
-      const projectPath = join70(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(join70(projectPath, file3), "utf-8");
+          const content = await readFile3(join69(projectPath, file3), "utf-8");
           const meta3 = JSON.parse(content);
           if (meta3.parentID)
             continue;
@@ -87315,7 +87217,7 @@ async function getAllSessions() {
       return [];
     }
   }
-  if (!existsSync69(MESSAGE_STORAGE))
+  if (!existsSync68(MESSAGE_STORAGE))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -87323,7 +87225,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join70(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);
@@ -87384,7 +87286,7 @@ async function readSessionMessages(sessionID) {
     }
   }
   const messageDir = getMessageDir(sessionID);
-  if (!messageDir || !existsSync69(messageDir))
+  if (!messageDir || !existsSync68(messageDir))
     return [];
   const messages2 = [];
   try {
@@ -87393,7 +87295,7 @@ async function readSessionMessages(sessionID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile3(join70(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({
@@ -87417,8 +87319,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join70(PART_STORAGE, messageID);
-  if (!existsSync69(partDir))
+  const partDir = join69(PART_STORAGE, messageID);
+  if (!existsSync68(partDir))
     return [];
   const parts = [];
   try {
@@ -87427,7 +87329,7 @@ async function readParts2(messageID) {
       if (!file3.endsWith(".json"))
         continue;
       try {
-        const content = await readFile3(join70(partDir, file3), "utf-8");
+        const content = await readFile3(join69(partDir, file3), "utf-8");
         parts.push(JSON.parse(content));
       } catch {}
     }
@@ -87451,14 +87353,14 @@ async function readSessionTodos(sessionID) {
       return [];
     }
   }
-  if (!existsSync69(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(join70(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) => ({
@@ -87476,10 +87378,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync69(TRANSCRIPT_DIR2))
+  if (!existsSync68(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join70(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync69(transcriptFile))
+  const transcriptFile = join69(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync68(transcriptFile))
     return 0;
   try {
     const content = await readFile3(transcriptFile, "utf-8");
@@ -87979,20 +87881,20 @@ function createSkillTool(options = {}) {
 }
 var skill = createSkillTool();
 // src/tools/slashcommand/command-discovery.ts
-import { existsSync as existsSync70, readdirSync as readdirSync21, readFileSync as readFileSync41 } from "fs";
-import { basename as basename8, join as join71 } from "path";
+import { existsSync as existsSync69, readdirSync as readdirSync21, readFileSync as readFileSync42 } from "fs";
+import { basename as basename8, join as join70 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync70(commandsDir))
+  if (!existsSync69(commandsDir))
     return [];
   const entries = readdirSync21(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join71(commandsDir, entry.name);
+    const commandPath = join70(commandsDir, entry.name);
     const commandName = basename8(entry.name, ".md");
     try {
-      const content = readFileSync41(commandPath, "utf-8");
+      const content = readFileSync42(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -88016,8 +87918,8 @@ function discoverCommandsFromDir2(commandsDir, scope) {
 }
 function discoverCommandsSync(directory) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
-  const opencodeGlobalDir = join71(configDir, "command");
-  const opencodeProjectDir = join71(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();
@@ -88041,7 +87943,7 @@ function discoverCommandsSync(directory) {
   ];
 }
 // src/tools/slashcommand/command-output-formatter.ts
-import { dirname as dirname18 } from "path";
+import { dirname as dirname16 } from "path";
 async function formatLoadedCommand(command, userMessage) {
   const sections = [];
   sections.push(`# /${command.name} Command
@@ -88080,7 +87982,7 @@ async function formatLoadedCommand(command, userMessage) {
   if (!content && command.lazyContentLoader) {
     content = await command.lazyContentLoader.load();
   }
-  const commandDir = command.path ? dirname18(command.path) : process.cwd();
+  const commandDir = command.path ? dirname16(command.path) : process.cwd();
   const withFileReferences = await resolveFileReferencesInText(content, commandDir);
   const resolvedContent = await resolveCommandsInText(withFileReferences);
   let finalContent = resolvedContent.trim();
@@ -88821,11 +88723,11 @@ function createBackgroundOutput(manager, client2) {
   });
 }
 // src/tools/background-task/create-background-revive.ts
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 
 // src/features/background-agent/handle-index.ts
-import { existsSync as existsSync71, mkdirSync as mkdirSync19, readdirSync as readdirSync22, readFileSync as readFileSync42, renameSync as renameSync5, unlinkSync as unlinkSync11, writeFileSync as writeFileSync25 } from "fs";
-import { dirname as dirname19, join as join72 } from "path";
+import { existsSync as existsSync70, mkdirSync as mkdirSync19, readdirSync as readdirSync22, readFileSync as readFileSync43, renameSync as renameSync5, unlinkSync as unlinkSync11, writeFileSync as writeFileSync25 } from "fs";
+import { dirname as dirname17, join as join71 } from "path";
 
 // src/features/background-agent/constants.ts
 var TASK_TTL_MS = 30 * 60 * 1000;
@@ -88876,13 +88778,13 @@ var BgHandleSchema = exports_external.object({
   completedAt: exports_external.number().optional()
 }).strict();
 function getBgHandleDir(directory) {
-  return join72(directory, ".matrixx", BG_HANDLE_DIR_NAME);
+  return join71(directory, ".matrixx", BG_HANDLE_DIR_NAME);
 }
 function getHandlePath(directory, taskId) {
-  return join72(getBgHandleDir(directory), `${taskId}.json`);
+  return join71(getBgHandleDir(directory), `${taskId}.json`);
 }
 function ensureDir3(dirPath) {
-  if (!existsSync71(dirPath)) {
+  if (!existsSync70(dirPath)) {
     mkdirSync19(dirPath, { recursive: true });
   }
 }
@@ -88906,14 +88808,14 @@ function toHandle(task) {
 }
 function writeHandle(directory, task) {
   const filePath = getHandlePath(directory, task.id);
-  ensureDir3(dirname19(filePath));
+  ensureDir3(dirname17(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
     writeFileSync25(tempPath, JSON.stringify(toHandle(task), null, 2), "utf-8");
     renameSync5(tempPath, filePath);
   } catch (error95) {
     try {
-      if (existsSync71(tempPath)) {
+      if (existsSync70(tempPath)) {
         unlinkSync11(tempPath);
       }
     } catch {}
@@ -88922,10 +88824,10 @@ function writeHandle(directory, task) {
 }
 function readHandleFile(filePath) {
   try {
-    if (!existsSync71(filePath)) {
+    if (!existsSync70(filePath)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync42(filePath, "utf-8"));
+    const parsed = JSON.parse(readFileSync43(filePath, "utf-8"));
     const result = BgHandleSchema.safeParse(parsed);
     return result.success ? result.data : null;
   } catch {
@@ -88934,7 +88836,7 @@ function readHandleFile(filePath) {
 }
 function readHandles(directory) {
   const dir = getBgHandleDir(directory);
-  if (!existsSync71(dir)) {
+  if (!existsSync70(dir)) {
     return [];
   }
   const handles = [];
@@ -88942,7 +88844,7 @@ function readHandles(directory) {
     if (!name.startsWith(BG_HANDLE_FILE_PREFIX) || !name.endsWith(".json")) {
       continue;
     }
-    const handle = readHandleFile(join72(dir, name));
+    const handle = readHandleFile(join71(dir, name));
     if (handle) {
       handles.push(handle);
     }
@@ -88951,7 +88853,7 @@ function readHandles(directory) {
 }
 function sweepStaleHandles(directory, ttlMs = TASK_TTL_MS, now = Date.now()) {
   const dir = getBgHandleDir(directory);
-  if (!existsSync71(dir)) {
+  if (!existsSync70(dir)) {
     return 0;
   }
   let removed = 0;
@@ -88959,7 +88861,7 @@ function sweepStaleHandles(directory, ttlMs = TASK_TTL_MS, now = Date.now()) {
     if (!name.startsWith(BG_HANDLE_FILE_PREFIX) || !name.endsWith(".json")) {
       continue;
     }
-    const filePath = join72(dir, name);
+    const filePath = join71(dir, name);
     const handle = readHandleFile(filePath);
     const timestamp = handle?.completedAt ?? handle?.startedAt ?? handle?.queuedAt;
     if (handle && timestamp !== undefined && now - timestamp <= ttlMs) {
@@ -89027,7 +88929,7 @@ Revive one with background_revive(taskId="<id>", prompt="<new instruction>").`;
 }
 function resolveFailure(identifier, message, directory) {
   if (message.includes("not found for revive")) {
-    const handleOnDisk = existsSync72(getHandlePath(directory, identifier));
+    const handleOnDisk = existsSync71(getHandlePath(directory, identifier));
     return { reason: handleOnDisk ? "unknown-task" : "expired", detail: message };
   }
   if (message.includes("still active"))
@@ -89442,9 +89344,9 @@ function createAssemblyTool(options) {
   });
 }
 // src/tools/dcp-switch-profile/tools.ts
-import { existsSync as existsSync73, writeFileSync as writeFileSync26 } from "fs";
+import { existsSync as existsSync72, writeFileSync as writeFileSync26 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join73 } from "path";
+import { join as join72 } from "path";
 
 // src/config/schema/dcp.ts
 var DcpCompressOverrideSchema = exports_external.object({
@@ -89644,11 +89546,11 @@ var DcpConfigSchema = exports_external.object({
 });
 
 // src/tools/dcp-switch-profile/tools.ts
-var DCP_PLUGIN_DIR = join73(homedir11(), ".config", "opencode", "node_modules", "@tarquinen", "opencode-dcp");
-var DCP_SYMLINK = join73(homedir11(), ".config", "opencode", "dcp.jsonc");
+var DCP_PLUGIN_DIR = join72(homedir11(), ".config", "opencode", "node_modules", "@tarquinen", "opencode-dcp");
+var DCP_SYMLINK = join72(homedir11(), ".config", "opencode", "dcp.jsonc");
 var VALID_PROFILES = ["economy", "balanced", "performance", "ultimate", "brutal"];
 function checkDcpInstalled() {
-  if (!existsSync73(DCP_PLUGIN_DIR)) {
+  if (!existsSync72(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;
@@ -90571,7 +90473,7 @@ async function executeBackgroundTask(args, ctx, executorCtx, parentContext, agen
 
 Task ID: ${task.id}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, timing.WAIT_FOR_SESSION_INTERVAL_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, timing.WAIT_FOR_SESSION_INTERVAL_MS));
       const updated = manager.getTask(task.id);
       if (updated && isLaunchTerminalStatus(updated.status)) {
         if (isQueueSaturated(updated.status, updated.terminalReason)) {
@@ -91106,10 +91008,11 @@ Create the work plan directly - that's your job as the planning agent.`
     if (!matchedAgent) {
       const isPrimaryAgent = agents.filter((a) => a.mode === "primary").find((agent) => agent.name.toLowerCase() === agentToUse.toLowerCase() || agent.name.toLowerCase() === resolvedDisplayName.toLowerCase());
       if (isPrimaryAgent) {
+        const architectHint = isPrimaryAgent.name.toLowerCase() === "architect" ? " Use /start-work to run Architect as session agent (issue #111 option b)." : "";
         return {
           agentToUse: "",
           categoryModel: undefined,
-          error: `Cannot call primary agent "${isPrimaryAgent.name}" via task. Primary agents are top-level orchestrators.`
+          error: `Cannot call primary agent "${isPrimaryAgent.name}" via task. Primary agents are top-level orchestrators.${architectHint}`
         };
       }
       const availableAgents = callableAgents.map((a) => a.name).sort().join(", ");
@@ -91536,7 +91439,7 @@ async function pollSyncSession(ctx, client2, input) {
 
 Session ID: ${input.sessionID}`;
     }
-    await new Promise((resolve10) => setTimeout(resolve10, syncTiming.POLL_INTERVAL_MS));
+    await new Promise((resolve9) => setTimeout(resolve9, syncTiming.POLL_INTERVAL_MS));
     pollCount++;
     let statusResult;
     try {
@@ -92083,7 +91986,7 @@ async function executeUnstableAgentTask(args, ctx, executorCtx, parentContext, a
 
 Task ID: ${task.id}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, timing.WAIT_FOR_SESSION_INTERVAL_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, timing.WAIT_FOR_SESSION_INTERVAL_MS));
       const updated = manager.getTask(task.id);
       sessionID = updated?.sessionID;
     }
@@ -92124,7 +92027,7 @@ Task ID: ${task.id}`;
 
 Session ID: ${sessionID}`;
       }
-      await new Promise((resolve10) => setTimeout(resolve10, timingCfg.POLL_INTERVAL_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, timingCfg.POLL_INTERVAL_MS));
       const currentTask = manager.getTask(task.id);
       if (currentTask && (currentTask.status === "interrupt" || currentTask.status === "error" || currentTask.status === "cancelled")) {
         terminalStatus = { status: currentTask.status, error: currentTask.error };
@@ -92768,8 +92671,8 @@ Original error: ${createResult.error}`;
   });
 }
 // src/tools/task/task-cleanup.ts
-import { existsSync as existsSync74, readdirSync as readdirSync23, readFileSync as readFileSync43, unlinkSync as unlinkSync12 } from "fs";
-import { join as join74 } from "path";
+import { existsSync as existsSync73, readdirSync as readdirSync23, readFileSync as readFileSync44, unlinkSync as unlinkSync12 } from "fs";
+import { join as join73 } from "path";
 init_logger();
 function parseOlderThan(value) {
   const match = value.trim().match(/^(\d+)(d|h|m)$/);
@@ -92829,17 +92732,17 @@ Returns counts: {deleted, remaining, deletedIds}`,
         }
         const directory = context?.directory ?? ctx?.directory ?? process.cwd();
         const taskDir = getTaskDir(config4, directory);
-        if (!existsSync74(taskDir)) {
+        if (!existsSync73(taskDir)) {
           return JSON.stringify({ deleted: 0, remaining: 0, deletedIds: [] });
         }
         const files = readdirSync23(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-"));
         const total = files.length;
         const deletedIds = [];
         for (const file3 of files) {
-          const filePath = join74(taskDir, file3);
+          const filePath = join73(taskDir, file3);
           let raw;
           try {
-            const content = readFileSync43(filePath, "utf-8");
+            const content = readFileSync44(filePath, "utf-8");
             raw = JSON.parse(content);
           } catch {
             continue;
@@ -92872,8 +92775,8 @@ Returns counts: {deleted, remaining, deletedIds}`,
   });
 }
 // src/tools/task/task-create.ts
-import { readdirSync as readdirSync24, statSync as statSync17 } from "fs";
-import { join as join75 } from "path";
+import { readdirSync as readdirSync24, statSync as statSync15 } from "fs";
+import { join as join74 } from "path";
 init_logger();
 function createTaskCreateTool(config4, ctx) {
   return tool({
@@ -92942,7 +92845,7 @@ async function handleCreate2(args, config4, ctx, context) {
         projectRoot: directory
       };
       const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(join75(taskDir, `${taskId}.json`), validatedTask);
+      writeJsonAtomic(join74(taskDir, `${taskId}.json`), validatedTask);
       return JSON.stringify({
         task: {
           id: validatedTask.id,
@@ -92971,7 +92874,7 @@ function findDuplicateTask(taskDir, subject, directory) {
     return null;
   }
   for (const file3 of files) {
-    const filePath = join75(taskDir, file3);
+    const filePath = join74(taskDir, file3);
     let existing;
     try {
       existing = readJsonSafe(filePath, TaskObjectSchema);
@@ -92990,7 +92893,7 @@ function findDuplicateTask(taskDir, subject, directory) {
       continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync17(filePath).mtimeMs;
+      mtimeMs = statSync15(filePath).mtimeMs;
     } catch (error95) {
       log(`[task-create] Failed to stat task file ${filePath} during dedup scan`, error95);
       continue;
@@ -93002,7 +92905,7 @@ function findDuplicateTask(taskDir, subject, directory) {
   return null;
 }
 // src/tools/task/task-get.ts
-import { join as join76 } from "path";
+import { join as join75 } from "path";
 function parseTaskId(id) {
   if (!TASK_ID_PATTERN.test(id))
     return null;
@@ -93028,7 +92931,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 = join76(taskDir, `${taskId}.json`);
+        const taskPath = join75(taskDir, `${taskId}.json`);
         const task = readJsonSafe(taskPath, TaskObjectSchema);
         return JSON.stringify({ task: task ?? null });
       } catch (error95) {
@@ -93041,8 +92944,8 @@ Returns null if the task does not exist or the file is invalid.`,
   });
 }
 // src/tools/task/task-list.ts
-import { existsSync as existsSync75, readdirSync as readdirSync25 } from "fs";
-import { join as join77 } from "path";
+import { existsSync as existsSync74, readdirSync as readdirSync25 } from "fs";
+import { join as join76 } from "path";
 function createTaskList(config4, ctx) {
   return tool({
     description: `[TRACKING \u2014 local progress records only. Spawns nothing, executes nothing.]
@@ -93061,7 +92964,7 @@ Optional \`parentID\` filter: when provided, returns only tasks whose parentID m
       const parentID = args.parentID;
       const directory = context?.directory ?? ctx?.directory ?? process.cwd();
       const taskDir = getTaskDir(config4, directory);
-      if (!existsSync75(taskDir)) {
+      if (!existsSync74(taskDir)) {
         return JSON.stringify({ tasks: [] });
       }
       const files = readdirSync25(taskDir).filter((f) => f.endsWith(".json") && f.startsWith("T-")).map((f) => f.replace(".json", ""));
@@ -93070,7 +92973,7 @@ Optional \`parentID\` filter: when provided, returns only tasks whose parentID m
       }
       const allTasks = [];
       for (const fileId of files) {
-        const task = readJsonSafe(join77(taskDir, `${fileId}.json`), TaskObjectSchema);
+        const task = readJsonSafe(join76(taskDir, `${fileId}.json`), TaskObjectSchema);
         if (task) {
           allTasks.push(task);
         }
@@ -93099,7 +93002,7 @@ Optional \`parentID\` filter: when provided, returns only tasks whose parentID m
   });
 }
 // src/tools/task/task-update.ts
-import { join as join78 } from "path";
+import { join as join77 } from "path";
 function parseTaskId2(id) {
   if (!TASK_ID_PATTERN.test(id))
     return null;
@@ -93146,7 +93049,7 @@ async function handleUpdate(args, config4, ctx, context) {
       return JSON.stringify({ error: "task_lock_unavailable" });
     }
     try {
-      const taskPath = join78(taskDir, `${taskId}.json`);
+      const taskPath = join77(taskDir, `${taskId}.json`);
       const task = readJsonSafe(taskPath, TaskObjectSchema);
       if (!task) {
         return JSON.stringify({ error: "task_not_found" });
@@ -93682,7 +93585,7 @@ class ConcurrencyManager {
     if (this.tryAcquireSlot(model)) {
       return { granted: true };
     }
-    return new Promise((resolve10) => {
+    return new Promise((resolve9) => {
       const queue = this.queues.get(model) ?? [];
       let timer;
       const entry = {
@@ -93694,7 +93597,7 @@ class ConcurrencyManager {
           entry.settled = true;
           if (timer !== undefined)
             clearTimeout(timer);
-          resolve10(outcome);
+          resolve9(outcome);
         }
       };
       queue.push(entry);
@@ -93711,7 +93614,7 @@ class ConcurrencyManager {
           if (index !== -1)
             pending.splice(index, 1);
         }
-        resolve10({ granted: false, reason: "timeout", waitedMs: Date.now() - entry.enqueuedAt });
+        resolve9({ granted: false, reason: "timeout", waitedMs: Date.now() - entry.enqueuedAt });
       }, timeoutMs);
     });
   }
@@ -93910,19 +93813,19 @@ function detectRepetitiveToolUse(window2) {
 }
 
 // src/features/background-agent/message-dir.ts
-import { existsSync as existsSync76, readdirSync as readdirSync26, readFileSync as readFileSync44 } from "fs";
-import { join as join79 } from "path";
+import { existsSync as existsSync75, readdirSync as readdirSync26, readFileSync as readFileSync45 } from "fs";
+import { join as join78 } from "path";
 var MESSAGE_DIR_CACHE_CAP = 1000;
 var messageDirCache = new Map;
 function computeMessageDir(sessionID) {
-  if (!existsSync76(MESSAGE_STORAGE))
+  if (!existsSync75(MESSAGE_STORAGE))
     return null;
-  const directPath = join79(MESSAGE_STORAGE, sessionID);
-  if (existsSync76(directPath))
+  const directPath = join78(MESSAGE_STORAGE, sessionID);
+  if (existsSync75(directPath))
     return directPath;
   for (const dir of readdirSync26(MESSAGE_STORAGE)) {
-    const sessionPath = join79(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync76(sessionPath))
+    const sessionPath = join78(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync75(sessionPath))
       return sessionPath;
   }
   return null;
@@ -93960,7 +93863,7 @@ function findNearestMessageExcludingCompaction(messageDir) {
     const parsedByFile = new Map;
     for (const file3 of files) {
       try {
-        const content = readFileSync44(join79(messageDir, file3), "utf-8");
+        const content = readFileSync45(join78(messageDir, file3), "utf-8");
         const parsed = JSON.parse(content);
         parsedByFile.set(file3, parsed);
         if (hasFullAgentAndModel(parsed)) {
@@ -96842,7 +96745,7 @@ class TmuxSessionManager {
       } catch (err) {
         log("[tmux-session-manager] session status check error", { error: String(err) });
       }
-      await new Promise((resolve10) => setTimeout(resolve10, SESSION_READY_POLL_INTERVAL_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, SESSION_READY_POLL_INTERVAL_MS));
     }
     log("[tmux-session-manager] session ready timeout", {
       sessionId,
@@ -97025,7 +96928,7 @@ class TmuxSessionManager {
 var SESSION_TIMEOUT_MS3 = 10 * 60 * 1000;
 var MIN_STABILITY_TIME_MS4 = 10 * 1000;
 // src/agents/dynamic-agent-prompt-builder.ts
-import { readFileSync as readFileSync45 } from "fs";
+import { readFileSync as readFileSync46 } from "fs";
 init_logger();
 function categorizeTools(toolNames) {
   return toolNames.map((name) => {
@@ -97313,6 +97216,28 @@ Oracle creates plans, not code. Invoke oracle to decompose complex requests into
 **Exception**: This is the ONLY case where you announce before acting. For all other work, start immediately without status updates.
 </Oracle_Usage>`;
 }
+function buildArchitectReferralSection() {
+  return `<Architect_Usage>
+## Architect \u2014 Session Orchestrator (/start-work-only)
+
+Architect is a /start-work-only session agent \u2014 it orchestrates work via a session until ALL tasks in a todo list are done. Architect is NOT callable via task().
+
+### WHEN to Refer:
+
+| Trigger | Action |
+| User provides a todo list path (.matrixx/plans/{name}.md) | /start-work FIRST, then Architect orchestrates |
+| Multiple tasks need to be completed in sequence or parallel | /start-work, NOT task() |
+| Work requires coordination across multiple specialized agents | /start-work, NOT task() |
+| Todo list path provided OR multiple tasks requiring multi-agent orchestration | /start-work |
+
+### HARD ROUTING RULE \u2014 Architect Referral (NON-NEGOTIABLE):
+- ANY task that executes \`.matrixx/plans/*.md\` MUST use \`/start-work\` \u2014 NEVER \`task(subagent_type="architect")\`
+- Architect is excluded from the task-delegation list by design. Do NOT attempt \`task(subagent_type="architect")\` \u2014 it will be rejected. Use \`/start-work\` instead.
+
+### Usage Pattern:
+Architect owns todo-list execution end to end. Invoke /start-work with the plan path so Architect can decompose and orchestrate the work across specialized agents.
+</Architect_Usage>`;
+}
 function buildHardBlocksSection() {
   const blocks = [
     "| Type error suppression (`as any`, `@ts-ignore`) | Never |",
@@ -97388,11 +97313,11 @@ function readDisciplineFile() {
   const p = resolveContextModeDisciplinePath();
   if (!p)
     throw new Error("discipline file not found");
-  const raw = readFileSync45(p, "utf8");
+  const raw = readFileSync46(p, "utf8");
   let version4 = "1.0.169";
   try {
     const pkgResolved = __require.resolve("context-mode/package.json");
-    const pkgRaw = readFileSync45(pkgResolved, "utf8");
+    const pkgRaw = readFileSync46(pkgResolved, "utf8");
     const pkg = JSON.parse(pkgRaw);
     if (pkg.version)
       version4 = pkg.version;
@@ -98375,17 +98300,13 @@ function buildDynamicOrchestratorPrompt(ctx) {
   return basePrompt.replace("{CATEGORY_SECTION}", categorySection).replace("{AGENT_SECTION}", agentSection).replace("{DECISION_MATRIX}", decisionMatrix).replace("{SKILLS_SECTION}", skillsSection).replace("{{CATEGORY_SKILLS_DELEGATION_GUIDE}}", categorySkillsGuide);
 }
 function createArchitectAgent(ctx) {
-  const restrictions = createAgentToolRestrictions([
-    "task"
-  ]);
   const baseConfig = {
     description: "Orchestrates work via task() to complete ALL tasks in a todo list until fully done. (Architect - Matrixx)",
     mode: MODE,
     ...ctx.model ? { model: ctx.model } : {},
     temperature: 0.1,
     prompt: buildDynamicOrchestratorPrompt(ctx),
-    color: "#10B981",
-    ...restrictions
+    color: "#10B981"
   };
   return baseConfig;
 }
@@ -98497,9 +98418,9 @@ function createBddContractAgent(model) {
 createBddContractAgent.mode = MODE2;
 
 // src/agents/builtin-agents/resolve-file-uri.ts
-import { existsSync as existsSync77, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync76, readFileSync as readFileSync47 } from "fs";
 import { homedir as homedir12 } from "os";
-import { isAbsolute as isAbsolute6, resolve as resolve10 } from "path";
+import { isAbsolute as isAbsolute6, resolve as resolve9 } from "path";
 function resolvePromptAppend(promptAppend, configDir) {
   if (!promptAppend.startsWith("file://"))
     return promptAppend;
@@ -98508,15 +98429,15 @@ function resolvePromptAppend(promptAppend, configDir) {
   try {
     const decoded = decodeURIComponent(encoded);
     const expanded = decoded.startsWith("~/") ? decoded.replace(/^~\//, `${homedir12()}/`) : decoded;
-    filePath = isAbsolute6(expanded) ? expanded : resolve10(configDir ?? process.cwd(), expanded);
+    filePath = isAbsolute6(expanded) ? expanded : resolve9(configDir ?? process.cwd(), expanded);
   } catch {
     return `[WARNING: Malformed file URI (invalid percent-encoding): ${promptAppend}]`;
   }
-  if (!existsSync77(filePath)) {
+  if (!existsSync76(filePath)) {
     return `[WARNING: Could not resolve file URI: ${promptAppend}]`;
   }
   try {
-    return readFileSync46(filePath, "utf8");
+    return readFileSync47(filePath, "utf8");
   } catch {
     return `[WARNING: Could not read file: ${promptAppend}]`;
   }
@@ -99545,6 +99466,7 @@ function buildDynamicMorpheusPrompt(availableAgents, availableTools = [], availa
   const categorySkillsGuide = buildCategorySkillsDelegationGuide(availableCategories, availableSkills);
   const delegationTable = buildDelegationTable(availableAgents);
   const oracleSection = buildOracleSection(availableAgents);
+  const architectReferral = buildArchitectReferralSection();
   const hardBlocks = buildHardBlocksSection();
   const antiPatterns = buildAntiPatternsSection();
   const hasContextMode = availableTools.some((t) => t.name.startsWith("ctx_"));
@@ -99841,6 +99763,8 @@ If verification fails:
 
 ${oracleSection}
 
+${architectReferral}
+
 ${taskManagementSection}
 
 <Tone_and_Style>
@@ -104309,10 +104233,12 @@ function applyToolConfig(params) {
   }
   const architect = agentByKey(params.agentResult, "architect");
   if (architect) {
-    architect.permission = {
-      ...architect.permission,
-      ...isTaskSystem ? { task: "allow", "task_*": "allow", teammate: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools }
-    };
+    const defaults = isTaskSystem ? { task: "allow", "task_*": "allow", teammate: "allow", ...denyTodoTools } : { todowrite: "allow", todoread: "allow", ...denyTaskTools };
+    const permission = architect.permission ?? {};
+    for (const [key, value] of Object.entries(defaults)) {
+      permission[key] ??= value;
+    }
+    architect.permission = permission;
   }
   const morpheus = agentByKey(params.agentResult, "morpheus");
   if (morpheus) {