@staff0rd/assist 0.637.0 → 0.638.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.637.0",
+  version: "0.638.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -307,8 +307,8 @@ function getRemoteOriginUrl(cwd) {
 }
 
 // src/commands/backlog/getCurrentOrigin.ts
-function stripLeadingSlashes(path90) {
-  return path90.replace(/^\/+/, "");
+function stripLeadingSlashes(path91) {
+  return path91.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -358,9 +358,9 @@ function findGitLink(dir) {
   }
   return null;
 }
-function isFile(path90) {
+function isFile(path91) {
   try {
-    return statSync(path90).isFile();
+    return statSync(path91).isFile();
   } catch {
     return false;
   }
@@ -379,9 +379,9 @@ function linkedGitDirParent(gitDir) {
   const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
   return match ? match[1] : null;
 }
-function readTrimmed(path90) {
+function readTrimmed(path91) {
   try {
-    const content = readFileSync2(path90, "utf8").trim();
+    const content = readFileSync2(path91, "utf8").trim();
     return content === "" ? null : content;
   } catch {
     return null;
@@ -394,10 +394,10 @@ function absolute(target, from) {
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path90) {
-  if (!existsSync3(path90)) return {};
+function loadRawYaml(path91) {
+  if (!existsSync3(path91)) return {};
   try {
-    const content = readFileSync3(path90, "utf8");
+    const content = readFileSync3(path91, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -469,8 +469,8 @@ function mergeRawConfigs(globalRaw, projectRaw) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path90 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path90.split("/").filter(Boolean);
+    const path91 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path91.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -2867,11 +2867,11 @@ function enumValues(node) {
 function opaqueConfigNode(inner, base) {
   return { ...base, kind: "other", type: leafTypeOf(inner) };
 }
-function build(node, path90) {
+function build(node, path91) {
   const { inner, defaultValue, optional } = unwrapSchemaNode(node);
   const secret = isSecretSchemaNode(node) || isSecretSchemaNode(inner);
   const base = {
-    path: path90,
+    path: path91,
     ...optional ? { optional: true } : {},
     ...defaultValue === void 0 ? {} : { defaultValue },
     ...secret ? { secret: true } : {}
@@ -2890,9 +2890,9 @@ function segmentText(segment) {
   if (segment.kind === "index") return `[${segment.index}]`;
   return "[]";
 }
-function formatConfigPath(path90) {
+function formatConfigPath(path91) {
   let text18 = "";
-  for (const segment of path90) {
+  for (const segment of path91) {
     const dotted = segment.kind === "key" || segment.kind === "entry";
     const rendered = segmentText(segment);
     text18 += dotted && text18 ? `.${rendered}` : rendered;
@@ -3590,9 +3590,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, path90) {
+function resolveStringsAtPath(data, path91) {
   let current = data;
-  for (const segment of path90.split(".")) {
+  for (const segment of path91.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3605,10 +3605,10 @@ function resolveStringsAtPath(data, path90) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path90 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path90)) {
+  for (const path91 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path91)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path90, value });
+        violations.push({ file: rule.file, path: path91, value });
     }
   }
   return violations;
@@ -3647,8 +3647,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path90, value } of violations) {
-    console.log(`  ${file} ${path90}: ${value}`);
+  for (const { file, path: path91, value } of violations) {
+    console.log(`  ${file} ${path91}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -4251,15 +4251,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path90) => MIGRATION_FILE3.test(basename2(path90)));
-  for (const path90 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path91) => MIGRATION_FILE3.test(basename2(path91)));
+  for (const path91 of paths) {
     try {
-      const content = execSync6(`git show "${ref}:${path90}"`, {
+      const content = execSync6(`git show "${ref}:${path91}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path90), content);
+      baseline.set(basename2(path91), content);
     } catch {
     }
   }
@@ -6307,10 +6307,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path90 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname13(path90), { recursive: true });
-  writeFileSync15(path90, JSON.stringify(hooksSettings, null, 2));
-  return path90;
+  const path91 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname13(path91), { recursive: true });
+  writeFileSync15(path91, JSON.stringify(hooksSettings, null, 2));
+  return path91;
 }
 
 // src/shared/spawnInherit.ts
@@ -6488,8 +6488,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path90 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path90}/${ref}`;
+  const path91 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path91}/${ref}`;
 }
 
 // src/commands/branch/buildBranchName.ts
@@ -6732,9 +6732,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path90 = join15(dir, ".assist", name);
-    if (existsSync19(path90)) {
-      renameSync(path90, `${path90}.bak`);
+    const path91 = join15(dir, ".assist", name);
+    if (existsSync19(path91)) {
+      renameSync(path91, `${path91}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -6972,12 +6972,15 @@ function attachGitRefs(item, rel, id) {
 
 // src/commands/backlog/attachSessions.ts
 function rowToSession(s) {
-  return {
+  const session = {
     phaseIdx: s.phaseIdx,
     claudeSessionId: s.claudeSessionId,
     hostname: s.hostname,
     osUser: s.osUser
   };
+  if (s.createdAt != null)
+    session.createdAt = new Date(s.createdAt).toISOString();
+  return session;
 }
 function attachSessions(item, rel, id) {
   const sessions = (rel.sessions.get(id) ?? []).map(rowToSession);
@@ -7147,7 +7150,8 @@ var phaseSessionSchema = z4.strictObject({
   phaseIdx: z4.number(),
   claudeSessionId: z4.string(),
   hostname: z4.string(),
-  osUser: z4.string()
+  osUser: z4.string(),
+  createdAt: z4.string().optional()
 });
 var phaseUsageTotalSchema = z4.strictObject({
   tokensUp: z4.number(),
@@ -7214,8 +7218,8 @@ var backlogItemSchema = z4.strictObject({
 var backlogFileSchema = z4.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path90) {
-  const content = readFileSync15(path90, "utf8").trim();
+function parseBacklogJsonl(path91) {
+  const content = readFileSync15(path91, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -8026,24 +8030,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path90 = getOwnerPath(itemId2);
-  mkdirSync7(dirname15(path90), { recursive: true });
-  writeFileSync17(path90, JSON.stringify({ sessionId }));
+  const path91 = getOwnerPath(itemId2);
+  mkdirSync7(dirname15(path91), { recursive: true });
+  writeFileSync17(path91, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path90 = getOwnerPath(itemId2);
-  if (!existsSync23(path90)) return void 0;
+  const path91 = getOwnerPath(itemId2);
+  if (!existsSync23(path91)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync16(path90, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path91, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path90 = getOwnerPath(itemId2);
+  const path91 = getOwnerPath(itemId2);
   try {
-    rmSync(path90);
+    rmSync(path91);
   } catch {
   }
 }
@@ -8080,19 +8084,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path90 = getSignalPath(target);
-  if (!path90) return;
+  const path91 = getSignalPath(target);
+  if (!path91) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname16(path90), { recursive: true });
-  writeFileSync18(path90, JSON.stringify(signal));
+  mkdirSync8(dirname16(path91), { recursive: true });
+  writeFileSync18(path91, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path90 = getSignalPath();
-  if (!path90 || !existsSync24(path90)) return void 0;
+  const path91 = getSignalPath();
+  if (!path91 || !existsSync24(path91)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path90, "utf8"));
+    return JSON.parse(readFileSync17(path91, "utf8"));
   } catch {
     return void 0;
   }
@@ -8290,13 +8294,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path90 = activityPath(sessionId);
-  mkdirSync9(dirname17(path90), { recursive: true });
-  writeFileSync19(path90, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path91 = activityPath(sessionId);
+  mkdirSync9(dirname17(path91), { recursive: true });
+  writeFileSync19(path91, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path90) {
+function readActivity(path91) {
   try {
-    return JSON.parse(readFileSync18(path90, "utf8"));
+    return JSON.parse(readFileSync18(path91, "utf8"));
   } catch {
     return void 0;
   }
@@ -8306,9 +8310,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path90 = activityPath(sessionId);
-  mkdirSync9(dirname17(path90), { recursive: true });
-  writeFileSync19(path90, JSON.stringify(activity2));
+  const path91 = activityPath(sessionId);
+  mkdirSync9(dirname17(path91), { recursive: true });
+  writeFileSync19(path91, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -9160,15 +9164,15 @@ import chalk52 from "chalk";
 // src/commands/backlog/groupActivityRefs.ts
 var ACTIVITY_COMMIT_LIMIT = 10;
 function groupActivityRefs(refs, commitLimit = ACTIVITY_COMMIT_LIMIT) {
-  const newestFirst = (kind) => refs.filter((r) => r.kind === kind).reverse();
-  const commits2 = newestFirst("commit");
+  const newestFirst2 = (kind) => refs.filter((r) => r.kind === kind).reverse();
+  const commits2 = newestFirst2("commit");
   return {
-    branches: newestFirst("branch"),
+    branches: newestFirst2("branch"),
     commits: commits2.slice(0, commitLimit),
     overflowCommits: commits2.slice(commitLimit),
-    prs: newestFirst("pr"),
-    slacks: newestFirst("slack"),
-    sessions: newestFirst("session")
+    prs: newestFirst2("pr"),
+    slacks: newestFirst2("slack"),
+    sessions: newestFirst2("session")
   };
 }
 
@@ -9761,10 +9765,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path90 = getStorePath(filename);
-  if (existsSync29(path90)) {
+  const path91 = getStorePath(filename);
+  if (existsSync29(path91)) {
     try {
-      return JSON.parse(readFileSync19(path90, "utf8"));
+      return JSON.parse(readFileSync19(path91, "utf8"));
     } catch {
       return {};
     }
@@ -9783,22 +9787,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(([path90, record]) => ({ path: path90, ...record }));
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path91, record]) => ({ path: path91, ...record }));
 }
-function worktreeAttributionIncludingReaped(path90) {
-  const record = loadJson(REGISTRY_FILE)[path90];
+function worktreeAttributionIncludingReaped(path91) {
+  const record = loadJson(REGISTRY_FILE)[path91];
   return record ? { clone: record.clone, origin: record.origin } : void 0;
 }
-function recordWorktree(path90, clone, origin) {
+function recordWorktree(path91, clone, origin) {
   const data = loadJson(REGISTRY_FILE);
-  data[path90] = { clone, origin };
+  data[path91] = { clone, origin };
   saveJson(REGISTRY_FILE, data);
 }
-function forgetWorktree(path90) {
+function forgetWorktree(path91) {
   const data = loadJson(REGISTRY_FILE);
-  const record = data[path90];
+  const record = data[path91];
   if (!record || record.reaped) return;
-  data[path90] = { ...record, reaped: true };
+  data[path91] = { ...record, reaped: true };
   saveJson(REGISTRY_FILE, data);
 }
 
@@ -10064,6 +10068,78 @@ async function updateStarred(orm, id, starred) {
   return row?.name;
 }
 
+// src/commands/sessions/shared/lookupSessionsById.ts
+import * as path30 from "path";
+var CODEX_ROLLOUT_ID_LENGTH = 36;
+async function lookupSessionsById(ids) {
+  const wanted = new Set(ids);
+  if (wanted.size === 0) return /* @__PURE__ */ new Map();
+  const found = /* @__PURE__ */ new Map();
+  const [claudePaths, codexPaths] = await Promise.all([
+    discoverSessionJsonlPaths(),
+    discoverCodexRolloutPaths()
+  ]);
+  await Promise.all([
+    ...claudePaths.map(async ({ path: filePath, origin }) => {
+      const id = path30.basename(filePath, ".jsonl");
+      if (!wanted.has(id)) return;
+      const session = await parseSessionFile(filePath, origin);
+      if (session) found.set(id, session);
+    }),
+    ...codexPaths.map(async (filePath) => {
+      const id = codexRolloutIdFromFilename(filePath);
+      if (!id || !wanted.has(id)) return;
+      const session = await parseCodexSessionFile(filePath);
+      if (session) found.set(id, session);
+    })
+  ]);
+  return found;
+}
+function codexRolloutIdFromFilename(filePath) {
+  const name = path30.basename(filePath, ".jsonl");
+  return name.length > CODEX_ROLLOUT_ID_LENGTH ? name.slice(-CODEX_ROLLOUT_ID_LENGTH) : void 0;
+}
+
+// src/commands/backlog/web/itemConversations.ts
+async function itemConversations(item) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const ref of item.gitRefs ?? []) {
+    if (ref.kind !== "session" || byId.has(ref.ref)) continue;
+    byId.set(ref.ref, {
+      sessionId: ref.ref,
+      ...ref.title && { title: ref.title },
+      ...ref.createdAt && { createdAt: ref.createdAt }
+    });
+  }
+  for (const session of item.phaseSessions ?? []) {
+    const { claudeSessionId: sessionId, createdAt } = session;
+    if (byId.has(sessionId)) continue;
+    byId.set(sessionId, { sessionId, ...createdAt && { createdAt } });
+  }
+  if (byId.size === 0) return [];
+  const transcripts = await lookupSessionsById([...byId.keys()]);
+  return [...byId.values()].map(
+    (conversation) => withTranscript(conversation, transcripts.get(conversation.sessionId))
+  ).sort(newestFirst);
+}
+function withTranscript(conversation, transcript) {
+  if (!transcript) return conversation;
+  return {
+    ...conversation,
+    ...transcript.cwd && { cwd: transcript.cwd },
+    ...transcript.harness && { harness: transcript.harness },
+    title: conversation.title ?? transcript.name,
+    createdAt: conversation.createdAt ?? transcript.timestamp
+  };
+}
+function sortKey(conversation) {
+  const parsed = Date.parse(conversation.createdAt ?? "");
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+function newestFirst(a, b) {
+  return sortKey(b) - sortKey(a);
+}
+
 // src/commands/backlog/loadBacklogSummaries.ts
 async function loadBacklogSummaries(allRepos = false) {
   const { orm } = await getReady();
@@ -10148,7 +10224,11 @@ async function findItemOr404(res, id) {
 }
 async function getItemById(res, id) {
   const result = await findItemOr404(res, id);
-  if (result) respondJson(res, 200, withReviewPhase(result.item));
+  if (!result) return;
+  const item = withReviewPhase(result.item);
+  const conversations = await itemConversations(item);
+  if (conversations.length > 0) item.conversations = conversations;
+  respondJson(res, 200, item);
 }
 async function deleteItem2(res, id) {
   const result = await findItemOr404(res, id);
@@ -10550,8 +10630,8 @@ async function loadCommittedPaths(cwd, sessionId) {
   for (const commit2 of commits2) {
     const resolved = await resolveCommit(cwd, commit2.sha);
     if (!resolved) continue;
-    for (const path90 of resolved.paths) {
-      if (!bases.has(path90)) bases.set(path90, resolved.base);
+    for (const path91 of resolved.paths) {
+      if (!bases.has(path91)) bases.set(path91, resolved.base);
     }
   }
   return { commits: commits2, bases };
@@ -10569,16 +10649,16 @@ async function itemChangeSet(cwd, sessionId) {
 }
 function groupByBase(bases) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [path90, base] of bases) {
+  for (const [path91, base] of bases) {
     const paths = groups.get(base);
-    if (paths) paths.push(path90);
-    else groups.set(base, [path90]);
+    if (paths) paths.push(path91);
+    else groups.set(base, [path91]);
   }
   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((path90) => path90 && !bases.has(path90)).sort();
+  return output.split("\n").filter((path91) => path91 && !bases.has(path91)).sort();
 }
 
 // src/commands/sessions/web/scopedDiff.ts
@@ -10587,8 +10667,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, path90) {
-  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path90], {
+async function untrackedFileDiff(cwd, path91) {
+  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path91], {
     maxBuffer: MAX_DIFF_BYTES,
     allowFailure: true
   });
@@ -10601,7 +10681,7 @@ async function untrackedDiff(cwd) {
   ]);
   const paths = list5.split("\n").filter(Boolean);
   const diffs = await Promise.all(
-    paths.map((path90) => untrackedFileDiff(cwd, path90))
+    paths.map((path91) => untrackedFileDiff(cwd, path91))
   );
   return diffs.join("");
 }
@@ -10694,9 +10774,9 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve10
 function repoRoot(cwd) {
   return resolve10(toGitCwd(cwd));
 }
-function resolveWithinCwd(cwd, path90) {
+function resolveWithinCwd(cwd, path91) {
   const root = repoRoot(cwd);
-  const target = resolve10(root, path90);
+  const target = resolve10(root, path91);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
@@ -10706,14 +10786,14 @@ function resolveWithinCwd(cwd, path90) {
 function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return null;
-  const path90 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+  const path91 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
-  if (!path90) {
+  if (!path91) {
     respondJson(res, 400, { error: "Missing path" });
     return null;
   }
-  const target = resolveWithinCwd(cwd, path90);
+  const target = resolveWithinCwd(cwd, path91);
   if (!target) {
     respondJson(res, 400, { error: "Path outside cwd" });
     return null;
@@ -10788,11 +10868,11 @@ function globalConfigTargetFor(cwd) {
 
 // src/commands/config/globalConfigFileLabel.ts
 var WINDOWS_MOUNT_PREFIX = "/mnt/";
-function globalConfigFileLabel(path90) {
-  if (path90 === getGlobalConfigPath()) return "~/.assist.yml";
-  if (path90.startsWith(WINDOWS_MOUNT_PREFIX))
-    return `${path90} on the Windows host`;
-  return path90;
+function globalConfigFileLabel(path91) {
+  if (path91 === getGlobalConfigPath()) return "~/.assist.yml";
+  if (path91.startsWith(WINDOWS_MOUNT_PREFIX))
+    return `${path91} on the Windows host`;
+  return path91;
 }
 
 // src/commands/config/readRawConfigLayers.ts
@@ -10849,35 +10929,35 @@ function isPlainRecord(value) {
 }
 
 // src/shared/mapConfigSecrets.ts
-function mapChildren(value, path90, childNode, map) {
+function mapChildren(value, path91, childNode, map) {
   if (!isPlainRecord(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([name, child]) => [
       name,
-      walk(child, [...path90, name], childNode(name), map)
+      walk(child, [...path91, name], childNode(name), map)
     ])
   );
 }
-function mapItems(value, path90, item, map) {
+function mapItems(value, path91, item, map) {
   if (!Array.isArray(value)) return value;
-  return value.map((entry, index3) => walk(entry, [...path90, index3], item, map));
+  return value.map((entry, index3) => walk(entry, [...path91, index3], item, map));
 }
-function walk(value, path90, node, map) {
+function walk(value, path91, node, map) {
   if (!node || value === void 0 || value === null) return value;
-  if (node.secret) return map(value, path90);
+  if (node.secret) return map(value, path91);
   switch (node.kind) {
     case "object":
     case "unionOfObjects":
       return mapChildren(
         value,
-        path90,
+        path91,
         (name) => configNodeField(node, name),
         map
       );
     case "objectList":
-      return mapItems(value, path90, node.item, map);
+      return mapItems(value, path91, node.item, map);
     case "record":
-      return mapChildren(value, path90, () => node.value, map);
+      return mapChildren(value, path91, () => node.value, map);
     default:
       return value;
   }
@@ -10902,9 +10982,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path90) {
+function getNestedValue(obj, path91) {
   let current = obj;
-  for (const key of path90.split(".")) current = stepInto(current, key);
+  for (const key of path91.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -10954,9 +11034,9 @@ function step(node, segment) {
       return void 0;
   }
 }
-function findConfigNode(root, path90) {
+function findConfigNode(root, path91) {
   let current = root;
-  for (const segment of path90) {
+  for (const segment of path91) {
     if (!current) return void 0;
     current = step(current, segment);
   }
@@ -10973,34 +11053,34 @@ function nameSegment(name) {
   return name === RECORD_ENTRY_TOKEN ? { kind: "entry" } : { kind: "key", name };
 }
 function parseConfigPath(text18) {
-  const path90 = [];
+  const path91 = [];
   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;
-      path90.push(segment);
+      path91.push(segment);
       at2 = close + 1;
       continue;
     }
     if (text18[at2] === ".") {
-      if (path90.length === 0) return void 0;
+      if (path91.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;
-    path90.push(nameSegment(name));
+    path91.push(nameSegment(name));
   }
-  return path90;
+  return path91;
 }
 
 // src/commands/config/configEntryNode.ts
 function configEntryNode(root, key) {
-  const path90 = parseConfigPath(key);
-  return path90 ? findConfigNode(root, path90) : void 0;
+  const path91 = parseConfigPath(key);
+  return path91 ? findConfigNode(root, path91) : void 0;
 }
 
 // src/commands/config/configHelpForKey.ts
@@ -11124,18 +11204,18 @@ function handleServerRuns(req, res) {
 import { execFile as execFile4 } from "child_process";
 import { readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir13 } from "os";
-import { basename as basename9, join as join30 } from "path";
+import { basename as basename10, join as join30 } from "path";
 import { promisify as promisify3 } from "util";
 
 // src/commands/sessions/web/findSynthesisForBranch.ts
 import { existsSync as existsSync32, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
-import { basename as basename8, dirname as dirname21, join as join29 } from "path";
+import { basename as basename9, dirname as dirname21, join as join29 } from "path";
 function findSynthesisForBranch(repoReviewsDir, branch2) {
   const branchKeyPath = join29(repoReviewsDir, `${branch2}-`);
   const parent = dirname21(branchKeyPath);
-  const branchPrefix = basename8(branchKeyPath);
+  const branchPrefix = basename9(branchKeyPath);
   if (!existsSync32(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path90) => existsSync32(path90)).map((path90) => ({ path: path90, mtime: statSync4(path90).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join29(parent, name, "synthesis.md")).filter((path91) => existsSync32(path91)).map((path91) => ({ path: path91, mtime: statSync4(path91).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -11157,7 +11237,7 @@ async function resolveSynthesisPath(cwd) {
     homedir13(),
     ".assist",
     "reviews",
-    basename9(repoRoot2)
+    basename10(repoRoot2)
   );
   return findSynthesisForBranch(repoReviewsDir, branch2);
 }
@@ -11165,12 +11245,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path90 = await resolveSynthesisPath(cwd);
-    if (!path90) {
+    const path91 = await resolveSynthesisPath(cwd);
+    if (!path91) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync21(path90, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path91, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -11253,8 +11333,8 @@ function parseDiffNameStatus(output) {
     if (!status3 || fields.length < 2) continue;
     const category = categorize(status3[0]);
     if (!category) continue;
-    const path90 = fields[fields.length - 1];
-    if (path90) result[category].push(path90);
+    const path91 = fields[fields.length - 1];
+    if (path91) result[category].push(path91);
   }
   return result;
 }
@@ -11390,21 +11470,21 @@ function subsequenceScore(text18, query) {
   }
   return score - Math.min(text18.length, MAX_LENGTH_PENALTY);
 }
-function scoreFilePath(path90, query) {
+function scoreFilePath(path91, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename27 = path90.slice(path90.lastIndexOf("/") + 1);
-  const inBasename = subsequenceScore(basename27, needle);
+  const basename28 = path91.slice(path91.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename28, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
-  return subsequenceScore(path90, needle);
+  return subsequenceScore(path91, needle);
 }
 
 // src/commands/sessions/web/rankFilePaths.ts
 function rankFilePaths(paths, query, limit) {
   const scored = [];
-  for (const path90 of paths) {
-    const score = scoreFilePath(path90, query);
-    if (score !== null) scored.push({ path: path90, score });
+  for (const path91 of paths) {
+    const score = scoreFilePath(path91, query);
+    if (score !== null) scored.push({ path: path91, score });
   }
   scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
   return scored.slice(0, limit).map((entry) => entry.path);
@@ -11563,11 +11643,11 @@ async function listNewsItems(_req, res) {
 }
 
 // src/commands/sessions/web/listScopedRules.ts
-import path32 from "path";
+import path33 from "path";
 
 // src/commands/rules/readScopedRules.ts
 import { existsSync as existsSync34, readFileSync as readFileSync22 } from "fs";
-import path31 from "path";
+import path32 from "path";
 
 // src/commands/rules/rulesSectionRange.ts
 var RULES_HEADING = /^##\s+rules\s*$/i;
@@ -11616,10 +11696,10 @@ function parseRulesSection(content) {
 
 // src/commands/rules/scopeDirectory.ts
 import { existsSync as existsSync33, statSync as statSync5 } from "fs";
-import path30 from "path";
+import path31 from "path";
 function scopeDirectory(target) {
-  const resolved = path30.resolve(target);
-  return existsSync33(resolved) && statSync5(resolved).isDirectory() ? resolved : path30.dirname(resolved);
+  const resolved = path31.resolve(target);
+  return existsSync33(resolved) && statSync5(resolved).isDirectory() ? resolved : path31.dirname(resolved);
 }
 
 // src/commands/rules/readScopedRules.ts
@@ -11629,10 +11709,10 @@ function scopedClaudeFiles(target) {
   const files = [];
   let current = startDir;
   while (true) {
-    const candidate = path31.join(current, "CLAUDE.md");
+    const candidate = path32.join(current, "CLAUDE.md");
     if (existsSync34(candidate)) files.push(candidate);
-    if (current === root || current === path31.dirname(current)) break;
-    current = path31.dirname(current);
+    if (current === root || current === path32.dirname(current)) break;
+    current = path32.dirname(current);
   }
   return files;
 }
@@ -11663,7 +11743,7 @@ function listScopedRules(req, res) {
     respondJson(res, 200, {
       rules: readScopedRules(target).map((rule) => ({
         ...rule,
-        source: path32.relative(root, rule.source) || rule.source
+        source: path33.relative(root, rule.source) || rule.source
       }))
     });
   } catch {
@@ -12145,38 +12225,38 @@ async function restartWeb(req, res, deps2 = {}) {
 import { relative as relative3 } from "path";
 
 // src/commands/sessions/web/revertPathChanges.ts
-async function isTracked(cwd, path90) {
+async function isTracked(cwd, path91) {
   try {
-    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path90]);
+    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path91]);
     return true;
   } catch {
     return false;
   }
 }
-async function isInHead(cwd, path90) {
-  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path90]);
+async function isInHead(cwd, path91) {
+  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path91]);
   return listing.trim().length > 0;
 }
-async function revertPathChanges(cwd, path90) {
-  if (!await isTracked(cwd, path90)) {
-    await execGit(cwd, ["clean", "-f", "--", path90]);
+async function revertPathChanges(cwd, path91) {
+  if (!await isTracked(cwd, path91)) {
+    await execGit(cwd, ["clean", "-f", "--", path91]);
     return;
   }
-  if (await isInHead(cwd, path90)) {
-    await execGit(cwd, ["checkout", "HEAD", "--", path90]);
+  if (await isInHead(cwd, path91)) {
+    await execGit(cwd, ["checkout", "HEAD", "--", path91]);
     return;
   }
-  await execGit(cwd, ["rm", "-f", "--", path90]);
+  await execGit(cwd, ["rm", "-f", "--", path91]);
 }
 
 // src/commands/sessions/web/revertDiffFile.ts
 async function revertDiffFile(req, res) {
   const resolved = getFileTarget(req, res);
   if (!resolved) return;
-  const path90 = relative3(repoRoot(resolved.cwd), resolved.target);
+  const path91 = relative3(repoRoot(resolved.cwd), resolved.target);
   try {
-    await revertPathChanges(resolved.cwd, path90);
-    respondJson(res, 200, { reverted: path90 });
+    await revertPathChanges(resolved.cwd, path91);
+    respondJson(res, 200, { reverted: path91 });
   } catch (error) {
     respondJson(res, 500, {
       error: error instanceof Error ? error.message : "Failed to revert file"
@@ -12198,7 +12278,7 @@ async function readJsonBody(req) {
 function requestedPaths(body) {
   const paths = body.paths;
   if (!Array.isArray(paths)) return null;
-  if (paths.some((path90) => typeof path90 !== "string")) return null;
+  if (paths.some((path91) => typeof path91 !== "string")) return null;
   return paths;
 }
 async function revertDiffPaths(req, res) {
@@ -12218,10 +12298,10 @@ async function revertDiffPaths(req, res) {
   const root = repoRoot(cwd);
   const reverted = [];
   const failed2 = [];
-  for (const path90 of paths) {
-    const target = resolveWithinCwd(cwd, path90);
+  for (const path91 of paths) {
+    const target = resolveWithinCwd(cwd, path91);
     if (!target) {
-      failed2.push({ path: path90, error: "Path outside cwd" });
+      failed2.push({ path: path91, error: "Path outside cwd" });
       continue;
     }
     const relativePath = relative4(root, target);
@@ -12311,11 +12391,11 @@ function coerceStructuredConfigValue(key, raw) {
   };
 }
 function formatIssue(key, issue) {
-  const path90 = formatConfigPath([
+  const path91 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
   ]);
-  return `${path90}: ${issue.message}`;
+  return `${path91}: ${issue.message}`;
 }
 function toSegment(part) {
   return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
@@ -12410,9 +12490,9 @@ function coerceUnion(key, raw, types) {
 }
 
 // src/shared/valueAtConfigPath.ts
-function valueAtConfigPath(value, path90) {
+function valueAtConfigPath(value, path91) {
   let current = value;
-  for (const key of path90) {
+  for (const key of path91) {
     if (typeof key === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[key];
@@ -12429,7 +12509,7 @@ function restoreConfigSecrets(value, stored, node) {
   return mapConfigSecrets(
     value,
     node,
-    (secret, path90) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path90) : secret
+    (secret, path91) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path91) : secret
   );
 }
 
@@ -12478,8 +12558,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path90, value) {
-  const keys = path90.split(".");
+function setNestedValue(obj, path91, value) {
+  const keys = path91.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -12506,8 +12586,8 @@ function formatIssue2(issue, key) {
     return issue.keys.map(
       (unrecognized) => `${[...issue.path, unrecognized].join(".")}: Unrecognized key`
     );
-  const path90 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return [`${path90}: ${issue.message}`];
+  const path91 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return [`${path91}: ${issue.message}`];
 }
 
 // src/commands/config/applyConfigSet.ts
@@ -12764,8 +12844,8 @@ function removeAt(container, keys) {
   }
   return removeFromChild(container, key, rest);
 }
-function unsetNestedValue(obj, path90) {
-  const { container, removed } = removeAt(obj, path90.split("."));
+function unsetNestedValue(obj, path91) {
+  const { container, removed } = removeAt(obj, path91.split("."));
   return { config: container, removed };
 }
 
@@ -13549,7 +13629,7 @@ import chalk63 from "chalk";
 
 // src/commands/sessions/shared/resolveSessionTranscript.ts
 import * as fs22 from "fs";
-import * as path34 from "path";
+import * as path35 from "path";
 
 // src/commands/sessions/summarise/readTranscriptHead.ts
 import * as fs21 from "fs";
@@ -13570,9 +13650,9 @@ function readTranscriptHead(filePath, maxBytes = 65536) {
 
 // src/commands/sessions/shared/claudeProjectsRoot.ts
 import * as os4 from "os";
-import * as path33 from "path";
+import * as path34 from "path";
 function claudeProjectsRoot() {
-  return path33.join(os4.homedir(), ".claude", "projects");
+  return path34.join(os4.homedir(), ".claude", "projects");
 }
 function projectSlug(cwd) {
   return cwd.replace(/[^a-zA-Z0-9]/g, "-");
@@ -13595,7 +13675,7 @@ function findTranscriptFile(sessionId, projectsRoot) {
     return void 0;
   }
   for (const dir of projectDirs) {
-    const candidate = path34.join(projectsRoot, dir, `${sessionId}.jsonl`);
+    const candidate = path35.join(projectsRoot, dir, `${sessionId}.jsonl`);
     if (fs22.existsSync(candidate)) return candidate;
   }
   return void 0;
@@ -13647,12 +13727,12 @@ import chalk64 from "chalk";
 
 // src/commands/sessions/shared/resolveCurrentSessionId.ts
 import * as fs23 from "fs";
-import * as path35 from "path";
+import * as path36 from "path";
 var SESSION_ID_ENV = "CLAUDE_CODE_SESSION_ID";
 function resolveCurrentSessionId(options2 = {}) {
   const fromEnv = (options2.env ?? process.env)[SESSION_ID_ENV];
   if (fromEnv) return fromEnv;
-  const dir = path35.join(
+  const dir = path36.join(
     options2.projectsRoot ?? claudeProjectsRoot(),
     projectSlug(options2.cwd ?? process.cwd())
   );
@@ -13668,10 +13748,10 @@ function newestTranscriptId(dir) {
   let newest;
   for (const entry of entries) {
     if (!entry.endsWith(".jsonl")) continue;
-    const modifiedAt = modifiedAtOf(path35.join(dir, entry));
+    const modifiedAt = modifiedAtOf(path36.join(dir, entry));
     if (modifiedAt === void 0) continue;
     if (!newest || modifiedAt > newest.modifiedAt)
-      newest = { id: path35.basename(entry, ".jsonl"), modifiedAt };
+      newest = { id: path36.basename(entry, ".jsonl"), modifiedAt };
   }
   return newest?.id;
 }
@@ -13908,9 +13988,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path90 = origin.slice(firstSlash + 1);
-  if (!path90) return null;
-  return `git@${host}:${path90}.git`;
+  const path91 = origin.slice(firstSlash + 1);
+  if (!path91) return null;
+  return `git@${host}:${path91}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -16538,7 +16618,7 @@ function registerBranch(program2) {
 }
 
 // src/commands/cliHook/index.ts
-import { basename as basename11 } from "path";
+import { basename as basename12 } from "path";
 
 // src/shared/splitCompound.ts
 import { parse } from "shell-quote";
@@ -16935,13 +17015,13 @@ function findBuiltinDenyRaw(rawCommand) {
 
 // src/commands/cliHook/findRestrictedPathDeny.ts
 var RESTRICTED_PATHS = [".assist/restricted"];
-function restrictedPathRegex(path90) {
-  const pattern2 = path90.split("/").map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join(String.raw`[/\\]`);
+function restrictedPathRegex(path91) {
+  const pattern2 = path91.split("/").map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join(String.raw`[/\\]`);
   return new RegExp(pattern2);
 }
-var RESTRICTED_PATH_RULES = RESTRICTED_PATHS.map((path90) => ({
-  path: path90,
-  regex: restrictedPathRegex(path90)
+var RESTRICTED_PATH_RULES = RESTRICTED_PATHS.map((path91) => ({
+  path: path91,
+  regex: restrictedPathRegex(path91)
 }));
 function findRestrictedPathDenyRaw(rawCommand) {
   const rule = RESTRICTED_PATH_RULES.find(
@@ -17090,9 +17170,9 @@ var __dirname4 = dirname23(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path90) {
-  if (!existsSync38(path90)) return [];
-  return readFileSync26(path90, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path91) {
+  if (!existsSync38(path91)) return [];
+  return readFileSync26(path91, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -17455,7 +17535,7 @@ async function cliHook() {
       logDeniedToolCall({
         tool: input.toolName,
         command: input.command,
-        repo: basename11(process.cwd()),
+        repo: basename12(process.cwd()),
         sessionId: process.env.CLAUDE_SESSION_ID,
         denyReason: decision.permissionDecisionReason
       });
@@ -17616,14 +17696,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, path90, description, depth, p) {
-  showProgress(p, path90.join(" "));
-  const subHelp = await runHelp([cli, ...path90]);
+async function resolveCommand(cli, path91, description, depth, p) {
+  showProgress(p, path91.join(" "));
+  const subHelp = await runHelp([cli, ...path91]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path90, description }];
+    return [{ path: path91, description }];
   }
-  const children = await discoverAt(cli, path90, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path90, description }];
+  const children = await discoverAt(cli, path91, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path91, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -17771,9 +17851,9 @@ function logPath(cli) {
   return join39(homedir17(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path90 = logPath(cli);
-  if (!existsSync40(path90)) return void 0;
-  return readFileSync28(path90, "utf8");
+  const path91 = logPath(cli);
+  if (!existsSync40(path91)) return void 0;
+  return readFileSync28(path91, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join39(homedir17(), ".assist");
@@ -17933,9 +18013,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path90 = join41(dir, entry);
+    const path91 = join41(dir, entry);
     try {
-      if (statSync7(path90).mtimeMs < cutoff) unlinkSync7(path90);
+      if (statSync7(path91).mtimeMs < cutoff) unlinkSync7(path91);
     } catch {
       continue;
     }
@@ -17945,10 +18025,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync41, readFileSync as readFileSync29 } from "fs";
 function readPinState(pin) {
-  const path90 = getPinStatePath(pin);
-  if (!existsSync41(path90)) return void 0;
+  const path91 = getPinStatePath(pin);
+  if (!existsSync41(path91)) return void 0;
   try {
-    const state = JSON.parse(readFileSync29(path90, "utf8"));
+    const state = JSON.parse(readFileSync29(path91, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -18280,8 +18360,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path90 = line.split("	")[1];
-    if (path90) found.add(path90.trim());
+    const path91 = line.split("	")[1];
+    if (path91) found.add(path91.trim());
   }
   return [...found];
 }
@@ -18603,13 +18683,13 @@ import chalk125 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs25 from "fs";
-import path37 from "path";
+import path38 from "path";
 import chalk124 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
 import fs24 from "fs";
-import path36 from "path";
+import path37 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
   const { complexity } = loadConfig();
@@ -18623,7 +18703,7 @@ function walk2(dir, results) {
   const extensions = [".ts", ".tsx"];
   const entries = fs24.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path36.join(dir, entry.name);
+    const fullPath = path37.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name !== "node_modules" && entry.name !== ".git") {
         walk2(fullPath, results);
@@ -18845,7 +18925,7 @@ function countSloc(content) {
 function createSourceFromFile(filePath) {
   const content = fs25.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
-    path37.basename(filePath),
+    path38.basename(filePath),
     content,
     ts5.ScriptTarget.Latest,
     true,
@@ -19007,12 +19087,12 @@ function formatResultLine(entry, failing) {
 
 // src/commands/complexity/maintainability/getMaintainabilityGitState.ts
 import { execSync as execSync36 } from "child_process";
-import path38 from "path";
+import path39 from "path";
 function git3(command) {
   return execSync36(command, { encoding: "utf8" });
 }
 function toAbsolute(root, repoRelative) {
-  return path38.resolve(root, repoRelative);
+  return path39.resolve(root, repoRelative);
 }
 function collectShrunkFiles(root) {
   const shrunk = /* @__PURE__ */ new Set();
@@ -19052,7 +19132,7 @@ function getMaintainabilityGitState() {
 }
 
 // src/commands/complexity/maintainability/printMaintainabilityFailure.ts
-import path39 from "path";
+import path40 from "path";
 import chalk128 from "chalk";
 var extractTemplate = "assist refactor extract <file> <functionName> <destination> --apply";
 function remediationLine(entry) {
@@ -19061,7 +19141,7 @@ function remediationLine(entry) {
     ${chalk128.cyan(extractTemplate)}`;
 }
 function cheatLine(entry, gitState) {
-  const shrank = gitState.shrunkFiles.has(path39.resolve(entry.file));
+  const shrank = gitState.shrunkFiles.has(path40.resolve(entry.file));
   if (!shrank || gitState.newFileCreated) return "";
   return `
     ${chalk128.red("\u2717 You shrank existing lines in this file without creating a new file. That cannot clear the gate \u2014 extract a responsibility to a new file.")}`;
@@ -19506,11 +19586,11 @@ async function loadPath(source) {
   }
 }
 async function criteriaExtension() {
-  const path90 = await loadPath(criteriaExtensionDir());
+  const path91 = await loadPath(criteriaExtensionDir());
   console.log(
     chalk139.bold("acceptance criteria outliner \u2014 GitHub browser extension")
   );
-  console.log(chalk139.dim(`load the unpacked extension from ${path90}`));
+  console.log(chalk139.dim(`load the unpacked extension from ${path91}`));
 }
 
 // src/commands/criteriaExtension/signCriteriaExtension.ts
@@ -19635,10 +19715,10 @@ async function signCriteriaExtension() {
     process.exitCode = 1;
     return;
   }
-  const path90 = await signedAddonInstallPath(
+  const path91 = await signedAddonInstallPath(
     await copySignedXpi(xpi, ARTIFACTS_DIR)
   );
-  console.log(chalk141.dim(`install the signed add-on from ${path90}`));
+  console.log(chalk141.dim(`install the signed add-on from ${path91}`));
 }
 
 // src/commands/registerCriteriaExtension.ts
@@ -19736,10 +19816,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync46, readFileSync as readFileSync31 } from "fs";
 function readMigrationPinState(pin) {
-  const path90 = getMigrationPinPath(pin);
-  if (!existsSync46(path90)) return void 0;
+  const path91 = getMigrationPinPath(pin);
+  if (!existsSync46(path91)) return void 0;
   try {
-    const state = JSON.parse(readFileSync31(path90, "utf8"));
+    const state = JSON.parse(readFileSync31(path91, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -19864,7 +19944,7 @@ function registerDeploy(program2) {
 
 // src/commands/devlog/list/index.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { basename as basename13 } from "path";
+import { basename as basename14 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
 import { homedir as homedir20 } from "os";
@@ -19883,7 +19963,7 @@ import chalk146 from "chalk";
 
 // src/shared/getRepoName.ts
 import { existsSync as existsSync48, readFileSync as readFileSync33 } from "fs";
-import { basename as basename12, join as join50 } from "path";
+import { basename as basename13, join as join50 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
@@ -19900,7 +19980,7 @@ function getRepoName() {
     } catch {
     }
   }
-  return basename12(process.cwd());
+  return basename13(process.cwd());
 }
 
 // src/commands/devlog/loadDevlogEntries.ts
@@ -20036,7 +20116,7 @@ function list3(options2) {
   const config = loadConfig();
   const days = options2.days ?? 30;
   const ignore3 = options2.ignore ?? config.devlog?.ignore ?? [];
-  const repoName = basename13(process.cwd());
+  const repoName = basename14(process.cwd());
   const skipDays = loadBlogSkipDays(repoName);
   const devlogEntries = loadDevlogEntries(repoName);
   const args = ["log"];
@@ -20448,7 +20528,7 @@ async function checkBuildLocksCommand() {
 
 // src/commands/dotnet/buildTree.ts
 import { readFileSync as readFileSync35 } from "fs";
-import path40 from "path";
+import path41 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
   const content = readFileSync35(csprojPath, "utf8");
@@ -20459,14 +20539,14 @@ function getProjectRefs(csprojPath) {
   return refs;
 }
 function buildTree(csprojPath, repoRoot2, visited = /* @__PURE__ */ new Set()) {
-  const abs = path40.resolve(csprojPath);
-  const rel = path40.relative(repoRoot2, abs);
+  const abs = path41.resolve(csprojPath);
+  const rel = path41.relative(repoRoot2, abs);
   const node = { path: abs, relativePath: rel, children: [] };
   if (visited.has(abs)) return node;
   visited.add(abs);
-  const dir = path40.dirname(abs);
+  const dir = path41.dirname(abs);
   for (const ref of getProjectRefs(abs)) {
-    const childAbs = path40.resolve(dir, ref);
+    const childAbs = path41.resolve(dir, ref);
     try {
       readFileSync35(childAbs);
       node.children.push(buildTree(childAbs, repoRoot2, visited));
@@ -20494,7 +20574,7 @@ function collectAllDeps(node) {
 
 // src/commands/dotnet/findContainingSolutions.ts
 import { readdirSync as readdirSync8, readFileSync as readFileSync36, statSync as statSync8 } from "fs";
-import path41 from "path";
+import path42 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
@@ -20507,7 +20587,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules" || entry === "packages")
       continue;
-    const full = path41.join(dir, entry);
+    const full = path42.join(dir, entry);
     try {
       const stat4 = statSync8(full);
       if (stat4.isFile() && entry.endsWith(".sln")) {
@@ -20521,8 +20601,8 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   return results;
 }
 function findContainingSolutions(csprojPath, repoRoot2) {
-  const csprojAbs = path41.resolve(csprojPath);
-  const csprojBasename = path41.basename(csprojAbs);
+  const csprojAbs = path42.resolve(csprojPath);
+  const csprojBasename = path42.basename(csprojAbs);
   const slnFiles = findSlnFiles(repoRoot2, 3);
   const matches = [];
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
@@ -20530,7 +20610,7 @@ function findContainingSolutions(csprojPath, repoRoot2) {
     try {
       const content = readFileSync36(sln, "utf8");
       if (pattern2.test(content)) {
-        matches.push(path41.relative(repoRoot2, sln));
+        matches.push(path42.relative(repoRoot2, sln));
       }
     } catch {
     }
@@ -20593,15 +20673,15 @@ function printJson(tree, totalCount, solutions) {
 
 // src/commands/dotnet/resolveCsproj.ts
 import { existsSync as existsSync49 } from "fs";
-import path42 from "path";
+import path43 from "path";
 import chalk155 from "chalk";
 function resolveCsproj(csprojPath) {
-  const resolved = path42.resolve(csprojPath);
+  const resolved = path43.resolve(csprojPath);
   if (!existsSync49(resolved)) {
     console.error(chalk155.red(`File not found: ${resolved}`));
     process.exit(1);
   }
-  const repoRoot2 = findRepoRoot(path42.dirname(resolved));
+  const repoRoot2 = findRepoRoot(path43.dirname(resolved));
   if (!repoRoot2) {
     console.error(chalk155.red("Could not find git repository root"));
     process.exit(1);
@@ -20766,7 +20846,7 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 
 // src/commands/dotnet/resolveSolution.ts
 import { existsSync as existsSync50 } from "fs";
-import path43 from "path";
+import path44 from "path";
 import chalk159 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
@@ -20805,7 +20885,7 @@ function findSolution() {
 // src/commands/dotnet/resolveSolution.ts
 function resolveSolution(sln) {
   if (sln) {
-    const resolved = path43.resolve(sln);
+    const resolved = path44.resolve(sln);
     if (!existsSync50(resolved)) {
       console.error(chalk159.red(`Solution file not found: ${resolved}`));
       process.exit(1);
@@ -20848,7 +20928,7 @@ function parseInspectReport(json) {
 import { execSync as execSync41 } from "child_process";
 import { existsSync as existsSync51, readFileSync as readFileSync37, unlinkSync as unlinkSync10 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import path44 from "path";
+import path45 from "path";
 import chalk160 from "chalk";
 function assertJbInstalled() {
   try {
@@ -20862,7 +20942,7 @@ function assertJbInstalled() {
   }
 }
 function runInspectCode(slnPath, include, swea) {
-  const reportPath = path44.join(tmpdir5(), `inspect-${Date.now()}.xml`);
+  const reportPath = path45.join(tmpdir5(), `inspect-${Date.now()}.xml`);
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
@@ -21169,10 +21249,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync52, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path90 = getMigrationApprovalPath(migrationId);
-  if (!existsSync52(path90)) return false;
+  const path91 = getMigrationApprovalPath(migrationId);
+  if (!existsSync52(path91)) return false;
   try {
-    unlinkSync11(path90);
+    unlinkSync11(path91);
     return true;
   } catch {
     return false;
@@ -22984,7 +23064,7 @@ import {
   rmSync as rmSync3,
   statSync as statSync9
 } from "fs";
-import { basename as basename14, join as join59 } from "path";
+import { basename as basename15, join as join59 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
 import { join as join57 } from "path";
@@ -23055,7 +23135,7 @@ async function migrateFile(orm, origin, file, createdAt) {
 async function migrateDiskHandovers(orm, origin, cwd = process.cwd()) {
   let migrated = 0;
   for (const file of collectMarkdown(getHandoversDir(cwd))) {
-    const createdAt = parseArchiveTimestamp(basename14(file)) ?? statSync9(file).mtime;
+    const createdAt = parseArchiveTimestamp(basename15(file)) ?? statSync9(file).mtime;
     await migrateFile(orm, origin, file, createdAt);
     migrated++;
   }
@@ -23408,25 +23488,25 @@ function recentDaemonLogLines() {
 // src/commands/sessions/daemon/worktree/canonicalTreePath.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve14 } from "path";
-function canonicalTreePath(path90) {
+function canonicalTreePath(path91) {
   try {
-    return realpathSync2(path90);
+    return realpathSync2(path91);
   } catch {
-    return resolve14(path90);
+    return resolve14(path91);
   }
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
 import { existsSync as existsSync55 } from "fs";
-import { basename as basename16, dirname as dirname26 } from "path";
+import { basename as basename17, dirname as dirname26 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
-import { basename as basename15, join as join60 } from "path";
+import { basename as basename16, join as join60 } from "path";
 function planAllocation(clone, boundTreeRoots2) {
   return boundTreeRoots2.has(clone) ? "spill" : "primary";
 }
 function nextWorktreePath(clone, base, isTaken) {
-  const name = basename15(clone);
+  const name = basename16(clone);
   for (let n = 2; n < 1e3; n++) {
     const candidate = join60(base, `${name}-${n}`);
     if (!isTaken(candidate)) return candidate;
@@ -23464,23 +23544,23 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const base = strategy.root ? expandTilde2(strategy.root) : dirname26(clone);
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
-  const isTaken = (candidate) => registered.has(candidate) || existsSync55(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate));
-  const path90 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
+  const isTaken = (candidate) => registered.has(candidate) || existsSync55(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename17(candidate));
+  const path91 = 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(path90),
-    path90,
+    basename17(path91),
+    path91,
     start3.ref
   ]);
-  recordWorktree(path90, clone, getCurrentOrigin(clone));
+  recordWorktree(path91, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path90} (branch ${basename16(path90)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path90} (branch ${basename16(path90)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path91} (branch ${basename17(path91)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path91} (branch ${basename17(path91)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
-  return path90;
+  return path91;
 }
 
 // src/commands/sessions/daemon/worktree/keptInTree.ts
@@ -23621,13 +23701,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 path90 = createWorktree(
+  const path91 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
     boundTreeRoots2,
     options2.replacesTree
   );
-  return { cwd: path90, kind: "worktree", created: true, clone };
+  return { cwd: path91, kind: "worktree", created: true, clone };
 }
 
 // src/commands/sessions/daemon/describePersistedSession.ts
@@ -23960,13 +24040,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 path90 = null;
+  let path91 = null;
   for (const line of listing.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("worktree "))
-      path90 = trimmed.slice("worktree ".length).trim();
+      path91 = trimmed.slice("worktree ".length).trim();
     else if (trimmed === `branch refs/heads/${branch2}`)
-      return path90 && path90 !== here ? path90 : null;
+      return path91 && path91 !== here ? path91 : null;
   }
   return null;
 }
@@ -24211,7 +24291,7 @@ import chalk175 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync40, writeFileSync as writeFileSync32 } from "fs";
-import { basename as basename17, extname as extname2, resolve as resolve15 } from "path";
+import { basename as basename18, extname as extname2, resolve as resolve15 } from "path";
 import chalk174 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -24238,7 +24318,7 @@ async function renderBlock(krokiUrl, source) {
 async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   const content = readFileSync40(file, "utf8");
   const blocks = extractMermaidBlocks(content);
-  const stem = basename17(file, extname2(file));
+  const stem = basename18(file, extname2(file));
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
@@ -25084,9 +25164,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path90] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path91] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path90) {
+    for (const key of path91) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -25706,16 +25786,16 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-async function comment2(path90, line, body, startLine) {
+async function comment2(path91, 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 ${path90}:${range}`, body, null);
+  await reviewProposedPrComment(`Comment on ${path91}:${range}`, body, null);
   try {
     const prId = getCurrentPrNodeId();
-    postReviewComment({ prId, body, path: path90, line, startLine });
-    console.log(`Added review comment on ${path90}:${range}`);
+    postReviewComment({ prId, body, path: path91, line, startLine });
+    console.log(`Added review comment on ${path91}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -26924,9 +27004,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 (path90, line, body) => {
+  ).action(async (path91, line, body) => {
     await comment2(
-      path90,
+      path91,
       Number.parseInt(line, 10),
       await readBodyArgument(body)
     );
@@ -27293,11 +27373,11 @@ async function loadBody(target) {
   if (target.kind === "file") return readDraftFile(target.path);
   return fetchPrBody(target.number, target.repo);
 }
-function readDraftFile(path90) {
+function readDraftFile(path91) {
   try {
-    return readFileSync45(path90, "utf8");
+    return readFileSync45(path91, "utf8");
   } catch {
-    console.error(`Error: Could not read \`${path90}\`.`);
+    console.error(`Error: Could not read \`${path91}\`.`);
     console.error(
       "Pass a pull request number, a GitHub pull request URL, - for stdin, or a path to a file."
     );
@@ -27576,10 +27656,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path90) {
+async function ravenFetch(connection, path91) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path90}`;
+  const url = `${connection.url}${path91}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -27669,16 +27749,16 @@ import chalk195 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path90;
+  let path91;
   if (opts.collection) {
-    path90 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path91 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path90 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path91 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path90 += `&query=${encodeURIComponent(opts.query)}`;
+    path91 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path90;
+  return path91;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -27687,7 +27767,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 path90 = buildQueryPath({
+    const path91 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -27695,7 +27775,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path90);
+    const data = await ravenFetch(connection, path91);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -27753,7 +27833,7 @@ function registerRavendb(program2) {
 
 // src/commands/refactor/check/index.ts
 import { spawn as spawn6 } from "child_process";
-import * as path45 from "path";
+import * as path46 from "path";
 
 // src/commands/refactor/logViolations.ts
 import chalk197 from "chalk";
@@ -27930,7 +28010,7 @@ ${failed2.length} verify script(s) failed:`);
 async function runVerifyQuietly() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
   if (!result) return true;
-  const packageDir = path45.dirname(result.packageJsonPath);
+  const packageDir = path46.dirname(result.packageJsonPath);
   const results = await Promise.all(
     result.verifyScripts.map((script) => runScript(script, packageDir))
   );
@@ -27956,7 +28036,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path53 from "path";
+import path54 from "path";
 import chalk200 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -28433,9 +28513,9 @@ function buildDestinationContent(functionTexts, imports, sourceRelativePath, sou
 }
 
 // src/commands/refactor/extract/getRelativeImportPath.ts
-import path46 from "path";
+import path47 from "path";
 function getRelativeImportPath(from, to) {
-  let rel = path46.relative(path46.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
+  let rel = path47.relative(path47.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel;
 }
@@ -28459,9 +28539,9 @@ function findImporters(functionName, sourceFile, destPath, project) {
 }
 
 // src/commands/refactor/extract/resolveBarrel.ts
-import path47 from "path";
+import path48 from "path";
 function resolveBarrel(functionName, sourcePath, destPath, project) {
-  const indexPath = path47.join(path47.dirname(destPath), "index.ts");
+  const indexPath = path48.join(path48.dirname(destPath), "index.ts");
   const barrel = project.getSourceFile(indexPath);
   if (!barrel) return { barrel: void 0, barrelRelPath: "" };
   const sourceRelFromBarrel = getRelativeImportPath(indexPath, sourcePath);
@@ -28479,15 +28559,15 @@ function resolveBarrel(functionName, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/rewriteImportPaths.ts
-import path48 from "path";
+import path49 from "path";
 function rewriteImportPaths(imports, sourcePath, destPath) {
-  const sourceDir = path48.dirname(sourcePath);
-  const destDir = path48.dirname(destPath);
+  const sourceDir = path49.dirname(sourcePath);
+  const destDir = path49.dirname(destPath);
   return imports.map((imp) => {
     if (!imp.moduleSpecifier.startsWith(".")) return imp;
-    const absolute2 = path48.resolve(sourceDir, imp.moduleSpecifier);
-    let rel = path48.relative(destDir, absolute2).replace(/\\/g, "/");
-    if (rel === "") rel = `../${path48.basename(absolute2)}`;
+    const absolute2 = path49.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path49.relative(destDir, absolute2).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path49.basename(absolute2)}`;
     else if (!rel.startsWith(".")) rel = `./${rel}`;
     return { ...imp, moduleSpecifier: rel };
   });
@@ -28555,7 +28635,7 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/displayPlan.ts
-import path49 from "path";
+import path50 from "path";
 import chalk198 from "chalk";
 function section2(title) {
   return `
@@ -28565,7 +28645,7 @@ function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section2("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
-    const rel = path49.relative(cwd, imp.file.getFilePath());
+    const rel = path50.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk198.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
@@ -28605,17 +28685,17 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
-import path52 from "path";
+import path53 from "path";
 import chalk199 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
 import fs32 from "fs";
-import path51 from "path";
+import path52 from "path";
 
 // src/commands/refactor/extract/findEnclosingTsConfig.ts
 import fs31 from "fs";
-import path50 from "path";
+import path51 from "path";
 
 // src/commands/refactor/extract/projectIncludesFile.ts
 import { Project as Project3 } from "ts-morph";
@@ -28630,16 +28710,16 @@ function projectIncludesFile(configPath, sourcePath) {
 
 // src/commands/refactor/extract/findEnclosingTsConfig.ts
 function findEnclosingTsConfig(sourcePath, rootDir, tried) {
-  let dir = path50.dirname(sourcePath);
-  while (dir.startsWith(rootDir + path50.sep) && dir !== rootDir) {
-    const nested = path50.join(dir, "tsconfig.json");
+  let dir = path51.dirname(sourcePath);
+  while (dir.startsWith(rootDir + path51.sep) && dir !== rootDir) {
+    const nested = path51.join(dir, "tsconfig.json");
     if (!tried.has(nested)) {
       tried.add(nested);
       if (fs31.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
         return nested;
       }
     }
-    const parent = path50.dirname(dir);
+    const parent = path51.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -28648,7 +28728,7 @@ function findEnclosingTsConfig(sourcePath, rootDir, tried) {
 
 // src/commands/refactor/extract/findTsConfig.ts
 function findTsConfig(sourcePath) {
-  const rootConfig = path51.resolve("tsconfig.json");
+  const rootConfig = path52.resolve("tsconfig.json");
   if (!fs32.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
@@ -28657,7 +28737,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludesFile(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs32.readdirSync(path51.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path51.resolve(path51.dirname(rootConfig), f));
+  const siblings = fs32.readdirSync(path52.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path52.resolve(path52.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -28665,7 +28745,7 @@ function findTsConfig(sourcePath) {
   }
   const nested = findEnclosingTsConfig(
     sourcePath,
-    path51.dirname(rootConfig),
+    path52.dirname(rootConfig),
     tried
   );
   if (nested) return nested;
@@ -28682,16 +28762,16 @@ function readReferences(configPath) {
     return [];
   }
   if (!parsed.references?.length) return [];
-  const cwd = path51.dirname(configPath);
+  const cwd = path52.dirname(configPath);
   return parsed.references.map((ref) => {
-    const refPath = path51.resolve(cwd, ref.path);
-    return fs32.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path51.join(refPath, "tsconfig.json") : refPath;
+    const refPath = path52.resolve(cwd, ref.path);
+    return fs32.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path52.join(refPath, "tsconfig.json") : refPath;
   }).filter((p) => fs32.existsSync(p));
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
 function loadProjectFile(file) {
-  const sourcePath = path52.resolve(file);
+  const sourcePath = path53.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project4({
     tsConfigFilePath: tsConfigPath
@@ -28706,10 +28786,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path53.resolve(file);
-  const destPath = path53.resolve(destination);
+  const sourcePath = path54.resolve(file);
+  const destPath = path54.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path53.relative(cwd, destPath);
+  const relDest = path54.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan2(
     functionName,
@@ -28757,16 +28837,16 @@ function ignore2(file) {
 
 // src/commands/refactor/rename/index.ts
 import fs36 from "fs";
-import path58 from "path";
+import path59 from "path";
 import chalk204 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs35 from "fs";
-import path55 from "path";
+import path56 from "path";
 import chalk202 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path54 from "path";
+import path55 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
 import fs34 from "fs";
@@ -28820,7 +28900,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path54.relative(path54.dirname(fromFile), toFile));
+  return normalizeSpecifier(path55.relative(path55.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -28868,20 +28948,20 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs35.writeFileSync(file, content, "utf8");
-    console.log(chalk202.cyan(`  Updated imports in ${path55.relative(cwd, file)}`));
+    console.log(chalk202.cyan(`  Updated imports in ${path56.relative(cwd, file)}`));
   }
-  const destDir = path55.dirname(destPath);
+  const destDir = path56.dirname(destPath);
   if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
   fs35.renameSync(sourcePath, destPath);
   console.log(
     chalk202.white(
-      `  Moved ${path55.relative(cwd, sourcePath)} \u2192 ${path55.relative(cwd, destPath)}`
+      `  Moved ${path56.relative(cwd, sourcePath)} \u2192 ${path56.relative(cwd, destPath)}`
     )
   );
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path56 from "path";
+import path57 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -28908,7 +28988,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path56.dirname(tsConfigPath)
+    path57.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -28924,7 +29004,7 @@ function resolveImport(specifier, filePath, options2) {
   const resolved = ts7.resolveModuleName(specifier, filePath, options2, ts7.sys);
   const resolvedPath = resolved.resolvedModule?.resolvedFileName;
   if (!resolvedPath || resolvedPath.includes("node_modules")) return null;
-  return path56.resolve(resolvedPath);
+  return path57.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -28933,7 +29013,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path56.resolve(sourceFile.fileName);
+    const filePath = path57.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -28960,13 +29040,13 @@ function computeRenameRewrites(sourcePath, destPath) {
 }
 
 // src/commands/refactor/rename/printRenamePreview.ts
-import path57 from "path";
+import path58 from "path";
 import chalk203 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
       chalk203.dim(
-        `  ${path57.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+        `  ${path58.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
@@ -28975,11 +29055,11 @@ function printRenamePreview(rewrites, cwd) {
 
 // src/commands/refactor/rename/index.ts
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path58.resolve(source);
-  const destPath = path58.resolve(destination);
+  const sourcePath = path59.resolve(source);
+  const destPath = path59.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path58.relative(cwd, sourcePath);
-  const relDest = path58.relative(cwd, destPath);
+  const relSource = path59.relative(cwd, sourcePath);
+  const relDest = path59.relative(cwd, destPath);
   if (!fs36.existsSync(sourcePath)) {
     console.log(chalk204.red(`File not found: ${source}`));
     process.exit(1);
@@ -29034,12 +29114,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path59 from "path";
+import path60 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path59.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path60.relative(cwd, ref.getSourceFile().getFilePath());
     const lines2 = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines2);
     lines2.push(ref.getStartLineNumber());
@@ -29078,16 +29158,16 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path66 from "path";
+import path67 from "path";
 import chalk208 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path60 from "path";
+import path61 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path60.dirname(edge.source);
-    const targetDir = path60.dirname(edge.target);
+    const sourceDir = path61.dirname(edge.source);
+    const targetDir = path61.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -29115,20 +29195,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path60.relative(ancestor, descendant);
+  const rel = path61.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path61 from "path";
+import path62 from "path";
 function findRootParent(file, importedBy, visited) {
   const importers = importedBy.get(file);
   if (!importers || importers.size !== 1) return file;
   const parent = [...importers][0];
-  const parentDir = path61.dirname(parent);
-  const fileDir = path61.dirname(file);
+  const parentDir = path62.dirname(parent);
+  const fileDir = path62.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path61.basename(parent, path61.extname(parent)) === "index") return file;
+  if (path62.basename(parent, path62.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -29136,16 +29216,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename27 = path61.basename(file, path61.extname(file));
-    if (basename27 === "index") continue;
+    const basename28 = path62.basename(file, path62.extname(file));
+    if (basename28 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
     if (!graph.files.has(parent)) continue;
-    const parentDir = path61.dirname(parent);
-    const fileDir = path61.dirname(file);
+    const parentDir = path62.dirname(parent);
+    const fileDir = path62.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path61.basename(parent, path61.extname(parent));
+    const parentBasename = path62.basename(parent, path62.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -29157,10 +29237,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path62 from "path";
+import path63 from "path";
 import chalk206 from "chalk";
 function relPath(filePath) {
-  return path62.relative(process.cwd(), filePath);
+  return path63.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -29210,33 +29290,33 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 
 // src/commands/refactor/restructure/executePlan.ts
 import fs37 from "fs";
-import path63 from "path";
+import path64 from "path";
 import chalk207 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs37.writeFileSync(file, content, "utf8");
     console.log(
-      chalk207.cyan(`  Rewrote imports in ${path63.relative(process.cwd(), file)}`)
+      chalk207.cyan(`  Rewrote imports in ${path64.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs37.mkdirSync(dir, { recursive: true });
-    console.log(chalk207.green(`  Created ${path63.relative(process.cwd(), dir)}/`));
+    console.log(chalk207.green(`  Created ${path64.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
-    const targetDir = path63.dirname(move2.to);
+    const targetDir = path64.dirname(move2.to);
     if (!fs37.existsSync(targetDir)) {
       fs37.mkdirSync(targetDir, { recursive: true });
     }
     fs37.renameSync(move2.from, move2.to);
     console.log(
       chalk207.white(
-        `  Moved ${path63.relative(process.cwd(), move2.from)} \u2192 ${path63.relative(process.cwd(), move2.to)}`
+        `  Moved ${path64.relative(process.cwd(), move2.from)} \u2192 ${path64.relative(process.cwd(), move2.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path63.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path64.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
@@ -29247,7 +29327,7 @@ function removeEmptyDirectories(dirs) {
       fs37.rmdirSync(dir);
       console.log(
         chalk207.dim(
-          `  Removed empty directory ${path63.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path64.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -29255,7 +29335,7 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path65 from "path";
+import path66 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
 import fs38 from "fs";
@@ -29270,9 +29350,9 @@ function checkDirConflict(result, label2, dir) {
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs39 from "fs";
-import path64 from "path";
+import path65 from "path";
 function collectEntry2(results, dir, entry) {
-  const full = path64.join(dir, entry.name);
+  const full = path65.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
@@ -29286,15 +29366,15 @@ function listFilesRecursive(dir) {
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason4) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path64.relative(childDir, file);
-    moves.push({ from: file, to: path64.join(newLocation, rel), reason: reason4 });
+    const rel = path65.relative(childDir, file);
+    moves.push({ from: file, to: path65.join(newLocation, rel), reason: reason4 });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path64.join(parentDir, path64.basename(childDir));
+  return path65.join(parentDir, path65.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path64.basename(parentDir)}/`;
+  return `Directory only imported from ${path65.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -29319,7 +29399,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path65.join(newDir, path65.basename(child));
+  const to = path66.join(newDir, path66.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -29327,15 +29407,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path65.basename(filePath, path65.extname(filePath));
+  return path66.basename(filePath, path66.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path65.join(path65.dirname(parent), getBaseName(parent));
+  return path66.join(path66.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path65.join(newDir, `index${path65.extname(parent)}`),
+    to: path66.join(newDir, `index${path66.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -29359,7 +29439,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path66.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path67.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -29382,7 +29462,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk208.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = findTsConfig(path66.resolve(files[0]));
+  const tsConfigPath = findTsConfig(path67.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk208.green("No restructuring needed"));
@@ -29561,13 +29641,13 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 
 // src/commands/review/buildReviewPaths.ts
 import { homedir as homedir23 } from "os";
-import { basename as basename18, join as join72 } from "path";
+import { basename as basename19, join as join72 } from "path";
 function buildReviewPaths(repoRoot2, key) {
   const reviewDir = join72(
     homedir23(),
     ".assist",
     "reviews",
-    basename18(repoRoot2),
+    basename19(repoRoot2),
     key
   );
   return {
@@ -30303,8 +30383,8 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync61, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path90 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync61(path90)) unlinkSync17(path90);
+  for (const path91 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync61(path91)) unlinkSync17(path91);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -31414,7 +31494,7 @@ function registerReview(program2) {
 
 // src/commands/rules/addRule.ts
 import { existsSync as existsSync66, readFileSync as readFileSync51, writeFileSync as writeFileSync41 } from "fs";
-import path71 from "path";
+import path72 from "path";
 import chalk211 from "chalk";
 
 // src/commands/rules/insertRuleBullet.ts
@@ -31442,7 +31522,7 @@ import { readFileSync as readFileSync48 } from "fs";
 
 // src/commands/rules/findClaudeFiles.ts
 import { readdirSync as readdirSync13 } from "fs";
-import path67 from "path";
+import path68 from "path";
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage"]);
 function findClaudeFiles(dir) {
   const results = [];
@@ -31450,9 +31530,9 @@ function findClaudeFiles(dir) {
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || SKIP_DIRECTORIES.has(entry.name))
         continue;
-      results.push(...findClaudeFiles(path67.join(dir, entry.name)));
+      results.push(...findClaudeFiles(path68.join(dir, entry.name)));
     } else if (entry.name === "CLAUDE.md") {
-      results.push(path67.join(dir, entry.name));
+      results.push(path68.join(dir, entry.name));
     }
   }
   return results;
@@ -31471,34 +31551,34 @@ function nextRuleCode(root) {
 
 // src/commands/rules/resolveRuleScope.ts
 import { existsSync as existsSync64 } from "fs";
-import path68 from "path";
+import path69 from "path";
 function resolveRuleScope(target) {
-  const resolved = path68.resolve(target);
-  if (path68.basename(resolved) === "CLAUDE.md") return resolved;
+  const resolved = path69.resolve(target);
+  if (path69.basename(resolved) === "CLAUDE.md") return resolved;
   const startDir = scopeDirectory(resolved);
   const root = findRepoRoot(startDir) ?? startDir;
   let current = startDir;
   while (true) {
-    const candidate = path68.join(current, "CLAUDE.md");
+    const candidate = path69.join(current, "CLAUDE.md");
     if (existsSync64(candidate)) return candidate;
-    if (current === root || current === path68.dirname(current)) break;
-    current = path68.dirname(current);
+    if (current === root || current === path69.dirname(current)) break;
+    current = path69.dirname(current);
   }
-  return path68.join(root, "CLAUDE.md");
+  return path69.join(root, "CLAUDE.md");
 }
 
 // src/commands/rules/updateScopedRulesIndex.ts
 import { existsSync as existsSync65, readFileSync as readFileSync50, writeFileSync as writeFileSync40 } from "fs";
-import path70 from "path";
+import path71 from "path";
 
 // src/commands/rules/scopedRuleDirectories.ts
 import { readFileSync as readFileSync49 } from "fs";
-import path69 from "path";
+import path70 from "path";
 function scopedRuleDirectories(root) {
   return findClaudeFiles(root).filter(
-    (file) => path69.dirname(file) !== root && parseRulesSection(readFileSync49(file, "utf8")).length > 0
+    (file) => path70.dirname(file) !== root && parseRulesSection(readFileSync49(file, "utf8")).length > 0
   ).map(
-    (file) => `${path69.relative(root, path69.dirname(file)).split(path69.sep).join("/")}/`
+    (file) => `${path70.relative(root, path70.dirname(file)).split(path70.sep).join("/")}/`
   ).sort();
 }
 
@@ -31537,7 +31617,7 @@ function upsertScopedRulesPointer(content, directories) {
 // src/commands/rules/updateScopedRulesIndex.ts
 function updateScopedRulesIndex(root) {
   const directories = scopedRuleDirectories(root);
-  const rootFile = path70.join(root, "CLAUDE.md");
+  const rootFile = path71.join(root, "CLAUDE.md");
   const before = existsSync65(rootFile) ? readFileSync50(rootFile, "utf8") : "";
   const after = upsertScopedRulesPointer(before, directories);
   if (after !== before) writeFileSync40(rootFile, after);
@@ -31556,7 +31636,7 @@ function addRule(text18, options2) {
     return;
   }
   const target = resolveRuleScope(options2.scope ?? process.cwd());
-  const targetDir = path71.dirname(target);
+  const targetDir = path72.dirname(target);
   const root = findRepoRoot(targetDir) ?? targetDir;
   const code = nextRuleCode(root);
   writeFileSync41(
@@ -31569,18 +31649,18 @@ function addRule(text18, options2) {
   );
   updateScopedRulesIndex(root);
   console.log(
-    `Added ${chalk211.cyan(code)} to ${path71.relative(process.cwd(), target) || target}`
+    `Added ${chalk211.cyan(code)} to ${path72.relative(process.cwd(), target) || target}`
   );
 }
 
 // src/commands/rules/indexRules.ts
-import path72 from "path";
+import path73 from "path";
 import chalk212 from "chalk";
 function indexRules() {
   const startDir = scopeDirectory(process.cwd());
   const root = findRepoRoot(startDir) ?? startDir;
   const directories = updateScopedRulesIndex(root);
-  const rootFile = path72.relative(process.cwd(), path72.join(root, "CLAUDE.md"));
+  const rootFile = path73.relative(process.cwd(), path73.join(root, "CLAUDE.md"));
   if (directories.length === 0) {
     console.log(
       chalk212.gray(`No directories carry their own \`## Rules\` under ${root}`)
@@ -31593,13 +31673,13 @@ function indexRules() {
 }
 
 // src/commands/rules/listRules.ts
-import path73 from "path";
+import path74 from "path";
 import chalk213 from "chalk";
 function listRules(target, options2 = {}) {
-  const resolved = path73.resolve(target ?? process.cwd());
+  const resolved = path74.resolve(target ?? process.cwd());
   const rules3 = readScopedRules(resolved);
   if (rules3.length === 0) {
-    const label2 = path73.relative(process.cwd(), resolved) || ".";
+    const label2 = path74.relative(process.cwd(), resolved) || ".";
     console.log(chalk213.gray(`No rules in scope for ${label2}`));
     return;
   }
@@ -31610,7 +31690,7 @@ function listRules(target, options2 = {}) {
     if (rule.source !== shown) {
       shown = rule.source;
       console.log(
-        chalk213.dim(base ? path73.relative(base, rule.source) : rule.source)
+        chalk213.dim(base ? path74.relative(base, rule.source) : rule.source)
       );
     }
     console.log(
@@ -31706,8 +31786,8 @@ import chalk219 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk216 from "chalk";
-async function fetchSeq(conn, path90, params) {
-  const url = `${conn.url}${path90}?${params}`;
+async function fetchSeq(conn, path91, params) {
+  const url = `${conn.url}${path91}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -32359,15 +32439,15 @@ function registerSql(program2) {
 // src/commands/sync.ts
 import * as fs48 from "fs";
 import * as os5 from "os";
-import * as path84 from "path";
+import * as path85 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 
 // src/commands/sync/pruneCommands.ts
-import * as path75 from "path";
+import * as path76 from "path";
 
 // src/commands/sync/pruneTarget.ts
 import * as fs40 from "fs";
-import * as path74 from "path";
+import * as path75 from "path";
 function pruneTarget(targetDir, keepNames, shape, options2) {
   const result = {
     orphans: [],
@@ -32385,7 +32465,7 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
     }
     if (keep.has(name)) continue;
     result.orphans.push(entry.name);
-    const entryPath = path74.join(targetDir, entry.name);
+    const entryPath = path75.join(targetDir, entry.name);
     const reason4 = shape.blockedBy?.(entryPath);
     if (reason4) {
       result.skipped.push({ name: entry.name, reason: reason4 });
@@ -32405,7 +32485,7 @@ function pruneCommands(targetDir, commandNames, options2) {
     targetDir,
     commandNames,
     {
-      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path75.basename(entry.name, ".md") : void 0
+      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path76.basename(entry.name, ".md") : void 0
     },
     options2
   );
@@ -32440,11 +32520,11 @@ function reportPrune(label2, result, force) {
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
-import * as path76 from "path";
+import * as path77 from "path";
 import chalk226 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path76.join(claudeDir, "CLAUDE.md");
-  const target = path76.join(targetBase, "CLAUDE.md");
+  const source = path77.join(claudeDir, "CLAUDE.md");
+  const target = path77.join(targetBase, "CLAUDE.md");
   const sourceContent = fs41.readFileSync(source, "utf8");
   if (fs41.existsSync(target)) {
     const targetContent = fs41.readFileSync(target, "utf8");
@@ -32472,13 +32552,13 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path79 from "path";
+import * as path80 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
 import * as fs42 from "fs";
-import * as path77 from "path";
+import * as path78 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path77.join(claudeDir, "commands");
+  const commandsSource = path78.join(claudeDir, "commands");
   const files = fs42.readdirSync(commandsSource);
   const names = [];
   let synced = 0;
@@ -32486,15 +32566,15 @@ function installHarnessCommands(claudeDir, harness, transform) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
     names.push(name);
-    const content = fs42.readFileSync(path77.join(commandsSource, file), "utf8");
-    const target = path77.join(harness.homeDir, harness.sync.commandDest(name));
-    fs42.mkdirSync(path77.dirname(target), { recursive: true });
+    const content = fs42.readFileSync(path78.join(commandsSource, file), "utf8");
+    const target = path78.join(harness.homeDir, harness.sync.commandDest(name));
+    fs42.mkdirSync(path78.dirname(target), { recursive: true });
     fs42.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path77.join(harness.homeDir, harness.sync.agentsFile);
-  fs42.mkdirSync(path77.dirname(agentsTarget), { recursive: true });
-  fs42.copyFileSync(path77.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path78.join(harness.homeDir, harness.sync.agentsFile);
+  fs42.mkdirSync(path78.dirname(agentsTarget), { recursive: true });
+  fs42.copyFileSync(path78.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced, names };
 }
 
@@ -32520,7 +32600,7 @@ function unexpectedContent(skillDir) {
 
 // src/commands/sync/syncCodexHooks.ts
 import * as fs44 from "fs";
-import * as path78 from "path";
+import * as path79 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -32551,9 +32631,9 @@ ${rest}
 }
 function syncCodexHooks(sourcePath) {
   const body = fs44.readFileSync(sourcePath, "utf8");
-  const configPath = path78.join(harnesses.codex.homeDir, "config.toml");
+  const configPath = path79.join(harnesses.codex.homeDir, "config.toml");
   const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
-  fs44.mkdirSync(path78.dirname(configPath), { recursive: true });
+  fs44.mkdirSync(path79.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)"
@@ -32585,7 +32665,7 @@ function syncCodex(claudeDir, options2) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path79.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path80.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
@@ -32593,42 +32673,42 @@ function syncCodex(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.codex/skills",
-    pruneSkills(path79.join(harnesses.codex.homeDir, "skills"), names, { force }),
+    pruneSkills(path80.join(harnesses.codex.homeDir, "skills"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncDesign.ts
 import * as fs45 from "fs";
-import * as path80 from "path";
+import * as path81 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path80.join(claudeDir, "design-system-prompt.md");
-  const systemPromptTarget = path80.join(targetBase, "design-system-prompt.md");
+  const systemPromptSource = path81.join(claudeDir, "design-system-prompt.md");
+  const systemPromptTarget = path81.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 = path80.join(claudeDir, "skills");
-  const skillsTarget = path80.join(targetBase, "skills");
+  const skillsSource = path81.join(claudeDir, "skills");
+  const skillsTarget = path81.join(targetBase, "skills");
   fs45.mkdirSync(skillsTarget, { recursive: true });
   const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
     fs45.copyFileSync(
-      path80.join(skillsSource, file),
-      path80.join(skillsTarget, file)
+      path81.join(skillsSource, file),
+      path81.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path82 from "path";
+import * as path83 from "path";
 
 // src/commands/sync/syncPiHooks.ts
 import * as fs46 from "fs";
-import * as path81 from "path";
+import * as path82 from "path";
 function piExtensionsDir() {
-  return path81.join(harnesses.pi.homeDir, "extensions");
+  return path82.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
@@ -32636,8 +32716,8 @@ function syncPiHooks(sourceDir) {
   const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
     fs46.copyFileSync(
-      path81.join(sourceDir, file),
-      path81.join(target, `assist-${file}`)
+      path82.join(sourceDir, file),
+      path82.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -32674,7 +32754,7 @@ function syncPi(claudeDir, options2) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path82.join(claudeDir, "..", "pi"));
+  syncPiHooks(path83.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
@@ -32682,18 +32762,18 @@ function syncPi(claudeDir, options2) {
   const force = options2.force ?? false;
   reportPrune(
     "~/.pi/agent/prompts",
-    pruneCommands(path82.join(harnesses.pi.homeDir, "prompts"), names, { force }),
+    pruneCommands(path83.join(harnesses.pi.homeDir, "prompts"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
-import * as path83 from "path";
+import * as path84 from "path";
 import chalk227 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path83.join(claudeDir, "settings.json");
-  const target = path83.join(targetBase, "settings.json");
+  const source = path84.join(claudeDir, "settings.json");
+  const target = path84.join(targetBase, "settings.json");
   const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
   const targetExists = fs47.existsSync(target);
@@ -32733,13 +32813,13 @@ async function syncSettings(claudeDir, targetBase, options2) {
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname5 = path84.dirname(__filename4);
+var __dirname5 = path85.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 = path84.join(__dirname5, "..", "claude");
-  const targetBase = path84.join(os5.homedir(), ".claude");
+  const claudeDir = path85.join(__dirname5, "..", "claude");
+  const targetBase = path85.join(os5.homedir(), ".claude");
   const commandFiles = syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -32747,21 +32827,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) => path84.basename(file, ".md"));
+  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path85.basename(file, ".md"));
   const force = options2.force ?? false;
   reportPrune(
     "~/.claude/commands",
-    pruneCommands(path84.join(targetBase, "commands"), commandNames, { force }),
+    pruneCommands(path85.join(targetBase, "commands"), commandNames, { force }),
     force
   );
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path84.join(claudeDir, "commands");
-  const targetDir = path84.join(targetBase, "commands");
+  const sourceDir = path85.join(claudeDir, "commands");
+  const targetDir = path85.join(targetBase, "commands");
   fs48.mkdirSync(targetDir, { recursive: true });
   const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs48.copyFileSync(path84.join(sourceDir, file), path84.join(targetDir, file));
+    fs48.copyFileSync(path85.join(sourceDir, file), path85.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -33164,7 +33244,7 @@ function list4() {
 
 // src/commands/transcript/move.ts
 import { existsSync as existsSync73, mkdirSync as mkdirSync28, renameSync as renameSync2, writeFileSync as writeFileSync46 } from "fs";
-import { basename as basename21, join as join85 } from "path";
+import { basename as basename22, join as join85 } from "path";
 
 // src/commands/transcript/convertVttToMarkdown.ts
 function convertVttToMarkdown(inputPath) {
@@ -33185,13 +33265,13 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename21(file);
+  const filename = basename22(file);
   const sourcePath = join85(vttDir, filename);
   if (!existsSync73(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename21(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename22(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
   const formattedDir = join85(transcriptsDir, client);
   mkdirSync28(formattedDir, { recursive: true });
@@ -33205,7 +33285,7 @@ function move(file, options2) {
 
 // src/commands/transcript/merge.ts
 import { existsSync as existsSync74, writeFileSync as writeFileSync47 } from "fs";
-import { basename as basename22 } from "path";
+import { basename as basename23 } from "path";
 
 // src/commands/transcript/failTranscript.ts
 function failTranscript(message3) {
@@ -33351,7 +33431,7 @@ function readSource2(file) {
   if (!existsSync74(file)) failTranscript(`VTT file not found: ${file}`);
   const cues = readCleanedCues(file);
   if (cues.length === 0) failTranscript(`no cues found in: ${file}`);
-  return { path: file, name: basename22(file), cues };
+  return { path: file, name: basename23(file), cues };
 }
 function wholePassages(sources) {
   return sources.map((source) => ({
@@ -33880,11 +33960,11 @@ var webUiPrefix = "src/commands/sessions/web/ui/";
 var sessionsPrefix = "src/commands/sessions/";
 var rules = [
   {
-    matches: (path90) => path90.startsWith(webUiPrefix),
+    matches: (path91) => path91.startsWith(webUiPrefix),
     advice: "restart the web server, then hard-reload the browser tab"
   },
   {
-    matches: (path90) => path90.startsWith(sessionsPrefix) && !path90.startsWith(webUiPrefix),
+    matches: (path91) => path91.startsWith(sessionsPrefix) && !path91.startsWith(webUiPrefix),
     advice: "restart the daemon"
   }
 ];
@@ -33895,31 +33975,31 @@ function restartAdvice(paths) {
 // src/commands/watch/syncAdvice.ts
 var rules2 = [
   {
-    matches: (path90) => path90.startsWith("claude/commands/"),
+    matches: (path91) => path91.startsWith("claude/commands/"),
     reason: "claude/commands changed"
   },
   {
-    matches: (path90) => path90.startsWith("claude/skills/"),
+    matches: (path91) => path91.startsWith("claude/skills/"),
     reason: "claude/skills changed"
   },
   {
-    matches: (path90) => path90 === "claude/settings.json",
+    matches: (path91) => path91 === "claude/settings.json",
     reason: "claude/settings.json changed"
   },
   {
-    matches: (path90) => path90 === "claude/CLAUDE.md",
+    matches: (path91) => path91 === "claude/CLAUDE.md",
     reason: "claude/CLAUDE.md changed"
   },
   {
-    matches: (path90) => path90 === "claude/design-system-prompt.md",
+    matches: (path91) => path91 === "claude/design-system-prompt.md",
     reason: "claude/design-system-prompt.md changed"
   },
   {
-    matches: (path90) => path90.startsWith("codex/"),
+    matches: (path91) => path91.startsWith("codex/"),
     reason: "codex sources changed"
   },
   {
-    matches: (path90) => path90.startsWith("pi/"),
+    matches: (path91) => path91.startsWith("pi/"),
     reason: "pi sources changed"
   }
 ];
@@ -34627,9 +34707,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path90 = join93(roamDir, name);
+    const path91 = join93(roamDir, name);
     try {
-      return { path: path90, mtimeMs: statSync12(path90).mtimeMs };
+      return { path: path91, mtimeMs: statSync12(path91).mtimeMs };
     } catch {
       return void 0;
     }
@@ -34873,11 +34953,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path90 = process.argv[idx + 1];
+  const path91 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path90, prefix: prefix2 };
+  return { path: path91, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -35619,14 +35699,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync85, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path85 from "path";
+import path86 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path85.join(path85.dirname(require4.resolve("node-pty")), "..");
-  const helper = path85.join(
+  const ptyRoot = path86.join(path86.dirname(require4.resolve("node-pty")), "..");
+  const helper = path86.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -35747,12 +35827,12 @@ function serverRunMeta(runName, cwd) {
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs49 from "fs";
-import * as path86 from "path";
+import * as path87 from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 var __filename5 = fileURLToPath10(import.meta.url);
-var __dirname7 = path86.dirname(__filename5);
+var __dirname7 = path87.dirname(__filename5);
 function readDesignSystemPrompt() {
-  const promptPath = path86.join(
+  const promptPath = path87.join(
     __dirname7,
     "..",
     "claude",
@@ -35851,7 +35931,7 @@ function setStatus2(session, newStatus) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 import { existsSync as existsSync88 } from "fs";
-import { basename as basename23 } from "path";
+import { basename as basename24 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
 import { existsSync as existsSync87 } from "fs";
@@ -35994,7 +36074,7 @@ async function reapWorktree(worktreePath, force = false) {
   const clone = owningClone(worktreePath);
   const removal = await removeTree(clone, worktreePath, force);
   if (!removal.removed) return removal;
-  await deleteWorktreeBranch(clone, basename23(worktreePath));
+  await deleteWorktreeBranch(clone, basename24(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return removal;
@@ -36748,8 +36828,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path90 = activityPath(session.id);
-  const dir = dirname39(path90);
+  const path91 = activityPath(session.id);
+  const dir = dirname39(path91);
   try {
     mkdirSync34(dir, { recursive: true });
   } catch {
@@ -36759,7 +36839,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   let timer = null;
   const read3 = () => {
     timer = null;
-    const activity2 = readActivity(path90);
+    const activity2 = readActivity(path91);
     if (!activity2) return;
     applyActivityToSession(session, activity2);
     if (activity2.claudeSessionId) onClaudeSessionId?.(session);
@@ -36768,11 +36848,11 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     notify2();
   };
   session.activityWatcher = watch2(dir, (_event, filename) => {
-    if (filename && !path90.endsWith(filename)) return;
+    if (filename && !path91.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read3, DEBOUNCE_MS2);
   });
-  if (existsSync91(path90)) read3();
+  if (existsSync91(path91)) read3();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -36915,12 +36995,12 @@ import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
 import * as fs51 from "fs";
-import * as path87 from "path";
+import * as path88 from "path";
 function projectDirForCwd(cwd) {
-  return path87.join(claudeProjectsRoot(), projectSlug(cwd));
+  return path88.join(claudeProjectsRoot(), projectSlug(cwd));
 }
 function transcriptPathFor(cwd, claudeSessionId) {
-  return path87.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+  return path88.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
@@ -36934,8 +37014,8 @@ function findTranscriptPathSync(cwd, claudeSessionId) {
   }
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
-    if (headContainsSessionId(path87.join(dir, file), claudeSessionId))
-      return path87.join(dir, file);
+    if (headContainsSessionId(path88.join(dir, file), claudeSessionId))
+      return path88.join(dir, file);
   }
   return null;
 }
@@ -38109,9 +38189,9 @@ function tempRoots() {
   }
   return [...roots];
 }
-function underTempRoot(path90) {
+function underTempRoot(path91) {
   return tempRoots().some(
-    (root) => path90.startsWith(root.endsWith(sep2) ? root : root + sep2)
+    (root) => path91.startsWith(root.endsWith(sep2) ? root : root + sep2)
   );
 }
 
@@ -38496,7 +38576,7 @@ function rearmStoppedSessions(sessions, notify2) {
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
 import { existsSync as existsSync94 } from "fs";
-import { basename as basename25 } from "path";
+import { basename as basename26 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
 function accountedTrees(sessions) {
@@ -38553,15 +38633,15 @@ function bindResumedWorktree(session, cwd, notify2) {
 import { existsSync as existsSync93 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
   if (!existsSync93(clone)) {
-    for (const { path: path90 } of paths) forgetWorktree(path90);
+    for (const { path: path91 } of paths) forgetWorktree(path91);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
   await pruneBookkeeping2(clone);
-  for (const { path: path90, branch: branch2 } of paths)
-    if (await reclaimBranch(clone, branch2)) forgetWorktree(path90);
+  for (const { path: path91, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path91);
 }
 async function pruneBookkeeping2(clone) {
   try {
@@ -38588,37 +38668,37 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/logVanishedTree.ts
-function logVanishedTree(sessions, path90) {
+function logVanishedTree(sessions, path91) {
   const claimants = [...sessions.values()].filter(
-    (s) => s.cwd === path90 || s.worktree?.path === path90
+    (s) => s.cwd === path91 || s.worktree?.path === path91
   );
   if (claimants.length === 0) {
-    daemonLog(`worktree ${path90} gone from disk and unclaimed; reclaiming it`);
+    daemonLog(`worktree ${path91} gone from disk and unclaimed; reclaiming it`);
     return;
   }
   for (const s of claimants)
     daemonLog(
-      `session ${s.id} ("${s.name}") claims worktree ${path90}, which is gone from disk; reclaiming it`
+      `session ${s.id} ("${s.name}") claims worktree ${path91}, which is gone from disk; reclaiming it`
     );
 }
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path90, reason4) {
-  if (reason4.startsWith("uncommitted")) return await changedFiles(path90);
-  if (reason4.startsWith("unpushed")) return await unpushedCommits(path90, reason4);
+async function describeHeldWork(path91, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path91);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path91, reason4);
   return { summary: reason4, items: [] };
 }
-async function changedFiles(path90) {
-  const status3 = await gitResult(path90, ["status", "--porcelain"]);
+async function changedFiles(path91) {
+  const status3 = await gitResult(path91, ["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(path90, reason4) {
-  const log2 = await gitResult(path90, ["log", "--oneline", "@{upstream}..HEAD"]);
+async function unpushedCommits(path91, reason4) {
+  const log2 = await gitResult(path91, ["log", "--oneline", "@{upstream}..HEAD"]);
   if (!log2.ok) return { summary: reason4, items: [] };
   const lines2 = nonEmptyLines(log2.out);
   return {
@@ -38638,7 +38718,7 @@ function capped(lines2) {
 }
 
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
-import { basename as basename24 } from "path";
+import { basename as basename25 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
   const { orphan, reason: reason4, held } = recovered;
   let id;
@@ -38661,7 +38741,7 @@ function orphanedSession(id, recovered) {
   const { orphan, reason: reason4, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
-    name: `recovered ${basename24(orphan.path)}`,
+    name: `recovered ${basename25(orphan.path)}`,
     subtitle: `${held.summary} in ${orphan.path}`,
     commandType: "claude",
     pty: null,
@@ -38710,24 +38790,24 @@ function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
 async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
-  for (const { path: path90, clone } of readWorktreeRegistry()) {
-    if (underTempRoot(path90)) {
-      forgetWorktree(path90);
+  for (const { path: path91, clone } of readWorktreeRegistry()) {
+    if (underTempRoot(path91)) {
+      forgetWorktree(path91);
       daemonLog(
-        `worktree ${path90} lies outside any project root; pruned from the registry rather than recovered`
+        `worktree ${path91} lies outside any project root; pruned from the registry rather than recovered`
       );
       continue;
     }
-    if (!existsSync94(path90)) {
-      logVanishedTree(sessions, path90);
+    if (!existsSync94(path91)) {
+      logVanishedTree(sessions, path91);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path90, branch: basename25(path90) }
+        { path: path91, branch: basename26(path91) }
       ]);
       continue;
     }
-    if (accounted.has(path90)) continue;
-    await recoverOrphan(sessions, spawnWith, { path: path90, clone }, notify2);
+    if (accounted.has(path91)) continue;
+    await recoverOrphan(sessions, spawnWith, { path: path91, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
     await reclaimVanishedWorktrees(clone, paths);
@@ -40479,12 +40559,12 @@ function handleSetStatus(client, m, d) {
 import * as fs54 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
-import * as path88 from "path";
+import * as path89 from "path";
 async function findCodexRolloutPath(sessionId) {
   if (!sessionId) return null;
   const paths = await discoverCodexRolloutPaths();
   const suffix = `-${sessionId}.jsonl`;
-  return paths.find((file) => path88.basename(file).endsWith(suffix)) ?? null;
+  return paths.find((file) => path89.basename(file).endsWith(suffix)) ?? null;
 }
 
 // src/commands/sessions/shared/codex/codexToolTarget.ts
@@ -41401,7 +41481,7 @@ async function statusLine() {
 
 // src/commands/update.ts
 import { execSync as execSync63 } from "child_process";
-import * as path89 from "path";
+import * as path90 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -41420,12 +41500,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path89.resolve(dir);
-    if (resolved.split(path89.sep).includes("node_modules")) {
+    const resolved = path90.resolve(dir);
+    if (resolved.split(path90.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync63("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path89.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path90.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }