@staff0rd/assist 0.600.0 → 0.601.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.600.0",
+  version: "0.601.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -187,8 +187,8 @@ function getRemoteOriginUrl(cwd) {
 }
 
 // src/commands/backlog/getCurrentOrigin.ts
-function stripLeadingSlashes(path88) {
-  return path88.replace(/^\/+/, "");
+function stripLeadingSlashes(path90) {
+  return path90.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -238,9 +238,9 @@ function findGitLink(dir) {
   }
   return null;
 }
-function isFile(path88) {
+function isFile(path90) {
   try {
-    return statSync(path88).isFile();
+    return statSync(path90).isFile();
   } catch {
     return false;
   }
@@ -259,9 +259,9 @@ function linkedGitDirParent(gitDir) {
   const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
   return match ? match[1] : null;
 }
-function readTrimmed(path88) {
+function readTrimmed(path90) {
   try {
-    const content = readFileSync(path88, "utf8").trim();
+    const content = readFileSync(path90, "utf8").trim();
     return content === "" ? null : content;
   } catch {
     return null;
@@ -274,10 +274,10 @@ function absolute(target, from) {
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path88) {
-  if (!existsSync2(path88)) return {};
+function loadRawYaml(path90) {
+  if (!existsSync2(path90)) return {};
   try {
-    const content = readFileSync2(path88, "utf8");
+    const content = readFileSync2(path90, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -349,8 +349,8 @@ function mergeRawConfigs(globalRaw, projectRaw) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path88 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path88.split("/").filter(Boolean);
+    const path90 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path90.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -1785,8 +1785,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path88 = line.split("	")[1];
-    if (path88) found.add(path88.trim());
+    const path90 = line.split("	")[1];
+    if (path90) found.add(path90.trim());
   }
   return [...found];
 }
@@ -1896,8 +1896,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path88 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path88}/${ref}`;
+  const path90 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path90}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -4273,11 +4273,11 @@ function enumValues(node) {
 function opaqueConfigNode(inner, base) {
   return { ...base, kind: "other", type: leafTypeOf(inner) };
 }
-function build(node, path88) {
+function build(node, path90) {
   const { inner, defaultValue, optional } = unwrapSchemaNode(node);
   const secret = isSecretSchemaNode(node) || isSecretSchemaNode(inner);
   const base = {
-    path: path88,
+    path: path90,
     ...optional ? { optional: true } : {},
     ...defaultValue === void 0 ? {} : { defaultValue },
     ...secret ? { secret: true } : {}
@@ -4296,9 +4296,9 @@ function segmentText(segment) {
   if (segment.kind === "index") return `[${segment.index}]`;
   return "[]";
 }
-function formatConfigPath(path88) {
+function formatConfigPath(path90) {
   let text18 = "";
-  for (const segment of path88) {
+  for (const segment of path90) {
     const dotted = segment.kind === "key" || segment.kind === "entry";
     const rendered = segmentText(segment);
     text18 += dotted && text18 ? `.${rendered}` : rendered;
@@ -4946,9 +4946,9 @@ import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
-function resolveStringsAtPath(data, path88) {
+function resolveStringsAtPath(data, path90) {
   let current = data;
-  for (const segment of path88.split(".")) {
+  for (const segment of path90.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -4961,10 +4961,10 @@ function resolveStringsAtPath(data, path88) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path88 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path88)) {
+  for (const path90 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path90)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path88, value });
+        violations.push({ file: rule.file, path: path90, value });
     }
   }
   return violations;
@@ -5003,8 +5003,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path88, value } of violations) {
-    console.log(`  ${file} ${path88}: ${value}`);
+  for (const { file, path: path90, value } of violations) {
+    console.log(`  ${file} ${path90}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -5319,15 +5319,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path88) => MIGRATION_FILE3.test(basename2(path88)));
-  for (const path88 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path90) => MIGRATION_FILE3.test(basename2(path90)));
+  for (const path90 of paths) {
     try {
-      const content = execSync14(`git show "${ref}:${path88}"`, {
+      const content = execSync14(`git show "${ref}:${path90}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path88), content);
+      baseline.set(basename2(path90), content);
     } catch {
     }
   }
@@ -6761,10 +6761,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path88 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname13(path88), { recursive: true });
-  writeFileSync15(path88, JSON.stringify(hooksSettings, null, 2));
-  return path88;
+  const path90 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname13(path90), { recursive: true });
+  writeFileSync15(path90, JSON.stringify(hooksSettings, null, 2));
+  return path90;
 }
 
 // src/shared/spawnInherit.ts
@@ -7062,9 +7062,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path88 = join15(dir, ".assist", name);
-    if (existsSync19(path88)) {
-      renameSync(path88, `${path88}.bak`);
+    const path90 = join15(dir, ".assist", name);
+    if (existsSync19(path90)) {
+      renameSync(path90, `${path90}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -7544,8 +7544,8 @@ var backlogItemSchema = z4.strictObject({
 var backlogFileSchema = z4.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path88) {
-  const content = readFileSync15(path88, "utf8").trim();
+function parseBacklogJsonl(path90) {
+  const content = readFileSync15(path90, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -8356,24 +8356,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path88 = getOwnerPath(itemId2);
-  mkdirSync7(dirname15(path88), { recursive: true });
-  writeFileSync17(path88, JSON.stringify({ sessionId }));
+  const path90 = getOwnerPath(itemId2);
+  mkdirSync7(dirname15(path90), { recursive: true });
+  writeFileSync17(path90, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path88 = getOwnerPath(itemId2);
-  if (!existsSync23(path88)) return void 0;
+  const path90 = getOwnerPath(itemId2);
+  if (!existsSync23(path90)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync16(path88, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path90, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path88 = getOwnerPath(itemId2);
+  const path90 = getOwnerPath(itemId2);
   try {
-    rmSync(path88);
+    rmSync(path90);
   } catch {
   }
 }
@@ -8410,19 +8410,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path88 = getSignalPath(target);
-  if (!path88) return;
+  const path90 = getSignalPath(target);
+  if (!path90) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname16(path88), { recursive: true });
-  writeFileSync18(path88, JSON.stringify(signal));
+  mkdirSync8(dirname16(path90), { recursive: true });
+  writeFileSync18(path90, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path88 = getSignalPath();
-  if (!path88 || !existsSync24(path88)) return void 0;
+  const path90 = getSignalPath();
+  if (!path90 || !existsSync24(path90)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path88, "utf8"));
+    return JSON.parse(readFileSync17(path90, "utf8"));
   } catch {
     return void 0;
   }
@@ -8619,13 +8619,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path88 = activityPath(sessionId);
-  mkdirSync9(dirname17(path88), { recursive: true });
-  writeFileSync19(path88, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path90 = activityPath(sessionId);
+  mkdirSync9(dirname17(path90), { recursive: true });
+  writeFileSync19(path90, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path88) {
+function readActivity(path90) {
   try {
-    return JSON.parse(readFileSync18(path88, "utf8"));
+    return JSON.parse(readFileSync18(path90, "utf8"));
   } catch {
     return void 0;
   }
@@ -8635,9 +8635,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path88 = activityPath(sessionId);
-  mkdirSync9(dirname17(path88), { recursive: true });
-  writeFileSync19(path88, JSON.stringify(activity2));
+  const path90 = activityPath(sessionId);
+  mkdirSync9(dirname17(path90), { recursive: true });
+  writeFileSync19(path90, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -10090,10 +10090,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path88 = getStorePath(filename);
-  if (existsSync29(path88)) {
+  const path90 = getStorePath(filename);
+  if (existsSync29(path90)) {
     try {
-      return JSON.parse(readFileSync19(path88, "utf8"));
+      return JSON.parse(readFileSync19(path90, "utf8"));
     } catch {
       return {};
     }
@@ -10112,22 +10112,22 @@ function saveJson(filename, data) {
 var REGISTRY_FILE = "worktrees.json";
 function readWorktreeRegistry() {
   const data = loadJson(REGISTRY_FILE);
-  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path88, record]) => ({ path: path88, ...record }));
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path90, record]) => ({ path: path90, ...record }));
 }
-function worktreeAttributionIncludingReaped(path88) {
-  const record = loadJson(REGISTRY_FILE)[path88];
+function worktreeAttributionIncludingReaped(path90) {
+  const record = loadJson(REGISTRY_FILE)[path90];
   return record ? { clone: record.clone, origin: record.origin } : void 0;
 }
-function recordWorktree(path88, clone, origin) {
+function recordWorktree(path90, clone, origin) {
   const data = loadJson(REGISTRY_FILE);
-  data[path88] = { clone, origin };
+  data[path90] = { clone, origin };
   saveJson(REGISTRY_FILE, data);
 }
-function forgetWorktree(path88) {
+function forgetWorktree(path90) {
   const data = loadJson(REGISTRY_FILE);
-  const record = data[path88];
+  const record = data[path90];
   if (!record || record.reaped) return;
-  data[path88] = { ...record, reaped: true };
+  data[path90] = { ...record, reaped: true };
   saveJson(REGISTRY_FILE, data);
 }
 
@@ -10878,8 +10878,8 @@ async function loadCommittedPaths(cwd, sessionId) {
   for (const commit2 of commits2) {
     const resolved = await resolveCommit(cwd, commit2.sha);
     if (!resolved) continue;
-    for (const path88 of resolved.paths) {
-      if (!bases.has(path88)) bases.set(path88, resolved.base);
+    for (const path90 of resolved.paths) {
+      if (!bases.has(path90)) bases.set(path90, resolved.base);
     }
   }
   return { commits: commits2, bases };
@@ -10897,16 +10897,16 @@ async function itemChangeSet(cwd, sessionId) {
 }
 function groupByBase(bases) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [path88, base] of bases) {
+  for (const [path90, base] of bases) {
     const paths = groups.get(base);
-    if (paths) paths.push(path88);
-    else groups.set(base, [path88]);
+    if (paths) paths.push(path90);
+    else groups.set(base, [path90]);
   }
   return [...groups].map(([base, paths]) => ({ base, paths: paths.sort() }));
 }
 async function dirtyPaths(cwd, bases) {
   const output = await execGit(cwd, ["diff", "--name-only", "HEAD"]);
-  return output.split("\n").filter((path88) => path88 && !bases.has(path88)).sort();
+  return output.split("\n").filter((path90) => path90 && !bases.has(path90)).sort();
 }
 
 // src/commands/sessions/web/scopedDiff.ts
@@ -10915,8 +10915,8 @@ async function scopedDiff(cwd, session, scope) {
   if (scope.kind === "commit") return commitDiff(cwd, scope.sha);
   return await trackedScopeDiff(cwd, session, scope) + await untrackedDiff(cwd);
 }
-async function untrackedFileDiff(cwd, path88) {
-  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path88], {
+async function untrackedFileDiff(cwd, path90) {
+  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path90], {
     maxBuffer: MAX_DIFF_BYTES,
     allowFailure: true
   });
@@ -10929,7 +10929,7 @@ async function untrackedDiff(cwd) {
   ]);
   const paths = list5.split("\n").filter(Boolean);
   const diffs = await Promise.all(
-    paths.map((path88) => untrackedFileDiff(cwd, path88))
+    paths.map((path90) => untrackedFileDiff(cwd, path90))
   );
   return diffs.join("");
 }
@@ -11022,9 +11022,9 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve10
 function repoRoot(cwd) {
   return resolve10(toGitCwd(cwd));
 }
-function resolveWithinCwd(cwd, path88) {
+function resolveWithinCwd(cwd, path90) {
   const root = repoRoot(cwd);
-  const target = resolve10(root, path88);
+  const target = resolve10(root, path90);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
@@ -11034,14 +11034,14 @@ function resolveWithinCwd(cwd, path88) {
 function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return null;
-  const path88 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+  const path90 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
-  if (!path88) {
+  if (!path90) {
     respondJson(res, 400, { error: "Missing path" });
     return null;
   }
-  const target = resolveWithinCwd(cwd, path88);
+  const target = resolveWithinCwd(cwd, path90);
   if (!target) {
     respondJson(res, 400, { error: "Path outside cwd" });
     return null;
@@ -11116,11 +11116,11 @@ function globalConfigTargetFor(cwd) {
 
 // src/commands/config/globalConfigFileLabel.ts
 var WINDOWS_MOUNT_PREFIX = "/mnt/";
-function globalConfigFileLabel(path88) {
-  if (path88 === getGlobalConfigPath()) return "~/.assist.yml";
-  if (path88.startsWith(WINDOWS_MOUNT_PREFIX))
-    return `${path88} on the Windows host`;
-  return path88;
+function globalConfigFileLabel(path90) {
+  if (path90 === getGlobalConfigPath()) return "~/.assist.yml";
+  if (path90.startsWith(WINDOWS_MOUNT_PREFIX))
+    return `${path90} on the Windows host`;
+  return path90;
 }
 
 // src/commands/config/readRawConfigLayers.ts
@@ -11177,35 +11177,35 @@ function isPlainRecord(value) {
 }
 
 // src/shared/mapConfigSecrets.ts
-function mapChildren(value, path88, childNode, map) {
+function mapChildren(value, path90, childNode, map) {
   if (!isPlainRecord(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([name, child]) => [
       name,
-      walk(child, [...path88, name], childNode(name), map)
+      walk(child, [...path90, name], childNode(name), map)
     ])
   );
 }
-function mapItems(value, path88, item, map) {
+function mapItems(value, path90, item, map) {
   if (!Array.isArray(value)) return value;
-  return value.map((entry, index3) => walk(entry, [...path88, index3], item, map));
+  return value.map((entry, index3) => walk(entry, [...path90, index3], item, map));
 }
-function walk(value, path88, node, map) {
+function walk(value, path90, node, map) {
   if (!node || value === void 0 || value === null) return value;
-  if (node.secret) return map(value, path88);
+  if (node.secret) return map(value, path90);
   switch (node.kind) {
     case "object":
     case "unionOfObjects":
       return mapChildren(
         value,
-        path88,
+        path90,
         (name) => configNodeField(node, name),
         map
       );
     case "objectList":
-      return mapItems(value, path88, node.item, map);
+      return mapItems(value, path90, node.item, map);
     case "record":
-      return mapChildren(value, path88, () => node.value, map);
+      return mapChildren(value, path90, () => node.value, map);
     default:
       return value;
   }
@@ -11230,9 +11230,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path88) {
+function getNestedValue(obj, path90) {
   let current = obj;
-  for (const key of path88.split(".")) current = stepInto(current, key);
+  for (const key of path90.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -11282,9 +11282,9 @@ function step(node, segment) {
       return void 0;
   }
 }
-function findConfigNode(root, path88) {
+function findConfigNode(root, path90) {
   let current = root;
-  for (const segment of path88) {
+  for (const segment of path90) {
     if (!current) return void 0;
     current = step(current, segment);
   }
@@ -11301,34 +11301,34 @@ function nameSegment(name) {
   return name === RECORD_ENTRY_TOKEN ? { kind: "entry" } : { kind: "key", name };
 }
 function parseConfigPath(text18) {
-  const path88 = [];
+  const path90 = [];
   let at2 = 0;
   while (at2 < text18.length) {
     if (text18[at2] === "[") {
       const close = text18.indexOf("]", at2);
       const segment = close === -1 ? void 0 : bracketSegment(text18.slice(at2 + 1, close));
       if (!segment) return void 0;
-      path88.push(segment);
+      path90.push(segment);
       at2 = close + 1;
       continue;
     }
     if (text18[at2] === ".") {
-      if (path88.length === 0) return void 0;
+      if (path90.length === 0) return void 0;
       at2 += 1;
     }
     const start3 = at2;
     while (at2 < text18.length && text18[at2] !== "." && text18[at2] !== "[") at2 += 1;
     const name = text18.slice(start3, at2);
     if (!name) return void 0;
-    path88.push(nameSegment(name));
+    path90.push(nameSegment(name));
   }
-  return path88;
+  return path90;
 }
 
 // src/commands/config/configEntryNode.ts
 function configEntryNode(root, key) {
-  const path88 = parseConfigPath(key);
-  return path88 ? findConfigNode(root, path88) : void 0;
+  const path90 = parseConfigPath(key);
+  return path90 ? findConfigNode(root, path90) : void 0;
 }
 
 // src/commands/config/configHelpForKey.ts
@@ -11463,7 +11463,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname21(branchKeyPath);
   const branchPrefix = basename8(branchKeyPath);
   if (!existsSync32(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path88) => existsSync32(path88)).map((path88) => ({ path: path88, mtime: statSync4(path88).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path90) => existsSync32(path90)).map((path90) => ({ path: path90, mtime: statSync4(path90).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -11493,12 +11493,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path88 = await resolveSynthesisPath(cwd);
-    if (!path88) {
+    const path90 = await resolveSynthesisPath(cwd);
+    if (!path90) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync21(path88, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path90, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -11581,8 +11581,8 @@ function parseDiffNameStatus(output) {
     if (!status3 || fields.length < 2) continue;
     const category = categorize(status3[0]);
     if (!category) continue;
-    const path88 = fields[fields.length - 1];
-    if (path88) result[category].push(path88);
+    const path90 = fields[fields.length - 1];
+    if (path90) result[category].push(path90);
   }
   return result;
 }
@@ -11718,21 +11718,21 @@ function subsequenceScore(text18, query) {
   }
   return score - Math.min(text18.length, MAX_LENGTH_PENALTY);
 }
-function scoreFilePath(path88, query) {
+function scoreFilePath(path90, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename26 = path88.slice(path88.lastIndexOf("/") + 1);
+  const basename26 = path90.slice(path90.lastIndexOf("/") + 1);
   const inBasename = subsequenceScore(basename26, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
-  return subsequenceScore(path88, needle);
+  return subsequenceScore(path90, needle);
 }
 
 // src/commands/sessions/web/rankFilePaths.ts
 function rankFilePaths(paths, query, limit) {
   const scored = [];
-  for (const path88 of paths) {
-    const score = scoreFilePath(path88, query);
-    if (score !== null) scored.push({ path: path88, score });
+  for (const path90 of paths) {
+    const score = scoreFilePath(path90, query);
+    if (score !== null) scored.push({ path: path90, score });
   }
   scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
   return scored.slice(0, limit).map((entry) => entry.path);
@@ -12298,38 +12298,38 @@ async function restartWeb(req, res, deps2 = {}) {
 import { relative as relative3 } from "path";
 
 // src/commands/sessions/web/revertPathChanges.ts
-async function isTracked(cwd, path88) {
+async function isTracked(cwd, path90) {
   try {
-    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path88]);
+    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path90]);
     return true;
   } catch {
     return false;
   }
 }
-async function isInHead(cwd, path88) {
-  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path88]);
+async function isInHead(cwd, path90) {
+  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path90]);
   return listing.trim().length > 0;
 }
-async function revertPathChanges(cwd, path88) {
-  if (!await isTracked(cwd, path88)) {
-    await execGit(cwd, ["clean", "-f", "--", path88]);
+async function revertPathChanges(cwd, path90) {
+  if (!await isTracked(cwd, path90)) {
+    await execGit(cwd, ["clean", "-f", "--", path90]);
     return;
   }
-  if (await isInHead(cwd, path88)) {
-    await execGit(cwd, ["checkout", "HEAD", "--", path88]);
+  if (await isInHead(cwd, path90)) {
+    await execGit(cwd, ["checkout", "HEAD", "--", path90]);
     return;
   }
-  await execGit(cwd, ["rm", "-f", "--", path88]);
+  await execGit(cwd, ["rm", "-f", "--", path90]);
 }
 
 // src/commands/sessions/web/revertDiffFile.ts
 async function revertDiffFile(req, res) {
   const resolved = getFileTarget(req, res);
   if (!resolved) return;
-  const path88 = relative3(repoRoot(resolved.cwd), resolved.target);
+  const path90 = relative3(repoRoot(resolved.cwd), resolved.target);
   try {
-    await revertPathChanges(resolved.cwd, path88);
-    respondJson(res, 200, { reverted: path88 });
+    await revertPathChanges(resolved.cwd, path90);
+    respondJson(res, 200, { reverted: path90 });
   } catch (error) {
     respondJson(res, 500, {
       error: error instanceof Error ? error.message : "Failed to revert file"
@@ -12351,7 +12351,7 @@ async function readJsonBody(req) {
 function requestedPaths(body) {
   const paths = body.paths;
   if (!Array.isArray(paths)) return null;
-  if (paths.some((path88) => typeof path88 !== "string")) return null;
+  if (paths.some((path90) => typeof path90 !== "string")) return null;
   return paths;
 }
 async function revertDiffPaths(req, res) {
@@ -12371,10 +12371,10 @@ async function revertDiffPaths(req, res) {
   const root = repoRoot(cwd);
   const reverted = [];
   const failed2 = [];
-  for (const path88 of paths) {
-    const target = resolveWithinCwd(cwd, path88);
+  for (const path90 of paths) {
+    const target = resolveWithinCwd(cwd, path90);
     if (!target) {
-      failed2.push({ path: path88, error: "Path outside cwd" });
+      failed2.push({ path: path90, error: "Path outside cwd" });
       continue;
     }
     const relativePath = relative4(root, target);
@@ -12464,11 +12464,11 @@ function coerceStructuredConfigValue(key, raw) {
   };
 }
 function formatIssue(key, issue) {
-  const path88 = formatConfigPath([
+  const path90 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
   ]);
-  return `${path88}: ${issue.message}`;
+  return `${path90}: ${issue.message}`;
 }
 function toSegment(part) {
   return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
@@ -12563,9 +12563,9 @@ function coerceUnion(key, raw, types) {
 }
 
 // src/shared/valueAtConfigPath.ts
-function valueAtConfigPath(value, path88) {
+function valueAtConfigPath(value, path90) {
   let current = value;
-  for (const key of path88) {
+  for (const key of path90) {
     if (typeof key === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[key];
@@ -12582,7 +12582,7 @@ function restoreConfigSecrets(value, stored, node) {
   return mapConfigSecrets(
     value,
     node,
-    (secret, path88) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path88) : secret
+    (secret, path90) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path90) : secret
   );
 }
 
@@ -12631,8 +12631,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path88, value) {
-  const keys = path88.split(".");
+function setNestedValue(obj, path90, value) {
+  const keys = path90.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -12659,8 +12659,8 @@ function formatIssue2(issue, key) {
     return issue.keys.map(
       (unrecognized) => `${[...issue.path, unrecognized].join(".")}: Unrecognized key`
     );
-  const path88 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return [`${path88}: ${issue.message}`];
+  const path90 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return [`${path90}: ${issue.message}`];
 }
 
 // src/commands/config/applyConfigSet.ts
@@ -12917,8 +12917,8 @@ function removeAt(container, keys) {
   }
   return removeFromChild(container, key, rest);
 }
-function unsetNestedValue(obj, path88) {
-  const { container, removed } = removeAt(obj, path88.split("."));
+function unsetNestedValue(obj, path90) {
+  const { container, removed } = removeAt(obj, path90.split("."));
   return { config: container, removed };
 }
 
@@ -14032,9 +14032,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path88 = origin.slice(firstSlash + 1);
-  if (!path88) return null;
-  return `git@${host}:${path88}.git`;
+  const path90 = origin.slice(firstSlash + 1);
+  if (!path90) return null;
+  return `git@${host}:${path90}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -17062,9 +17062,9 @@ var __dirname4 = dirname23(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path88) {
-  if (!existsSync38(path88)) return [];
-  return readFileSync26(path88, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path90) {
+  if (!existsSync38(path90)) return [];
+  return readFileSync26(path90, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -17585,14 +17585,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path88, description, depth, p) {
-  showProgress(p, path88.join(" "));
-  const subHelp = await runHelp([cli, ...path88]);
+async function resolveCommand(cli, path90, description, depth, p) {
+  showProgress(p, path90.join(" "));
+  const subHelp = await runHelp([cli, ...path90]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path88, description }];
+    return [{ path: path90, description }];
   }
-  const children = await discoverAt(cli, path88, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path88, description }];
+  const children = await discoverAt(cli, path90, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path90, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -17740,9 +17740,9 @@ function logPath(cli) {
   return join39(homedir17(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path88 = logPath(cli);
-  if (!existsSync40(path88)) return void 0;
-  return readFileSync28(path88, "utf8");
+  const path90 = logPath(cli);
+  if (!existsSync40(path90)) return void 0;
+  return readFileSync28(path90, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join39(homedir17(), ".assist");
@@ -17902,9 +17902,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path88 = join41(dir, entry);
+    const path90 = join41(dir, entry);
     try {
-      if (statSync7(path88).mtimeMs < cutoff) unlinkSync7(path88);
+      if (statSync7(path90).mtimeMs < cutoff) unlinkSync7(path90);
     } catch {
       continue;
     }
@@ -17914,10 +17914,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync41, readFileSync as readFileSync29 } from "fs";
 function readPinState(pin) {
-  const path88 = getPinStatePath(pin);
-  if (!existsSync41(path88)) return void 0;
+  const path90 = getPinStatePath(pin);
+  if (!existsSync41(path90)) return void 0;
   try {
-    const state = JSON.parse(readFileSync29(path88, "utf8"));
+    const state = JSON.parse(readFileSync29(path90, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -19056,11 +19056,11 @@ async function loadPath(source) {
   }
 }
 async function criteriaExtension() {
-  const path88 = await loadPath(criteriaExtensionDir());
+  const path90 = await loadPath(criteriaExtensionDir());
   console.log(
     chalk139.bold("acceptance criteria outliner \u2014 GitHub browser extension")
   );
-  console.log(chalk139.dim(`load the unpacked extension from ${path88}`));
+  console.log(chalk139.dim(`load the unpacked extension from ${path90}`));
 }
 
 // src/commands/criteriaExtension/signCriteriaExtension.ts
@@ -19185,10 +19185,10 @@ async function signCriteriaExtension() {
     process.exitCode = 1;
     return;
   }
-  const path88 = await signedAddonInstallPath(
+  const path90 = await signedAddonInstallPath(
     await copySignedXpi(xpi, ARTIFACTS_DIR)
   );
-  console.log(chalk141.dim(`install the signed add-on from ${path88}`));
+  console.log(chalk141.dim(`install the signed add-on from ${path90}`));
 }
 
 // src/commands/registerCriteriaExtension.ts
@@ -19286,10 +19286,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync46, readFileSync as readFileSync31 } from "fs";
 function readMigrationPinState(pin) {
-  const path88 = getMigrationPinPath(pin);
-  if (!existsSync46(path88)) return void 0;
+  const path90 = getMigrationPinPath(pin);
+  if (!existsSync46(path90)) return void 0;
   try {
-    const state = JSON.parse(readFileSync31(path88, "utf8"));
+    const state = JSON.parse(readFileSync31(path90, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -20719,10 +20719,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync52, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path88 = getMigrationApprovalPath(migrationId);
-  if (!existsSync52(path88)) return false;
+  const path90 = getMigrationApprovalPath(migrationId);
+  if (!existsSync52(path90)) return false;
   try {
-    unlinkSync11(path88);
+    unlinkSync11(path90);
     return true;
   } catch {
     return false;
@@ -22416,11 +22416,11 @@ function recentDaemonLogLines() {
 // src/commands/sessions/daemon/worktree/canonicalTreePath.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve14 } from "path";
-function canonicalTreePath(path88) {
+function canonicalTreePath(path90) {
   try {
-    return realpathSync2(path88);
+    return realpathSync2(path90);
   } catch {
-    return resolve14(path88);
+    return resolve14(path90);
   }
 }
 
@@ -22473,22 +22473,22 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
   const isTaken = (candidate) => registered.has(candidate) || existsSync55(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
-  const path88 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
+  const path90 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
     "worktree",
     "add",
     start3.track ? "--track" : "--no-track",
     "-b",
-    basename16(path88),
-    path88,
+    basename16(path90),
+    path90,
     start3.ref
   ]);
-  recordWorktree(path88, clone, getCurrentOrigin(clone));
+  recordWorktree(path90, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path88} (branch ${basename16(path88)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path88} (branch ${basename16(path88)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path90} (branch ${basename16(path90)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path90} (branch ${basename16(path90)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
-  return path88;
+  return path90;
 }
 
 // src/commands/sessions/daemon/worktree/keptInTree.ts
@@ -22629,13 +22629,13 @@ function allocateTree(requestedCwd, boundTreeRoots2, options2 = {}) {
   if (forcedSpill) daemonLog(forcedSpill);
   else if (reusesClone(clone, boundTreeRoots2, reuse))
     return { cwd: clone, kind: "primary", created: false, clone };
-  const path88 = createWorktree(
+  const path90 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
     boundTreeRoots2,
     options2.replacesTree
   );
-  return { cwd: path88, kind: "worktree", created: true, clone };
+  return { cwd: path90, kind: "worktree", created: true, clone };
 }
 
 // src/commands/sessions/daemon/describePersistedSession.ts
@@ -22966,13 +22966,13 @@ function worktreeHoldingBranch(cwd, branch2) {
   const listing = gitSyncOrNull(cwd, ["worktree", "list", "--porcelain"]);
   if (!listing) return null;
   const here = gitSyncOrNull(cwd, ["rev-parse", "--show-toplevel"]);
-  let path88 = null;
+  let path90 = null;
   for (const line of listing.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("worktree "))
-      path88 = trimmed.slice("worktree ".length).trim();
+      path90 = trimmed.slice("worktree ".length).trim();
     else if (trimmed === `branch refs/heads/${branch2}`)
-      return path88 && path88 !== here ? path88 : null;
+      return path90 && path90 !== here ? path90 : null;
   }
   return null;
 }
@@ -24014,9 +24014,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path88] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path90] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path88) {
+    for (const key of path90) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -24719,16 +24719,16 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-async function comment2(path88, line, body, startLine) {
+async function comment2(path90, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-  await reviewProposedPrComment(`Comment on ${path88}:${range}`, body, null);
+  await reviewProposedPrComment(`Comment on ${path90}:${range}`, body, null);
   try {
     const prId = getCurrentPrNodeId();
-    postReviewComment({ prId, body, path: path88, line, startLine });
-    console.log(`Added review comment on ${path88}:${range}`);
+    postReviewComment({ prId, body, path: path90, line, startLine });
+    console.log(`Added review comment on ${path90}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -25930,9 +25930,9 @@ function registerPrsComments(prsCommand) {
   });
   prsCommand.command("comment <path> <line> <body>").description(
     "Add a line comment to the pending review (body of - reads it from stdin)"
-  ).action(async (path88, line, body) => {
+  ).action(async (path90, line, body) => {
     await comment2(
-      path88,
+      path90,
       Number.parseInt(line, 10),
       await readBodyArgument(body)
     );
@@ -26396,10 +26396,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path88) {
+async function ravenFetch(connection, path90) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path88}`;
+  const url = `${connection.url}${path90}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -26489,16 +26489,16 @@ import chalk193 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path88;
+  let path90;
   if (opts.collection) {
-    path88 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path90 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path88 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path90 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path88 += `&query=${encodeURIComponent(opts.query)}`;
+    path90 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path88;
+  return path90;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -26507,7 +26507,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path88 = buildQueryPath({
+    const path90 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -26515,7 +26515,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path88);
+    const data = await ravenFetch(connection, path90);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -29123,8 +29123,8 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync61, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path88 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync61(path88)) unlinkSync17(path88);
+  for (const path90 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync61(path90)) unlinkSync17(path90);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -30173,8 +30173,8 @@ function registerReview(program2) {
 }
 
 // src/commands/rules/addRule.ts
-import { existsSync as existsSync65, readFileSync as readFileSync49, writeFileSync as writeFileSync40 } from "fs";
-import path70 from "path";
+import { existsSync as existsSync66, readFileSync as readFileSync50, writeFileSync as writeFileSync41 } from "fs";
+import path71 from "path";
 import chalk209 from "chalk";
 
 // src/commands/rules/insertRuleBullet.ts
@@ -30244,6 +30244,10 @@ function resolveRuleScope(target) {
   return path68.join(root, "CLAUDE.md");
 }
 
+// src/commands/rules/updateScopedRulesIndex.ts
+import { existsSync as existsSync65, readFileSync as readFileSync49, writeFileSync as writeFileSync40 } from "fs";
+import path70 from "path";
+
 // src/commands/rules/scopedRuleDirectories.ts
 import { readFileSync as readFileSync48 } from "fs";
 import path69 from "path";
@@ -30287,9 +30291,19 @@ function upsertScopedRulesPointer(content, directories) {
 `;
 }
 
+// src/commands/rules/updateScopedRulesIndex.ts
+function updateScopedRulesIndex(root) {
+  const directories = scopedRuleDirectories(root);
+  const rootFile = path70.join(root, "CLAUDE.md");
+  const before = existsSync65(rootFile) ? readFileSync49(rootFile, "utf8") : "";
+  const after = upsertScopedRulesPointer(before, directories);
+  if (after !== before) writeFileSync40(rootFile, after);
+  return directories;
+}
+
 // src/commands/rules/addRule.ts
 function read2(file) {
-  return existsSync65(file) ? readFileSync49(file, "utf8") : "";
+  return existsSync66(file) ? readFileSync50(file, "utf8") : "";
 }
 function addRule(text18, options2) {
   const rule = text18.trim();
@@ -30299,28 +30313,44 @@ function addRule(text18, options2) {
     return;
   }
   const target = resolveRuleScope(options2.scope ?? process.cwd());
-  const targetDir = path70.dirname(target);
+  const targetDir = path71.dirname(target);
   const root = findRepoRoot(targetDir) ?? targetDir;
   const code = nextRuleCode(root);
-  writeFileSync40(target, insertRuleBullet(read2(target), code, rule));
-  const rootFile = path70.join(root, "CLAUDE.md");
-  const before = read2(rootFile);
-  const after = upsertScopedRulesPointer(before, scopedRuleDirectories(root));
-  if (after !== before) writeFileSync40(rootFile, after);
+  writeFileSync41(target, insertRuleBullet(read2(target), code, rule));
+  updateScopedRulesIndex(root);
   console.log(
-    `Added ${chalk209.cyan(code)} to ${path70.relative(process.cwd(), target) || target}`
+    `Added ${chalk209.cyan(code)} to ${path71.relative(process.cwd(), target) || target}`
   );
 }
 
-// src/commands/rules/listRules.ts
-import path71 from "path";
+// src/commands/rules/indexRules.ts
+import path72 from "path";
 import chalk210 from "chalk";
+function indexRules(target) {
+  const startDir = scopeDirectory(path72.resolve(target ?? process.cwd()));
+  const root = findRepoRoot(startDir) ?? startDir;
+  const directories = updateScopedRulesIndex(root);
+  const rootFile = path72.relative(process.cwd(), path72.join(root, "CLAUDE.md"));
+  if (directories.length === 0) {
+    console.log(
+      chalk210.gray(`No directories carry their own \`## Rules\` under ${root}`)
+    );
+    return;
+  }
+  console.log(`Recorded in ${rootFile || "CLAUDE.md"}`);
+  for (const directory of directories)
+    console.log(`  ${chalk210.cyan(directory)}`);
+}
+
+// src/commands/rules/listRules.ts
+import path73 from "path";
+import chalk211 from "chalk";
 function listRules(target) {
-  const resolved = path71.resolve(target ?? process.cwd());
+  const resolved = path73.resolve(target ?? process.cwd());
   const rules3 = readScopedRules(resolved);
   if (rules3.length === 0) {
-    const label2 = path71.relative(process.cwd(), resolved) || ".";
-    console.log(chalk210.gray(`No rules in scope for ${label2}`));
+    const label2 = path73.relative(process.cwd(), resolved) || ".";
+    console.log(chalk211.gray(`No rules in scope for ${label2}`));
     return;
   }
   const base = findRepoRoot(scopeDirectory(resolved));
@@ -30330,10 +30360,10 @@ function listRules(target) {
     if (rule.source !== shown) {
       shown = rule.source;
       console.log(
-        chalk210.dim(base ? path71.relative(base, rule.source) : rule.source)
+        chalk211.dim(base ? path73.relative(base, rule.source) : rule.source)
       );
     }
-    console.log(`  ${chalk210.cyan(rule.code.padEnd(width))}  ${rule.text}`);
+    console.log(`  ${chalk211.cyan(rule.code.padEnd(width))}  ${rule.text}`);
   }
 }
 
@@ -30351,10 +30381,13 @@ function registerRules(program2) {
   ).action(
     (text18, options2) => addRule(text18, options2)
   );
+  rulesCommand.command("index [path]").description(
+    "Record the directories that carry their own `## Rules` in the repo root's CLAUDE.md, so scoped rules are discoverable from the root"
+  ).action((target) => indexRules(target));
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk212 from "chalk";
+import chalk213 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -30383,10 +30416,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk211 from "chalk";
+import chalk212 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk211.red(`Connection "${name}" already exists.`));
+    console.error(chalk212.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -30404,18 +30437,18 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk212.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk213.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk216 from "chalk";
+import chalk217 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk213 from "chalk";
-async function fetchSeq(conn, path88, params) {
-  const url = `${conn.url}${path88}?${params}`;
+import chalk214 from "chalk";
+async function fetchSeq(conn, path90, params) {
+  const url = `${conn.url}${path90}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -30424,7 +30457,7 @@ async function fetchSeq(conn, path88, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk213.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk214.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -30483,23 +30516,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk214 from "chalk";
+import chalk215 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk214.bgRed.white;
+      return chalk215.bgRed.white;
     case "Error":
-      return chalk214.red;
+      return chalk215.red;
     case "Warning":
-      return chalk214.yellow;
+      return chalk215.yellow;
     case "Information":
-      return chalk214.cyan;
+      return chalk215.cyan;
     case "Debug":
-      return chalk214.gray;
+      return chalk215.gray;
     case "Verbose":
-      return chalk214.dim;
+      return chalk215.dim;
     default:
-      return chalk214.white;
+      return chalk215.white;
   }
 }
 function levelAbbrev(level) {
@@ -30540,12 +30573,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk214.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk215.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines2 = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines2.push(chalk214.red(`  ${line}`));
+      lines2.push(chalk215.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -30578,11 +30611,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk215 from "chalk";
+import chalk216 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk215.red(
+      chalk216.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -30591,7 +30624,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk215.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk216.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -30620,7 +30653,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk216.yellow("No events found."));
+    console.log(chalk217.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -30631,11 +30664,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk216.dim(`
+  console.log(chalk217.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk216.yellow(
+      chalk217.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -30643,10 +30676,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk217 from "chalk";
+import chalk218 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk217.red(`Connection "${name}" not found.`));
+    console.error(chalk218.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -30695,7 +30728,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk219 from "chalk";
+import chalk220 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -30724,7 +30757,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk218 from "chalk";
+import chalk219 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -30732,7 +30765,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk218.red(`Invalid port "${portStr}".`));
+    console.error(chalk219.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -30745,13 +30778,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk219.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk220.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk220 from "chalk";
+import chalk221 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -30760,7 +30793,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk220.yellow("(no rows)"));
+    console.log(chalk221.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -30768,13 +30801,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk220.dim(header));
-  console.log(chalk220.dim("-".repeat(header.length)));
+  console.log(chalk221.dim(header));
+  console.log(chalk221.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk220.dim(`
+  console.log(chalk221.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -30834,7 +30867,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk221 from "chalk";
+import chalk222 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -30868,7 +30901,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk221.red(
+      chalk222.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -30878,18 +30911,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk221.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk222.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk222 from "chalk";
+import chalk223 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk222.red(
+      chalk223.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -30904,7 +30937,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk222.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk223.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -30967,15 +31000,15 @@ function registerSql(program2) {
 // src/commands/sync.ts
 import * as fs48 from "fs";
 import * as os5 from "os";
-import * as path82 from "path";
+import * as path84 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/sync/pruneCommands.ts
-import * as path73 from "path";
+import * as path75 from "path";
 
 // src/commands/sync/pruneTarget.ts
 import * as fs40 from "fs";
-import * as path72 from "path";
+import * as path74 from "path";
 function pruneTarget(targetDir, keepNames, shape, options2) {
   const result = {
     orphans: [],
@@ -30993,7 +31026,7 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
     }
     if (keep.has(name)) continue;
     result.orphans.push(entry.name);
-    const entryPath = path72.join(targetDir, entry.name);
+    const entryPath = path74.join(targetDir, entry.name);
     const reason4 = shape.blockedBy?.(entryPath);
     if (reason4) {
       result.skipped.push({ name: entry.name, reason: reason4 });
@@ -31013,7 +31046,7 @@ function pruneCommands(targetDir, commandNames, options2) {
     targetDir,
     commandNames,
     {
-      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path73.basename(entry.name, ".md") : void 0
+      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path75.basename(entry.name, ".md") : void 0
     },
     options2
   );
@@ -31048,24 +31081,24 @@ function reportPrune(label2, result, force) {
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
-import * as path74 from "path";
-import chalk223 from "chalk";
+import * as path76 from "path";
+import chalk224 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path74.join(claudeDir, "CLAUDE.md");
-  const target = path74.join(targetBase, "CLAUDE.md");
+  const source = path76.join(claudeDir, "CLAUDE.md");
+  const target = path76.join(targetBase, "CLAUDE.md");
   const sourceContent = fs41.readFileSync(source, "utf8");
   if (fs41.existsSync(target)) {
     const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk223.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk224.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk223.red("Overwrite existing CLAUDE.md?"),
+          chalk224.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -31080,13 +31113,13 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path77 from "path";
+import * as path79 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
 import * as fs42 from "fs";
-import * as path75 from "path";
+import * as path77 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path75.join(claudeDir, "commands");
+  const commandsSource = path77.join(claudeDir, "commands");
   const files = fs42.readdirSync(commandsSource);
   const names = [];
   let synced = 0;
@@ -31094,15 +31127,15 @@ function installHarnessCommands(claudeDir, harness, transform) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
     names.push(name);
-    const content = fs42.readFileSync(path75.join(commandsSource, file), "utf8");
-    const target = path75.join(harness.homeDir, harness.sync.commandDest(name));
-    fs42.mkdirSync(path75.dirname(target), { recursive: true });
+    const content = fs42.readFileSync(path77.join(commandsSource, file), "utf8");
+    const target = path77.join(harness.homeDir, harness.sync.commandDest(name));
+    fs42.mkdirSync(path77.dirname(target), { recursive: true });
     fs42.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path75.join(harness.homeDir, harness.sync.agentsFile);
-  fs42.mkdirSync(path75.dirname(agentsTarget), { recursive: true });
-  fs42.copyFileSync(path75.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path77.join(harness.homeDir, harness.sync.agentsFile);
+  fs42.mkdirSync(path77.dirname(agentsTarget), { recursive: true });
+  fs42.copyFileSync(path77.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced, names };
 }
 
@@ -31128,7 +31161,7 @@ function unexpectedContent(skillDir) {
 
 // src/commands/sync/syncCodexHooks.ts
 import * as fs44 from "fs";
-import * as path76 from "path";
+import * as path78 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -31159,9 +31192,9 @@ ${rest}
 }
 function syncCodexHooks(sourcePath) {
   const body = fs44.readFileSync(sourcePath, "utf8");
-  const configPath = path76.join(harnesses.codex.homeDir, "config.toml");
+  const configPath = path78.join(harnesses.codex.homeDir, "config.toml");
   const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
-  fs44.mkdirSync(path76.dirname(configPath), { recursive: true });
+  fs44.mkdirSync(path78.dirname(configPath), { recursive: true });
   fs44.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (UserPromptSubmit, PreToolUse, PostToolUse, PermissionRequest, Stop)"
@@ -31193,7 +31226,7 @@ function syncCodex(claudeDir, options2) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path77.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path79.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
@@ -31201,42 +31234,42 @@ function syncCodex(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.codex/skills",
-    pruneSkills(path77.join(harnesses.codex.homeDir, "skills"), names, { force }),
+    pruneSkills(path79.join(harnesses.codex.homeDir, "skills"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncDesign.ts
 import * as fs45 from "fs";
-import * as path78 from "path";
+import * as path80 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path78.join(claudeDir, "design-system-prompt.md");
-  const systemPromptTarget = path78.join(targetBase, "design-system-prompt.md");
+  const systemPromptSource = path80.join(claudeDir, "design-system-prompt.md");
+  const systemPromptTarget = path80.join(targetBase, "design-system-prompt.md");
   fs45.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log(
     "Copied design-system-prompt.md to ~/.claude/design-system-prompt.md"
   );
-  const skillsSource = path78.join(claudeDir, "skills");
-  const skillsTarget = path78.join(targetBase, "skills");
+  const skillsSource = path80.join(claudeDir, "skills");
+  const skillsTarget = path80.join(targetBase, "skills");
   fs45.mkdirSync(skillsTarget, { recursive: true });
   const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
     fs45.copyFileSync(
-      path78.join(skillsSource, file),
-      path78.join(skillsTarget, file)
+      path80.join(skillsSource, file),
+      path80.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path80 from "path";
+import * as path82 from "path";
 
 // src/commands/sync/syncPiHooks.ts
 import * as fs46 from "fs";
-import * as path79 from "path";
+import * as path81 from "path";
 function piExtensionsDir() {
-  return path79.join(harnesses.pi.homeDir, "extensions");
+  return path81.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
@@ -31244,8 +31277,8 @@ function syncPiHooks(sourceDir) {
   const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     fs46.copyFileSync(
-      path79.join(sourceDir, file),
-      path79.join(target, `assist-${file}`)
+      path81.join(sourceDir, file),
+      path81.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -31282,7 +31315,7 @@ function syncPi(claudeDir, options2) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path80.join(claudeDir, "..", "pi"));
+  syncPiHooks(path82.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
@@ -31290,18 +31323,18 @@ function syncPi(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.pi/agent/prompts",
-    pruneCommands(path80.join(harnesses.pi.homeDir, "prompts"), names, { force }),
+    pruneCommands(path82.join(harnesses.pi.homeDir, "prompts"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
-import * as path81 from "path";
-import chalk224 from "chalk";
+import * as path83 from "path";
+import chalk225 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path81.join(claudeDir, "settings.json");
-  const target = path81.join(targetBase, "settings.json");
+  const source = path83.join(claudeDir, "settings.json");
+  const target = path83.join(targetBase, "settings.json");
   const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
   const targetExists = fs47.existsSync(target);
@@ -31317,7 +31350,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk224.yellow(
+          chalk225.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -31325,7 +31358,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk224.red("Overwrite existing settings.json?"),
+          chalk225.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -31341,13 +31374,13 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname5 = path82.dirname(__filename4);
+var __dirname5 = path84.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
   const prune = { prune: options2?.prune, force: options2?.force };
-  const claudeDir = path82.join(__dirname5, "..", "claude");
-  const targetBase = path82.join(os5.homedir(), ".claude");
+  const claudeDir = path84.join(__dirname5, "..", "claude");
+  const targetBase = path84.join(os5.homedir(), ".claude");
   const commandFiles = syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -31355,21 +31388,21 @@ async function sync(options2) {
   syncCodex(claudeDir, prune);
   syncPi(claudeDir, prune);
   if (!options2?.prune) return;
-  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path82.basename(file, ".md"));
+  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path84.basename(file, ".md"));
   const force = options2.force ?? false;
   reportPrune(
     "~/.claude/commands",
-    pruneCommands(path82.join(targetBase, "commands"), commandNames, { force }),
+    pruneCommands(path84.join(targetBase, "commands"), commandNames, { force }),
     force
   );
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path82.join(claudeDir, "commands");
-  const targetDir = path82.join(targetBase, "commands");
+  const sourceDir = path84.join(claudeDir, "commands");
+  const targetDir = path84.join(targetBase, "commands");
   fs48.mkdirSync(targetDir, { recursive: true });
   const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs48.copyFileSync(path82.join(sourceDir, file), path82.join(targetDir, file));
+    fs48.copyFileSync(path84.join(sourceDir, file), path84.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -31397,7 +31430,7 @@ function registerSync(program2) {
 }
 
 // src/commands/transcript/clean.ts
-import { existsSync as existsSync70 } from "fs";
+import { existsSync as existsSync71 } from "fs";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text18) {
@@ -31621,9 +31654,9 @@ function formatVtt(cues) {
 }
 
 // src/commands/transcript/convert/readCleanedCues.ts
-import { readFileSync as readFileSync54 } from "fs";
+import { readFileSync as readFileSync55 } from "fs";
 function readCleanedCues(inputPath) {
-  return deduplicateCues(parseVtt(readFileSync54(inputPath, "utf8")));
+  return deduplicateCues(parseVtt(readFileSync55(inputPath, "utf8")));
 }
 
 // src/commands/transcript/clean.ts
@@ -31642,7 +31675,7 @@ function clean(file, options2 = {}) {
     );
     process.exit(1);
   }
-  if (!existsSync70(file)) {
+  if (!existsSync71(file)) {
     console.error(`Error: VTT file not found: ${file}`);
     process.exit(1);
   }
@@ -31725,11 +31758,11 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync71, readdirSync as readdirSync20, statSync as statSync11 } from "fs";
+import { existsSync as existsSync72, readdirSync as readdirSync20, statSync as statSync11 } from "fs";
 import { join as join83 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync71(vttDir)) return;
+  if (!existsSync72(vttDir)) return;
   for (const entry of readdirSync20(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
     if (statSync11(join83(vttDir, entry)).isDirectory()) continue;
@@ -31738,7 +31771,7 @@ function list4() {
 }
 
 // src/commands/transcript/move.ts
-import { existsSync as existsSync72, mkdirSync as mkdirSync27, renameSync as renameSync2, writeFileSync as writeFileSync44 } from "fs";
+import { existsSync as existsSync73, mkdirSync as mkdirSync27, renameSync as renameSync2, writeFileSync as writeFileSync45 } from "fs";
 import { basename as basename21, join as join84 } from "path";
 
 // src/commands/transcript/convertVttToMarkdown.ts
@@ -31762,7 +31795,7 @@ function move(file, options2) {
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename21(file);
   const sourcePath = join84(vttDir, filename);
-  if (!existsSync72(sourcePath)) {
+  if (!existsSync73(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
@@ -31771,7 +31804,7 @@ function move(file, options2) {
   const formattedDir = join84(transcriptsDir, client);
   mkdirSync27(formattedDir, { recursive: true });
   const formattedPath = join84(formattedDir, outputName);
-  writeFileSync44(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
+  writeFileSync45(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
   const summaryPath = join84(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
@@ -31892,14 +31925,14 @@ function devices() {
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync73, readFileSync as readFileSync55 } from "fs";
+import { existsSync as existsSync74, readFileSync as readFileSync56 } from "fs";
 function logs(options2) {
-  if (!existsSync73(voicePaths.log)) {
+  if (!existsSync74(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync55(voicePaths.log, "utf8").trim();
+  const content = readFileSync56(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -31926,7 +31959,7 @@ import { join as join88 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync74, mkdirSync as mkdirSync28, readFileSync as readFileSync56, writeFileSync as writeFileSync45 } from "fs";
+import { existsSync as existsSync75, mkdirSync as mkdirSync28, readFileSync as readFileSync57, writeFileSync as writeFileSync46 } from "fs";
 import { join as join87 } from "path";
 function isProcessAlive2(pid) {
   try {
@@ -31938,9 +31971,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync74(lockFile)) return;
+  if (!existsSync75(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync56(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync57(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -31951,7 +31984,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync74(getVenvPython())) return;
+  if (existsSync75(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync58(
@@ -31965,7 +31998,7 @@ function bootstrapVenv() {
 function writeLockFile(pid) {
   const lockFile = getLockFile();
   mkdirSync28(join87(lockFile, ".."), { recursive: true });
-  writeFileSync45(
+  writeFileSync46(
     lockFile,
     JSON.stringify({
       pid,
@@ -31993,7 +32026,7 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync46 } from "fs";
+import { mkdirSync as mkdirSync30, writeFileSync as writeFileSync47 } from "fs";
 import { join as join89 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
@@ -32022,7 +32055,7 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync46(voicePaths.pid, String(pid));
+  writeFileSync47(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
@@ -32042,7 +32075,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync75, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync76, readFileSync as readFileSync58 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -32052,16 +32085,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync75(voicePaths.log)) return [];
-  const lines2 = readFileSync57(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync76(voicePaths.log)) return [];
+  const lines2 = readFileSync58(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync75(voicePaths.pid)) {
+  if (!existsSync76(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync57(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync58(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -32080,13 +32113,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync76, readFileSync as readFileSync58, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync77, readFileSync as readFileSync59, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync76(voicePaths.pid)) {
+  if (!existsSync77(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync58(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync59(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -32099,7 +32132,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync76(lockFile)) unlinkSync20(lockFile);
+    if (existsSync77(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -32224,11 +32257,11 @@ var webUiPrefix = "src/commands/sessions/web/ui/";
 var sessionsPrefix = "src/commands/sessions/";
 var rules = [
   {
-    matches: (path88) => path88.startsWith(webUiPrefix),
+    matches: (path90) => path90.startsWith(webUiPrefix),
     advice: "restart the web server, then hard-reload the browser tab"
   },
   {
-    matches: (path88) => path88.startsWith(sessionsPrefix) && !path88.startsWith(webUiPrefix),
+    matches: (path90) => path90.startsWith(sessionsPrefix) && !path90.startsWith(webUiPrefix),
     advice: "restart the daemon"
   }
 ];
@@ -32239,31 +32272,31 @@ function restartAdvice(paths) {
 // src/commands/watch/syncAdvice.ts
 var rules2 = [
   {
-    matches: (path88) => path88.startsWith("claude/commands/"),
+    matches: (path90) => path90.startsWith("claude/commands/"),
     reason: "claude/commands changed"
   },
   {
-    matches: (path88) => path88.startsWith("claude/skills/"),
+    matches: (path90) => path90.startsWith("claude/skills/"),
     reason: "claude/skills changed"
   },
   {
-    matches: (path88) => path88 === "claude/settings.json",
+    matches: (path90) => path90 === "claude/settings.json",
     reason: "claude/settings.json changed"
   },
   {
-    matches: (path88) => path88 === "claude/CLAUDE.md",
+    matches: (path90) => path90 === "claude/CLAUDE.md",
     reason: "claude/CLAUDE.md changed"
   },
   {
-    matches: (path88) => path88 === "claude/design-system-prompt.md",
+    matches: (path90) => path90 === "claude/design-system-prompt.md",
     reason: "claude/design-system-prompt.md changed"
   },
   {
-    matches: (path88) => path88.startsWith("codex/"),
+    matches: (path90) => path90.startsWith("codex/"),
     reason: "codex sources changed"
   },
   {
-    matches: (path88) => path88.startsWith("pi/"),
+    matches: (path90) => path90.startsWith("pi/"),
     reason: "pi sources changed"
   }
 ];
@@ -32504,7 +32537,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync77 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 import { resolve as resolve19 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -32517,17 +32550,17 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve19(baseDir, config.cwd);
-  if (!existsSync77(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync78(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import { existsSync as existsSync78 } from "fs";
+import { existsSync as existsSync79 } from "fs";
 import { dirname as dirname37, join as join91, resolve as resolve20 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
@@ -32535,7 +32568,7 @@ function resolveCommand2(command) {
     const gitPath = execFileSync16("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve20(dirname37(gitPath), "..");
     const gitBash = join91(gitRoot, "bin", "bash.exe");
-    if (existsSync78(gitBash)) return gitBash;
+    if (existsSync79(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -32545,7 +32578,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync79(cwd)) {
+    if (cwd && !existsSync80(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -32802,7 +32835,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk225 from "chalk";
+import chalk226 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -32933,13 +32966,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk225.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk226.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk225.white("http://localhost:14523/callback\n"));
-  console.log(chalk225.blue("Opening browser for authorization..."));
-  console.log(chalk225.dim("Waiting for authorization callback..."));
+  console.log(chalk226.white("http://localhost:14523/callback\n"));
+  console.log(chalk226.blue("Opening browser for authorization..."));
+  console.log(chalk226.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk225.dim("Exchanging code for tokens..."));
+  console.log(chalk226.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -32955,13 +32988,13 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk225.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk226.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import { readdirSync as readdirSync21, readFileSync as readFileSync59, statSync as statSync12 } from "fs";
+import { readdirSync as readdirSync21, readFileSync as readFileSync60, statSync as statSync12 } from "fs";
 import { join as join92 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -32971,9 +33004,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path88 = join92(roamDir, name);
+    const path90 = join92(roamDir, name);
     try {
-      return { path: path88, mtimeMs: statSync12(path88).mtimeMs };
+      return { path: path90, mtimeMs: statSync12(path90).mtimeMs };
     } catch {
       return void 0;
     }
@@ -32987,7 +33020,7 @@ function postRoamActivity(app, event) {
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync59(portFile, "utf8").trim();
+    port = readFileSync60(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -33115,7 +33148,7 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync47 } from "fs";
+import { mkdirSync as mkdirSync31, writeFileSync as writeFileSync48 } from "fs";
 import { join as join93 } from "path";
 
 // src/commands/run/extractOption.ts
@@ -33186,7 +33219,7 @@ description: Run ${name}
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
   const filePath = join93(dir, `${name}.md`);
-  writeFileSync47(filePath, content);
+  writeFileSync48(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -33209,11 +33242,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path88 = process.argv[idx + 1];
+  const path90 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path88, prefix: prefix2 };
+  return { path: path90, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -33241,7 +33274,7 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync80, unlinkSync as unlinkSync21 } from "fs";
+import { existsSync as existsSync81, unlinkSync as unlinkSync21 } from "fs";
 import { join as join94 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
@@ -33258,7 +33291,7 @@ function parseRemoveName() {
 }
 function deleteCommandFile(name) {
   const filePath = join94(".claude", "commands", `${name}.md`);
-  if (existsSync80(filePath)) {
+  if (existsSync81(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -33303,10 +33336,10 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync81, mkdirSync as mkdirSync32, unlinkSync as unlinkSync22, writeFileSync as writeFileSync48 } from "fs";
+import { existsSync as existsSync82, mkdirSync as mkdirSync32, unlinkSync as unlinkSync22, writeFileSync as writeFileSync49 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
 import { join as join95, resolve as resolve21 } from "path";
-import chalk226 from "chalk";
+import chalk227 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -33435,7 +33468,7 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync81(outputDir)) {
+  if (!existsSync82(outputDir)) {
     mkdirSync32(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -33443,7 +33476,7 @@ function buildOutputPath(outputDir, processName) {
 }
 function runPowerShellScript(processName, outputPath) {
   const scriptPath = join95(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync48(scriptPath, captureWindowPs1, "utf8");
+  writeFileSync49(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync60(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -33457,13 +33490,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve21(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk226.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk227.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk226.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk227.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk226.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk227.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -33519,11 +33552,11 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/readDaemonPidFile.ts
-import { readFileSync as readFileSync60 } from "fs";
+import { readFileSync as readFileSync61 } from "fs";
 function readDaemonPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync60(daemonPaths.pid, "utf8").trim(),
+      readFileSync61(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -33780,12 +33813,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync82 } from "fs";
+import { existsSync as existsSync83 } from "fs";
 function joinRefusal(session) {
   if (session.commandType === "run") return "a server run has no agent stream";
   if (session.closing === true) return "the session is closing";
   if (!session.cwd) return "the session has no working directory";
-  if (!existsSync82(session.cwd))
+  if (!existsSync83(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -33949,26 +33982,26 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync84 } from "fs";
+import { existsSync as existsSync85 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync83, statSync as statSync13 } from "fs";
+import { chmodSync, existsSync as existsSync84, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path83 from "path";
+import path85 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path83.join(path83.dirname(require4.resolve("node-pty")), "..");
-  const helper = path83.join(
+  const ptyRoot = path85.join(path85.dirname(require4.resolve("node-pty")), "..");
+  const helper = path85.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync83(helper)) return;
+  if (!existsSync84(helper)) return;
   const mode = statSync13(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -34004,7 +34037,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync84(cwd)) return;
+  if (!cwd || existsSync85(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -34083,12 +34116,12 @@ function serverRunMeta(runName, cwd) {
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs49 from "fs";
-import * as path84 from "path";
+import * as path86 from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 var __filename5 = fileURLToPath10(import.meta.url);
-var __dirname7 = path84.dirname(__filename5);
+var __dirname7 = path86.dirname(__filename5);
 function readDesignSystemPrompt() {
-  const promptPath = path84.join(
+  const promptPath = path86.join(
     __dirname7,
     "..",
     "claude",
@@ -34186,11 +34219,11 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync86 } from "fs";
+import { existsSync as existsSync87 } from "fs";
 import { basename as basename22 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync86 } from "fs";
 import { join as join98 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
@@ -34260,7 +34293,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync85(join98(worktreePath, ".git")))
+  if (!existsSync86(join98(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -34312,7 +34345,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync86(worktreePath)) {
+  if (!existsSync87(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -34337,7 +34370,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync86(recorded)) return recorded;
+  if (recorded && existsSync87(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -34468,12 +34501,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync87, watch } from "fs";
+import { existsSync as existsSync88, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync87(common)) return void 0;
+  if (!common || !existsSync88(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -34950,10 +34983,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync88 } from "fs";
+import { existsSync as existsSync89 } from "fs";
 import { resolve as resolve22 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync88(session.cwd))
+  if (session.cwd && !existsSync89(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -34967,7 +35000,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve22(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync88(configured)) return void 0;
+  if (existsSync89(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -35008,7 +35041,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync89, mkdirSync as mkdirSync33, watch as watch2 } from "fs";
+import { existsSync as existsSync90, mkdirSync as mkdirSync33, watch as watch2 } from "fs";
 import { dirname as dirname39 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -35070,8 +35103,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path88 = activityPath(session.id);
-  const dir = dirname39(path88);
+  const path90 = activityPath(session.id);
+  const dir = dirname39(path90);
   try {
     mkdirSync33(dir, { recursive: true });
   } catch {
@@ -35081,7 +35114,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   let timer = null;
   const read3 = () => {
     timer = null;
-    const activity2 = readActivity(path88);
+    const activity2 = readActivity(path90);
     if (!activity2) return;
     applyActivityToSession(session, activity2);
     if (activity2.claudeSessionId) onClaudeSessionId?.(session);
@@ -35090,11 +35123,11 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     notify2();
   };
   session.activityWatcher = watch2(dir, (_event, filename) => {
-    if (filename && !path88.endsWith(filename)) return;
+    if (filename && !path90.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read3, DEBOUNCE_MS2);
   });
-  if (existsSync89(path88)) read3();
+  if (existsSync90(path90)) read3();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -35237,12 +35270,12 @@ import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
 import * as fs51 from "fs";
-import * as path85 from "path";
+import * as path87 from "path";
 function projectDirForCwd(cwd) {
-  return path85.join(claudeProjectsRoot(), projectSlug(cwd));
+  return path87.join(claudeProjectsRoot(), projectSlug(cwd));
 }
 function transcriptPathFor(cwd, claudeSessionId) {
-  return path85.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+  return path87.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
@@ -35256,8 +35289,8 @@ function findTranscriptPathSync(cwd, claudeSessionId) {
   }
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
-    if (headContainsSessionId(path85.join(dir, file), claudeSessionId))
-      return path85.join(dir, file);
+    if (headContainsSessionId(path87.join(dir, file), claudeSessionId))
+      return path87.join(dir, file);
   }
   return null;
 }
@@ -36431,9 +36464,9 @@ function tempRoots() {
   }
   return [...roots];
 }
-function underTempRoot(path88) {
+function underTempRoot(path90) {
   return tempRoots().some(
-    (root) => path88.startsWith(root.endsWith(sep2) ? root : root + sep2)
+    (root) => path90.startsWith(root.endsWith(sep2) ? root : root + sep2)
   );
 }
 
@@ -36745,7 +36778,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync92 } from "fs";
+import { existsSync as existsSync93 } from "fs";
 import { basename as basename24 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -36800,18 +36833,18 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync91 } from "fs";
+import { existsSync as existsSync92 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync91(clone)) {
-    for (const { path: path88 } of paths) forgetWorktree(path88);
+  if (!existsSync92(clone)) {
+    for (const { path: path90 } of paths) forgetWorktree(path90);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
   await pruneBookkeeping2(clone);
-  for (const { path: path88, branch: branch2 } of paths)
-    if (await reclaimBranch(clone, branch2)) forgetWorktree(path88);
+  for (const { path: path90, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path90);
 }
 async function pruneBookkeeping2(clone) {
   try {
@@ -36838,37 +36871,37 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/logVanishedTree.ts
-function logVanishedTree(sessions, path88) {
+function logVanishedTree(sessions, path90) {
   const claimants = [...sessions.values()].filter(
-    (s) => s.cwd === path88 || s.worktree?.path === path88
+    (s) => s.cwd === path90 || s.worktree?.path === path90
   );
   if (claimants.length === 0) {
-    daemonLog(`worktree ${path88} gone from disk and unclaimed; reclaiming it`);
+    daemonLog(`worktree ${path90} gone from disk and unclaimed; reclaiming it`);
     return;
   }
   for (const s of claimants)
     daemonLog(
-      `session ${s.id} ("${s.name}") claims worktree ${path88}, which is gone from disk; reclaiming it`
+      `session ${s.id} ("${s.name}") claims worktree ${path90}, which is gone from disk; reclaiming it`
     );
 }
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path88, reason4) {
-  if (reason4.startsWith("uncommitted")) return await changedFiles(path88);
-  if (reason4.startsWith("unpushed")) return await unpushedCommits(path88, reason4);
+async function describeHeldWork(path90, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path90);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path90, reason4);
   return { summary: reason4, items: [] };
 }
-async function changedFiles(path88) {
-  const status3 = await gitResult(path88, ["status", "--porcelain"]);
+async function changedFiles(path90) {
+  const status3 = await gitResult(path90, ["status", "--porcelain"]);
   const lines2 = status3.ok ? nonEmptyLines(status3.out) : [];
   return {
     summary: `${lines2.length} uncommitted ${lines2.length === 1 ? "file" : "files"}`,
     items: capped(lines2)
   };
 }
-async function unpushedCommits(path88, reason4) {
-  const log2 = await gitResult(path88, ["log", "--oneline", "@{upstream}..HEAD"]);
+async function unpushedCommits(path90, reason4) {
+  const log2 = await gitResult(path90, ["log", "--oneline", "@{upstream}..HEAD"]);
   if (!log2.ok) return { summary: reason4, items: [] };
   const lines2 = nonEmptyLines(log2.out);
   return {
@@ -36960,24 +36993,24 @@ function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
 async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
-  for (const { path: path88, clone } of readWorktreeRegistry()) {
-    if (underTempRoot(path88)) {
-      forgetWorktree(path88);
+  for (const { path: path90, clone } of readWorktreeRegistry()) {
+    if (underTempRoot(path90)) {
+      forgetWorktree(path90);
       daemonLog(
-        `worktree ${path88} lies outside any project root; pruned from the registry rather than recovered`
+        `worktree ${path90} lies outside any project root; pruned from the registry rather than recovered`
       );
       continue;
     }
-    if (!existsSync92(path88)) {
-      logVanishedTree(sessions, path88);
+    if (!existsSync93(path90)) {
+      logVanishedTree(sessions, path90);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path88, branch: basename24(path88) }
+        { path: path90, branch: basename24(path90) }
       ]);
       continue;
     }
-    if (accounted.has(path88)) continue;
-    await recoverOrphan(sessions, spawnWith, { path: path88, clone }, notify2);
+    if (accounted.has(path90)) continue;
+    await recoverOrphan(sessions, spawnWith, { path: path90, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
     await reclaimVanishedWorktrees(clone, paths);
@@ -37585,14 +37618,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync93, readFileSync as readFileSync62 } from "fs";
+import { existsSync as existsSync94, readFileSync as readFileSync63 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync93(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync62(sessionsFile, "utf8"));
+    if (!existsSync94(sessionsFile)) return false;
+    const data = JSON.parse(readFileSync63(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
@@ -38326,7 +38359,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync96 } from "fs";
+import { existsSync as existsSync97 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -38357,10 +38390,10 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync95 } from "fs";
+import { existsSync as existsSync96 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync94, mkdirSync as mkdirSync35 } from "fs";
+import { copyFileSync as copyFileSync7, existsSync as existsSync95, mkdirSync as mkdirSync35 } from "fs";
 import { join as join100 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
@@ -38371,7 +38404,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   const dest = join100(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync94(dest)) {
+  if (existsSync95(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -38422,7 +38455,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync95(clone))
+  if (!clone || !existsSync96(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -38431,7 +38464,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync96(cwd))
+  if (!existsSync97(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -38698,12 +38731,12 @@ function handleSetStatus(client, m, d) {
 import * as fs54 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
-import * as path86 from "path";
+import * as path88 from "path";
 async function findCodexRolloutPath(sessionId) {
   if (!sessionId) return null;
   const paths = await discoverCodexRolloutPaths();
   const suffix = `-${sessionId}.jsonl`;
-  return paths.find((file) => path86.basename(file).endsWith(suffix)) ?? null;
+  return paths.find((file) => path88.basename(file).endsWith(suffix)) ?? null;
 }
 
 // src/commands/sessions/shared/codex/codexToolTarget.ts
@@ -39008,10 +39041,10 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync49 } from "fs";
+import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync50 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync63 } from "fs";
+import { readFileSync as readFileSync64 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -39022,7 +39055,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync63(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync64(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -39030,7 +39063,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync49(daemonPaths.pid, String(process.pid));
+  writeFileSync50(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     void manager.flushActiveMs().finally(() => {
@@ -39272,7 +39305,7 @@ function registerSetStatusCommand(cmd) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs56 from "fs";
-import chalk227 from "chalk";
+import chalk228 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs55 from "fs";
@@ -39331,22 +39364,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk227.yellow("No sessions found."));
+    console.log(chalk228.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk227.green("All sessions already summarised."));
+    console.log(chalk228.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk227.cyan(
+    chalk228.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk227.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk227.yellow(`, ${failed2} skipped`) : "")
+    chalk228.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk228.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -39366,16 +39399,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk227.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk228.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk227.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk228.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk227.yellow("skip")}
+      process.stdout.write(` ${chalk228.yellow("skip")}
 `);
     }
   }
@@ -39396,7 +39429,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk229 from "chalk";
+import chalk230 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -39406,7 +39439,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk228 from "chalk";
+import chalk229 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -39444,9 +39477,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk228.green,
-  warn: chalk228.yellow,
-  over: chalk228.red
+  ok: chalk229.green,
+  warn: chalk229.yellow,
+  over: chalk229.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -39477,7 +39510,7 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync65, statSync as statSync16 } from "fs";
+import { readFileSync as readFileSync66, statSync as statSync16 } from "fs";
 import { isAbsolute as isAbsolute5, join as join101, resolve as resolve23 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join101(cwd, ".git");
@@ -39492,7 +39525,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync65(dotGit, "utf8");
+    contents = readFileSync66(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -39510,7 +39543,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync65(join101(gitDir, "HEAD"), "utf8");
+    head = readFileSync66(join101(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -39542,7 +39575,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk229.level = 3;
+chalk230.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -39550,9 +39583,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk229.red(label2);
+      return chalk230.red(label2);
     case "yellow":
-      return chalk229.yellow(label2);
+      return chalk230.yellow(label2);
     default:
       return label2;
   }
@@ -39565,7 +39598,7 @@ async function statusLine() {
   const usedPct = data.context_window.used_percentage ?? 0;
   const dir = data.workspace?.current_dir ?? data.cwd;
   const branch2 = dir ? readGitBranch(toGitCwd(dir)) : null;
-  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk229.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk230.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -39579,7 +39612,7 @@ async function statusLine() {
 
 // src/commands/update.ts
 import { execSync as execSync61 } from "child_process";
-import * as path87 from "path";
+import * as path89 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -39598,12 +39631,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path87.resolve(dir);
-    if (resolved.split(path87.sep).includes("node_modules")) {
+    const resolved = path89.resolve(dir);
+    if (resolved.split(path89.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync61("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path87.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path89.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -39635,10 +39668,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk230 from "chalk";
+import chalk231 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk230.red(error.message));
+    console.error(chalk231.red(error.message));
   } else {
     console.error(error);
   }