@staff0rd/assist 0.595.0 → 0.596.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.595.0",
+  version: "0.596.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -187,8 +187,8 @@ function getRemoteOriginUrl(cwd) {
 }
 
 // src/commands/backlog/getCurrentOrigin.ts
-function stripLeadingSlashes(path83) {
-  return path83.replace(/^\/+/, "");
+function stripLeadingSlashes(path84) {
+  return path84.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -238,9 +238,9 @@ function findGitLink(dir) {
   }
   return null;
 }
-function isFile(path83) {
+function isFile(path84) {
   try {
-    return statSync(path83).isFile();
+    return statSync(path84).isFile();
   } catch {
     return false;
   }
@@ -259,9 +259,9 @@ function linkedGitDirParent(gitDir) {
   const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
   return match ? match[1] : null;
 }
-function readTrimmed(path83) {
+function readTrimmed(path84) {
   try {
-    const content = readFileSync(path83, "utf8").trim();
+    const content = readFileSync(path84, "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(path83) {
-  if (!existsSync2(path83)) return {};
+function loadRawYaml(path84) {
+  if (!existsSync2(path84)) return {};
   try {
-    const content = readFileSync2(path83, "utf8");
+    const content = readFileSync2(path84, "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 path83 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path83.split("/").filter(Boolean);
+    const path84 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path84.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 path83 = line.split("	")[1];
-    if (path83) found.add(path83.trim());
+    const path84 = line.split("	")[1];
+    if (path84) found.add(path84.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 path83 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path83}/${ref}`;
+  const path84 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path84}/${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, path83) {
+function build(node, path84) {
   const { inner, defaultValue, optional } = unwrapSchemaNode(node);
   const secret = isSecretSchemaNode(node) || isSecretSchemaNode(inner);
   const base = {
-    path: path83,
+    path: path84,
     ...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(path83) {
+function formatConfigPath(path84) {
   let text18 = "";
-  for (const segment of path83) {
+  for (const segment of path84) {
     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, path83) {
+function resolveStringsAtPath(data, path84) {
   let current = data;
-  for (const segment of path83.split(".")) {
+  for (const segment of path84.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -4961,10 +4961,10 @@ function resolveStringsAtPath(data, path83) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path83 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path83)) {
+  for (const path84 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path84)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path83, value });
+        violations.push({ file: rule.file, path: path84, value });
     }
   }
   return violations;
@@ -5003,8 +5003,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path83, value } of violations) {
-    console.log(`  ${file} ${path83}: ${value}`);
+  for (const { file, path: path84, value } of violations) {
+    console.log(`  ${file} ${path84}: ${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((path83) => MIGRATION_FILE3.test(basename2(path83)));
-  for (const path83 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path84) => MIGRATION_FILE3.test(basename2(path84)));
+  for (const path84 of paths) {
     try {
-      const content = execSync14(`git show "${ref}:${path83}"`, {
+      const content = execSync14(`git show "${ref}:${path84}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path83), content);
+      baseline.set(basename2(path84), content);
     } catch {
     }
   }
@@ -6761,10 +6761,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path83 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname13(path83), { recursive: true });
-  writeFileSync15(path83, JSON.stringify(hooksSettings, null, 2));
-  return path83;
+  const path84 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname13(path84), { recursive: true });
+  writeFileSync15(path84, JSON.stringify(hooksSettings, null, 2));
+  return path84;
 }
 
 // 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 path83 = join15(dir, ".assist", name);
-    if (existsSync19(path83)) {
-      renameSync(path83, `${path83}.bak`);
+    const path84 = join15(dir, ".assist", name);
+    if (existsSync19(path84)) {
+      renameSync(path84, `${path84}.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(path83) {
-  const content = readFileSync15(path83, "utf8").trim();
+function parseBacklogJsonl(path84) {
+  const content = readFileSync15(path84, "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 path83 = getOwnerPath(itemId2);
-  mkdirSync7(dirname15(path83), { recursive: true });
-  writeFileSync17(path83, JSON.stringify({ sessionId }));
+  const path84 = getOwnerPath(itemId2);
+  mkdirSync7(dirname15(path84), { recursive: true });
+  writeFileSync17(path84, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path83 = getOwnerPath(itemId2);
-  if (!existsSync23(path83)) return void 0;
+  const path84 = getOwnerPath(itemId2);
+  if (!existsSync23(path84)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync16(path83, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path84, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path83 = getOwnerPath(itemId2);
+  const path84 = getOwnerPath(itemId2);
   try {
-    rmSync(path83);
+    rmSync(path84);
   } catch {
   }
 }
@@ -8410,19 +8410,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path83 = getSignalPath(target);
-  if (!path83) return;
+  const path84 = getSignalPath(target);
+  if (!path84) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname16(path83), { recursive: true });
-  writeFileSync18(path83, JSON.stringify(signal));
+  mkdirSync8(dirname16(path84), { recursive: true });
+  writeFileSync18(path84, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path83 = getSignalPath();
-  if (!path83 || !existsSync24(path83)) return void 0;
+  const path84 = getSignalPath();
+  if (!path84 || !existsSync24(path84)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path83, "utf8"));
+    return JSON.parse(readFileSync17(path84, "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 path83 = activityPath(sessionId);
-  mkdirSync9(dirname17(path83), { recursive: true });
-  writeFileSync19(path83, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path84 = activityPath(sessionId);
+  mkdirSync9(dirname17(path84), { recursive: true });
+  writeFileSync19(path84, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path83) {
+function readActivity(path84) {
   try {
-    return JSON.parse(readFileSync18(path83, "utf8"));
+    return JSON.parse(readFileSync18(path84, "utf8"));
   } catch {
     return void 0;
   }
@@ -8635,9 +8635,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path83 = activityPath(sessionId);
-  mkdirSync9(dirname17(path83), { recursive: true });
-  writeFileSync19(path83, JSON.stringify(activity2));
+  const path84 = activityPath(sessionId);
+  mkdirSync9(dirname17(path84), { recursive: true });
+  writeFileSync19(path84, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -10090,10 +10090,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path83 = getStorePath(filename);
-  if (existsSync29(path83)) {
+  const path84 = getStorePath(filename);
+  if (existsSync29(path84)) {
     try {
-      return JSON.parse(readFileSync19(path83, "utf8"));
+      return JSON.parse(readFileSync19(path84, "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(([path83, record]) => ({ path: path83, ...record }));
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path84, record]) => ({ path: path84, ...record }));
 }
-function worktreeAttributionIncludingReaped(path83) {
-  const record = loadJson(REGISTRY_FILE)[path83];
+function worktreeAttributionIncludingReaped(path84) {
+  const record = loadJson(REGISTRY_FILE)[path84];
   return record ? { clone: record.clone, origin: record.origin } : void 0;
 }
-function recordWorktree(path83, clone, origin) {
+function recordWorktree(path84, clone, origin) {
   const data = loadJson(REGISTRY_FILE);
-  data[path83] = { clone, origin };
+  data[path84] = { clone, origin };
   saveJson(REGISTRY_FILE, data);
 }
-function forgetWorktree(path83) {
+function forgetWorktree(path84) {
   const data = loadJson(REGISTRY_FILE);
-  const record = data[path83];
+  const record = data[path84];
   if (!record || record.reaped) return;
-  data[path83] = { ...record, reaped: true };
+  data[path84] = { ...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 path83 of resolved.paths) {
-      if (!bases.has(path83)) bases.set(path83, resolved.base);
+    for (const path84 of resolved.paths) {
+      if (!bases.has(path84)) bases.set(path84, 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 [path83, base] of bases) {
+  for (const [path84, base] of bases) {
     const paths = groups.get(base);
-    if (paths) paths.push(path83);
-    else groups.set(base, [path83]);
+    if (paths) paths.push(path84);
+    else groups.set(base, [path84]);
   }
   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((path83) => path83 && !bases.has(path83)).sort();
+  return output.split("\n").filter((path84) => path84 && !bases.has(path84)).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, path83) {
-  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path83], {
+async function untrackedFileDiff(cwd, path84) {
+  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path84], {
     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((path83) => untrackedFileDiff(cwd, path83))
+    paths.map((path84) => untrackedFileDiff(cwd, path84))
   );
   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, path83) {
+function resolveWithinCwd(cwd, path84) {
   const root = repoRoot(cwd);
-  const target = resolve10(root, path83);
+  const target = resolve10(root, path84);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
@@ -11034,14 +11034,14 @@ function resolveWithinCwd(cwd, path83) {
 function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return null;
-  const path83 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+  const path84 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
-  if (!path83) {
+  if (!path84) {
     respondJson(res, 400, { error: "Missing path" });
     return null;
   }
-  const target = resolveWithinCwd(cwd, path83);
+  const target = resolveWithinCwd(cwd, path84);
   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(path83) {
-  if (path83 === getGlobalConfigPath()) return "~/.assist.yml";
-  if (path83.startsWith(WINDOWS_MOUNT_PREFIX))
-    return `${path83} on the Windows host`;
-  return path83;
+function globalConfigFileLabel(path84) {
+  if (path84 === getGlobalConfigPath()) return "~/.assist.yml";
+  if (path84.startsWith(WINDOWS_MOUNT_PREFIX))
+    return `${path84} on the Windows host`;
+  return path84;
 }
 
 // src/commands/config/readRawConfigLayers.ts
@@ -11177,35 +11177,35 @@ function isPlainRecord(value) {
 }
 
 // src/shared/mapConfigSecrets.ts
-function mapChildren(value, path83, childNode, map) {
+function mapChildren(value, path84, childNode, map) {
   if (!isPlainRecord(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([name, child]) => [
       name,
-      walk(child, [...path83, name], childNode(name), map)
+      walk(child, [...path84, name], childNode(name), map)
     ])
   );
 }
-function mapItems(value, path83, item, map) {
+function mapItems(value, path84, item, map) {
   if (!Array.isArray(value)) return value;
-  return value.map((entry, index3) => walk(entry, [...path83, index3], item, map));
+  return value.map((entry, index3) => walk(entry, [...path84, index3], item, map));
 }
-function walk(value, path83, node, map) {
+function walk(value, path84, node, map) {
   if (!node || value === void 0 || value === null) return value;
-  if (node.secret) return map(value, path83);
+  if (node.secret) return map(value, path84);
   switch (node.kind) {
     case "object":
     case "unionOfObjects":
       return mapChildren(
         value,
-        path83,
+        path84,
         (name) => configNodeField(node, name),
         map
       );
     case "objectList":
-      return mapItems(value, path83, node.item, map);
+      return mapItems(value, path84, node.item, map);
     case "record":
-      return mapChildren(value, path83, () => node.value, map);
+      return mapChildren(value, path84, () => 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, path83) {
+function getNestedValue(obj, path84) {
   let current = obj;
-  for (const key of path83.split(".")) current = stepInto(current, key);
+  for (const key of path84.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -11282,9 +11282,9 @@ function step(node, segment) {
       return void 0;
   }
 }
-function findConfigNode(root, path83) {
+function findConfigNode(root, path84) {
   let current = root;
-  for (const segment of path83) {
+  for (const segment of path84) {
     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 path83 = [];
+  const path84 = [];
   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;
-      path83.push(segment);
+      path84.push(segment);
       at2 = close + 1;
       continue;
     }
     if (text18[at2] === ".") {
-      if (path83.length === 0) return void 0;
+      if (path84.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;
-    path83.push(nameSegment(name));
+    path84.push(nameSegment(name));
   }
-  return path83;
+  return path84;
 }
 
 // src/commands/config/configEntryNode.ts
 function configEntryNode(root, key) {
-  const path83 = parseConfigPath(key);
-  return path83 ? findConfigNode(root, path83) : void 0;
+  const path84 = parseConfigPath(key);
+  return path84 ? findConfigNode(root, path84) : 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((path83) => existsSync32(path83)).map((path83) => ({ path: path83, mtime: statSync4(path83).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((path84) => existsSync32(path84)).map((path84) => ({ path: path84, mtime: statSync4(path84).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 path83 = await resolveSynthesisPath(cwd);
-    if (!path83) {
+    const path84 = await resolveSynthesisPath(cwd);
+    if (!path84) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync21(path83, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path84, "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 path83 = fields[fields.length - 1];
-    if (path83) result[category].push(path83);
+    const path84 = fields[fields.length - 1];
+    if (path84) result[category].push(path84);
   }
   return result;
 }
@@ -11718,21 +11718,21 @@ function subsequenceScore(text18, query) {
   }
   return score - Math.min(text18.length, MAX_LENGTH_PENALTY);
 }
-function scoreFilePath(path83, query) {
+function scoreFilePath(path84, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename26 = path83.slice(path83.lastIndexOf("/") + 1);
+  const basename26 = path84.slice(path84.lastIndexOf("/") + 1);
   const inBasename = subsequenceScore(basename26, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
-  return subsequenceScore(path83, needle);
+  return subsequenceScore(path84, needle);
 }
 
 // src/commands/sessions/web/rankFilePaths.ts
 function rankFilePaths(paths, query, limit) {
   const scored = [];
-  for (const path83 of paths) {
-    const score = scoreFilePath(path83, query);
-    if (score !== null) scored.push({ path: path83, score });
+  for (const path84 of paths) {
+    const score = scoreFilePath(path84, query);
+    if (score !== null) scored.push({ path: path84, score });
   }
   scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
   return scored.slice(0, limit).map((entry) => entry.path);
@@ -11890,6 +11890,91 @@ async function listNewsItems(_req, res) {
   respondJson(res, 200, cachedItems);
 }
 
+// src/commands/sessions/web/listScopedRules.ts
+import path32 from "path";
+
+// src/commands/rules/readScopedRules.ts
+import { existsSync as existsSync34, readFileSync as readFileSync22 } from "fs";
+import path31 from "path";
+
+// src/commands/rules/parseRulesSection.ts
+var RULES_HEADING = /^##\s+rules\s*$/i;
+var SECTION_END = /^#{1,2}\s/;
+var RULE_BULLET = /^\s*[-*]\s+\*\*\s*([^*]+?)\s*\*\*\s*(?:[—–:-]\s*)?(.*)$/;
+function parseRulesSection(content) {
+  const lines2 = content.split(/\r?\n/);
+  const start3 = lines2.findIndex((line) => RULES_HEADING.test(line));
+  if (start3 === -1) return [];
+  const rules3 = [];
+  for (const line of lines2.slice(start3 + 1)) {
+    if (SECTION_END.test(line)) break;
+    const match = RULE_BULLET.exec(line);
+    if (!match) continue;
+    const code = match[1].trim();
+    const text18 = match[2].trim();
+    if (code === "" || text18 === "") continue;
+    rules3.push({ code, text: text18 });
+  }
+  return rules3;
+}
+
+// src/commands/rules/scopeDirectory.ts
+import { existsSync as existsSync33, statSync as statSync5 } from "fs";
+import path30 from "path";
+function scopeDirectory(target) {
+  const resolved = path30.resolve(target);
+  return existsSync33(resolved) && statSync5(resolved).isDirectory() ? resolved : path30.dirname(resolved);
+}
+
+// src/commands/rules/readScopedRules.ts
+function scopedClaudeFiles(target) {
+  const startDir = scopeDirectory(target);
+  const root = findRepoRoot(startDir) ?? startDir;
+  const files = [];
+  let current = startDir;
+  while (true) {
+    const candidate = path31.join(current, "CLAUDE.md");
+    if (existsSync34(candidate)) files.push(candidate);
+    if (current === root || current === path31.dirname(current)) break;
+    current = path31.dirname(current);
+  }
+  return files;
+}
+function readScopedRules(target) {
+  return scopedClaudeFiles(target).flatMap(
+    (source) => parseRulesSection(readFileSync22(source, "utf8")).map((rule) => ({
+      ...rule,
+      source
+    }))
+  );
+}
+
+// src/commands/sessions/web/listScopedRules.ts
+function listScopedRules(req, res) {
+  const cwd = getCwdParam(req, res);
+  if (!cwd) return;
+  const requested = new URL(
+    req.url ?? "/",
+    "http://localhost"
+  ).searchParams.get("path");
+  const root = repoRoot(cwd);
+  const target = requested ? resolveWithinCwd(cwd, requested) : root;
+  if (!target) {
+    respondJson(res, 400, { error: "Path outside cwd" });
+    return;
+  }
+  try {
+    respondJson(res, 200, {
+      rules: readScopedRules(target).map((rule) => ({
+        ...rule,
+        source: path32.relative(root, rule.source) || rule.source
+      }))
+    });
+  } catch {
+    respondJson(res, 500, { error: "Failed to read rules" });
+  }
+}
+
 // src/shared/db/countUsagePeaks.ts
 import { count, eq as eq18 } from "drizzle-orm";
 async function countUsagePeaks(db, window) {
@@ -12197,38 +12282,38 @@ async function restartWeb(req, res, deps2 = {}) {
 import { relative as relative3 } from "path";
 
 // src/commands/sessions/web/revertPathChanges.ts
-async function isTracked(cwd, path83) {
+async function isTracked(cwd, path84) {
   try {
-    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path83]);
+    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path84]);
     return true;
   } catch {
     return false;
   }
 }
-async function isInHead(cwd, path83) {
-  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path83]);
+async function isInHead(cwd, path84) {
+  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path84]);
   return listing.trim().length > 0;
 }
-async function revertPathChanges(cwd, path83) {
-  if (!await isTracked(cwd, path83)) {
-    await execGit(cwd, ["clean", "-f", "--", path83]);
+async function revertPathChanges(cwd, path84) {
+  if (!await isTracked(cwd, path84)) {
+    await execGit(cwd, ["clean", "-f", "--", path84]);
     return;
   }
-  if (await isInHead(cwd, path83)) {
-    await execGit(cwd, ["checkout", "HEAD", "--", path83]);
+  if (await isInHead(cwd, path84)) {
+    await execGit(cwd, ["checkout", "HEAD", "--", path84]);
     return;
   }
-  await execGit(cwd, ["rm", "-f", "--", path83]);
+  await execGit(cwd, ["rm", "-f", "--", path84]);
 }
 
 // src/commands/sessions/web/revertDiffFile.ts
 async function revertDiffFile(req, res) {
   const resolved = getFileTarget(req, res);
   if (!resolved) return;
-  const path83 = relative3(repoRoot(resolved.cwd), resolved.target);
+  const path84 = relative3(repoRoot(resolved.cwd), resolved.target);
   try {
-    await revertPathChanges(resolved.cwd, path83);
-    respondJson(res, 200, { reverted: path83 });
+    await revertPathChanges(resolved.cwd, path84);
+    respondJson(res, 200, { reverted: path84 });
   } catch (error) {
     respondJson(res, 500, {
       error: error instanceof Error ? error.message : "Failed to revert file"
@@ -12250,7 +12335,7 @@ async function readJsonBody(req) {
 function requestedPaths(body) {
   const paths = body.paths;
   if (!Array.isArray(paths)) return null;
-  if (paths.some((path83) => typeof path83 !== "string")) return null;
+  if (paths.some((path84) => typeof path84 !== "string")) return null;
   return paths;
 }
 async function revertDiffPaths(req, res) {
@@ -12270,10 +12355,10 @@ async function revertDiffPaths(req, res) {
   const root = repoRoot(cwd);
   const reverted = [];
   const failed2 = [];
-  for (const path83 of paths) {
-    const target = resolveWithinCwd(cwd, path83);
+  for (const path84 of paths) {
+    const target = resolveWithinCwd(cwd, path84);
     if (!target) {
-      failed2.push({ path: path83, error: "Path outside cwd" });
+      failed2.push({ path: path84, error: "Path outside cwd" });
       continue;
     }
     const relativePath = relative4(root, target);
@@ -12363,11 +12448,11 @@ function coerceStructuredConfigValue(key, raw) {
   };
 }
 function formatIssue(key, issue) {
-  const path83 = formatConfigPath([
+  const path84 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
   ]);
-  return `${path83}: ${issue.message}`;
+  return `${path84}: ${issue.message}`;
 }
 function toSegment(part) {
   return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
@@ -12462,9 +12547,9 @@ function coerceUnion(key, raw, types) {
 }
 
 // src/shared/valueAtConfigPath.ts
-function valueAtConfigPath(value, path83) {
+function valueAtConfigPath(value, path84) {
   let current = value;
-  for (const key of path83) {
+  for (const key of path84) {
     if (typeof key === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[key];
@@ -12481,7 +12566,7 @@ function restoreConfigSecrets(value, stored, node) {
   return mapConfigSecrets(
     value,
     node,
-    (secret, path83) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path83) : secret
+    (secret, path84) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path84) : secret
   );
 }
 
@@ -12530,8 +12615,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path83, value) {
-  const keys = path83.split(".");
+function setNestedValue(obj, path84, value) {
+  const keys = path84.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -12558,8 +12643,8 @@ function formatIssue2(issue, key) {
     return issue.keys.map(
       (unrecognized) => `${[...issue.path, unrecognized].join(".")}: Unrecognized key`
     );
-  const path83 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return [`${path83}: ${issue.message}`];
+  const path84 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return [`${path84}: ${issue.message}`];
 }
 
 // src/commands/config/applyConfigSet.ts
@@ -12816,8 +12901,8 @@ function removeAt(container, keys) {
   }
   return removeFromChild(container, key, rest);
 }
-function unsetNestedValue(obj, path83) {
-  const { container, removed } = removeAt(obj, path83.split("."));
+function unsetNestedValue(obj, path84) {
+  const { container, removed } = removeAt(obj, path84.split("."));
   return { config: container, removed };
 }
 
@@ -13038,7 +13123,7 @@ import { readFile as readFile2, stat as stat3, writeFile as writeFile3 } from "f
 
 // src/commands/sessions/web/formatWithOxfmt.ts
 import { execFile as execFile8 } from "child_process";
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync35 } from "fs";
 import { dirname as dirname22, join as join32 } from "path";
 import { promisify as promisify8 } from "util";
 var execFileAsync7 = promisify8(execFile8);
@@ -13047,7 +13132,7 @@ function findOxfmtScript(root) {
   let dir = root;
   for (; ; ) {
     const candidate = join32(dir, "node_modules", "oxfmt", "bin", "oxfmt");
-    if (existsSync33(candidate)) return candidate;
+    if (existsSync35(candidate)) return candidate;
     const parent = dirname22(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -13118,7 +13203,7 @@ async function writeFileContent(req, res) {
 
 // src/commands/sessions/web/createCssHandler.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 import { createRequire as createRequire2 } from "module";
 var require3 = createRequire2(import.meta.url);
 function createCssHandler(packageEntry) {
@@ -13126,7 +13211,7 @@ function createCssHandler(packageEntry) {
   return (req, res) => {
     if (!cache5) {
       const resolved = require3.resolve(packageEntry);
-      const body = readFileSync22(resolved, "utf8");
+      const body = readFileSync23(resolved, "utf8");
       const etag = `"${createHash2("sha256").update(body).digest("hex").slice(0, 16)}"`;
       cache5 = { body, etag };
     }
@@ -13182,6 +13267,7 @@ var routes2 = {
   "GET /api/file": fileContent,
   "POST /api/file": writeFileContent,
   "GET /api/files": listFiles,
+  "GET /api/rules": listScopedRules,
   "GET /api/jira-site": jiraSite,
   "GET /api/harness": harnessCapabilities,
   "GET /api/session-layout": sessionLayout,
@@ -13588,13 +13674,13 @@ import chalk64 from "chalk";
 
 // src/commands/sessions/shared/resolveSessionTranscript.ts
 import * as fs22 from "fs";
-import * as path31 from "path";
+import * as path34 from "path";
 
 // src/commands/sessions/shared/claudeProjectsRoot.ts
 import * as os4 from "os";
-import * as path30 from "path";
+import * as path33 from "path";
 function claudeProjectsRoot() {
-  return path30.join(os4.homedir(), ".claude", "projects");
+  return path33.join(os4.homedir(), ".claude", "projects");
 }
 function projectSlug(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
@@ -13617,7 +13703,7 @@ function findTranscriptFile(sessionId, projectsRoot) {
     return void 0;
   }
   for (const dir of projectDirs) {
-    const candidate = path31.join(projectsRoot, dir, `${sessionId}.jsonl`);
+    const candidate = path34.join(projectsRoot, dir, `${sessionId}.jsonl`);
     if (fs22.existsSync(candidate)) return candidate;
   }
   return void 0;
@@ -13669,12 +13755,12 @@ import chalk65 from "chalk";
 
 // src/commands/sessions/shared/resolveCurrentSessionId.ts
 import * as fs23 from "fs";
-import * as path32 from "path";
+import * as path35 from "path";
 var SESSION_ID_ENV = "CLAUDE_CODE_SESSION_ID";
 function resolveCurrentSessionId(options2 = {}) {
   const fromEnv = (options2.env ?? process.env)[SESSION_ID_ENV];
   if (fromEnv) return fromEnv;
-  const dir = path32.join(
+  const dir = path35.join(
     options2.projectsRoot ?? claudeProjectsRoot(),
     projectSlug(options2.cwd ?? process.cwd())
   );
@@ -13690,10 +13776,10 @@ function newestTranscriptId(dir) {
   let newest;
   for (const entry of entries) {
     if (!entry.endsWith(".jsonl")) continue;
-    const modifiedAt = modifiedAtOf(path32.join(dir, entry));
+    const modifiedAt = modifiedAtOf(path35.join(dir, entry));
     if (modifiedAt === void 0) continue;
     if (!newest || modifiedAt > newest.modifiedAt)
-      newest = { id: path32.basename(entry, ".jsonl"), modifiedAt };
+      newest = { id: path35.basename(entry, ".jsonl"), modifiedAt };
   }
   return newest?.id;
 }
@@ -13920,7 +14006,7 @@ function registerAssociateJiraCommand(cmd) {
 
 // src/commands/backlog/cloneRepo.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync35 } from "fs";
+import { existsSync as existsSync37 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
 import chalk70 from "chalk";
 
@@ -13930,9 +14016,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path83 = origin.slice(firstSlash + 1);
-  if (!path83) return null;
-  return `git@${host}:${path83}.git`;
+  const path84 = origin.slice(firstSlash + 1);
+  if (!path84) return null;
+  return `git@${host}:${path84}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -13956,7 +14042,7 @@ async function cloneRepo(originRaw) {
   if (!target) {
     return fail2(`Could not derive a repository name from "${origin}".`);
   }
-  if (existsSync35(target)) {
+  if (existsSync37(target)) {
     return fail2(`Clone target already exists: ${target}`);
   }
   await mkdir3(baseDir, { recursive: true });
@@ -14507,7 +14593,7 @@ function ensureRemoteOrigin() {
 
 // src/commands/backlog/add/shared.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync23, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync24, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join36 } from "path";
 import enquirer6 from "enquirer";
@@ -14557,7 +14643,7 @@ function openEditor() {
     unlinkSync6(filePath);
     return void 0;
   }
-  const content = readFileSync23(filePath, "utf8").trim();
+  const content = readFileSync24(filePath, "utf8").trim();
   unlinkSync6(filePath);
   return content || void 0;
 }
@@ -14733,7 +14819,7 @@ async function list2(options2) {
 import chalk83 from "chalk";
 
 // src/commands/backlog/readJsonPayload.ts
-import { readFileSync as readFileSync24 } from "fs";
+import { readFileSync as readFileSync25 } from "fs";
 import chalk81 from "chalk";
 function fail3(message3) {
   console.error(chalk81.red(message3));
@@ -14745,7 +14831,7 @@ function describe(error) {
 async function readSource(source) {
   try {
     if (source === "-") return (await readStdinBuffer()).toString("utf8");
-    return readFileSync24(source, "utf8");
+    return readFileSync25(source, "utf8");
   } catch (error) {
     return fail3(
       `Cannot read the payload from ${source === "-" ? "stdin" : source}: ${describe(error)}`
@@ -16952,7 +17038,7 @@ function extractGraphqlQuery(args) {
 }
 
 // src/shared/loadCliReads.ts
-import { existsSync as existsSync36, readFileSync as readFileSync25, writeFileSync as writeFileSync22 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync26, writeFileSync as writeFileSync22 } from "fs";
 import { dirname as dirname23, resolve as resolve12 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
@@ -16960,9 +17046,9 @@ var __dirname4 = dirname23(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path83) {
-  if (!existsSync36(path83)) return [];
-  return readFileSync25(path83, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path84) {
+  if (!existsSync38(path84)) return [];
+  return readFileSync26(path84, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -17008,7 +17094,7 @@ function findCliWrite(command) {
 }
 
 // src/shared/readSettingsPerms.ts
-import { existsSync as existsSync37, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync27 } from "fs";
 import { homedir as homedir15 } from "os";
 import { join as join37 } from "path";
 function readSettingsPerms(key) {
@@ -17024,9 +17110,9 @@ function readSettingsPerms(key) {
   return entries;
 }
 function readPermissionArray(filePath, key) {
-  if (!existsSync37(filePath)) return [];
+  if (!existsSync39(filePath)) return [];
   try {
-    const data = JSON.parse(readFileSync26(filePath, "utf8"));
+    const data = JSON.parse(readFileSync27(filePath, "utf8"));
     const arr = data?.permissions?.[key];
     return Array.isArray(arr) ? arr.filter((e) => typeof e === "string") : [];
   } catch {
@@ -17370,7 +17456,7 @@ ${reasons.join("\n")}`);
 }
 
 // src/commands/permitCliReads/index.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync13, readFileSync as readFileSync27, writeFileSync as writeFileSync23 } from "fs";
+import { existsSync as existsSync40, mkdirSync as mkdirSync13, readFileSync as readFileSync28, writeFileSync as writeFileSync23 } from "fs";
 import { homedir as homedir17 } from "os";
 import { join as join39 } from "path";
 
@@ -17483,14 +17569,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, path83, description, depth, p) {
-  showProgress(p, path83.join(" "));
-  const subHelp = await runHelp([cli, ...path83]);
+async function resolveCommand(cli, path84, description, depth, p) {
+  showProgress(p, path84.join(" "));
+  const subHelp = await runHelp([cli, ...path84]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path83, description }];
+    return [{ path: path84, description }];
   }
-  const children = await discoverAt(cli, path83, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path83, description }];
+  const children = await discoverAt(cli, path84, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path84, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -17638,9 +17724,9 @@ function logPath(cli) {
   return join39(homedir17(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path83 = logPath(cli);
-  if (!existsSync38(path83)) return void 0;
-  return readFileSync27(path83, "utf8");
+  const path84 = logPath(cli);
+  if (!existsSync40(path84)) return void 0;
+  return readFileSync28(path84, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join39(homedir17(), ".assist");
@@ -17774,7 +17860,7 @@ function registerCliHook(program2) {
 }
 
 // src/commands/codeComment/codeCommentConfirm.ts
-import { existsSync as existsSync40, readFileSync as readFileSync29, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync30, unlinkSync as unlinkSync8, writeFileSync as writeFileSync24 } from "fs";
 import chalk122 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
@@ -17788,7 +17874,7 @@ function getPinStatePath(pin) {
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
-import { readdirSync as readdirSync5, statSync as statSync6, unlinkSync as unlinkSync7 } from "fs";
+import { readdirSync as readdirSync5, statSync as statSync7, unlinkSync as unlinkSync7 } from "fs";
 import { join as join41 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
@@ -17800,9 +17886,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path83 = join41(dir, entry);
+    const path84 = join41(dir, entry);
     try {
-      if (statSync6(path83).mtimeMs < cutoff) unlinkSync7(path83);
+      if (statSync7(path84).mtimeMs < cutoff) unlinkSync7(path84);
     } catch {
       continue;
     }
@@ -17810,12 +17896,12 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 }
 
 // src/commands/codeComment/readPinState.ts
-import { existsSync as existsSync39, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync29 } from "fs";
 function readPinState(pin) {
-  const path83 = getPinStatePath(pin);
-  if (!existsSync39(path83)) return void 0;
+  const path84 = getPinStatePath(pin);
+  if (!existsSync41(path84)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path83, "utf8"));
+    const state = JSON.parse(readFileSync29(path84, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -17832,12 +17918,12 @@ function codeCommentConfirm(pin) {
     process.exitCode = 1;
     return;
   }
-  if (!existsSync40(state.file)) {
+  if (!existsSync42(state.file)) {
     console.error(chalk122.red(`Target file no longer exists: ${state.file}`));
     process.exitCode = 1;
     return;
   }
-  const original = readFileSync29(state.file, "utf8");
+  const original = readFileSync30(state.file, "utf8");
   const lines2 = original.split("\n");
   const index3 = state.line - 1;
   if (index3 > lines2.length) {
@@ -18051,13 +18137,13 @@ import chalk125 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs25 from "fs";
-import path34 from "path";
+import path37 from "path";
 import chalk124 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
 import fs24 from "fs";
-import path33 from "path";
+import path36 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
   const { complexity } = loadConfig();
@@ -18071,7 +18157,7 @@ function walk2(dir, results) {
   const extensions = [".ts", ".tsx"];
   const entries = fs24.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path33.join(dir, entry.name);
+    const fullPath = path36.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name !== "node_modules" && entry.name !== ".git") {
         walk2(fullPath, results);
@@ -18293,7 +18379,7 @@ function countSloc(content) {
 function createSourceFromFile(filePath) {
   const content = fs25.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
-    path34.basename(filePath),
+    path37.basename(filePath),
     content,
     ts5.ScriptTarget.Latest,
     true,
@@ -18455,12 +18541,12 @@ function formatResultLine(entry, failing) {
 
 // src/commands/complexity/maintainability/getMaintainabilityGitState.ts
 import { execSync as execSync35 } from "child_process";
-import path35 from "path";
+import path38 from "path";
 function git3(command) {
   return execSync35(command, { encoding: "utf8" });
 }
 function toAbsolute(root, repoRelative) {
-  return path35.resolve(root, repoRelative);
+  return path38.resolve(root, repoRelative);
 }
 function collectShrunkFiles(root) {
   const shrunk = /* @__PURE__ */ new Set();
@@ -18500,7 +18586,7 @@ function getMaintainabilityGitState() {
 }
 
 // src/commands/complexity/maintainability/printMaintainabilityFailure.ts
-import path36 from "path";
+import path39 from "path";
 import chalk128 from "chalk";
 var extractTemplate = "assist refactor extract <file> <functionName> <destination> --apply";
 function remediationLine(entry) {
@@ -18509,7 +18595,7 @@ function remediationLine(entry) {
     ${chalk128.cyan(extractTemplate)}`;
 }
 function cheatLine(entry, gitState) {
-  const shrank = gitState.shrunkFiles.has(path36.resolve(entry.file));
+  const shrank = gitState.shrunkFiles.has(path39.resolve(entry.file));
   if (!shrank || gitState.newFileCreated) return "";
   return `
     ${chalk128.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
@@ -18923,7 +19009,7 @@ import { cp } from "fs/promises";
 import chalk139 from "chalk";
 
 // src/commands/criteriaExtension/criteriaExtensionDir.ts
-import { existsSync as existsSync41 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import { dirname as dirname24, join as join42 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var moduleDir = dirname24(fileURLToPath6(import.meta.url));
@@ -18934,7 +19020,7 @@ function criteriaExtensionDir() {
     "criteriaExtension",
     "criteria-extension"
   );
-  if (existsSync41(bundled)) return bundled;
+  if (existsSync43(bundled)) return bundled;
   return join42(moduleDir, "..", "..", "..", "criteria-extension");
 }
 
@@ -18954,11 +19040,11 @@ async function loadPath(source) {
   }
 }
 async function criteriaExtension() {
-  const path83 = await loadPath(criteriaExtensionDir());
+  const path84 = await loadPath(criteriaExtensionDir());
   console.log(
     chalk139.bold("acceptance criteria outliner \u2014 GitHub browser extension")
   );
-  console.log(chalk139.dim(`load the unpacked extension from ${path83}`));
+  console.log(chalk139.dim(`load the unpacked extension from ${path84}`));
 }
 
 // src/commands/registerCriteriaExtension.ts
@@ -19049,12 +19135,12 @@ function getMigrationApprovalPath(migrationId) {
 }
 
 // src/commands/dbMigration/readMigrationPinState.ts
-import { existsSync as existsSync42, readFileSync as readFileSync30 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync31 } from "fs";
 function readMigrationPinState(pin) {
-  const path83 = getMigrationPinPath(pin);
-  if (!existsSync42(path83)) return void 0;
+  const path84 = getMigrationPinPath(pin);
+  if (!existsSync44(path84)) return void 0;
   try {
-    const state = JSON.parse(readFileSync30(path83, "utf8"));
+    const state = JSON.parse(readFileSync31(path84, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -19141,7 +19227,7 @@ function registerDbMigration(parent) {
 }
 
 // src/commands/deploy/redirect.ts
-import { existsSync as existsSync43, readFileSync as readFileSync31, writeFileSync as writeFileSync28 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync32, writeFileSync as writeFileSync28 } from "fs";
 import chalk143 from "chalk";
 var TRAILING_SLASH_SCRIPT = `    <script>
       if (!window.location.pathname.endsWith('/')) {
@@ -19150,11 +19236,11 @@ var TRAILING_SLASH_SCRIPT = `    <script>
     </script>`;
 function redirect() {
   const indexPath = "index.html";
-  if (!existsSync43(indexPath)) {
+  if (!existsSync45(indexPath)) {
     console.log(chalk143.yellow("No index.html found"));
     return;
   }
-  const content = readFileSync31(indexPath, "utf8");
+  const content = readFileSync32(indexPath, "utf8");
   if (content.includes("window.location.pathname.endsWith('/')")) {
     console.log(chalk143.dim("Trailing slash script already present"));
     return;
@@ -19197,7 +19283,7 @@ import { execSync as execSync36 } from "child_process";
 import chalk144 from "chalk";
 
 // src/shared/getRepoName.ts
-import { existsSync as existsSync44, readFileSync as readFileSync32 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync33 } from "fs";
 import { basename as basename12, join as join45 } from "path";
 function getRepoName() {
   const config = loadConfig();
@@ -19205,9 +19291,9 @@ function getRepoName() {
     return config.devlog.name;
   }
   const packageJsonPath = join45(process.cwd(), "package.json");
-  if (existsSync44(packageJsonPath)) {
+  if (existsSync46(packageJsonPath)) {
     try {
-      const content = readFileSync32(packageJsonPath, "utf8");
+      const content = readFileSync33(packageJsonPath, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name) {
         return pkg.name;
@@ -19219,7 +19305,7 @@ function getRepoName() {
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync33 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync34 } from "fs";
 import { join as join46 } from "path";
 var DEVLOG_DIR = join46(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
@@ -19249,7 +19335,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync6(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync33(join46(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync34(join46(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -19762,11 +19848,11 @@ async function checkBuildLocksCommand() {
 }
 
 // src/commands/dotnet/buildTree.ts
-import { readFileSync as readFileSync34 } from "fs";
-import path37 from "path";
+import { readFileSync as readFileSync35 } from "fs";
+import path40 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
-  const content = readFileSync34(csprojPath, "utf8");
+  const content = readFileSync35(csprojPath, "utf8");
   const refs = [];
   for (const match of content.matchAll(PROJECT_REF_RE)) {
     refs.push(match[1].replace(/\\/g, "/"));
@@ -19774,16 +19860,16 @@ function getProjectRefs(csprojPath) {
   return refs;
 }
 function buildTree(csprojPath, repoRoot2, visited = /* @__PURE__ */ new Set()) {
-  const abs = path37.resolve(csprojPath);
-  const rel = path37.relative(repoRoot2, abs);
+  const abs = path40.resolve(csprojPath);
+  const rel = path40.relative(repoRoot2, abs);
   const node = { path: abs, relativePath: rel, children: [] };
   if (visited.has(abs)) return node;
   visited.add(abs);
-  const dir = path37.dirname(abs);
+  const dir = path40.dirname(abs);
   for (const ref of getProjectRefs(abs)) {
-    const childAbs = path37.resolve(dir, ref);
+    const childAbs = path40.resolve(dir, ref);
     try {
-      readFileSync34(childAbs);
+      readFileSync35(childAbs);
       node.children.push(buildTree(childAbs, repoRoot2, visited));
     } catch {
       node.children.push({
@@ -19808,8 +19894,8 @@ function collectAllDeps(node) {
 }
 
 // src/commands/dotnet/findContainingSolutions.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync35, statSync as statSync7 } from "fs";
-import path38 from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync36, statSync as statSync8 } from "fs";
+import path41 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
@@ -19822,9 +19908,9 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules" || entry === "packages")
       continue;
-    const full = path38.join(dir, entry);
+    const full = path41.join(dir, entry);
     try {
-      const stat4 = statSync7(full);
+      const stat4 = statSync8(full);
       if (stat4.isFile() && entry.endsWith(".sln")) {
         results.push(full);
       } else if (stat4.isDirectory()) {
@@ -19836,16 +19922,16 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   return results;
 }
 function findContainingSolutions(csprojPath, repoRoot2) {
-  const csprojAbs = path38.resolve(csprojPath);
-  const csprojBasename = path38.basename(csprojAbs);
+  const csprojAbs = path41.resolve(csprojPath);
+  const csprojBasename = path41.basename(csprojAbs);
   const slnFiles = findSlnFiles(repoRoot2, 3);
   const matches = [];
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
   for (const sln of slnFiles) {
     try {
-      const content = readFileSync35(sln, "utf8");
+      const content = readFileSync36(sln, "utf8");
       if (pattern2.test(content)) {
-        matches.push(path38.relative(repoRoot2, sln));
+        matches.push(path41.relative(repoRoot2, sln));
       }
     } catch {
     }
@@ -19907,16 +19993,16 @@ function printJson(tree, totalCount, solutions) {
 }
 
 // src/commands/dotnet/resolveCsproj.ts
-import { existsSync as existsSync45 } from "fs";
-import path39 from "path";
+import { existsSync as existsSync47 } from "fs";
+import path42 from "path";
 import chalk153 from "chalk";
 function resolveCsproj(csprojPath) {
-  const resolved = path39.resolve(csprojPath);
-  if (!existsSync45(resolved)) {
+  const resolved = path42.resolve(csprojPath);
+  if (!existsSync47(resolved)) {
     console.error(chalk153.red(`File not found: ${resolved}`));
     process.exit(1);
   }
-  const repoRoot2 = findRepoRoot(path39.dirname(resolved));
+  const repoRoot2 = findRepoRoot(path42.dirname(resolved));
   if (!repoRoot2) {
     console.error(chalk153.red("Could not find git repository root"));
     process.exit(1);
@@ -20080,8 +20166,8 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 }
 
 // src/commands/dotnet/resolveSolution.ts
-import { existsSync as existsSync46 } from "fs";
-import path40 from "path";
+import { existsSync as existsSync48 } from "fs";
+import path43 from "path";
 import chalk157 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
@@ -20120,8 +20206,8 @@ function findSolution() {
 // src/commands/dotnet/resolveSolution.ts
 function resolveSolution(sln) {
   if (sln) {
-    const resolved = path40.resolve(sln);
-    if (!existsSync46(resolved)) {
+    const resolved = path43.resolve(sln);
+    if (!existsSync48(resolved)) {
       console.error(chalk157.red(`Solution file not found: ${resolved}`));
       process.exit(1);
     }
@@ -20161,9 +20247,9 @@ function parseInspectReport(json) {
 
 // src/commands/dotnet/runInspectCode.ts
 import { execSync as execSync40 } from "child_process";
-import { existsSync as existsSync47, readFileSync as readFileSync36, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync49, readFileSync as readFileSync37, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import path41 from "path";
+import path44 from "path";
 import chalk158 from "chalk";
 function assertJbInstalled() {
   try {
@@ -20177,7 +20263,7 @@ function assertJbInstalled() {
   }
 }
 function runInspectCode(slnPath, include, swea) {
-  const reportPath = path41.join(tmpdir4(), `inspect-${Date.now()}.xml`);
+  const reportPath = path44.join(tmpdir4(), `inspect-${Date.now()}.xml`);
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
@@ -20192,11 +20278,11 @@ function runInspectCode(slnPath, include, swea) {
     console.error(chalk158.red("jb inspectcode failed"));
     process.exit(1);
   }
-  if (!existsSync47(reportPath)) {
+  if (!existsSync49(reportPath)) {
     console.error(chalk158.red("Report file not generated"));
     process.exit(1);
   }
-  const xml = readFileSync36(reportPath, "utf8");
+  const xml = readFileSync37(reportPath, "utf8");
   unlinkSync10(reportPath);
   return xml;
 }
@@ -20481,13 +20567,13 @@ function decideCommentGuard(input, existingContent) {
 }
 
 // src/commands/dbMigration/consumeMigrationApproval.ts
-import { existsSync as existsSync48, unlinkSync as unlinkSync11 } from "fs";
+import { existsSync as existsSync50, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path83 = getMigrationApprovalPath(migrationId);
-  if (!existsSync48(path83)) return false;
+  const path84 = getMigrationApprovalPath(migrationId);
+  if (!existsSync50(path84)) return false;
   try {
-    unlinkSync11(path83);
+    unlinkSync11(path84);
     return true;
   } catch {
     return false;
@@ -21541,7 +21627,7 @@ function fetchIssue2(number, repo) {
 }
 
 // src/commands/github/issue/resumeIssueBody.ts
-import { existsSync as existsSync49, readFileSync as readFileSync37 } from "fs";
+import { existsSync as existsSync51, readFileSync as readFileSync38 } from "fs";
 
 // src/commands/github/issue/issueWorkingFile.ts
 import { join as join51 } from "path";
@@ -21558,11 +21644,11 @@ function issueWorkingFile(slug, number) {
 // src/commands/github/issue/resumeIssueBody.ts
 function resumeIssueBody(slug, number, updatedAt) {
   const { bodyPath, metaPath } = issueWorkingFile(slug, number);
-  if (!existsSync49(bodyPath) || !existsSync49(metaPath)) return void 0;
+  if (!existsSync51(bodyPath) || !existsSync51(metaPath)) return void 0;
   try {
-    const meta = JSON.parse(readFileSync37(metaPath, "utf8"));
+    const meta = JSON.parse(readFileSync38(metaPath, "utf8"));
     if (meta.updatedAt !== updatedAt) return void 0;
-    return readFileSync37(bodyPath, "utf8");
+    return readFileSync38(bodyPath, "utf8");
   } catch {
     return void 0;
   }
@@ -21751,11 +21837,11 @@ async function countPendingHandovers(orm, origin) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 import {
-  existsSync as existsSync50,
+  existsSync as existsSync52,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync38,
+  readFileSync as readFileSync39,
   rmSync as rmSync3,
-  statSync as statSync8
+  statSync as statSync9
 } from "fs";
 import { basename as basename14, join as join54 } from "path";
 
@@ -21806,7 +21892,7 @@ function summariseHandoverContent(content) {
 
 // src/commands/handover/migrateDiskHandovers.ts
 function collectMarkdown(dir) {
-  if (!existsSync50(dir)) return [];
+  if (!existsSync52(dir)) return [];
   const out = [];
   for (const entry of readdirSync10(dir, { withFileTypes: true })) {
     const full = join54(dir, entry.name);
@@ -21816,7 +21902,7 @@ function collectMarkdown(dir) {
   return out;
 }
 async function migrateFile(orm, origin, file, createdAt) {
-  const content = readFileSync38(file, "utf8");
+  const content = readFileSync39(file, "utf8");
   await saveHandover(orm, {
     origin,
     summary: summariseHandoverContent(content),
@@ -21828,13 +21914,13 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename14(file)) ?? statSync8(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename14(file)) ?? statSync9(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
   const handoverPath = getHandoverPath(cwd);
-  if (existsSync50(handoverPath)) {
-    await migrateFile(orm, origin, handoverPath, statSync8(handoverPath).mtime);
+  if (existsSync52(handoverPath)) {
+    await migrateFile(orm, origin, handoverPath, statSync9(handoverPath).mtime);
     migrated++;
   }
   return migrated;
@@ -22181,16 +22267,16 @@ function recentDaemonLogLines() {
 // src/commands/sessions/daemon/worktree/canonicalTreePath.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve14 } from "path";
-function canonicalTreePath(path83) {
+function canonicalTreePath(path84) {
   try {
-    return realpathSync2(path83);
+    return realpathSync2(path84);
   } catch {
-    return resolve14(path83);
+    return resolve14(path84);
   }
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync51 } from "fs";
+import { existsSync as existsSync53 } from "fs";
 import { basename as basename16, dirname as dirname26 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
@@ -22237,23 +22323,23 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const base = strategy.root ? expandTilde2(strategy.root) : dirname26(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
-  const isTaken = (candidate) => registered.has(candidate) || existsSync51(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
-  const path83 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
+  const isTaken = (candidate) => registered.has(candidate) || existsSync53(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
+  const path84 = 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(path83),
-    path83,
+    basename16(path84),
+    path84,
     start3.ref
   ]);
-  recordWorktree(path83, clone, getCurrentOrigin(clone));
+  recordWorktree(path84, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path83} (branch ${basename16(path83)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path83} (branch ${basename16(path83)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path84} (branch ${basename16(path84)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path84} (branch ${basename16(path84)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
-  return path83;
+  return path84;
 }
 
 // src/commands/sessions/daemon/worktree/keptInTree.ts
@@ -22263,7 +22349,7 @@ function keptInTree(cwd, reason4) {
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
-import { existsSync as existsSync52 } from "fs";
+import { existsSync as existsSync54 } from "fs";
 var treeIsGone = { durable: true, gone: true };
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
@@ -22294,14 +22380,14 @@ function* durabilityProbes() {
   });
 }
 async function checkDurability(cwd) {
-  if (!existsSync52(cwd)) return treeIsGone;
+  if (!existsSync54(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
   return step2.value;
 }
 function checkDurabilitySync(cwd) {
-  if (!existsSync52(cwd)) return treeIsGone;
+  if (!existsSync54(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
@@ -22394,13 +22480,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 path83 = createWorktree(
+  const path84 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
     boundTreeRoots2,
     options2.replacesTree
   );
-  return { cwd: path83, kind: "worktree", created: true, clone };
+  return { cwd: path84, kind: "worktree", created: true, clone };
 }
 
 // src/commands/sessions/daemon/describePersistedSession.ts
@@ -22544,20 +22630,20 @@ function persistedTreeRoots() {
 }
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
-import { copyFileSync, existsSync as existsSync54, mkdirSync as mkdirSync17 } from "fs";
+import { copyFileSync, existsSync as existsSync56, mkdirSync as mkdirSync17 } from "fs";
 import { dirname as dirname27, join as join57 } from "path";
 
 // src/commands/sessions/daemon/worktree/runInstall.ts
 import { spawn as spawn5 } from "child_process";
 
 // src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
-import { existsSync as existsSync53 } from "fs";
+import { existsSync as existsSync55 } from "fs";
 import { join as join56 } from "path";
 function detectInstallCommand(repoRoot2) {
-  if (!existsSync53(join56(repoRoot2, "package.json"))) return null;
-  if (existsSync53(join56(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync53(join56(repoRoot2, "yarn.lock"))) return "yarn install";
-  if (existsSync53(join56(repoRoot2, "bun.lockb"))) return "bun install";
+  if (!existsSync55(join56(repoRoot2, "package.json"))) return null;
+  if (existsSync55(join56(repoRoot2, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync55(join56(repoRoot2, "yarn.lock"))) return "yarn install";
+  if (existsSync55(join56(repoRoot2, "bun.lockb"))) return "bun install";
   return "npm install";
 }
 function resolveInstallCommand(repoRoot2, install) {
@@ -22670,7 +22756,7 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
     const src = join57(clone, rel);
-    if (!existsSync54(src)) continue;
+    if (!existsSync56(src)) continue;
     const dest = join57(worktreePath, rel);
     try {
       mkdirSync17(dirname27(dest), { recursive: true });
@@ -22731,13 +22817,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 path83 = null;
+  let path84 = null;
   for (const line of listing.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("worktree "))
-      path83 = trimmed.slice("worktree ".length).trim();
+      path84 = trimmed.slice("worktree ".length).trim();
     else if (trimmed === `branch refs/heads/${branch2}`)
-      return path83 && path83 !== here ? path83 : null;
+      return path84 && path84 !== here ? path84 : null;
   }
   return null;
 }
@@ -22905,7 +22991,7 @@ import { resolve as resolve16 } from "path";
 import chalk171 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
-import { readFileSync as readFileSync39, writeFileSync as writeFileSync32 } from "fs";
+import { readFileSync as readFileSync40, writeFileSync as writeFileSync32 } from "fs";
 import { basename as basename17, extname as extname2, resolve as resolve15 } from "path";
 import chalk170 from "chalk";
 
@@ -22931,7 +23017,7 @@ async function renderBlock(krokiUrl, source) {
 
 // src/commands/mermaid/exportFile.ts
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
-  const content = readFileSync39(file, "utf8");
+  const content = readFileSync40(file, "utf8");
   const blocks = extractMermaidBlocks(content);
   const stem = basename17(file, extname2(file));
   if (onlyIndex !== void 0) {
@@ -23143,14 +23229,14 @@ function applyIgnore(texts, ignore3) {
 }
 
 // src/commands/miro/readIgnoreList.ts
-import { existsSync as existsSync55, readFileSync as readFileSync40 } from "fs";
+import { existsSync as existsSync57, readFileSync as readFileSync41 } from "fs";
 import { parse as parse2 } from "yaml";
 function readIgnoreList(file) {
-  if (!existsSync55(file))
+  if (!existsSync57(file))
     throw new MiroExtractError(
       `No ignore file at ${file}. Write a YAML list of the box texts to drop, or omit --ignore.`
     );
-  const parsed = parse2(readFileSync40(file, "utf8"));
+  const parsed = parse2(readFileSync41(file, "utf8"));
   if (parsed === null || parsed === void 0) return [];
   if (!Array.isArray(parsed) || parsed.some((entry) => typeof entry !== "string"))
     throw new MiroExtractError(
@@ -23332,7 +23418,7 @@ async function pickAnchors(sessionId, items2) {
 }
 
 // src/commands/miro/readMiroItems.ts
-import { readFileSync as readFileSync41 } from "fs";
+import { readFileSync as readFileSync42 } from "fs";
 function tryParse(text18) {
   try {
     return JSON.parse(text18);
@@ -23361,7 +23447,7 @@ function parsePages(raw, file) {
   return Array.isArray(parsed) ? parsed.map(toPage) : [toPage(parsed)];
 }
 function readMiroItems(file) {
-  const items2 = parsePages(readFileSync41(file, "utf8"), file).flatMap(
+  const items2 = parsePages(readFileSync42(file, "utf8"), file).flatMap(
     (page) => page.data ?? []
   );
   if (items2.length === 0)
@@ -23757,7 +23843,7 @@ import { join as join62 } from "path";
 import chalk176 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync43 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -23779,9 +23865,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path83] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path84] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path83) {
+    for (const key of path84) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -24153,7 +24239,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines2 = readFileSync42(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines2 = readFileSync43(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines2) {
     let entry;
@@ -24484,16 +24570,16 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-async function comment2(path83, line, body, startLine) {
+async function comment2(path84, 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 ${path83}:${range}`, body, null);
+  await reviewProposedPrComment(`Comment on ${path84}:${range}`, body, null);
   try {
     const prId = getCurrentPrNodeId();
-    postReviewComment({ prId, body, path: path83, line, startLine });
-    console.log(`Added review comment on ${path83}:${range}`);
+    postReviewComment({ prId, body, path: path84, line, startLine });
+    console.log(`Added review comment on ${path84}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -24727,7 +24813,7 @@ import { tmpdir as tmpdir6 } from "os";
 import { join as join64 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync56, readFileSync as readFileSync43, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync58, readFileSync as readFileSync44, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse3 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
@@ -24747,15 +24833,15 @@ function commentsCachePath(org, repo, prNumber) {
 // src/commands/prs/loadCommentsCache.ts
 function loadCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (!existsSync56(cachePath)) {
+  if (!existsSync58(cachePath)) {
     return null;
   }
-  const content = readFileSync43(cachePath, "utf8");
+  const content = readFileSync44(cachePath, "utf8");
   return parse3(content);
 }
 function deleteCommentsCache(org, repo, prNumber) {
   const cachePath = commentsCachePath(org, repo, prNumber);
-  if (existsSync56(cachePath)) {
+  if (existsSync58(cachePath)) {
     unlinkSync13(cachePath);
     console.log("No more unresolved line comments. Cache dropped.");
   }
@@ -25695,9 +25781,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 (path83, line, body) => {
+  ).action(async (path84, line, body) => {
     await comment2(
-      path83,
+      path84,
       Number.parseInt(line, 10),
       await readBodyArgument(body)
     );
@@ -26161,10 +26247,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path83) {
+async function ravenFetch(connection, path84) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path83}`;
+  const url = `${connection.url}${path84}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -26254,16 +26340,16 @@ import chalk191 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path83;
+  let path84;
   if (opts.collection) {
-    path83 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path84 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path83 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path84 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path83 += `&query=${encodeURIComponent(opts.query)}`;
+    path84 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path83;
+  return path84;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -26272,7 +26358,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 path83 = buildQueryPath({
+    const path84 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -26280,7 +26366,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path83);
+    const data = await ravenFetch(connection, path84);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -26338,7 +26424,7 @@ function registerRavendb(program2) {
 
 // src/commands/refactor/check/index.ts
 import { spawn as spawn6 } from "child_process";
-import * as path42 from "path";
+import * as path45 from "path";
 
 // src/commands/refactor/logViolations.ts
 import chalk193 from "chalk";
@@ -26515,7 +26601,7 @@ ${failed2.length} verify script(s) failed:`);
 async function runVerifyQuietly() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
   if (!result) return true;
-  const packageDir = path42.dirname(result.packageJsonPath);
+  const packageDir = path45.dirname(result.packageJsonPath);
   const results = await Promise.all(
     result.verifyScripts.map((script) => runScript(script, packageDir))
   );
@@ -26541,7 +26627,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path50 from "path";
+import path53 from "path";
 import chalk196 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -27018,9 +27104,9 @@ function buildDestinationContent(functionTexts, imports, sourceRelativePath, sou
 }
 
 // src/commands/refactor/extract/getRelativeImportPath.ts
-import path43 from "path";
+import path46 from "path";
 function getRelativeImportPath(from, to) {
-  let rel = path43.relative(path43.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
+  let rel = path46.relative(path46.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel;
 }
@@ -27044,9 +27130,9 @@ function findImporters(functionName, sourceFile, destPath, project) {
 }
 
 // src/commands/refactor/extract/resolveBarrel.ts
-import path44 from "path";
+import path47 from "path";
 function resolveBarrel(functionName, sourcePath, destPath, project) {
-  const indexPath = path44.join(path44.dirname(destPath), "index.ts");
+  const indexPath = path47.join(path47.dirname(destPath), "index.ts");
   const barrel = project.getSourceFile(indexPath);
   if (!barrel) return { barrel: void 0, barrelRelPath: "" };
   const sourceRelFromBarrel = getRelativeImportPath(indexPath, sourcePath);
@@ -27064,15 +27150,15 @@ function resolveBarrel(functionName, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/rewriteImportPaths.ts
-import path45 from "path";
+import path48 from "path";
 function rewriteImportPaths(imports, sourcePath, destPath) {
-  const sourceDir = path45.dirname(sourcePath);
-  const destDir = path45.dirname(destPath);
+  const sourceDir = path48.dirname(sourcePath);
+  const destDir = path48.dirname(destPath);
   return imports.map((imp) => {
     if (!imp.moduleSpecifier.startsWith(".")) return imp;
-    const absolute2 = path45.resolve(sourceDir, imp.moduleSpecifier);
-    let rel = path45.relative(destDir, absolute2).replace(/\\/g, "/");
-    if (rel === "") rel = `../${path45.basename(absolute2)}`;
+    const absolute2 = path48.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path48.relative(destDir, absolute2).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path48.basename(absolute2)}`;
     else if (!rel.startsWith(".")) rel = `./${rel}`;
     return { ...imp, moduleSpecifier: rel };
   });
@@ -27140,7 +27226,7 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/displayPlan.ts
-import path46 from "path";
+import path49 from "path";
 import chalk194 from "chalk";
 function section2(title) {
   return `
@@ -27150,7 +27236,7 @@ function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section2("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
-    const rel = path46.relative(cwd, imp.file.getFilePath());
+    const rel = path49.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk194.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
@@ -27190,17 +27276,17 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
-import path49 from "path";
+import path52 from "path";
 import chalk195 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
 import fs32 from "fs";
-import path48 from "path";
+import path51 from "path";
 
 // src/commands/refactor/extract/findEnclosingTsConfig.ts
 import fs31 from "fs";
-import path47 from "path";
+import path50 from "path";
 
 // src/commands/refactor/extract/projectIncludesFile.ts
 import { Project as Project3 } from "ts-morph";
@@ -27215,16 +27301,16 @@ function projectIncludesFile(configPath, sourcePath) {
 
 // src/commands/refactor/extract/findEnclosingTsConfig.ts
 function findEnclosingTsConfig(sourcePath, rootDir, tried) {
-  let dir = path47.dirname(sourcePath);
-  while (dir.startsWith(rootDir + path47.sep) && dir !== rootDir) {
-    const nested = path47.join(dir, "tsconfig.json");
+  let dir = path50.dirname(sourcePath);
+  while (dir.startsWith(rootDir + path50.sep) && dir !== rootDir) {
+    const nested = path50.join(dir, "tsconfig.json");
     if (!tried.has(nested)) {
       tried.add(nested);
       if (fs31.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
         return nested;
       }
     }
-    const parent = path47.dirname(dir);
+    const parent = path50.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -27233,7 +27319,7 @@ function findEnclosingTsConfig(sourcePath, rootDir, tried) {
 
 // src/commands/refactor/extract/findTsConfig.ts
 function findTsConfig(sourcePath) {
-  const rootConfig = path48.resolve("tsconfig.json");
+  const rootConfig = path51.resolve("tsconfig.json");
   if (!fs32.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
@@ -27242,7 +27328,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludesFile(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs32.readdirSync(path48.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path48.resolve(path48.dirname(rootConfig), f));
+  const siblings = fs32.readdirSync(path51.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path51.resolve(path51.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -27250,7 +27336,7 @@ function findTsConfig(sourcePath) {
   }
   const nested = findEnclosingTsConfig(
     sourcePath,
-    path48.dirname(rootConfig),
+    path51.dirname(rootConfig),
     tried
   );
   if (nested) return nested;
@@ -27267,16 +27353,16 @@ function readReferences(configPath) {
     return [];
   }
   if (!parsed.references?.length) return [];
-  const cwd = path48.dirname(configPath);
+  const cwd = path51.dirname(configPath);
   return parsed.references.map((ref) => {
-    const refPath = path48.resolve(cwd, ref.path);
-    return fs32.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path48.join(refPath, "tsconfig.json") : refPath;
+    const refPath = path51.resolve(cwd, ref.path);
+    return fs32.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path51.join(refPath, "tsconfig.json") : refPath;
   }).filter((p) => fs32.existsSync(p));
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
 function loadProjectFile(file) {
-  const sourcePath = path49.resolve(file);
+  const sourcePath = path52.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project4({
     tsConfigFilePath: tsConfigPath
@@ -27291,10 +27377,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path50.resolve(file);
-  const destPath = path50.resolve(destination);
+  const sourcePath = path53.resolve(file);
+  const destPath = path53.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path50.relative(cwd, destPath);
+  const relDest = path53.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan2(
     functionName,
@@ -27342,16 +27428,16 @@ function ignore2(file) {
 
 // src/commands/refactor/rename/index.ts
 import fs36 from "fs";
-import path55 from "path";
+import path58 from "path";
 import chalk200 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs35 from "fs";
-import path52 from "path";
+import path55 from "path";
 import chalk198 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path51 from "path";
+import path54 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
 import fs34 from "fs";
@@ -27405,7 +27491,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path51.relative(path51.dirname(fromFile), toFile));
+  return normalizeSpecifier(path54.relative(path54.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -27453,20 +27539,20 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs35.writeFileSync(file, content, "utf8");
-    console.log(chalk198.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
+    console.log(chalk198.cyan(`  Updated imports in ${path55.relative(cwd, file)}`));
   }
-  const destDir = path52.dirname(destPath);
+  const destDir = path55.dirname(destPath);
   if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
   fs35.renameSync(sourcePath, destPath);
   console.log(
     chalk198.white(
-      `  Moved ${path52.relative(cwd, sourcePath)} \u2192 ${path52.relative(cwd, destPath)}`
+      `  Moved ${path55.relative(cwd, sourcePath)} \u2192 ${path55.relative(cwd, destPath)}`
     )
   );
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path53 from "path";
+import path56 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -27493,7 +27579,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path53.dirname(tsConfigPath)
+    path56.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -27509,7 +27595,7 @@ function resolveImport(specifier, filePath, options2) {
   const resolved = ts7.resolveModuleName(specifier, filePath, options2, ts7.sys);
   const resolvedPath = resolved.resolvedModule?.resolvedFileName;
   if (!resolvedPath || resolvedPath.includes("node_modules")) return null;
-  return path53.resolve(resolvedPath);
+  return path56.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -27518,7 +27604,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path53.resolve(sourceFile.fileName);
+    const filePath = path56.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -27545,13 +27631,13 @@ function computeRenameRewrites(sourcePath, destPath) {
 }
 
 // src/commands/refactor/rename/printRenamePreview.ts
-import path54 from "path";
+import path57 from "path";
 import chalk199 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
       chalk199.dim(
-        `  ${path54.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+        `  ${path57.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
@@ -27560,11 +27646,11 @@ function printRenamePreview(rewrites, cwd) {
 
 // src/commands/refactor/rename/index.ts
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path55.resolve(source);
-  const destPath = path55.resolve(destination);
+  const sourcePath = path58.resolve(source);
+  const destPath = path58.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path55.relative(cwd, sourcePath);
-  const relDest = path55.relative(cwd, destPath);
+  const relSource = path58.relative(cwd, sourcePath);
+  const relDest = path58.relative(cwd, destPath);
   if (!fs36.existsSync(sourcePath)) {
     console.log(chalk200.red(`File not found: ${source}`));
     process.exit(1);
@@ -27619,12 +27705,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path56 from "path";
+import path59 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path56.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path59.relative(cwd, ref.getSourceFile().getFilePath());
     const lines2 = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines2);
     lines2.push(ref.getStartLineNumber());
@@ -27663,16 +27749,16 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path63 from "path";
+import path66 from "path";
 import chalk204 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path57 from "path";
+import path60 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path57.dirname(edge.source);
-    const targetDir = path57.dirname(edge.target);
+    const sourceDir = path60.dirname(edge.source);
+    const targetDir = path60.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -27700,20 +27786,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path57.relative(ancestor, descendant);
+  const rel = path60.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path58 from "path";
+import path61 from "path";
 function findRootParent(file, importedBy, visited) {
   const importers = importedBy.get(file);
   if (!importers || importers.size !== 1) return file;
   const parent = [...importers][0];
-  const parentDir = path58.dirname(parent);
-  const fileDir = path58.dirname(file);
+  const parentDir = path61.dirname(parent);
+  const fileDir = path61.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path58.basename(parent, path58.extname(parent)) === "index") return file;
+  if (path61.basename(parent, path61.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -27721,16 +27807,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename26 = path58.basename(file, path58.extname(file));
+    const basename26 = path61.basename(file, path61.extname(file));
     if (basename26 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
     if (!graph.files.has(parent)) continue;
-    const parentDir = path58.dirname(parent);
-    const fileDir = path58.dirname(file);
+    const parentDir = path61.dirname(parent);
+    const fileDir = path61.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path58.basename(parent, path58.extname(parent));
+    const parentBasename = path61.basename(parent, path61.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -27742,10 +27828,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path59 from "path";
+import path62 from "path";
 import chalk202 from "chalk";
 function relPath(filePath) {
-  return path59.relative(process.cwd(), filePath);
+  return path62.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -27795,33 +27881,33 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 
 // src/commands/refactor/restructure/executePlan.ts
 import fs37 from "fs";
-import path60 from "path";
+import path63 from "path";
 import chalk203 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs37.writeFileSync(file, content, "utf8");
     console.log(
-      chalk203.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
+      chalk203.cyan(`  Rewrote imports in ${path63.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs37.mkdirSync(dir, { recursive: true });
-    console.log(chalk203.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
+    console.log(chalk203.green(`  Created ${path63.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
-    const targetDir = path60.dirname(move2.to);
+    const targetDir = path63.dirname(move2.to);
     if (!fs37.existsSync(targetDir)) {
       fs37.mkdirSync(targetDir, { recursive: true });
     }
     fs37.renameSync(move2.from, move2.to);
     console.log(
       chalk203.white(
-        `  Moved ${path60.relative(process.cwd(), move2.from)} \u2192 ${path60.relative(process.cwd(), move2.to)}`
+        `  Moved ${path63.relative(process.cwd(), move2.from)} \u2192 ${path63.relative(process.cwd(), move2.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path60.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path63.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
@@ -27832,7 +27918,7 @@ function removeEmptyDirectories(dirs) {
       fs37.rmdirSync(dir);
       console.log(
         chalk203.dim(
-          `  Removed empty directory ${path60.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path63.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -27840,7 +27926,7 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path62 from "path";
+import path65 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
 import fs38 from "fs";
@@ -27855,9 +27941,9 @@ function checkDirConflict(result, label2, dir) {
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs39 from "fs";
-import path61 from "path";
+import path64 from "path";
 function collectEntry2(results, dir, entry) {
-  const full = path61.join(dir, entry.name);
+  const full = path64.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
@@ -27871,15 +27957,15 @@ function listFilesRecursive(dir) {
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason4) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path61.relative(childDir, file);
-    moves.push({ from: file, to: path61.join(newLocation, rel), reason: reason4 });
+    const rel = path64.relative(childDir, file);
+    moves.push({ from: file, to: path64.join(newLocation, rel), reason: reason4 });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path61.join(parentDir, path61.basename(childDir));
+  return path64.join(parentDir, path64.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path61.basename(parentDir)}/`;
+  return `Directory only imported from ${path64.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -27904,7 +27990,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path62.join(newDir, path62.basename(child));
+  const to = path65.join(newDir, path65.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -27912,15 +27998,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path62.basename(filePath, path62.extname(filePath));
+  return path65.basename(filePath, path65.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path62.join(path62.dirname(parent), getBaseName(parent));
+  return path65.join(path65.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path62.join(newDir, `index${path62.extname(parent)}`),
+    to: path65.join(newDir, `index${path65.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -27944,7 +28030,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path63.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path66.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -27967,7 +28053,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk204.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = findTsConfig(path63.resolve(files[0]));
+  const tsConfigPath = findTsConfig(path66.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk204.green("No restructuring needed"));
@@ -28302,7 +28388,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync44 } from "fs";
+import { readFileSync as readFileSync45 } from "fs";
 
 // src/commands/review/carriedUnanchoredFindings.ts
 function carriedUnanchoredFindings(unanchored) {
@@ -28750,7 +28836,7 @@ async function confirmPost(prNumber, work, options2) {
   return promptConfirm(`Post ${work} to PR #${prNumber}?`, false);
 }
 async function postFindingsToPr(prInfo, synthesisPath, options2) {
-  const markdown = readFileSync44(synthesisPath, "utf8");
+  const markdown = readFileSync45(synthesisPath, "utf8");
   const { inDiff, unanchored } = selectPostableFindings(markdown, prInfo);
   const carried = carriedUnanchoredFindings(unanchored);
   if (inDiff.length === 0 && carried.length === 0) return NOTHING_POSTED;
@@ -28886,10 +28972,10 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 }
 
 // src/commands/review/prepareReviewDir.ts
-import { existsSync as existsSync57, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
+import { existsSync as existsSync59, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path83 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync57(path83)) unlinkSync17(path83);
+  for (const path84 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync59(path84)) unlinkSync17(path84);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -28899,11 +28985,11 @@ function prepareReviewDir(paths, requestBody, force) {
 }
 
 // src/commands/review/cachedReviewerResult.ts
-import { statSync as statSync9 } from "fs";
+import { statSync as statSync10 } from "fs";
 function cachedReviewerResult(name, outputPath) {
   let size;
   try {
-    size = statSync9(outputPath).size;
+    size = statSync10(outputPath).size;
   } catch {
     return null;
   }
@@ -29116,7 +29202,7 @@ function printReviewerFailures(results) {
 }
 
 // src/commands/review/runAndSynthesise.ts
-import { existsSync as existsSync59, unlinkSync as unlinkSync19 } from "fs";
+import { existsSync as existsSync61, unlinkSync as unlinkSync19 } from "fs";
 
 // src/commands/review/buildReviewerStdin.ts
 var REVIEW_PROMPT = `You are acting as a reviewer for a proposed code change made by another engineer. The full review request \u2014 branch, base, changed files, and unified diff \u2014 is in the request file whose absolute path is given below.
@@ -29545,7 +29631,7 @@ function resolveClaude(args) {
 }
 
 // src/commands/review/runCodexReviewer.ts
-import { existsSync as existsSync58, unlinkSync as unlinkSync18 } from "fs";
+import { existsSync as existsSync60, unlinkSync as unlinkSync18 } from "fs";
 
 // src/commands/review/parseCodexEvent.ts
 function isItemStarted(value) {
@@ -29597,7 +29683,7 @@ async function runCodexReviewer(spec) {
       reportReviewerToolUse(spec.name, event, spinner);
     }
   });
-  if (result.exitCode !== 0 && existsSync58(spec.outputPath)) {
+  if (result.exitCode !== 0 && existsSync60(spec.outputPath)) {
     unlinkSync18(spec.outputPath);
   }
   return finaliseReviewerRun({ ...spec, command }, spinner, result);
@@ -29639,7 +29725,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync45 } from "fs";
+import { readFileSync as readFileSync46 } from "fs";
 
 // src/commands/review/buildSynthesisStdin.ts
 var SYNTHESIS_PROMPT = `You are consolidating two independent code reviews of the same change. The original review request is in request.md. The two reviews are in claude.md and codex.md in the current working directory.
@@ -29704,7 +29790,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync45(synthesisPath, "utf8");
+  const markdown = readFileSync46(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -29752,7 +29838,7 @@ async function runAndSynthesise(args) {
     console.error("Both reviewers failed; skipping synthesis.");
     return { ok: false, failures };
   }
-  if (anyFresh && existsSync59(paths.synthesisPath)) {
+  if (anyFresh && existsSync61(paths.synthesisPath)) {
     unlinkSync19(paths.synthesisPath);
   }
   const synthesisResult = await synthesise(paths, { multi });
@@ -29938,71 +30024,13 @@ function registerReview(program2) {
 }
 
 // src/commands/rules/listRules.ts
-import path66 from "path";
+import path67 from "path";
 import chalk207 from "chalk";
-
-// src/commands/rules/readScopedRules.ts
-import { existsSync as existsSync61, readFileSync as readFileSync46 } from "fs";
-import path65 from "path";
-
-// src/commands/rules/parseRulesSection.ts
-var RULES_HEADING = /^##\s+rules\s*$/i;
-var SECTION_END = /^#{1,2}\s/;
-var RULE_BULLET = /^\s*[-*]\s+\*\*\s*([^*]+?)\s*\*\*\s*(?:[—–:-]\s*)?(.*)$/;
-function parseRulesSection(content) {
-  const lines2 = content.split(/\r?\n/);
-  const start3 = lines2.findIndex((line) => RULES_HEADING.test(line));
-  if (start3 === -1) return [];
-  const rules3 = [];
-  for (const line of lines2.slice(start3 + 1)) {
-    if (SECTION_END.test(line)) break;
-    const match = RULE_BULLET.exec(line);
-    if (!match) continue;
-    const code = match[1].trim();
-    const text18 = match[2].trim();
-    if (code === "" || text18 === "") continue;
-    rules3.push({ code, text: text18 });
-  }
-  return rules3;
-}
-
-// src/commands/rules/scopeDirectory.ts
-import { existsSync as existsSync60, statSync as statSync10 } from "fs";
-import path64 from "path";
-function scopeDirectory(target) {
-  const resolved = path64.resolve(target);
-  return existsSync60(resolved) && statSync10(resolved).isDirectory() ? resolved : path64.dirname(resolved);
-}
-
-// src/commands/rules/readScopedRules.ts
-function scopedClaudeFiles(target) {
-  const startDir = scopeDirectory(target);
-  const root = findRepoRoot(startDir) ?? startDir;
-  const files = [];
-  let current = startDir;
-  while (true) {
-    const candidate = path65.join(current, "CLAUDE.md");
-    if (existsSync61(candidate)) files.push(candidate);
-    if (current === root || current === path65.dirname(current)) break;
-    current = path65.dirname(current);
-  }
-  return files;
-}
-function readScopedRules(target) {
-  return scopedClaudeFiles(target).flatMap(
-    (source) => parseRulesSection(readFileSync46(source, "utf8")).map((rule) => ({
-      ...rule,
-      source
-    }))
-  );
-}
-
-// src/commands/rules/listRules.ts
 function listRules(target) {
-  const resolved = path66.resolve(target ?? process.cwd());
+  const resolved = path67.resolve(target ?? process.cwd());
   const rules3 = readScopedRules(resolved);
   if (rules3.length === 0) {
-    const label2 = path66.relative(process.cwd(), resolved) || ".";
+    const label2 = path67.relative(process.cwd(), resolved) || ".";
     console.log(chalk207.gray(`No rules in scope for ${label2}`));
     return;
   }
@@ -30013,7 +30041,7 @@ function listRules(target) {
     if (rule.source !== shown) {
       shown = rule.source;
       console.log(
-        chalk207.dim(base ? path66.relative(base, rule.source) : rule.source)
+        chalk207.dim(base ? path67.relative(base, rule.source) : rule.source)
       );
     }
     console.log(`  ${chalk207.cyan(rule.code.padEnd(width))}  ${rule.text}`);
@@ -30089,8 +30117,8 @@ import chalk213 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk210 from "chalk";
-async function fetchSeq(conn, path83, params) {
-  const url = `${conn.url}${path83}?${params}`;
+async function fetchSeq(conn, path84, params) {
+  const url = `${conn.url}${path84}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -30642,15 +30670,15 @@ function registerSql(program2) {
 // src/commands/sync.ts
 import * as fs48 from "fs";
 import * as os5 from "os";
-import * as path77 from "path";
+import * as path78 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/sync/pruneCommands.ts
-import * as path68 from "path";
+import * as path69 from "path";
 
 // src/commands/sync/pruneTarget.ts
 import * as fs40 from "fs";
-import * as path67 from "path";
+import * as path68 from "path";
 function pruneTarget(targetDir, keepNames, shape, options2) {
   const result = {
     orphans: [],
@@ -30668,7 +30696,7 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
     }
     if (keep.has(name)) continue;
     result.orphans.push(entry.name);
-    const entryPath = path67.join(targetDir, entry.name);
+    const entryPath = path68.join(targetDir, entry.name);
     const reason4 = shape.blockedBy?.(entryPath);
     if (reason4) {
       result.skipped.push({ name: entry.name, reason: reason4 });
@@ -30688,7 +30716,7 @@ function pruneCommands(targetDir, commandNames, options2) {
     targetDir,
     commandNames,
     {
-      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path68.basename(entry.name, ".md") : void 0
+      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path69.basename(entry.name, ".md") : void 0
     },
     options2
   );
@@ -30723,11 +30751,11 @@ function reportPrune(label2, result, force) {
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
-import * as path69 from "path";
+import * as path70 from "path";
 import chalk220 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path69.join(claudeDir, "CLAUDE.md");
-  const target = path69.join(targetBase, "CLAUDE.md");
+  const source = path70.join(claudeDir, "CLAUDE.md");
+  const target = path70.join(targetBase, "CLAUDE.md");
   const sourceContent = fs41.readFileSync(source, "utf8");
   if (fs41.existsSync(target)) {
     const targetContent = fs41.readFileSync(target, "utf8");
@@ -30755,13 +30783,13 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path72 from "path";
+import * as path73 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
 import * as fs42 from "fs";
-import * as path70 from "path";
+import * as path71 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path70.join(claudeDir, "commands");
+  const commandsSource = path71.join(claudeDir, "commands");
   const files = fs42.readdirSync(commandsSource);
   const names = [];
   let synced = 0;
@@ -30769,15 +30797,15 @@ function installHarnessCommands(claudeDir, harness, transform) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
     names.push(name);
-    const content = fs42.readFileSync(path70.join(commandsSource, file), "utf8");
-    const target = path70.join(harness.homeDir, harness.sync.commandDest(name));
-    fs42.mkdirSync(path70.dirname(target), { recursive: true });
+    const content = fs42.readFileSync(path71.join(commandsSource, file), "utf8");
+    const target = path71.join(harness.homeDir, harness.sync.commandDest(name));
+    fs42.mkdirSync(path71.dirname(target), { recursive: true });
     fs42.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path70.join(harness.homeDir, harness.sync.agentsFile);
-  fs42.mkdirSync(path70.dirname(agentsTarget), { recursive: true });
-  fs42.copyFileSync(path70.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path71.join(harness.homeDir, harness.sync.agentsFile);
+  fs42.mkdirSync(path71.dirname(agentsTarget), { recursive: true });
+  fs42.copyFileSync(path71.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced, names };
 }
 
@@ -30803,7 +30831,7 @@ function unexpectedContent(skillDir) {
 
 // src/commands/sync/syncCodexHooks.ts
 import * as fs44 from "fs";
-import * as path71 from "path";
+import * as path72 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -30834,9 +30862,9 @@ ${rest}
 }
 function syncCodexHooks(sourcePath) {
   const body = fs44.readFileSync(sourcePath, "utf8");
-  const configPath = path71.join(harnesses.codex.homeDir, "config.toml");
+  const configPath = path72.join(harnesses.codex.homeDir, "config.toml");
   const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
-  fs44.mkdirSync(path71.dirname(configPath), { recursive: true });
+  fs44.mkdirSync(path72.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)"
@@ -30868,7 +30896,7 @@ function syncCodex(claudeDir, options2) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path72.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path73.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
@@ -30876,42 +30904,42 @@ function syncCodex(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.codex/skills",
-    pruneSkills(path72.join(harnesses.codex.homeDir, "skills"), names, { force }),
+    pruneSkills(path73.join(harnesses.codex.homeDir, "skills"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncDesign.ts
 import * as fs45 from "fs";
-import * as path73 from "path";
+import * as path74 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path73.join(claudeDir, "design-system-prompt.md");
-  const systemPromptTarget = path73.join(targetBase, "design-system-prompt.md");
+  const systemPromptSource = path74.join(claudeDir, "design-system-prompt.md");
+  const systemPromptTarget = path74.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 = path73.join(claudeDir, "skills");
-  const skillsTarget = path73.join(targetBase, "skills");
+  const skillsSource = path74.join(claudeDir, "skills");
+  const skillsTarget = path74.join(targetBase, "skills");
   fs45.mkdirSync(skillsTarget, { recursive: true });
   const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
     fs45.copyFileSync(
-      path73.join(skillsSource, file),
-      path73.join(skillsTarget, file)
+      path74.join(skillsSource, file),
+      path74.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path75 from "path";
+import * as path76 from "path";
 
 // src/commands/sync/syncPiHooks.ts
 import * as fs46 from "fs";
-import * as path74 from "path";
+import * as path75 from "path";
 function piExtensionsDir() {
-  return path74.join(harnesses.pi.homeDir, "extensions");
+  return path75.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
@@ -30919,8 +30947,8 @@ function syncPiHooks(sourceDir) {
   const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     fs46.copyFileSync(
-      path74.join(sourceDir, file),
-      path74.join(target, `assist-${file}`)
+      path75.join(sourceDir, file),
+      path75.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -30957,7 +30985,7 @@ function syncPi(claudeDir, options2) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path75.join(claudeDir, "..", "pi"));
+  syncPiHooks(path76.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
@@ -30965,18 +30993,18 @@ function syncPi(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.pi/agent/prompts",
-    pruneCommands(path75.join(harnesses.pi.homeDir, "prompts"), names, { force }),
+    pruneCommands(path76.join(harnesses.pi.homeDir, "prompts"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
-import * as path76 from "path";
+import * as path77 from "path";
 import chalk221 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path76.join(claudeDir, "settings.json");
-  const target = path76.join(targetBase, "settings.json");
+  const source = path77.join(claudeDir, "settings.json");
+  const target = path77.join(targetBase, "settings.json");
   const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
   const targetExists = fs47.existsSync(target);
@@ -31016,13 +31044,13 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname5 = path77.dirname(__filename4);
+var __dirname5 = path78.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 = path77.join(__dirname5, "..", "claude");
-  const targetBase = path77.join(os5.homedir(), ".claude");
+  const claudeDir = path78.join(__dirname5, "..", "claude");
+  const targetBase = path78.join(os5.homedir(), ".claude");
   const commandFiles = syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -31030,21 +31058,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) => path77.basename(file, ".md"));
+  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path78.basename(file, ".md"));
   const force = options2.force ?? false;
   reportPrune(
     "~/.claude/commands",
-    pruneCommands(path77.join(targetBase, "commands"), commandNames, { force }),
+    pruneCommands(path78.join(targetBase, "commands"), commandNames, { force }),
     force
   );
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path77.join(claudeDir, "commands");
-  const targetDir = path77.join(targetBase, "commands");
+  const sourceDir = path78.join(claudeDir, "commands");
+  const targetDir = path78.join(targetBase, "commands");
   fs48.mkdirSync(targetDir, { recursive: true });
   const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs48.copyFileSync(path77.join(sourceDir, file), path77.join(targetDir, file));
+    fs48.copyFileSync(path78.join(sourceDir, file), path78.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -31203,11 +31231,8 @@ function parseTimestamp(ts8) {
 }
 function extractSpeaker(fullText) {
   const match = fullText.match(/^<v\s+([^>]+)>/);
-  if (!match) return { speaker: null, text: fullText };
-  return {
-    speaker: match[1],
-    text: fullText.replace(/<v\s+[^>]+>/, "").trim()
-  };
+  const text18 = fullText.replace(/<v\s+[^>]+>|<\/v>/g, "").trim();
+  return { speaker: match ? match[1] : null, text: text18 };
 }
 function isTextLine(line) {
   return !!line.trim() && !line.includes("-->");
@@ -31902,11 +31927,11 @@ var webUiPrefix = "src/commands/sessions/web/ui/";
 var sessionsPrefix = "src/commands/sessions/";
 var rules = [
   {
-    matches: (path83) => path83.startsWith(webUiPrefix),
+    matches: (path84) => path84.startsWith(webUiPrefix),
     advice: "restart the web server, then hard-reload the browser tab"
   },
   {
-    matches: (path83) => path83.startsWith(sessionsPrefix) && !path83.startsWith(webUiPrefix),
+    matches: (path84) => path84.startsWith(sessionsPrefix) && !path84.startsWith(webUiPrefix),
     advice: "restart the daemon"
   }
 ];
@@ -31917,31 +31942,31 @@ function restartAdvice(paths) {
 // src/commands/watch/syncAdvice.ts
 var rules2 = [
   {
-    matches: (path83) => path83.startsWith("claude/commands/"),
+    matches: (path84) => path84.startsWith("claude/commands/"),
     reason: "claude/commands changed"
   },
   {
-    matches: (path83) => path83.startsWith("claude/skills/"),
+    matches: (path84) => path84.startsWith("claude/skills/"),
     reason: "claude/skills changed"
   },
   {
-    matches: (path83) => path83 === "claude/settings.json",
+    matches: (path84) => path84 === "claude/settings.json",
     reason: "claude/settings.json changed"
   },
   {
-    matches: (path83) => path83 === "claude/CLAUDE.md",
+    matches: (path84) => path84 === "claude/CLAUDE.md",
     reason: "claude/CLAUDE.md changed"
   },
   {
-    matches: (path83) => path83 === "claude/design-system-prompt.md",
+    matches: (path84) => path84 === "claude/design-system-prompt.md",
     reason: "claude/design-system-prompt.md changed"
   },
   {
-    matches: (path83) => path83.startsWith("codex/"),
+    matches: (path84) => path84.startsWith("codex/"),
     reason: "codex sources changed"
   },
   {
-    matches: (path83) => path83.startsWith("pi/"),
+    matches: (path84) => path84.startsWith("pi/"),
     reason: "pi sources changed"
   }
 ];
@@ -32649,9 +32674,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path83 = join87(roamDir, name);
+    const path84 = join87(roamDir, name);
     try {
-      return { path: path83, mtimeMs: statSync12(path83).mtimeMs };
+      return { path: path84, mtimeMs: statSync12(path84).mtimeMs };
     } catch {
       return void 0;
     }
@@ -32887,11 +32912,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path83 = process.argv[idx + 1];
+  const path84 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path83, prefix: prefix2 };
+  return { path: path84, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -33633,14 +33658,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync79, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path78 from "path";
+import path79 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path78.join(path78.dirname(require4.resolve("node-pty")), "..");
-  const helper = path78.join(
+  const ptyRoot = path79.join(path79.dirname(require4.resolve("node-pty")), "..");
+  const helper = path79.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -33761,12 +33786,12 @@ function serverRunMeta(runName, cwd) {
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs49 from "fs";
-import * as path79 from "path";
+import * as path80 from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 var __filename5 = fileURLToPath10(import.meta.url);
-var __dirname7 = path79.dirname(__filename5);
+var __dirname7 = path80.dirname(__filename5);
 function readDesignSystemPrompt() {
-  const promptPath = path79.join(
+  const promptPath = path80.join(
     __dirname7,
     "..",
     "claude",
@@ -34748,8 +34773,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path83 = activityPath(session.id);
-  const dir = dirname39(path83);
+  const path84 = activityPath(session.id);
+  const dir = dirname39(path84);
   try {
     mkdirSync33(dir, { recursive: true });
   } catch {
@@ -34759,7 +34784,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   let timer = null;
   const read2 = () => {
     timer = null;
-    const activity2 = readActivity(path83);
+    const activity2 = readActivity(path84);
     if (!activity2) return;
     applyActivityToSession(session, activity2);
     if (activity2.claudeSessionId) onClaudeSessionId?.(session);
@@ -34768,11 +34793,11 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     notify2();
   };
   session.activityWatcher = watch2(dir, (_event, filename) => {
-    if (filename && !path83.endsWith(filename)) return;
+    if (filename && !path84.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read2, DEBOUNCE_MS2);
   });
-  if (existsSync85(path83)) read2();
+  if (existsSync85(path84)) read2();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -34915,12 +34940,12 @@ import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
 import * as fs51 from "fs";
-import * as path80 from "path";
+import * as path81 from "path";
 function projectDirForCwd(cwd) {
-  return path80.join(claudeProjectsRoot(), projectSlug(cwd));
+  return path81.join(claudeProjectsRoot(), projectSlug(cwd));
 }
 function transcriptPathFor(cwd, claudeSessionId) {
-  return path80.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+  return path81.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
@@ -34934,8 +34959,8 @@ function findTranscriptPathSync(cwd, claudeSessionId) {
   }
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
-    if (headContainsSessionId(path80.join(dir, file), claudeSessionId))
-      return path80.join(dir, file);
+    if (headContainsSessionId(path81.join(dir, file), claudeSessionId))
+      return path81.join(dir, file);
   }
   return null;
 }
@@ -36109,9 +36134,9 @@ function tempRoots() {
   }
   return [...roots];
 }
-function underTempRoot(path83) {
+function underTempRoot(path84) {
   return tempRoots().some(
-    (root) => path83.startsWith(root.endsWith(sep2) ? root : root + sep2)
+    (root) => path84.startsWith(root.endsWith(sep2) ? root : root + sep2)
   );
 }
 
@@ -36481,15 +36506,15 @@ function bindResumedWorktree(session, cwd, notify2) {
 import { existsSync as existsSync87 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
   if (!existsSync87(clone)) {
-    for (const { path: path83 } of paths) forgetWorktree(path83);
+    for (const { path: path84 } of paths) forgetWorktree(path84);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
   await pruneBookkeeping2(clone);
-  for (const { path: path83, branch: branch2 } of paths)
-    if (await reclaimBranch(clone, branch2)) forgetWorktree(path83);
+  for (const { path: path84, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path84);
 }
 async function pruneBookkeeping2(clone) {
   try {
@@ -36516,37 +36541,37 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/logVanishedTree.ts
-function logVanishedTree(sessions, path83) {
+function logVanishedTree(sessions, path84) {
   const claimants = [...sessions.values()].filter(
-    (s) => s.cwd === path83 || s.worktree?.path === path83
+    (s) => s.cwd === path84 || s.worktree?.path === path84
   );
   if (claimants.length === 0) {
-    daemonLog(`worktree ${path83} gone from disk and unclaimed; reclaiming it`);
+    daemonLog(`worktree ${path84} gone from disk and unclaimed; reclaiming it`);
     return;
   }
   for (const s of claimants)
     daemonLog(
-      `session ${s.id} ("${s.name}") claims worktree ${path83}, which is gone from disk; reclaiming it`
+      `session ${s.id} ("${s.name}") claims worktree ${path84}, which is gone from disk; reclaiming it`
     );
 }
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path83, reason4) {
-  if (reason4.startsWith("uncommitted")) return await changedFiles(path83);
-  if (reason4.startsWith("unpushed")) return await unpushedCommits(path83, reason4);
+async function describeHeldWork(path84, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path84);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path84, reason4);
   return { summary: reason4, items: [] };
 }
-async function changedFiles(path83) {
-  const status3 = await gitResult(path83, ["status", "--porcelain"]);
+async function changedFiles(path84) {
+  const status3 = await gitResult(path84, ["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(path83, reason4) {
-  const log2 = await gitResult(path83, ["log", "--oneline", "@{upstream}..HEAD"]);
+async function unpushedCommits(path84, reason4) {
+  const log2 = await gitResult(path84, ["log", "--oneline", "@{upstream}..HEAD"]);
   if (!log2.ok) return { summary: reason4, items: [] };
   const lines2 = nonEmptyLines(log2.out);
   return {
@@ -36638,24 +36663,24 @@ function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
 async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
-  for (const { path: path83, clone } of readWorktreeRegistry()) {
-    if (underTempRoot(path83)) {
-      forgetWorktree(path83);
+  for (const { path: path84, clone } of readWorktreeRegistry()) {
+    if (underTempRoot(path84)) {
+      forgetWorktree(path84);
       daemonLog(
-        `worktree ${path83} lies outside any project root; pruned from the registry rather than recovered`
+        `worktree ${path84} lies outside any project root; pruned from the registry rather than recovered`
       );
       continue;
     }
-    if (!existsSync88(path83)) {
-      logVanishedTree(sessions, path83);
+    if (!existsSync88(path84)) {
+      logVanishedTree(sessions, path84);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path83, branch: basename24(path83) }
+        { path: path84, branch: basename24(path84) }
       ]);
       continue;
     }
-    if (accounted.has(path83)) continue;
-    await recoverOrphan(sessions, spawnWith, { path: path83, clone }, notify2);
+    if (accounted.has(path84)) continue;
+    await recoverOrphan(sessions, spawnWith, { path: path84, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
     await reclaimVanishedWorktrees(clone, paths);
@@ -38376,12 +38401,12 @@ function handleSetStatus(client, m, d) {
 import * as fs54 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
-import * as path81 from "path";
+import * as path82 from "path";
 async function findCodexRolloutPath(sessionId) {
   if (!sessionId) return null;
   const paths = await discoverCodexRolloutPaths();
   const suffix = `-${sessionId}.jsonl`;
-  return paths.find((file) => path81.basename(file).endsWith(suffix)) ?? null;
+  return paths.find((file) => path82.basename(file).endsWith(suffix)) ?? null;
 }
 
 // src/commands/sessions/shared/codex/codexToolTarget.ts
@@ -39257,7 +39282,7 @@ async function statusLine() {
 
 // src/commands/update.ts
 import { execSync as execSync61 } from "child_process";
-import * as path82 from "path";
+import * as path83 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -39276,12 +39301,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path82.resolve(dir);
-    if (resolved.split(path82.sep).includes("node_modules")) {
+    const resolved = path83.resolve(dir);
+    if (resolved.split(path83.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync61("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path82.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path83.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }