@staff0rd/assist 0.593.0 → 0.595.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.593.0",
+  version: "0.595.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -187,8 +187,8 @@ function getRemoteOriginUrl(cwd) {
 }
 
 // src/commands/backlog/getCurrentOrigin.ts
-function stripLeadingSlashes(path80) {
-  return path80.replace(/^\/+/, "");
+function stripLeadingSlashes(path83) {
+  return path83.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -238,9 +238,9 @@ function findGitLink(dir) {
   }
   return null;
 }
-function isFile(path80) {
+function isFile(path83) {
   try {
-    return statSync(path80).isFile();
+    return statSync(path83).isFile();
   } catch {
     return false;
   }
@@ -259,9 +259,9 @@ function linkedGitDirParent(gitDir) {
   const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
   return match ? match[1] : null;
 }
-function readTrimmed(path80) {
+function readTrimmed(path83) {
   try {
-    const content = readFileSync(path80, "utf8").trim();
+    const content = readFileSync(path83, "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(path80) {
-  if (!existsSync2(path80)) return {};
+function loadRawYaml(path83) {
+  if (!existsSync2(path83)) return {};
   try {
-    const content = readFileSync2(path80, "utf8");
+    const content = readFileSync2(path83, "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 path80 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path80.split("/").filter(Boolean);
+    const path83 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path83.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 path80 = line.split("	")[1];
-    if (path80) found.add(path80.trim());
+    const path83 = line.split("	")[1];
+    if (path83) found.add(path83.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 path80 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path80}/${ref}`;
+  const path83 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path83}/${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, path80) {
+function build(node, path83) {
   const { inner, defaultValue, optional } = unwrapSchemaNode(node);
   const secret = isSecretSchemaNode(node) || isSecretSchemaNode(inner);
   const base = {
-    path: path80,
+    path: path83,
     ...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(path80) {
+function formatConfigPath(path83) {
   let text18 = "";
-  for (const segment of path80) {
+  for (const segment of path83) {
     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, path80) {
+function resolveStringsAtPath(data, path83) {
   let current = data;
-  for (const segment of path80.split(".")) {
+  for (const segment of path83.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -4961,10 +4961,10 @@ function resolveStringsAtPath(data, path80) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path80 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path80)) {
+  for (const path83 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path83)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path80, value });
+        violations.push({ file: rule.file, path: path83, value });
     }
   }
   return violations;
@@ -5003,8 +5003,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path80, value } of violations) {
-    console.log(`  ${file} ${path80}: ${value}`);
+  for (const { file, path: path83, value } of violations) {
+    console.log(`  ${file} ${path83}: ${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((path80) => MIGRATION_FILE3.test(basename2(path80)));
-  for (const path80 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path83) => MIGRATION_FILE3.test(basename2(path83)));
+  for (const path83 of paths) {
     try {
-      const content = execSync14(`git show "${ref}:${path80}"`, {
+      const content = execSync14(`git show "${ref}:${path83}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path80), content);
+      baseline.set(basename2(path83), content);
     } catch {
     }
   }
@@ -6761,10 +6761,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path80 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname13(path80), { recursive: true });
-  writeFileSync15(path80, JSON.stringify(hooksSettings, null, 2));
-  return path80;
+  const path83 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname13(path83), { recursive: true });
+  writeFileSync15(path83, JSON.stringify(hooksSettings, null, 2));
+  return path83;
 }
 
 // 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 path80 = join15(dir, ".assist", name);
-    if (existsSync19(path80)) {
-      renameSync(path80, `${path80}.bak`);
+    const path83 = join15(dir, ".assist", name);
+    if (existsSync19(path83)) {
+      renameSync(path83, `${path83}.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(path80) {
-  const content = readFileSync15(path80, "utf8").trim();
+function parseBacklogJsonl(path83) {
+  const content = readFileSync15(path83, "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 path80 = getOwnerPath(itemId2);
-  mkdirSync7(dirname15(path80), { recursive: true });
-  writeFileSync17(path80, JSON.stringify({ sessionId }));
+  const path83 = getOwnerPath(itemId2);
+  mkdirSync7(dirname15(path83), { recursive: true });
+  writeFileSync17(path83, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path80 = getOwnerPath(itemId2);
-  if (!existsSync23(path80)) return void 0;
+  const path83 = getOwnerPath(itemId2);
+  if (!existsSync23(path83)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync16(path80, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path83, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path80 = getOwnerPath(itemId2);
+  const path83 = getOwnerPath(itemId2);
   try {
-    rmSync(path80);
+    rmSync(path83);
   } catch {
   }
 }
@@ -8410,19 +8410,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path80 = getSignalPath(target);
-  if (!path80) return;
+  const path83 = getSignalPath(target);
+  if (!path83) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname16(path80), { recursive: true });
-  writeFileSync18(path80, JSON.stringify(signal));
+  mkdirSync8(dirname16(path83), { recursive: true });
+  writeFileSync18(path83, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path80 = getSignalPath();
-  if (!path80 || !existsSync24(path80)) return void 0;
+  const path83 = getSignalPath();
+  if (!path83 || !existsSync24(path83)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path80, "utf8"));
+    return JSON.parse(readFileSync17(path83, "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 path80 = activityPath(sessionId);
-  mkdirSync9(dirname17(path80), { recursive: true });
-  writeFileSync19(path80, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path83 = activityPath(sessionId);
+  mkdirSync9(dirname17(path83), { recursive: true });
+  writeFileSync19(path83, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path80) {
+function readActivity(path83) {
   try {
-    return JSON.parse(readFileSync18(path80, "utf8"));
+    return JSON.parse(readFileSync18(path83, "utf8"));
   } catch {
     return void 0;
   }
@@ -8635,9 +8635,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path80 = activityPath(sessionId);
-  mkdirSync9(dirname17(path80), { recursive: true });
-  writeFileSync19(path80, JSON.stringify(activity2));
+  const path83 = activityPath(sessionId);
+  mkdirSync9(dirname17(path83), { recursive: true });
+  writeFileSync19(path83, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -10090,10 +10090,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path80 = getStorePath(filename);
-  if (existsSync29(path80)) {
+  const path83 = getStorePath(filename);
+  if (existsSync29(path83)) {
     try {
-      return JSON.parse(readFileSync19(path80, "utf8"));
+      return JSON.parse(readFileSync19(path83, "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(([path80, record]) => ({ path: path80, ...record }));
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path83, record]) => ({ path: path83, ...record }));
 }
-function worktreeAttributionIncludingReaped(path80) {
-  const record = loadJson(REGISTRY_FILE)[path80];
+function worktreeAttributionIncludingReaped(path83) {
+  const record = loadJson(REGISTRY_FILE)[path83];
   return record ? { clone: record.clone, origin: record.origin } : void 0;
 }
-function recordWorktree(path80, clone, origin) {
+function recordWorktree(path83, clone, origin) {
   const data = loadJson(REGISTRY_FILE);
-  data[path80] = { clone, origin };
+  data[path83] = { clone, origin };
   saveJson(REGISTRY_FILE, data);
 }
-function forgetWorktree(path80) {
+function forgetWorktree(path83) {
   const data = loadJson(REGISTRY_FILE);
-  const record = data[path80];
+  const record = data[path83];
   if (!record || record.reaped) return;
-  data[path80] = { ...record, reaped: true };
+  data[path83] = { ...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 path80 of resolved.paths) {
-      if (!bases.has(path80)) bases.set(path80, resolved.base);
+    for (const path83 of resolved.paths) {
+      if (!bases.has(path83)) bases.set(path83, 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 [path80, base] of bases) {
+  for (const [path83, base] of bases) {
     const paths = groups.get(base);
-    if (paths) paths.push(path80);
-    else groups.set(base, [path80]);
+    if (paths) paths.push(path83);
+    else groups.set(base, [path83]);
   }
   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((path80) => path80 && !bases.has(path80)).sort();
+  return output.split("\n").filter((path83) => path83 && !bases.has(path83)).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, path80) {
-  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path80], {
+async function untrackedFileDiff(cwd, path83) {
+  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path83], {
     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((path80) => untrackedFileDiff(cwd, path80))
+    paths.map((path83) => untrackedFileDiff(cwd, path83))
   );
   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, path80) {
+function resolveWithinCwd(cwd, path83) {
   const root = repoRoot(cwd);
-  const target = resolve10(root, path80);
+  const target = resolve10(root, path83);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
@@ -11034,14 +11034,14 @@ function resolveWithinCwd(cwd, path80) {
 function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return null;
-  const path80 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+  const path83 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
-  if (!path80) {
+  if (!path83) {
     respondJson(res, 400, { error: "Missing path" });
     return null;
   }
-  const target = resolveWithinCwd(cwd, path80);
+  const target = resolveWithinCwd(cwd, path83);
   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(path80) {
-  if (path80 === getGlobalConfigPath()) return "~/.assist.yml";
-  if (path80.startsWith(WINDOWS_MOUNT_PREFIX))
-    return `${path80} on the Windows host`;
-  return path80;
+function globalConfigFileLabel(path83) {
+  if (path83 === getGlobalConfigPath()) return "~/.assist.yml";
+  if (path83.startsWith(WINDOWS_MOUNT_PREFIX))
+    return `${path83} on the Windows host`;
+  return path83;
 }
 
 // src/commands/config/readRawConfigLayers.ts
@@ -11177,35 +11177,35 @@ function isPlainRecord(value) {
 }
 
 // src/shared/mapConfigSecrets.ts
-function mapChildren(value, path80, childNode, map) {
+function mapChildren(value, path83, childNode, map) {
   if (!isPlainRecord(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([name, child]) => [
       name,
-      walk(child, [...path80, name], childNode(name), map)
+      walk(child, [...path83, name], childNode(name), map)
     ])
   );
 }
-function mapItems(value, path80, item, map) {
+function mapItems(value, path83, item, map) {
   if (!Array.isArray(value)) return value;
-  return value.map((entry, index3) => walk(entry, [...path80, index3], item, map));
+  return value.map((entry, index3) => walk(entry, [...path83, index3], item, map));
 }
-function walk(value, path80, node, map) {
+function walk(value, path83, node, map) {
   if (!node || value === void 0 || value === null) return value;
-  if (node.secret) return map(value, path80);
+  if (node.secret) return map(value, path83);
   switch (node.kind) {
     case "object":
     case "unionOfObjects":
       return mapChildren(
         value,
-        path80,
+        path83,
         (name) => configNodeField(node, name),
         map
       );
     case "objectList":
-      return mapItems(value, path80, node.item, map);
+      return mapItems(value, path83, node.item, map);
     case "record":
-      return mapChildren(value, path80, () => node.value, map);
+      return mapChildren(value, path83, () => 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, path80) {
+function getNestedValue(obj, path83) {
   let current = obj;
-  for (const key of path80.split(".")) current = stepInto(current, key);
+  for (const key of path83.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -11282,9 +11282,9 @@ function step(node, segment) {
       return void 0;
   }
 }
-function findConfigNode(root, path80) {
+function findConfigNode(root, path83) {
   let current = root;
-  for (const segment of path80) {
+  for (const segment of path83) {
     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 path80 = [];
+  const path83 = [];
   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;
-      path80.push(segment);
+      path83.push(segment);
       at2 = close + 1;
       continue;
     }
     if (text18[at2] === ".") {
-      if (path80.length === 0) return void 0;
+      if (path83.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;
-    path80.push(nameSegment(name));
+    path83.push(nameSegment(name));
   }
-  return path80;
+  return path83;
 }
 
 // src/commands/config/configEntryNode.ts
 function configEntryNode(root, key) {
-  const path80 = parseConfigPath(key);
-  return path80 ? findConfigNode(root, path80) : void 0;
+  const path83 = parseConfigPath(key);
+  return path83 ? findConfigNode(root, path83) : 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((path80) => existsSync32(path80)).map((path80) => ({ path: path80, mtime: statSync4(path80).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((path83) => existsSync32(path83)).map((path83) => ({ path: path83, mtime: statSync4(path83).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 path80 = await resolveSynthesisPath(cwd);
-    if (!path80) {
+    const path83 = await resolveSynthesisPath(cwd);
+    if (!path83) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync21(path80, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path83, "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 path80 = fields[fields.length - 1];
-    if (path80) result[category].push(path80);
+    const path83 = fields[fields.length - 1];
+    if (path83) result[category].push(path83);
   }
   return result;
 }
@@ -11718,21 +11718,21 @@ function subsequenceScore(text18, query) {
   }
   return score - Math.min(text18.length, MAX_LENGTH_PENALTY);
 }
-function scoreFilePath(path80, query) {
+function scoreFilePath(path83, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename26 = path80.slice(path80.lastIndexOf("/") + 1);
+  const basename26 = path83.slice(path83.lastIndexOf("/") + 1);
   const inBasename = subsequenceScore(basename26, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
-  return subsequenceScore(path80, needle);
+  return subsequenceScore(path83, needle);
 }
 
 // src/commands/sessions/web/rankFilePaths.ts
 function rankFilePaths(paths, query, limit) {
   const scored = [];
-  for (const path80 of paths) {
-    const score = scoreFilePath(path80, query);
-    if (score !== null) scored.push({ path: path80, score });
+  for (const path83 of paths) {
+    const score = scoreFilePath(path83, query);
+    if (score !== null) scored.push({ path: path83, score });
   }
   scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
   return scored.slice(0, limit).map((entry) => entry.path);
@@ -12197,38 +12197,38 @@ async function restartWeb(req, res, deps2 = {}) {
 import { relative as relative3 } from "path";
 
 // src/commands/sessions/web/revertPathChanges.ts
-async function isTracked(cwd, path80) {
+async function isTracked(cwd, path83) {
   try {
-    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path80]);
+    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path83]);
     return true;
   } catch {
     return false;
   }
 }
-async function isInHead(cwd, path80) {
-  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path80]);
+async function isInHead(cwd, path83) {
+  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path83]);
   return listing.trim().length > 0;
 }
-async function revertPathChanges(cwd, path80) {
-  if (!await isTracked(cwd, path80)) {
-    await execGit(cwd, ["clean", "-f", "--", path80]);
+async function revertPathChanges(cwd, path83) {
+  if (!await isTracked(cwd, path83)) {
+    await execGit(cwd, ["clean", "-f", "--", path83]);
     return;
   }
-  if (await isInHead(cwd, path80)) {
-    await execGit(cwd, ["checkout", "HEAD", "--", path80]);
+  if (await isInHead(cwd, path83)) {
+    await execGit(cwd, ["checkout", "HEAD", "--", path83]);
     return;
   }
-  await execGit(cwd, ["rm", "-f", "--", path80]);
+  await execGit(cwd, ["rm", "-f", "--", path83]);
 }
 
 // src/commands/sessions/web/revertDiffFile.ts
 async function revertDiffFile(req, res) {
   const resolved = getFileTarget(req, res);
   if (!resolved) return;
-  const path80 = relative3(repoRoot(resolved.cwd), resolved.target);
+  const path83 = relative3(repoRoot(resolved.cwd), resolved.target);
   try {
-    await revertPathChanges(resolved.cwd, path80);
-    respondJson(res, 200, { reverted: path80 });
+    await revertPathChanges(resolved.cwd, path83);
+    respondJson(res, 200, { reverted: path83 });
   } catch (error) {
     respondJson(res, 500, {
       error: error instanceof Error ? error.message : "Failed to revert file"
@@ -12250,7 +12250,7 @@ async function readJsonBody(req) {
 function requestedPaths(body) {
   const paths = body.paths;
   if (!Array.isArray(paths)) return null;
-  if (paths.some((path80) => typeof path80 !== "string")) return null;
+  if (paths.some((path83) => typeof path83 !== "string")) return null;
   return paths;
 }
 async function revertDiffPaths(req, res) {
@@ -12270,10 +12270,10 @@ async function revertDiffPaths(req, res) {
   const root = repoRoot(cwd);
   const reverted = [];
   const failed2 = [];
-  for (const path80 of paths) {
-    const target = resolveWithinCwd(cwd, path80);
+  for (const path83 of paths) {
+    const target = resolveWithinCwd(cwd, path83);
     if (!target) {
-      failed2.push({ path: path80, error: "Path outside cwd" });
+      failed2.push({ path: path83, error: "Path outside cwd" });
       continue;
     }
     const relativePath = relative4(root, target);
@@ -12363,11 +12363,11 @@ function coerceStructuredConfigValue(key, raw) {
   };
 }
 function formatIssue(key, issue) {
-  const path80 = formatConfigPath([
+  const path83 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
   ]);
-  return `${path80}: ${issue.message}`;
+  return `${path83}: ${issue.message}`;
 }
 function toSegment(part) {
   return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
@@ -12462,9 +12462,9 @@ function coerceUnion(key, raw, types) {
 }
 
 // src/shared/valueAtConfigPath.ts
-function valueAtConfigPath(value, path80) {
+function valueAtConfigPath(value, path83) {
   let current = value;
-  for (const key of path80) {
+  for (const key of path83) {
     if (typeof key === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[key];
@@ -12481,7 +12481,7 @@ function restoreConfigSecrets(value, stored, node) {
   return mapConfigSecrets(
     value,
     node,
-    (secret, path80) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path80) : secret
+    (secret, path83) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path83) : secret
   );
 }
 
@@ -12530,8 +12530,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path80, value) {
-  const keys = path80.split(".");
+function setNestedValue(obj, path83, value) {
+  const keys = path83.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -12558,8 +12558,8 @@ function formatIssue2(issue, key) {
     return issue.keys.map(
       (unrecognized) => `${[...issue.path, unrecognized].join(".")}: Unrecognized key`
     );
-  const path80 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return [`${path80}: ${issue.message}`];
+  const path83 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return [`${path83}: ${issue.message}`];
 }
 
 // src/commands/config/applyConfigSet.ts
@@ -12816,8 +12816,8 @@ function removeAt(container, keys) {
   }
   return removeFromChild(container, key, rest);
 }
-function unsetNestedValue(obj, path80) {
-  const { container, removed } = removeAt(obj, path80.split("."));
+function unsetNestedValue(obj, path83) {
+  const { container, removed } = removeAt(obj, path83.split("."));
   return { config: container, removed };
 }
 
@@ -13930,9 +13930,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path80 = origin.slice(firstSlash + 1);
-  if (!path80) return null;
-  return `git@${host}:${path80}.git`;
+  const path83 = origin.slice(firstSlash + 1);
+  if (!path83) return null;
+  return `git@${host}:${path83}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -16960,9 +16960,9 @@ var __dirname4 = dirname23(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path80) {
-  if (!existsSync36(path80)) return [];
-  return readFileSync25(path80, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path83) {
+  if (!existsSync36(path83)) return [];
+  return readFileSync25(path83, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -17483,14 +17483,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, path80, description, depth, p) {
-  showProgress(p, path80.join(" "));
-  const subHelp = await runHelp([cli, ...path80]);
+async function resolveCommand(cli, path83, description, depth, p) {
+  showProgress(p, path83.join(" "));
+  const subHelp = await runHelp([cli, ...path83]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path80, description }];
+    return [{ path: path83, description }];
   }
-  const children = await discoverAt(cli, path80, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path80, description }];
+  const children = await discoverAt(cli, path83, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path83, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -17638,9 +17638,9 @@ function logPath(cli) {
   return join39(homedir17(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path80 = logPath(cli);
-  if (!existsSync38(path80)) return void 0;
-  return readFileSync27(path80, "utf8");
+  const path83 = logPath(cli);
+  if (!existsSync38(path83)) return void 0;
+  return readFileSync27(path83, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join39(homedir17(), ".assist");
@@ -17800,9 +17800,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path80 = join41(dir, entry);
+    const path83 = join41(dir, entry);
     try {
-      if (statSync6(path80).mtimeMs < cutoff) unlinkSync7(path80);
+      if (statSync6(path83).mtimeMs < cutoff) unlinkSync7(path83);
     } catch {
       continue;
     }
@@ -17812,10 +17812,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync39, readFileSync as readFileSync28 } from "fs";
 function readPinState(pin) {
-  const path80 = getPinStatePath(pin);
-  if (!existsSync39(path80)) return void 0;
+  const path83 = getPinStatePath(pin);
+  if (!existsSync39(path83)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path80, "utf8"));
+    const state = JSON.parse(readFileSync28(path83, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -18954,11 +18954,11 @@ async function loadPath(source) {
   }
 }
 async function criteriaExtension() {
-  const path80 = await loadPath(criteriaExtensionDir());
+  const path83 = await loadPath(criteriaExtensionDir());
   console.log(
     chalk139.bold("acceptance criteria outliner \u2014 GitHub browser extension")
   );
-  console.log(chalk139.dim(`load the unpacked extension from ${path80}`));
+  console.log(chalk139.dim(`load the unpacked extension from ${path83}`));
 }
 
 // src/commands/registerCriteriaExtension.ts
@@ -19051,10 +19051,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync42, readFileSync as readFileSync30 } from "fs";
 function readMigrationPinState(pin) {
-  const path80 = getMigrationPinPath(pin);
-  if (!existsSync42(path80)) return void 0;
+  const path83 = getMigrationPinPath(pin);
+  if (!existsSync42(path83)) return void 0;
   try {
-    const state = JSON.parse(readFileSync30(path80, "utf8"));
+    const state = JSON.parse(readFileSync30(path83, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -20484,10 +20484,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync48, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path80 = getMigrationApprovalPath(migrationId);
-  if (!existsSync48(path80)) return false;
+  const path83 = getMigrationApprovalPath(migrationId);
+  if (!existsSync48(path83)) return false;
   try {
-    unlinkSync11(path80);
+    unlinkSync11(path83);
     return true;
   } catch {
     return false;
@@ -22009,15 +22009,15 @@ function renderNodes(nodes, indent3) {
 function isListNode(node) {
   return node.type === "orderedList" || node.type === "bulletList";
 }
-function renderListChild(child, indent3, pad, marker2, isFirst) {
+function renderListChild(child, indent3, pad2, marker2, isFirst) {
   if (isListNode(child)) return renderNodes([child], indent3 + 1);
   if (child.type !== "paragraph") return renderNode(child, indent3);
   const text18 = renderChildren(child, indent3);
-  return isFirst ? `${pad}${marker2} ${text18}` : `${pad}  ${text18}`;
+  return isFirst ? `${pad2}${marker2} ${text18}` : `${pad2}  ${text18}`;
 }
 function renderListItem(node, indent3, marker2) {
-  const pad = "  ".repeat(indent3);
-  return (node.content ?? []).map((child, i) => renderListChild(child, indent3, pad, marker2, i === 0)).join("\n");
+  const pad2 = "  ".repeat(indent3);
+  return (node.content ?? []).map((child, i) => renderListChild(child, indent3, pad2, marker2, i === 0)).join("\n");
 }
 function adfToText(doc) {
   return renderNodes([doc], 0);
@@ -22181,11 +22181,11 @@ function recentDaemonLogLines() {
 // src/commands/sessions/daemon/worktree/canonicalTreePath.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve14 } from "path";
-function canonicalTreePath(path80) {
+function canonicalTreePath(path83) {
   try {
-    return realpathSync2(path80);
+    return realpathSync2(path83);
   } catch {
-    return resolve14(path80);
+    return resolve14(path83);
   }
 }
 
@@ -22238,22 +22238,22 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
   const isTaken = (candidate) => registered.has(candidate) || existsSync51(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
-  const path80 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
+  const path83 = 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(path80),
-    path80,
+    basename16(path83),
+    path83,
     start3.ref
   ]);
-  recordWorktree(path80, clone, getCurrentOrigin(clone));
+  recordWorktree(path83, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path80} (branch ${basename16(path80)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path80} (branch ${basename16(path80)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    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}`
   );
-  return path80;
+  return path83;
 }
 
 // src/commands/sessions/daemon/worktree/keptInTree.ts
@@ -22394,13 +22394,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 path80 = createWorktree(
+  const path83 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
     boundTreeRoots2,
     options2.replacesTree
   );
-  return { cwd: path80, kind: "worktree", created: true, clone };
+  return { cwd: path83, kind: "worktree", created: true, clone };
 }
 
 // src/commands/sessions/daemon/describePersistedSession.ts
@@ -22731,13 +22731,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 path80 = null;
+  let path83 = null;
   for (const line of listing.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("worktree "))
-      path80 = trimmed.slice("worktree ".length).trim();
+      path83 = trimmed.slice("worktree ".length).trim();
     else if (trimmed === `branch refs/heads/${branch2}`)
-      return path80 && path80 !== here ? path80 : null;
+      return path83 && path83 !== here ? path83 : null;
   }
   return null;
 }
@@ -23779,9 +23779,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path80] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path83] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path80) {
+    for (const key of path83) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -24484,16 +24484,16 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-async function comment2(path80, line, body, startLine) {
+async function comment2(path83, 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 ${path80}:${range}`, body, null);
+  await reviewProposedPrComment(`Comment on ${path83}:${range}`, body, null);
   try {
     const prId = getCurrentPrNodeId();
-    postReviewComment({ prId, body, path: path80, line, startLine });
-    console.log(`Added review comment on ${path80}:${range}`);
+    postReviewComment({ prId, body, path: path83, line, startLine });
+    console.log(`Added review comment on ${path83}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -25695,9 +25695,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 (path80, line, body) => {
+  ).action(async (path83, line, body) => {
     await comment2(
-      path80,
+      path83,
       Number.parseInt(line, 10),
       await readBodyArgument(body)
     );
@@ -26161,10 +26161,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path80) {
+async function ravenFetch(connection, path83) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path80}`;
+  const url = `${connection.url}${path83}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -26254,16 +26254,16 @@ import chalk191 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path80;
+  let path83;
   if (opts.collection) {
-    path80 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path83 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path80 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path83 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path80 += `&query=${encodeURIComponent(opts.query)}`;
+    path83 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path80;
+  return path83;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -26272,7 +26272,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 path80 = buildQueryPath({
+    const path83 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -26280,7 +26280,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path80);
+    const data = await ravenFetch(connection, path83);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -28888,8 +28888,8 @@ 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";
 function clearReviewFiles(paths) {
-  for (const path80 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync57(path80)) unlinkSync17(path80);
+  for (const path83 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync57(path83)) unlinkSync17(path83);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -29937,8 +29937,99 @@ function registerReview(program2) {
   );
 }
 
+// src/commands/rules/listRules.ts
+import path66 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 rules3 = readScopedRules(resolved);
+  if (rules3.length === 0) {
+    const label2 = path66.relative(process.cwd(), resolved) || ".";
+    console.log(chalk207.gray(`No rules in scope for ${label2}`));
+    return;
+  }
+  const base = findRepoRoot(scopeDirectory(resolved));
+  const width = Math.max(...rules3.map((rule) => rule.code.length));
+  let shown;
+  for (const rule of rules3) {
+    if (rule.source !== shown) {
+      shown = rule.source;
+      console.log(
+        chalk207.dim(base ? path66.relative(base, rule.source) : rule.source)
+      );
+    }
+    console.log(`  ${chalk207.cyan(rule.code.padEnd(width))}  ${rule.text}`);
+  }
+}
+
+// src/commands/registerRules.ts
+function registerRules(program2) {
+  const rulesCommand = program2.command("rules").description("Read the CLAUDE.md rules in scope for a path");
+  rulesCommand.command("list [path]").description(
+    "List the rules from the `## Rules` section of every CLAUDE.md from a path's directory up to the repo root (default: cwd)"
+  ).action((target) => listRules(target));
+}
+
 // src/commands/seq/seqAuth.ts
-import chalk208 from "chalk";
+import chalk209 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -29967,10 +30058,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk207 from "chalk";
+import chalk208 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk207.red(`Connection "${name}" already exists.`));
+    console.error(chalk208.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -29988,18 +30079,18 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk208.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk209.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk212 from "chalk";
+import chalk213 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk209 from "chalk";
-async function fetchSeq(conn, path80, params) {
-  const url = `${conn.url}${path80}?${params}`;
+import chalk210 from "chalk";
+async function fetchSeq(conn, path83, params) {
+  const url = `${conn.url}${path83}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -30008,7 +30099,7 @@ async function fetchSeq(conn, path80, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk209.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk210.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -30067,23 +30158,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk210 from "chalk";
+import chalk211 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk210.bgRed.white;
+      return chalk211.bgRed.white;
     case "Error":
-      return chalk210.red;
+      return chalk211.red;
     case "Warning":
-      return chalk210.yellow;
+      return chalk211.yellow;
     case "Information":
-      return chalk210.cyan;
+      return chalk211.cyan;
     case "Debug":
-      return chalk210.gray;
+      return chalk211.gray;
     case "Verbose":
-      return chalk210.dim;
+      return chalk211.dim;
     default:
-      return chalk210.white;
+      return chalk211.white;
   }
 }
 function levelAbbrev(level) {
@@ -30124,12 +30215,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk210.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk211.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines2 = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines2.push(chalk210.red(`  ${line}`));
+      lines2.push(chalk211.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -30162,11 +30253,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk211 from "chalk";
+import chalk212 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk211.red(
+      chalk212.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -30175,7 +30266,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk211.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk212.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -30204,7 +30295,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk212.yellow("No events found."));
+    console.log(chalk213.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -30215,11 +30306,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk212.dim(`
+  console.log(chalk213.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk212.yellow(
+      chalk213.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -30227,10 +30318,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk213 from "chalk";
+import chalk214 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk213.red(`Connection "${name}" not found.`));
+    console.error(chalk214.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -30279,7 +30370,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk215 from "chalk";
+import chalk216 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -30308,7 +30399,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk214 from "chalk";
+import chalk215 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -30316,7 +30407,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk214.red(`Invalid port "${portStr}".`));
+    console.error(chalk215.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -30329,13 +30420,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk215.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk216.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk216 from "chalk";
+import chalk217 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -30344,7 +30435,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk216.yellow("(no rows)"));
+    console.log(chalk217.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -30352,13 +30443,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk216.dim(header));
-  console.log(chalk216.dim("-".repeat(header.length)));
+  console.log(chalk217.dim(header));
+  console.log(chalk217.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk216.dim(`
+  console.log(chalk217.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -30418,7 +30509,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk217 from "chalk";
+import chalk218 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -30452,7 +30543,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk217.red(
+      chalk218.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -30462,18 +30553,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk217.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk218.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk218 from "chalk";
+import chalk219 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk218.red(
+      chalk219.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -30488,7 +30579,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk218.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk219.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -30551,15 +30642,15 @@ function registerSql(program2) {
 // src/commands/sync.ts
 import * as fs48 from "fs";
 import * as os5 from "os";
-import * as path74 from "path";
+import * as path77 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/sync/pruneCommands.ts
-import * as path65 from "path";
+import * as path68 from "path";
 
 // src/commands/sync/pruneTarget.ts
 import * as fs40 from "fs";
-import * as path64 from "path";
+import * as path67 from "path";
 function pruneTarget(targetDir, keepNames, shape, options2) {
   const result = {
     orphans: [],
@@ -30577,7 +30668,7 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
     }
     if (keep.has(name)) continue;
     result.orphans.push(entry.name);
-    const entryPath = path64.join(targetDir, entry.name);
+    const entryPath = path67.join(targetDir, entry.name);
     const reason4 = shape.blockedBy?.(entryPath);
     if (reason4) {
       result.skipped.push({ name: entry.name, reason: reason4 });
@@ -30597,7 +30688,7 @@ function pruneCommands(targetDir, commandNames, options2) {
     targetDir,
     commandNames,
     {
-      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path65.basename(entry.name, ".md") : void 0
+      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path68.basename(entry.name, ".md") : void 0
     },
     options2
   );
@@ -30632,24 +30723,24 @@ function reportPrune(label2, result, force) {
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
-import * as path66 from "path";
-import chalk219 from "chalk";
+import * as path69 from "path";
+import chalk220 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path66.join(claudeDir, "CLAUDE.md");
-  const target = path66.join(targetBase, "CLAUDE.md");
+  const source = path69.join(claudeDir, "CLAUDE.md");
+  const target = path69.join(targetBase, "CLAUDE.md");
   const sourceContent = fs41.readFileSync(source, "utf8");
   if (fs41.existsSync(target)) {
     const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk219.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk220.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk219.red("Overwrite existing CLAUDE.md?"),
+          chalk220.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -30664,13 +30755,13 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path69 from "path";
+import * as path72 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
 import * as fs42 from "fs";
-import * as path67 from "path";
+import * as path70 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path67.join(claudeDir, "commands");
+  const commandsSource = path70.join(claudeDir, "commands");
   const files = fs42.readdirSync(commandsSource);
   const names = [];
   let synced = 0;
@@ -30678,15 +30769,15 @@ function installHarnessCommands(claudeDir, harness, transform) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
     names.push(name);
-    const content = fs42.readFileSync(path67.join(commandsSource, file), "utf8");
-    const target = path67.join(harness.homeDir, harness.sync.commandDest(name));
-    fs42.mkdirSync(path67.dirname(target), { recursive: true });
+    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 });
     fs42.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path67.join(harness.homeDir, harness.sync.agentsFile);
-  fs42.mkdirSync(path67.dirname(agentsTarget), { recursive: true });
-  fs42.copyFileSync(path67.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path70.join(harness.homeDir, harness.sync.agentsFile);
+  fs42.mkdirSync(path70.dirname(agentsTarget), { recursive: true });
+  fs42.copyFileSync(path70.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced, names };
 }
 
@@ -30712,7 +30803,7 @@ function unexpectedContent(skillDir) {
 
 // src/commands/sync/syncCodexHooks.ts
 import * as fs44 from "fs";
-import * as path68 from "path";
+import * as path71 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -30743,9 +30834,9 @@ ${rest}
 }
 function syncCodexHooks(sourcePath) {
   const body = fs44.readFileSync(sourcePath, "utf8");
-  const configPath = path68.join(harnesses.codex.homeDir, "config.toml");
+  const configPath = path71.join(harnesses.codex.homeDir, "config.toml");
   const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
-  fs44.mkdirSync(path68.dirname(configPath), { recursive: true });
+  fs44.mkdirSync(path71.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)"
@@ -30777,7 +30868,7 @@ function syncCodex(claudeDir, options2) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path69.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path72.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
@@ -30785,42 +30876,42 @@ function syncCodex(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.codex/skills",
-    pruneSkills(path69.join(harnesses.codex.homeDir, "skills"), names, { force }),
+    pruneSkills(path72.join(harnesses.codex.homeDir, "skills"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncDesign.ts
 import * as fs45 from "fs";
-import * as path70 from "path";
+import * as path73 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path70.join(claudeDir, "design-system-prompt.md");
-  const systemPromptTarget = path70.join(targetBase, "design-system-prompt.md");
+  const systemPromptSource = path73.join(claudeDir, "design-system-prompt.md");
+  const systemPromptTarget = path73.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 = path70.join(claudeDir, "skills");
-  const skillsTarget = path70.join(targetBase, "skills");
+  const skillsSource = path73.join(claudeDir, "skills");
+  const skillsTarget = path73.join(targetBase, "skills");
   fs45.mkdirSync(skillsTarget, { recursive: true });
   const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
     fs45.copyFileSync(
-      path70.join(skillsSource, file),
-      path70.join(skillsTarget, file)
+      path73.join(skillsSource, file),
+      path73.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path72 from "path";
+import * as path75 from "path";
 
 // src/commands/sync/syncPiHooks.ts
 import * as fs46 from "fs";
-import * as path71 from "path";
+import * as path74 from "path";
 function piExtensionsDir() {
-  return path71.join(harnesses.pi.homeDir, "extensions");
+  return path74.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
@@ -30828,8 +30919,8 @@ function syncPiHooks(sourceDir) {
   const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     fs46.copyFileSync(
-      path71.join(sourceDir, file),
-      path71.join(target, `assist-${file}`)
+      path74.join(sourceDir, file),
+      path74.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -30866,7 +30957,7 @@ function syncPi(claudeDir, options2) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path72.join(claudeDir, "..", "pi"));
+  syncPiHooks(path75.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
@@ -30874,18 +30965,18 @@ function syncPi(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.pi/agent/prompts",
-    pruneCommands(path72.join(harnesses.pi.homeDir, "prompts"), names, { force }),
+    pruneCommands(path75.join(harnesses.pi.homeDir, "prompts"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
-import * as path73 from "path";
-import chalk220 from "chalk";
+import * as path76 from "path";
+import chalk221 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path73.join(claudeDir, "settings.json");
-  const target = path73.join(targetBase, "settings.json");
+  const source = path76.join(claudeDir, "settings.json");
+  const target = path76.join(targetBase, "settings.json");
   const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
   const targetExists = fs47.existsSync(target);
@@ -30901,7 +30992,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk220.yellow(
+          chalk221.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -30909,7 +31000,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk220.red("Overwrite existing settings.json?"),
+          chalk221.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -30925,13 +31016,13 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname5 = path74.dirname(__filename4);
+var __dirname5 = path77.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 = path74.join(__dirname5, "..", "claude");
-  const targetBase = path74.join(os5.homedir(), ".claude");
+  const claudeDir = path77.join(__dirname5, "..", "claude");
+  const targetBase = path77.join(os5.homedir(), ".claude");
   const commandFiles = syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -30939,21 +31030,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) => path74.basename(file, ".md"));
+  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path77.basename(file, ".md"));
   const force = options2.force ?? false;
   reportPrune(
     "~/.claude/commands",
-    pruneCommands(path74.join(targetBase, "commands"), commandNames, { force }),
+    pruneCommands(path77.join(targetBase, "commands"), commandNames, { force }),
     force
   );
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path74.join(claudeDir, "commands");
-  const targetDir = path74.join(targetBase, "commands");
+  const sourceDir = path77.join(claudeDir, "commands");
+  const targetDir = path77.join(targetBase, "commands");
   fs48.mkdirSync(targetDir, { recursive: true });
   const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs48.copyFileSync(path74.join(sourceDir, file), path74.join(targetDir, file));
+    fs48.copyFileSync(path77.join(sourceDir, file), path77.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -30981,10 +31072,7 @@ function registerSync(program2) {
 }
 
 // src/commands/transcript/clean.ts
-import { existsSync as existsSync64 } from "fs";
-
-// src/commands/transcript/convertVttToMarkdown.ts
-import { readFileSync as readFileSync50 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text18) {
@@ -31189,25 +31277,59 @@ function formatChatLog(messages) {
   return messages.map((msg) => `${msg.speaker}: ${msg.text}`).join("\n\n");
 }
 
-// src/commands/transcript/convertVttToMarkdown.ts
-function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync50(inputPath, "utf8"));
-  const messages = cuesToChatMessages(deduplicateCues(cues));
-  return formatChatLog(messages);
+// src/commands/transcript/convert/formatVtt.ts
+function pad(value, width) {
+  return String(value).padStart(width, "0");
+}
+function formatTimestamp2(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  return `${pad(hours, 2)}:${pad(minutes, 2)}:${pad(seconds, 2)}.${pad(ms % 1e3, 3)}`;
+}
+function formatCue(cue) {
+  const timing = `${formatTimestamp2(cue.startMs)} --> ${formatTimestamp2(cue.endMs)}`;
+  const text18 = cue.speaker ? `<v ${cue.speaker}>${cue.text}` : cue.text;
+  return `${timing}
+${text18}`;
+}
+function formatVtt(cues) {
+  return ["WEBVTT", ...cues.map(formatCue)].join("\n\n");
+}
+
+// src/commands/transcript/convert/readCleanedCues.ts
+import { readFileSync as readFileSync51 } from "fs";
+function readCleanedCues(inputPath) {
+  return deduplicateCues(parseVtt(readFileSync51(inputPath, "utf8")));
 }
 
 // src/commands/transcript/clean.ts
-function clean(file) {
-  if (!existsSync64(file)) {
+var FORMATS = ["md", "vtt"];
+function isCleanFormat(value) {
+  return FORMATS.includes(value);
+}
+function serialise(cues, format) {
+  return format === "vtt" ? formatVtt(cues) : formatChatLog(cuesToChatMessages(cues));
+}
+function clean(file, options2 = {}) {
+  const format = options2.format ?? "md";
+  if (!isCleanFormat(format)) {
+    console.error(
+      `Error: --format must be one of: ${FORMATS.join(", ")} (got: ${format})`
+    );
+    process.exit(1);
+  }
+  if (!existsSync66(file)) {
     console.error(`Error: VTT file not found: ${file}`);
     process.exit(1);
   }
-  const markdown = convertVttToMarkdown(file);
-  if (!markdown) {
+  const cues = readCleanedCues(file);
+  if (cues.length === 0) {
     console.error(`Error: no cues found in: ${file}`);
     process.exit(1);
   }
-  console.log(markdown);
+  console.log(serialise(cues, format));
 }
 
 // src/commands/transcript/shared.ts
@@ -31281,21 +31403,28 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync65, readdirSync as readdirSync19, statSync as statSync10 } from "fs";
+import { existsSync as existsSync67, readdirSync as readdirSync19, statSync as statSync11 } from "fs";
 import { join as join78 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync65(vttDir)) return;
+  if (!existsSync67(vttDir)) return;
   for (const entry of readdirSync19(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync10(join78(vttDir, entry)).isDirectory()) continue;
+    if (statSync11(join78(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
-import { existsSync as existsSync66, mkdirSync as mkdirSync27, renameSync as renameSync2, writeFileSync as writeFileSync43 } from "fs";
+import { existsSync as existsSync68, mkdirSync as mkdirSync27, renameSync as renameSync2, writeFileSync as writeFileSync43 } from "fs";
 import { basename as basename21, join as join79 } from "path";
+
+// src/commands/transcript/convertVttToMarkdown.ts
+function convertVttToMarkdown(inputPath) {
+  return formatChatLog(cuesToChatMessages(readCleanedCues(inputPath)));
+}
+
+// src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function archiveRawVtt(vttDir, sourcePath, filename) {
   const processedDir = join79(vttDir, "processed");
@@ -31311,7 +31440,7 @@ function move(file, options2) {
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename21(file);
   const sourcePath = join79(vttDir, filename);
-  if (!existsSync66(sourcePath)) {
+  if (!existsSync68(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
@@ -31333,7 +31462,7 @@ function registerTranscript(program2) {
   configHelp(transcriptCommand, transcriptConfigHelp);
   transcriptCommand.command("configure").description("Configure transcript directories").action(configure);
   transcriptCommand.command("list").description("List raw .vtt filenames waiting in the pick-up directory").action(list4);
-  transcriptCommand.command("clean <path>").description("Clean any .vtt file and write the chat log to stdout").action(clean);
+  transcriptCommand.command("clean <path>").description("Clean any .vtt file and write the result to stdout").option("--format <md|vtt>", "output format", "md").action(clean);
   transcriptCommand.command("move <file>").description(
     "Convert a raw .vtt to a dated markdown transcript and archive the original"
   ).requiredOption("--date <YYYY-MM-DD>", "meeting date").requiredOption("--client <name>", "client name").action(move);
@@ -31441,14 +31570,14 @@ function devices() {
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync67, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync69, readFileSync as readFileSync52 } from "fs";
 function logs(options2) {
-  if (!existsSync67(voicePaths.log)) {
+  if (!existsSync69(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync51(voicePaths.log, "utf8").trim();
+  const content = readFileSync52(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -31475,7 +31604,7 @@ import { join as join83 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync68, mkdirSync as mkdirSync28, readFileSync as readFileSync52, writeFileSync as writeFileSync44 } from "fs";
+import { existsSync as existsSync70, mkdirSync as mkdirSync28, readFileSync as readFileSync53, writeFileSync as writeFileSync44 } from "fs";
 import { join as join82 } from "path";
 function isProcessAlive2(pid) {
   try {
@@ -31487,9 +31616,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync68(lockFile)) return;
+  if (!existsSync70(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync52(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync53(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -31500,7 +31629,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync68(getVenvPython())) return;
+  if (existsSync70(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync58(
@@ -31591,7 +31720,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync69, readFileSync as readFileSync53 } from "fs";
+import { existsSync as existsSync71, readFileSync as readFileSync54 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -31601,16 +31730,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync69(voicePaths.log)) return [];
-  const lines2 = readFileSync53(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync71(voicePaths.log)) return [];
+  const lines2 = readFileSync54(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync69(voicePaths.pid)) {
+  if (!existsSync71(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync53(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync54(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -31629,13 +31758,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync70, readFileSync as readFileSync54, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync72, readFileSync as readFileSync55, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync70(voicePaths.pid)) {
+  if (!existsSync72(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync54(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync55(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -31648,7 +31777,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync70(lockFile)) unlinkSync20(lockFile);
+    if (existsSync72(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -31773,11 +31902,11 @@ var webUiPrefix = "src/commands/sessions/web/ui/";
 var sessionsPrefix = "src/commands/sessions/";
 var rules = [
   {
-    matches: (path80) => path80.startsWith(webUiPrefix),
+    matches: (path83) => path83.startsWith(webUiPrefix),
     advice: "restart the web server, then hard-reload the browser tab"
   },
   {
-    matches: (path80) => path80.startsWith(sessionsPrefix) && !path80.startsWith(webUiPrefix),
+    matches: (path83) => path83.startsWith(sessionsPrefix) && !path83.startsWith(webUiPrefix),
     advice: "restart the daemon"
   }
 ];
@@ -31788,31 +31917,31 @@ function restartAdvice(paths) {
 // src/commands/watch/syncAdvice.ts
 var rules2 = [
   {
-    matches: (path80) => path80.startsWith("claude/commands/"),
+    matches: (path83) => path83.startsWith("claude/commands/"),
     reason: "claude/commands changed"
   },
   {
-    matches: (path80) => path80.startsWith("claude/skills/"),
+    matches: (path83) => path83.startsWith("claude/skills/"),
     reason: "claude/skills changed"
   },
   {
-    matches: (path80) => path80 === "claude/settings.json",
+    matches: (path83) => path83 === "claude/settings.json",
     reason: "claude/settings.json changed"
   },
   {
-    matches: (path80) => path80 === "claude/CLAUDE.md",
+    matches: (path83) => path83 === "claude/CLAUDE.md",
     reason: "claude/CLAUDE.md changed"
   },
   {
-    matches: (path80) => path80 === "claude/design-system-prompt.md",
+    matches: (path83) => path83 === "claude/design-system-prompt.md",
     reason: "claude/design-system-prompt.md changed"
   },
   {
-    matches: (path80) => path80.startsWith("codex/"),
+    matches: (path83) => path83.startsWith("codex/"),
     reason: "codex sources changed"
   },
   {
-    matches: (path80) => path80.startsWith("pi/"),
+    matches: (path83) => path83.startsWith("pi/"),
     reason: "pi sources changed"
   }
 ];
@@ -32053,7 +32182,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 import { resolve as resolve19 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -32066,17 +32195,17 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve19(baseDir, config.cwd);
-  if (!existsSync71(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync73(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync73 } from "fs";
+import { existsSync as existsSync75 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync16 } from "child_process";
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync74 } from "fs";
 import { dirname as dirname37, join as join86, resolve as resolve20 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
@@ -32084,7 +32213,7 @@ function resolveCommand2(command) {
     const gitPath = execFileSync16("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve20(dirname37(gitPath), "..");
     const gitBash = join86(gitRoot, "bin", "bash.exe");
-    if (existsSync72(gitBash)) return gitBash;
+    if (existsSync74(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -32094,7 +32223,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync73(cwd)) {
+    if (cwd && !existsSync75(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -32351,7 +32480,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk221 from "chalk";
+import chalk222 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -32482,13 +32611,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk221.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk222.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk221.white("http://localhost:14523/callback\n"));
-  console.log(chalk221.blue("Opening browser for authorization..."));
-  console.log(chalk221.dim("Waiting for authorization callback..."));
+  console.log(chalk222.white("http://localhost:14523/callback\n"));
+  console.log(chalk222.blue("Opening browser for authorization..."));
+  console.log(chalk222.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk221.dim("Exchanging code for tokens..."));
+  console.log(chalk222.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -32504,13 +32633,13 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk221.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk222.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import { readdirSync as readdirSync20, readFileSync as readFileSync55, statSync as statSync11 } from "fs";
+import { readdirSync as readdirSync20, readFileSync as readFileSync56, statSync as statSync12 } from "fs";
 import { join as join87 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -32520,9 +32649,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path80 = join87(roamDir, name);
+    const path83 = join87(roamDir, name);
     try {
-      return { path: path80, mtimeMs: statSync11(path80).mtimeMs };
+      return { path: path83, mtimeMs: statSync12(path83).mtimeMs };
     } catch {
       return void 0;
     }
@@ -32536,7 +32665,7 @@ function postRoamActivity(app, event) {
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync55(portFile, "utf8").trim();
+    port = readFileSync56(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -32758,11 +32887,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path80 = process.argv[idx + 1];
+  const path83 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path80, prefix: prefix2 };
+  return { path: path83, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -32790,7 +32919,7 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync74, unlinkSync as unlinkSync21 } from "fs";
+import { existsSync as existsSync76, unlinkSync as unlinkSync21 } from "fs";
 import { join as join89 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
@@ -32807,7 +32936,7 @@ function parseRemoveName() {
 }
 function deleteCommandFile(name) {
   const filePath = join89(".claude", "commands", `${name}.md`);
-  if (existsSync74(filePath)) {
+  if (existsSync76(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -32852,10 +32981,10 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync75, mkdirSync as mkdirSync32, unlinkSync as unlinkSync22, writeFileSync as writeFileSync47 } from "fs";
+import { existsSync as existsSync77, mkdirSync as mkdirSync32, unlinkSync as unlinkSync22, writeFileSync as writeFileSync47 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
 import { join as join90, resolve as resolve21 } from "path";
-import chalk222 from "chalk";
+import chalk223 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -32984,7 +33113,7 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync75(outputDir)) {
+  if (!existsSync77(outputDir)) {
     mkdirSync32(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -33006,13 +33135,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve21(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk222.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk223.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk222.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk223.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk222.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk223.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -33068,11 +33197,11 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/readDaemonPidFile.ts
-import { readFileSync as readFileSync56 } from "fs";
+import { readFileSync as readFileSync57 } from "fs";
 function readDaemonPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync56(daemonPaths.pid, "utf8").trim(),
+      readFileSync57(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -33329,12 +33458,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync76 } from "fs";
+import { existsSync as existsSync78 } from "fs";
 function joinRefusal(session) {
   if (session.commandType === "run") return "a server run has no agent stream";
   if (session.closing === true) return "the session is closing";
   if (!session.cwd) return "the session has no working directory";
-  if (!existsSync76(session.cwd))
+  if (!existsSync78(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -33498,27 +33627,27 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync78 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync77, statSync as statSync12 } from "fs";
+import { chmodSync, existsSync as existsSync79, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path75 from "path";
+import path78 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path75.join(path75.dirname(require4.resolve("node-pty")), "..");
-  const helper = path75.join(
+  const ptyRoot = path78.join(path78.dirname(require4.resolve("node-pty")), "..");
+  const helper = path78.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync77(helper)) return;
-  const mode = statSync12(helper).mode;
+  if (!existsSync79(helper)) return;
+  const mode = statSync13(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
 
@@ -33553,7 +33682,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync78(cwd)) return;
+  if (!cwd || existsSync80(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -33632,12 +33761,12 @@ function serverRunMeta(runName, cwd) {
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs49 from "fs";
-import * as path76 from "path";
+import * as path79 from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 var __filename5 = fileURLToPath10(import.meta.url);
-var __dirname7 = path76.dirname(__filename5);
+var __dirname7 = path79.dirname(__filename5);
 function readDesignSystemPrompt() {
-  const promptPath = path76.join(
+  const promptPath = path79.join(
     __dirname7,
     "..",
     "claude",
@@ -33735,15 +33864,15 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync80 } from "fs";
+import { existsSync as existsSync82 } from "fs";
 import { basename as basename22 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync79 } from "fs";
+import { existsSync as existsSync81 } from "fs";
 import { join as join93 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
-import { statSync as statSync13 } from "fs";
+import { statSync as statSync14 } from "fs";
 import { rm as rm2 } from "fs/promises";
 import { join as join92 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
@@ -33773,7 +33902,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync13(join92(worktreePath, ".git"), {
+  return statSync14(join92(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -33809,7 +33938,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync79(join93(worktreePath, ".git")))
+  if (!existsSync81(join93(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -33861,7 +33990,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync80(worktreePath)) {
+  if (!existsSync82(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -33886,7 +34015,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync80(recorded)) return recorded;
+  if (recorded && existsSync82(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -34017,12 +34146,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync81, watch } from "fs";
+import { existsSync as existsSync83, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync81(common)) return void 0;
+  if (!common || !existsSync83(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -34499,10 +34628,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync82 } from "fs";
+import { existsSync as existsSync84 } from "fs";
 import { resolve as resolve22 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync82(session.cwd))
+  if (session.cwd && !existsSync84(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -34516,7 +34645,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve22(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync82(configured)) return void 0;
+  if (existsSync84(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -34557,7 +34686,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync83, mkdirSync as mkdirSync33, watch as watch2 } from "fs";
+import { existsSync as existsSync85, mkdirSync as mkdirSync33, watch as watch2 } from "fs";
 import { dirname as dirname39 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -34619,8 +34748,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path80 = activityPath(session.id);
-  const dir = dirname39(path80);
+  const path83 = activityPath(session.id);
+  const dir = dirname39(path83);
   try {
     mkdirSync33(dir, { recursive: true });
   } catch {
@@ -34630,7 +34759,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   let timer = null;
   const read2 = () => {
     timer = null;
-    const activity2 = readActivity(path80);
+    const activity2 = readActivity(path83);
     if (!activity2) return;
     applyActivityToSession(session, activity2);
     if (activity2.claudeSessionId) onClaudeSessionId?.(session);
@@ -34639,11 +34768,11 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     notify2();
   };
   session.activityWatcher = watch2(dir, (_event, filename) => {
-    if (filename && !path80.endsWith(filename)) return;
+    if (filename && !path83.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read2, DEBOUNCE_MS2);
   });
-  if (existsSync83(path80)) read2();
+  if (existsSync85(path83)) read2();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -34786,12 +34915,12 @@ import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
 import * as fs51 from "fs";
-import * as path77 from "path";
+import * as path80 from "path";
 function projectDirForCwd(cwd) {
-  return path77.join(claudeProjectsRoot(), projectSlug(cwd));
+  return path80.join(claudeProjectsRoot(), projectSlug(cwd));
 }
 function transcriptPathFor(cwd, claudeSessionId) {
-  return path77.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+  return path80.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
@@ -34805,8 +34934,8 @@ function findTranscriptPathSync(cwd, claudeSessionId) {
   }
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
-    if (headContainsSessionId(path77.join(dir, file), claudeSessionId))
-      return path77.join(dir, file);
+    if (headContainsSessionId(path80.join(dir, file), claudeSessionId))
+      return path80.join(dir, file);
   }
   return null;
 }
@@ -35980,9 +36109,9 @@ function tempRoots() {
   }
   return [...roots];
 }
-function underTempRoot(path80) {
+function underTempRoot(path83) {
   return tempRoots().some(
-    (root) => path80.startsWith(root.endsWith(sep2) ? root : root + sep2)
+    (root) => path83.startsWith(root.endsWith(sep2) ? root : root + sep2)
   );
 }
 
@@ -36294,7 +36423,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync86 } from "fs";
+import { existsSync as existsSync88 } from "fs";
 import { basename as basename24 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -36349,18 +36478,18 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync87 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync85(clone)) {
-    for (const { path: path80 } of paths) forgetWorktree(path80);
+  if (!existsSync87(clone)) {
+    for (const { path: path83 } of paths) forgetWorktree(path83);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
   await pruneBookkeeping2(clone);
-  for (const { path: path80, branch: branch2 } of paths)
-    if (await reclaimBranch(clone, branch2)) forgetWorktree(path80);
+  for (const { path: path83, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path83);
 }
 async function pruneBookkeeping2(clone) {
   try {
@@ -36387,37 +36516,37 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/logVanishedTree.ts
-function logVanishedTree(sessions, path80) {
+function logVanishedTree(sessions, path83) {
   const claimants = [...sessions.values()].filter(
-    (s) => s.cwd === path80 || s.worktree?.path === path80
+    (s) => s.cwd === path83 || s.worktree?.path === path83
   );
   if (claimants.length === 0) {
-    daemonLog(`worktree ${path80} gone from disk and unclaimed; reclaiming it`);
+    daemonLog(`worktree ${path83} gone from disk and unclaimed; reclaiming it`);
     return;
   }
   for (const s of claimants)
     daemonLog(
-      `session ${s.id} ("${s.name}") claims worktree ${path80}, which is gone from disk; reclaiming it`
+      `session ${s.id} ("${s.name}") claims worktree ${path83}, which is gone from disk; reclaiming it`
     );
 }
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path80, reason4) {
-  if (reason4.startsWith("uncommitted")) return await changedFiles(path80);
-  if (reason4.startsWith("unpushed")) return await unpushedCommits(path80, reason4);
+async function describeHeldWork(path83, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path83);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path83, reason4);
   return { summary: reason4, items: [] };
 }
-async function changedFiles(path80) {
-  const status3 = await gitResult(path80, ["status", "--porcelain"]);
+async function changedFiles(path83) {
+  const status3 = await gitResult(path83, ["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(path80, reason4) {
-  const log2 = await gitResult(path80, ["log", "--oneline", "@{upstream}..HEAD"]);
+async function unpushedCommits(path83, reason4) {
+  const log2 = await gitResult(path83, ["log", "--oneline", "@{upstream}..HEAD"]);
   if (!log2.ok) return { summary: reason4, items: [] };
   const lines2 = nonEmptyLines(log2.out);
   return {
@@ -36509,24 +36638,24 @@ function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
 async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
-  for (const { path: path80, clone } of readWorktreeRegistry()) {
-    if (underTempRoot(path80)) {
-      forgetWorktree(path80);
+  for (const { path: path83, clone } of readWorktreeRegistry()) {
+    if (underTempRoot(path83)) {
+      forgetWorktree(path83);
       daemonLog(
-        `worktree ${path80} lies outside any project root; pruned from the registry rather than recovered`
+        `worktree ${path83} lies outside any project root; pruned from the registry rather than recovered`
       );
       continue;
     }
-    if (!existsSync86(path80)) {
-      logVanishedTree(sessions, path80);
+    if (!existsSync88(path83)) {
+      logVanishedTree(sessions, path83);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path80, branch: basename24(path80) }
+        { path: path83, branch: basename24(path83) }
       ]);
       continue;
     }
-    if (accounted.has(path80)) continue;
-    await recoverOrphan(sessions, spawnWith, { path: path80, clone }, notify2);
+    if (accounted.has(path83)) continue;
+    await recoverOrphan(sessions, spawnWith, { path: path83, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
     await reclaimVanishedWorktrees(clone, paths);
@@ -37134,14 +37263,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync87, readFileSync as readFileSync58 } from "fs";
+import { existsSync as existsSync89, readFileSync as readFileSync59 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync87(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync58(sessionsFile, "utf8"));
+    if (!existsSync89(sessionsFile)) return false;
+    const data = JSON.parse(readFileSync59(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
@@ -37875,7 +38004,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync90 } from "fs";
+import { existsSync as existsSync92 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -37906,10 +38035,10 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync89 } from "fs";
+import { existsSync as existsSync91 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync7, existsSync as existsSync88, mkdirSync as mkdirSync35 } from "fs";
+import { copyFileSync as copyFileSync7, existsSync as existsSync90, mkdirSync as mkdirSync35 } from "fs";
 import { join as join95 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
@@ -37920,7 +38049,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   const dest = join95(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync88(dest)) {
+  if (existsSync90(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -37971,7 +38100,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync89(clone))
+  if (!clone || !existsSync91(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -37980,7 +38109,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync90(cwd))
+  if (!existsSync92(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -38247,12 +38376,12 @@ function handleSetStatus(client, m, d) {
 import * as fs54 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
-import * as path78 from "path";
+import * as path81 from "path";
 async function findCodexRolloutPath(sessionId) {
   if (!sessionId) return null;
   const paths = await discoverCodexRolloutPaths();
   const suffix = `-${sessionId}.jsonl`;
-  return paths.find((file) => path78.basename(file).endsWith(suffix)) ?? null;
+  return paths.find((file) => path81.basename(file).endsWith(suffix)) ?? null;
 }
 
 // src/commands/sessions/shared/codex/codexToolTarget.ts
@@ -38560,7 +38689,7 @@ function handleConnection(socket, manager) {
 import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync48 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync59 } from "fs";
+import { readFileSync as readFileSync60 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -38571,7 +38700,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync59(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync60(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -38821,7 +38950,7 @@ function registerSetStatusCommand(cmd) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs56 from "fs";
-import chalk223 from "chalk";
+import chalk224 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs55 from "fs";
@@ -38880,22 +39009,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk223.yellow("No sessions found."));
+    console.log(chalk224.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk223.green("All sessions already summarised."));
+    console.log(chalk224.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk223.cyan(
+    chalk224.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk223.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk223.yellow(`, ${failed2} skipped`) : "")
+    chalk224.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk224.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -38915,16 +39044,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk223.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk224.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk223.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk224.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk223.yellow("skip")}
+      process.stdout.write(` ${chalk224.yellow("skip")}
 `);
     }
   }
@@ -38945,7 +39074,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk225 from "chalk";
+import chalk226 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -38955,7 +39084,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk224 from "chalk";
+import chalk225 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -38993,9 +39122,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk224.green,
-  warn: chalk224.yellow,
-  over: chalk224.red
+  ok: chalk225.green,
+  warn: chalk225.yellow,
+  over: chalk225.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -39026,13 +39155,13 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync61, statSync as statSync15 } from "fs";
+import { readFileSync as readFileSync62, statSync as statSync16 } from "fs";
 import { isAbsolute as isAbsolute5, join as join96, resolve as resolve23 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join96(cwd, ".git");
   let stat4;
   try {
-    stat4 = statSync15(dotGit);
+    stat4 = statSync16(dotGit);
   } catch {
     return null;
   }
@@ -39041,7 +39170,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync61(dotGit, "utf8");
+    contents = readFileSync62(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -39059,7 +39188,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync61(join96(gitDir, "HEAD"), "utf8");
+    head = readFileSync62(join96(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -39091,7 +39220,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk225.level = 3;
+chalk226.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -39099,9 +39228,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk225.red(label2);
+      return chalk226.red(label2);
     case "yellow":
-      return chalk225.yellow(label2);
+      return chalk226.yellow(label2);
     default:
       return label2;
   }
@@ -39114,7 +39243,7 @@ async function statusLine() {
   const usedPct = data.context_window.used_percentage ?? 0;
   const dir = data.workspace?.current_dir ?? data.cwd;
   const branch2 = dir ? readGitBranch(toGitCwd(dir)) : null;
-  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk225.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk226.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -39128,7 +39257,7 @@ async function statusLine() {
 
 // src/commands/update.ts
 import { execSync as execSync61 } from "child_process";
-import * as path79 from "path";
+import * as path82 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -39147,12 +39276,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path79.resolve(dir);
-    if (resolved.split(path79.sep).includes("node_modules")) {
+    const resolved = path82.resolve(dir);
+    if (resolved.split(path82.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync61("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path79.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path82.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -39184,10 +39313,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk226 from "chalk";
+import chalk227 from "chalk";
 function reportCliError(error) {
   if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
-    console.error(chalk226.red(error.message));
+    console.error(chalk227.red(error.message));
   } else {
     console.error(error);
   }
@@ -39239,6 +39368,7 @@ registerList(program);
 registerVerify(program);
 registerRefactor(program);
 registerReview(program);
+registerRules(program);
 registerDevlog(program);
 registerDeploy(program);
 registerComplexity(program);