@staff0rd/assist 0.533.2 → 0.534.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.533.2",
+  version: "0.534.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -149,8 +149,8 @@ import { dirname as dirname2, join as join2 } from "path";
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path71) {
-  return path71.replace(/^\/+/, "");
+function stripLeadingSlashes(path73) {
+  return path73.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -225,9 +225,9 @@ function findGitLink(dir) {
   }
   return null;
 }
-function isFile(path71) {
+function isFile(path73) {
   try {
-    return statSync(path71).isFile();
+    return statSync(path73).isFile();
   } catch {
     return false;
   }
@@ -246,9 +246,9 @@ function linkedGitDirParent(gitDir) {
   const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
   return match ? match[1] : null;
 }
-function readTrimmed(path71) {
+function readTrimmed(path73) {
   try {
-    const content = readFileSync(path71, "utf8").trim();
+    const content = readFileSync(path73, "utf8").trim();
     return content === "" ? null : content;
   } catch {
     return null;
@@ -261,10 +261,10 @@ function absolute(target, from) {
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path71) {
-  if (!existsSync2(path71)) return {};
+function loadRawYaml(path73) {
+  if (!existsSync2(path73)) return {};
   try {
-    const content = readFileSync2(path71, "utf8");
+    const content = readFileSync2(path73, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -336,8 +336,8 @@ function mergeRawConfigs(globalRaw, projectRaw) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path71 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path71.split("/").filter(Boolean);
+    const path73 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path73.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -1746,8 +1746,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path71 = line.split("	")[1];
-    if (path71) found.add(path71.trim());
+    const path73 = line.split("	")[1];
+    if (path73) found.add(path73.trim());
   }
   return [...found];
 }
@@ -1857,8 +1857,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path71 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path71}/${ref}`;
+  const path73 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path73}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -3833,11 +3833,11 @@ function enumValues(node) {
 function opaqueConfigNode(inner, base) {
   return { ...base, kind: "other", type: leafTypeOf(inner) };
 }
-function build(node, path71) {
+function build(node, path73) {
   const { inner, defaultValue, optional } = unwrapSchemaNode(node);
   const secret = isSecretSchemaNode(node) || isSecretSchemaNode(inner);
   const base = {
-    path: path71,
+    path: path73,
     ...optional ? { optional: true } : {},
     ...defaultValue === void 0 ? {} : { defaultValue },
     ...secret ? { secret: true } : {}
@@ -3856,9 +3856,9 @@ function segmentText(segment) {
   if (segment.kind === "index") return `[${segment.index}]`;
   return "[]";
 }
-function formatConfigPath(path71) {
+function formatConfigPath(path73) {
   let text17 = "";
-  for (const segment of path71) {
+  for (const segment of path73) {
     const dotted = segment.kind === "key" || segment.kind === "entry";
     const rendered = segmentText(segment);
     text17 += dotted && text17 ? `.${rendered}` : rendered;
@@ -4471,9 +4471,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, path71) {
+function resolveStringsAtPath(data, path73) {
   let current = data;
-  for (const segment of path71.split(".")) {
+  for (const segment of path73.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -4486,10 +4486,10 @@ function resolveStringsAtPath(data, path71) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path71 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path71)) {
+  for (const path73 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path73)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path71, value });
+        violations.push({ file: rule.file, path: path73, value });
     }
   }
   return violations;
@@ -4528,8 +4528,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path71, value } of violations) {
-    console.log(`  ${file} ${path71}: ${value}`);
+  for (const { file, path: path73, value } of violations) {
+    console.log(`  ${file} ${path73}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -4844,15 +4844,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path71) => MIGRATION_FILE3.test(basename2(path71)));
-  for (const path71 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path73) => MIGRATION_FILE3.test(basename2(path73)));
+  for (const path73 of paths) {
     try {
-      const content = execSync14(`git show "${ref}:${path71}"`, {
+      const content = execSync14(`git show "${ref}:${path73}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path71), content);
+      baseline.set(basename2(path73), content);
     } catch {
     }
   }
@@ -6286,10 +6286,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path71 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname13(path71), { recursive: true });
-  writeFileSync15(path71, JSON.stringify(hooksSettings, null, 2));
-  return path71;
+  const path73 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname13(path73), { recursive: true });
+  writeFileSync15(path73, JSON.stringify(hooksSettings, null, 2));
+  return path73;
 }
 
 // src/shared/spawnInherit.ts
@@ -6587,9 +6587,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path71 = join15(dir, ".assist", name);
-    if (existsSync19(path71)) {
-      renameSync(path71, `${path71}.bak`);
+    const path73 = join15(dir, ".assist", name);
+    if (existsSync19(path73)) {
+      renameSync(path73, `${path73}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -7068,8 +7068,8 @@ var backlogItemSchema = z4.strictObject({
 var backlogFileSchema = z4.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path71) {
-  const content = readFileSync15(path71, "utf8").trim();
+function parseBacklogJsonl(path73) {
+  const content = readFileSync15(path73, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -7856,24 +7856,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path71 = getOwnerPath(itemId2);
-  mkdirSync7(dirname15(path71), { recursive: true });
-  writeFileSync17(path71, JSON.stringify({ sessionId }));
+  const path73 = getOwnerPath(itemId2);
+  mkdirSync7(dirname15(path73), { recursive: true });
+  writeFileSync17(path73, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path71 = getOwnerPath(itemId2);
-  if (!existsSync23(path71)) return void 0;
+  const path73 = getOwnerPath(itemId2);
+  if (!existsSync23(path73)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync16(path71, "utf8"));
+    const parsed = JSON.parse(readFileSync16(path73, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path71 = getOwnerPath(itemId2);
+  const path73 = getOwnerPath(itemId2);
   try {
-    rmSync(path71);
+    rmSync(path73);
   } catch {
   }
 }
@@ -7910,19 +7910,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path71 = getSignalPath(target);
-  if (!path71) return;
+  const path73 = getSignalPath(target);
+  if (!path73) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname16(path71), { recursive: true });
-  writeFileSync18(path71, JSON.stringify(signal));
+  mkdirSync8(dirname16(path73), { recursive: true });
+  writeFileSync18(path73, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path71 = getSignalPath();
-  if (!path71 || !existsSync24(path71)) return void 0;
+  const path73 = getSignalPath();
+  if (!path73 || !existsSync24(path73)) return void 0;
   try {
-    return JSON.parse(readFileSync17(path71, "utf8"));
+    return JSON.parse(readFileSync17(path73, "utf8"));
   } catch {
     return void 0;
   }
@@ -8119,13 +8119,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path71 = activityPath(sessionId);
-  mkdirSync9(dirname17(path71), { recursive: true });
-  writeFileSync19(path71, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path73 = activityPath(sessionId);
+  mkdirSync9(dirname17(path73), { recursive: true });
+  writeFileSync19(path73, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path71) {
+function readActivity(path73) {
   try {
-    return JSON.parse(readFileSync18(path71, "utf8"));
+    return JSON.parse(readFileSync18(path73, "utf8"));
   } catch {
     return void 0;
   }
@@ -8135,9 +8135,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path71 = activityPath(sessionId);
-  mkdirSync9(dirname17(path71), { recursive: true });
-  writeFileSync19(path71, JSON.stringify(activity2));
+  const path73 = activityPath(sessionId);
+  mkdirSync9(dirname17(path73), { recursive: true });
+  writeFileSync19(path73, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -9380,10 +9380,10 @@ function getStorePath(filename) {
   return join24(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path71 = getStorePath(filename);
-  if (existsSync27(path71)) {
+  const path73 = getStorePath(filename);
+  if (existsSync27(path73)) {
     try {
-      return JSON.parse(readFileSync19(path71, "utf8"));
+      return JSON.parse(readFileSync19(path73, "utf8"));
     } catch {
       return {};
     }
@@ -9402,22 +9402,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(([path71, record]) => ({ path: path71, ...record }));
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path73, record]) => ({ path: path73, ...record }));
 }
-function worktreeAttributionIncludingReaped(path71) {
-  const record = loadJson(REGISTRY_FILE)[path71];
+function worktreeAttributionIncludingReaped(path73) {
+  const record = loadJson(REGISTRY_FILE)[path73];
   return record ? { clone: record.clone, origin: record.origin } : void 0;
 }
-function recordWorktree(path71, clone, origin) {
+function recordWorktree(path73, clone, origin) {
   const data = loadJson(REGISTRY_FILE);
-  data[path71] = { clone, origin };
+  data[path73] = { clone, origin };
   saveJson(REGISTRY_FILE, data);
 }
-function forgetWorktree(path71) {
+function forgetWorktree(path73) {
   const data = loadJson(REGISTRY_FILE);
-  const record = data[path71];
+  const record = data[path73];
   if (!record || record.reaped) return;
-  data[path71] = { ...record, reaped: true };
+  data[path73] = { ...record, reaped: true };
   saveJson(REGISTRY_FILE, data);
 }
 
@@ -10173,8 +10173,8 @@ async function loadCommittedPaths(cwd, sessionId) {
   for (const commit2 of commits2) {
     const resolved = await resolveCommit(cwd, commit2.sha);
     if (!resolved) continue;
-    for (const path71 of resolved.paths) {
-      if (!bases.has(path71)) bases.set(path71, resolved.base);
+    for (const path73 of resolved.paths) {
+      if (!bases.has(path73)) bases.set(path73, resolved.base);
     }
   }
   return { commits: commits2, bases };
@@ -10192,16 +10192,16 @@ async function itemChangeSet(cwd, sessionId) {
 }
 function groupByBase(bases) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [path71, base] of bases) {
+  for (const [path73, base] of bases) {
     const paths = groups.get(base);
-    if (paths) paths.push(path71);
-    else groups.set(base, [path71]);
+    if (paths) paths.push(path73);
+    else groups.set(base, [path73]);
   }
   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((path71) => path71 && !bases.has(path71)).sort();
+  return output.split("\n").filter((path73) => path73 && !bases.has(path73)).sort();
 }
 
 // src/commands/sessions/web/scopedDiff.ts
@@ -10210,8 +10210,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, path71) {
-  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path71], {
+async function untrackedFileDiff(cwd, path73) {
+  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path73], {
     maxBuffer: MAX_DIFF_BYTES,
     allowFailure: true
   });
@@ -10224,7 +10224,7 @@ async function untrackedDiff(cwd) {
   ]);
   const paths = list5.split("\n").filter(Boolean);
   const diffs = await Promise.all(
-    paths.map((path71) => untrackedFileDiff(cwd, path71))
+    paths.map((path73) => untrackedFileDiff(cwd, path73))
   );
   return diffs.join("");
 }
@@ -10317,9 +10317,9 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve10
 function repoRoot(cwd) {
   return resolve10(toGitCwd(cwd));
 }
-function resolveWithinCwd(cwd, path71) {
+function resolveWithinCwd(cwd, path73) {
   const root = repoRoot(cwd);
-  const target = resolve10(root, path71);
+  const target = resolve10(root, path73);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
@@ -10329,14 +10329,14 @@ function resolveWithinCwd(cwd, path71) {
 function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return null;
-  const path71 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+  const path73 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
-  if (!path71) {
+  if (!path73) {
     respondJson(res, 400, { error: "Missing path" });
     return null;
   }
-  const target = resolveWithinCwd(cwd, path71);
+  const target = resolveWithinCwd(cwd, path73);
   if (!target) {
     respondJson(res, 400, { error: "Path outside cwd" });
     return null;
@@ -10405,35 +10405,35 @@ function isPlainRecord(value) {
 }
 
 // src/shared/mapConfigSecrets.ts
-function mapChildren(value, path71, childNode, map) {
+function mapChildren(value, path73, childNode, map) {
   if (!isPlainRecord(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([name, child]) => [
       name,
-      walk(child, [...path71, name], childNode(name), map)
+      walk(child, [...path73, name], childNode(name), map)
     ])
   );
 }
-function mapItems(value, path71, item, map) {
+function mapItems(value, path73, item, map) {
   if (!Array.isArray(value)) return value;
-  return value.map((entry, index3) => walk(entry, [...path71, index3], item, map));
+  return value.map((entry, index3) => walk(entry, [...path73, index3], item, map));
 }
-function walk(value, path71, node, map) {
+function walk(value, path73, node, map) {
   if (!node || value === void 0 || value === null) return value;
-  if (node.secret) return map(value, path71);
+  if (node.secret) return map(value, path73);
   switch (node.kind) {
     case "object":
     case "unionOfObjects":
       return mapChildren(
         value,
-        path71,
+        path73,
         (name) => configNodeField(node, name),
         map
       );
     case "objectList":
-      return mapItems(value, path71, node.item, map);
+      return mapItems(value, path73, node.item, map);
     case "record":
-      return mapChildren(value, path71, () => node.value, map);
+      return mapChildren(value, path73, () => node.value, map);
     default:
       return value;
   }
@@ -10465,9 +10465,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path71) {
+function getNestedValue(obj, path73) {
   let current = obj;
-  for (const key of path71.split(".")) current = stepInto(current, key);
+  for (const key of path73.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -10552,9 +10552,9 @@ function step(node, segment) {
       return void 0;
   }
 }
-function findConfigNode(root, path71) {
+function findConfigNode(root, path73) {
   let current = root;
-  for (const segment of path71) {
+  for (const segment of path73) {
     if (!current) return void 0;
     current = step(current, segment);
   }
@@ -10571,34 +10571,34 @@ function nameSegment(name) {
   return name === RECORD_ENTRY_TOKEN ? { kind: "entry" } : { kind: "key", name };
 }
 function parseConfigPath(text17) {
-  const path71 = [];
+  const path73 = [];
   let at2 = 0;
   while (at2 < text17.length) {
     if (text17[at2] === "[") {
       const close = text17.indexOf("]", at2);
       const segment = close === -1 ? void 0 : bracketSegment(text17.slice(at2 + 1, close));
       if (!segment) return void 0;
-      path71.push(segment);
+      path73.push(segment);
       at2 = close + 1;
       continue;
     }
     if (text17[at2] === ".") {
-      if (path71.length === 0) return void 0;
+      if (path73.length === 0) return void 0;
       at2 += 1;
     }
     const start3 = at2;
     while (at2 < text17.length && text17[at2] !== "." && text17[at2] !== "[") at2 += 1;
     const name = text17.slice(start3, at2);
     if (!name) return void 0;
-    path71.push(nameSegment(name));
+    path73.push(nameSegment(name));
   }
-  return path71;
+  return path73;
 }
 
 // src/commands/config/configEntryNode.ts
 function configEntryNode(root, key) {
-  const path71 = parseConfigPath(key);
-  return path71 ? findConfigNode(root, path71) : void 0;
+  const path73 = parseConfigPath(key);
+  return path73 ? findConfigNode(root, path73) : void 0;
 }
 
 // src/commands/config/readConfigEntries.ts
@@ -10703,7 +10703,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname21(branchKeyPath);
   const branchPrefix = basename7(branchKeyPath);
   if (!existsSync29(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join27(parent, name, "synthesis.md")).filter((path71) => existsSync29(path71)).map((path71) => ({ path: path71, mtime: statSync4(path71).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join27(parent, name, "synthesis.md")).filter((path73) => existsSync29(path73)).map((path73) => ({ path: path73, mtime: statSync4(path73).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -10733,12 +10733,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path71 = await resolveSynthesisPath(cwd);
-    if (!path71) {
+    const path73 = await resolveSynthesisPath(cwd);
+    if (!path73) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync21(path71, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync21(path73, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -10821,8 +10821,8 @@ function parseDiffNameStatus(output) {
     if (!status3 || fields.length < 2) continue;
     const category = categorize(status3[0]);
     if (!category) continue;
-    const path71 = fields[fields.length - 1];
-    if (path71) result[category].push(path71);
+    const path73 = fields[fields.length - 1];
+    if (path73) result[category].push(path73);
   }
   return result;
 }
@@ -10958,21 +10958,21 @@ function subsequenceScore(text17, query) {
   }
   return score - Math.min(text17.length, MAX_LENGTH_PENALTY);
 }
-function scoreFilePath(path71, query) {
+function scoreFilePath(path73, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename21 = path71.slice(path71.lastIndexOf("/") + 1);
-  const inBasename = subsequenceScore(basename21, needle);
+  const basename23 = path73.slice(path73.lastIndexOf("/") + 1);
+  const inBasename = subsequenceScore(basename23, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
-  return subsequenceScore(path71, needle);
+  return subsequenceScore(path73, needle);
 }
 
 // src/commands/sessions/web/rankFilePaths.ts
 function rankFilePaths(paths, query, limit) {
   const scored = [];
-  for (const path71 of paths) {
-    const score = scoreFilePath(path71, query);
-    if (score !== null) scored.push({ path: path71, score });
+  for (const path73 of paths) {
+    const score = scoreFilePath(path73, query);
+    if (score !== null) scored.push({ path: path73, score });
   }
   scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
   return scored.slice(0, limit).map((entry) => entry.path);
@@ -11437,38 +11437,38 @@ async function restartWeb(req, res, deps2 = {}) {
 import { relative as relative3 } from "path";
 
 // src/commands/sessions/web/revertPathChanges.ts
-async function isTracked(cwd, path71) {
+async function isTracked(cwd, path73) {
   try {
-    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path71]);
+    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path73]);
     return true;
   } catch {
     return false;
   }
 }
-async function isInHead(cwd, path71) {
-  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path71]);
+async function isInHead(cwd, path73) {
+  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path73]);
   return listing.trim().length > 0;
 }
-async function revertPathChanges(cwd, path71) {
-  if (!await isTracked(cwd, path71)) {
-    await execGit(cwd, ["clean", "-f", "--", path71]);
+async function revertPathChanges(cwd, path73) {
+  if (!await isTracked(cwd, path73)) {
+    await execGit(cwd, ["clean", "-f", "--", path73]);
     return;
   }
-  if (await isInHead(cwd, path71)) {
-    await execGit(cwd, ["checkout", "HEAD", "--", path71]);
+  if (await isInHead(cwd, path73)) {
+    await execGit(cwd, ["checkout", "HEAD", "--", path73]);
     return;
   }
-  await execGit(cwd, ["rm", "-f", "--", path71]);
+  await execGit(cwd, ["rm", "-f", "--", path73]);
 }
 
 // src/commands/sessions/web/revertDiffFile.ts
 async function revertDiffFile(req, res) {
   const resolved = getFileTarget(req, res);
   if (!resolved) return;
-  const path71 = relative3(repoRoot(resolved.cwd), resolved.target);
+  const path73 = relative3(repoRoot(resolved.cwd), resolved.target);
   try {
-    await revertPathChanges(resolved.cwd, path71);
-    respondJson(res, 200, { reverted: path71 });
+    await revertPathChanges(resolved.cwd, path73);
+    respondJson(res, 200, { reverted: path73 });
   } catch (error) {
     respondJson(res, 500, {
       error: error instanceof Error ? error.message : "Failed to revert file"
@@ -11549,11 +11549,11 @@ function coerceStructuredConfigValue(key, raw) {
   };
 }
 function formatIssue(key, issue) {
-  const path71 = formatConfigPath([
+  const path73 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
   ]);
-  return `${path71}: ${issue.message}`;
+  return `${path73}: ${issue.message}`;
 }
 function toSegment(part) {
   return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
@@ -11648,9 +11648,9 @@ function coerceUnion(key, raw, types) {
 }
 
 // src/shared/valueAtConfigPath.ts
-function valueAtConfigPath(value, path71) {
+function valueAtConfigPath(value, path73) {
   let current = value;
-  for (const key of path71) {
+  for (const key of path73) {
     if (typeof key === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[key];
@@ -11667,7 +11667,7 @@ function restoreConfigSecrets(value, stored, node) {
   return mapConfigSecrets(
     value,
     node,
-    (secret, path71) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path71) : secret
+    (secret, path73) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path73) : secret
   );
 }
 
@@ -11716,8 +11716,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path71, value) {
-  const keys = path71.split(".");
+function setNestedValue(obj, path73, value) {
+  const keys = path73.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -11738,8 +11738,8 @@ function validateConfig(updated, key, schema2 = assistConfigSchema) {
   };
 }
 function formatIssue2(issue, key) {
-  const path71 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return `${path71}: ${issue.message}`;
+  const path73 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return `${path73}: ${issue.message}`;
 }
 
 // src/commands/config/applyConfigSet.ts
@@ -11970,8 +11970,8 @@ function removeAt(container, keys) {
   }
   return removeFromChild(container, key, rest);
 }
-function unsetNestedValue(obj, path71) {
-  const { container, removed } = removeAt(obj, path71.split("."));
+function unsetNestedValue(obj, path73) {
+  const { container, removed } = removeAt(obj, path73.split("."));
   return { config: container, removed };
 }
 
@@ -12963,9 +12963,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path71 = origin.slice(firstSlash + 1);
-  if (!path71) return null;
-  return `git@${host}:${path71}.git`;
+  const path73 = origin.slice(firstSlash + 1);
+  if (!path73) return null;
+  return `git@${host}:${path73}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -15937,9 +15937,9 @@ var __dirname4 = dirname23(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path71) {
-  if (!existsSync32(path71)) return [];
-  return readFileSync25(path71, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path73) {
+  if (!existsSync32(path73)) return [];
+  return readFileSync25(path73, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -16433,14 +16433,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, path71, description, depth, p) {
-  showProgress(p, path71.join(" "));
-  const subHelp = await runHelp([cli, ...path71]);
+async function resolveCommand(cli, path73, description, depth, p) {
+  showProgress(p, path73.join(" "));
+  const subHelp = await runHelp([cli, ...path73]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path71, description }];
+    return [{ path: path73, description }];
   }
-  const children = await discoverAt(cli, path71, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path71, description }];
+  const children = await discoverAt(cli, path73, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path73, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -16588,9 +16588,9 @@ function logPath(cli) {
   return join34(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path71 = logPath(cli);
-  if (!existsSync34(path71)) return void 0;
-  return readFileSync27(path71, "utf8");
+  const path73 = logPath(cli);
+  if (!existsSync34(path73)) return void 0;
+  return readFileSync27(path73, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join34(homedir16(), ".assist");
@@ -16750,9 +16750,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path71 = join36(dir, entry);
+    const path73 = join36(dir, entry);
     try {
-      if (statSync5(path71).mtimeMs < cutoff) unlinkSync7(path71);
+      if (statSync5(path73).mtimeMs < cutoff) unlinkSync7(path73);
     } catch {
       continue;
     }
@@ -16762,10 +16762,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync35, readFileSync as readFileSync28 } from "fs";
 function readPinState(pin) {
-  const path71 = getPinStatePath(pin);
-  if (!existsSync35(path71)) return void 0;
+  const path73 = getPinStatePath(pin);
+  if (!existsSync35(path73)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path71, "utf8"));
+    const state = JSON.parse(readFileSync28(path73, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -17850,10 +17850,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync37, readFileSync as readFileSync30 } from "fs";
 function readMigrationPinState(pin) {
-  const path71 = getMigrationPinPath(pin);
-  if (!existsSync37(path71)) return void 0;
+  const path73 = getMigrationPinPath(pin);
+  if (!existsSync37(path73)) return void 0;
   try {
-    const state = JSON.parse(readFileSync30(path71, "utf8"));
+    const state = JSON.parse(readFileSync30(path73, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -19251,10 +19251,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync43, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path71 = getMigrationApprovalPath(migrationId);
-  if (!existsSync43(path71)) return false;
+  const path73 = getMigrationApprovalPath(migrationId);
+  if (!existsSync43(path73)) return false;
   try {
-    unlinkSync11(path71);
+    unlinkSync11(path73);
     return true;
   } catch {
     return false;
@@ -20061,22 +20061,22 @@ function createWorktree(clone, strategy, boundTreeRoots2, preferredPath) {
   const registered = new Set(listWorktreePaths(clone));
   const branches = new Set(listLocalBranches(clone));
   const isTaken = (candidate) => registered.has(candidate) || existsSync45(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename14(candidate));
-  const path71 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
+  const path73 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
     "worktree",
     "add",
     start3.track ? "--track" : "--no-track",
     "-b",
-    basename14(path71),
-    path71,
+    basename14(path73),
+    path73,
     start3.ref
   ]);
-  recordWorktree(path71, clone, getCurrentOrigin(clone));
+  recordWorktree(path73, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path71} (branch ${basename14(path71)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path71} (branch ${basename14(path71)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path73} (branch ${basename14(path73)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path73} (branch ${basename14(path73)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
-  return path71;
+  return path73;
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
@@ -20188,13 +20188,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 path71 = createWorktree(
+  const path73 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
     boundTreeRoots2,
     options2.replacesTree
   );
-  return { cwd: path71, kind: "worktree", created: true, clone };
+  return { cwd: path73, kind: "worktree", created: true, clone };
 }
 function keptInPlace(cwd) {
   daemonLog(
@@ -20525,13 +20525,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 path71 = null;
+  let path73 = null;
   for (const line of listing.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("worktree "))
-      path71 = trimmed.slice("worktree ".length).trim();
+      path73 = trimmed.slice("worktree ".length).trim();
     else if (trimmed === `branch refs/heads/${branch2}`)
-      return path71 && path71 !== here ? path71 : null;
+      return path73 && path73 !== here ? path73 : null;
   }
   return null;
 }
@@ -20988,9 +20988,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path71] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path73] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path71) {
+    for (const key of path73) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -21676,15 +21676,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path71, line, body, startLine) {
+function comment2(path73, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path71, line, startLine });
+    postComment({ prId, body, path: path73, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path71}:${range}`);
+    console.log(`Added review comment on ${path73}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -22939,8 +22939,8 @@ function registerPrs(program2) {
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path71, line, body) => {
-    comment2(path71, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path73, line, body) => {
+    comment2(path73, Number.parseInt(line, 10), body);
   });
   configHelp(prsCommand, prsConfigHelp);
 }
@@ -23193,10 +23193,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path71) {
+async function ravenFetch(connection, path73) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path71}`;
+  const url = `${connection.url}${path73}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -23286,16 +23286,16 @@ import chalk182 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path71;
+  let path73;
   if (opts.collection) {
-    path71 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path73 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path71 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path73 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path71 += `&query=${encodeURIComponent(opts.query)}`;
+    path73 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path71;
+  return path73;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -23304,7 +23304,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 path71 = buildQueryPath({
+    const path73 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -23312,7 +23312,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path71);
+    const data = await ravenFetch(connection, path73);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -24753,8 +24753,8 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename21 = path52.basename(file, path52.extname(file));
-    if (basename21 === "index") continue;
+    const basename23 = path52.basename(file, path52.extname(file));
+    if (basename23 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
@@ -25907,8 +25907,8 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync50, mkdirSync as mkdirSync19, unlinkSync as unlinkSync17, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path71 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync50(path71)) unlinkSync17(path71);
+  for (const path73 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync50(path73)) unlinkSync17(path73);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -26998,8 +26998,8 @@ import chalk203 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk200 from "chalk";
-async function fetchSeq(conn, path71, params) {
-  const url = `${conn.url}${path71}?${params}`;
+async function fetchSeq(conn, path73, params) {
+  const url = `${conn.url}${path73}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -27548,6 +27548,438 @@ function registerSql(program2) {
   configHelp(cmd, sqlConfigHelp);
 }
 
+// src/commands/sync.ts
+import * as fs43 from "fs";
+import * as os4 from "os";
+import * as path68 from "path";
+import { fileURLToPath as fileURLToPath7 } from "url";
+
+// src/commands/sync/pruneCommands.ts
+import * as path59 from "path";
+
+// src/commands/sync/pruneTarget.ts
+import * as fs35 from "fs";
+import * as path58 from "path";
+function pruneTarget(targetDir, keepNames, shape, options2) {
+  const result = {
+    orphans: [],
+    removed: [],
+    skipped: [],
+    unmanaged: []
+  };
+  if (!fs35.existsSync(targetDir)) return result;
+  const keep = new Set(keepNames);
+  for (const entry of fs35.readdirSync(targetDir, { withFileTypes: true })) {
+    const name = shape.nameOf(entry);
+    if (name === void 0) {
+      result.unmanaged.push(entry.name);
+      continue;
+    }
+    if (keep.has(name)) continue;
+    result.orphans.push(entry.name);
+    const entryPath = path58.join(targetDir, entry.name);
+    const reason4 = shape.blockedBy?.(entryPath);
+    if (reason4) {
+      result.skipped.push({ name: entry.name, reason: reason4 });
+      continue;
+    }
+    if (options2.force) {
+      fs35.rmSync(entryPath, { recursive: true });
+      result.removed.push(entry.name);
+    }
+  }
+  return result;
+}
+
+// src/commands/sync/pruneCommands.ts
+function pruneCommands(targetDir, commandNames, options2) {
+  return pruneTarget(
+    targetDir,
+    commandNames,
+    {
+      nameOf: (entry) => entry.isFile() && entry.name.endsWith(".md") ? path59.basename(entry.name, ".md") : void 0
+    },
+    options2
+  );
+}
+
+// src/commands/sync/reportPrune.ts
+function reportPrune(label2, result, force) {
+  if (result.orphans.length === 0) {
+    console.log(`No orphaned commands in ${label2}`);
+  } else if (force) {
+    for (const name of result.removed) {
+      console.log(`Removed ${name} from ${label2}`);
+    }
+  } else {
+    console.log(`Orphaned commands in ${label2} (run with --force to remove):`);
+    for (const name of result.orphans) {
+      console.log(`  ${name}`);
+    }
+  }
+  if (result.skipped.length > 0) {
+    console.log(`Left in place in ${label2} (not written by sync):`);
+    for (const { name, reason: reason4 } of result.skipped) {
+      console.log(`  ${name} - ${reason4}`);
+    }
+  }
+  if (result.unmanaged.length === 0) return;
+  console.log(`Not managed by sync in ${label2} (never removed):`);
+  for (const name of result.unmanaged) {
+    console.log(`  ${name}`);
+  }
+}
+
+// src/commands/sync/syncClaudeMd.ts
+import * as fs36 from "fs";
+import * as path60 from "path";
+import chalk210 from "chalk";
+async function syncClaudeMd(claudeDir, targetBase, options2) {
+  const source = path60.join(claudeDir, "CLAUDE.md");
+  const target = path60.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs36.readFileSync(source, "utf8");
+  if (fs36.existsSync(target)) {
+    const targetContent = fs36.readFileSync(target, "utf8");
+    if (sourceContent !== targetContent) {
+      console.log(
+        chalk210.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+      );
+      console.log();
+      printDiff(targetContent, sourceContent);
+      if (!options2?.yes) {
+        printAutoConfirmHint();
+        const confirm = await promptConfirm(
+          chalk210.red("Overwrite existing CLAUDE.md?"),
+          false
+        );
+        if (!confirm) {
+          console.log("Skipped CLAUDE.md");
+          return;
+        }
+      }
+    }
+  }
+  fs36.copyFileSync(source, target);
+  console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
+}
+
+// src/commands/sync/syncCodex.ts
+import * as path63 from "path";
+
+// src/commands/sync/installHarnessCommands.ts
+import * as fs37 from "fs";
+import * as path61 from "path";
+function installHarnessCommands(claudeDir, harness, transform) {
+  const commandsSource = path61.join(claudeDir, "commands");
+  const files = fs37.readdirSync(commandsSource);
+  const names = [];
+  let synced = 0;
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const name = file.replace(/\.md$/, "");
+    names.push(name);
+    const content = fs37.readFileSync(path61.join(commandsSource, file), "utf8");
+    const target = path61.join(harness.homeDir, harness.sync.commandDest(name));
+    fs37.mkdirSync(path61.dirname(target), { recursive: true });
+    fs37.writeFileSync(target, transform(name, content));
+    synced++;
+  }
+  const agentsTarget = path61.join(harness.homeDir, harness.sync.agentsFile);
+  fs37.mkdirSync(path61.dirname(agentsTarget), { recursive: true });
+  fs37.copyFileSync(path61.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  return { total: files.length, synced, names };
+}
+
+// src/commands/sync/pruneSkills.ts
+import * as fs38 from "fs";
+function pruneSkills(targetDir, skillNames, options2) {
+  return pruneTarget(
+    targetDir,
+    skillNames,
+    {
+      nameOf: (entry) => entry.isDirectory() ? entry.name : void 0,
+      blockedBy: unexpectedContent
+    },
+    options2
+  );
+}
+function unexpectedContent(skillDir) {
+  const entries = fs38.readdirSync(skillDir);
+  const others = entries.filter((entry) => entry !== "SKILL.md");
+  if (others.length > 0) return `contains ${others.sort().join(", ")}`;
+  return entries.length === 0 ? "no SKILL.md" : void 0;
+}
+
+// src/commands/sync/syncCodexHooks.ts
+import * as fs39 from "fs";
+import * as path62 from "path";
+var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
+var END = "# <<< assist codex hooks (managed) <<<";
+function upsertManagedBlock(existing, body) {
+  const block = `${BEGIN}
+${body.trim()}
+${END}`;
+  const begin = existing.indexOf(BEGIN);
+  if (begin === -1) {
+    const base = existing.replace(/\s*$/, "");
+    return base ? `${base}
+
+${block}
+` : `${block}
+`;
+  }
+  const endMarker = existing.indexOf(END, begin);
+  const after = endMarker === -1 ? existing.length : endMarker + END.length;
+  const before = existing.slice(0, begin).replace(/\s*$/, "");
+  const rest = existing.slice(after).replace(/^\s*/, "");
+  const head = before ? `${before}
+
+${block}` : block;
+  return rest ? `${head}
+
+${rest}
+` : `${head}
+`;
+}
+function syncCodexHooks(sourcePath) {
+  const body = fs39.readFileSync(sourcePath, "utf8");
+  const configPath = path62.join(harnesses.codex.homeDir, "config.toml");
+  const existing = fs39.existsSync(configPath) ? fs39.readFileSync(configPath, "utf8") : "";
+  fs39.mkdirSync(path62.dirname(configPath), { recursive: true });
+  fs39.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  console.log(
+    "Registered assist codex-hook in ~/.codex/config.toml (PreToolUse, PermissionRequest)"
+  );
+}
+
+// src/commands/sync/syncCodex.ts
+function quoteYaml(value) {
+  return `"${value.replace(/\\/g, String.raw`\\`).replace(/"/g, String.raw`\"`)}"`;
+}
+function commandToSkill(name, content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const frontmatter = match ? match[1] : "";
+  const body = match ? content.slice(match[0].length) : content;
+  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
+  const description = descriptionMatch ? descriptionMatch[1].trim().replace(/^["']|["']$/g, "") : name;
+  const header = `---
+name: ${name}
+description: ${quoteYaml(description)}
+---
+
+`;
+  return header + body.replace(/^\r?\n+/, "");
+}
+function syncCodex(claudeDir, options2) {
+  if (!isHarnessAvailable("codex")) return;
+  const { total, names } = installHarnessCommands(
+    claudeDir,
+    harnesses.codex,
+    commandToSkill
+  );
+  syncCodexHooks(path63.join(claudeDir, "..", "codex", "config.toml"));
+  console.log(
+    `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
+  );
+  if (!options2?.prune) return;
+  const force = options2.force ?? false;
+  reportPrune(
+    "~/.codex/skills",
+    pruneSkills(path63.join(harnesses.codex.homeDir, "skills"), names, { force }),
+    force
+  );
+}
+
+// src/commands/sync/syncDesign.ts
+import * as fs40 from "fs";
+import * as path64 from "path";
+function syncDesign(claudeDir, targetBase) {
+  const systemPromptSource = path64.join(claudeDir, "design-system-prompt.md");
+  const systemPromptTarget = path64.join(targetBase, "design-system-prompt.md");
+  fs40.copyFileSync(systemPromptSource, systemPromptTarget);
+  console.log(
+    "Copied design-system-prompt.md to ~/.claude/design-system-prompt.md"
+  );
+  const skillsSource = path64.join(claudeDir, "skills");
+  const skillsTarget = path64.join(targetBase, "skills");
+  fs40.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs40.readdirSync(skillsSource);
+  for (const file of files) {
+    fs40.copyFileSync(
+      path64.join(skillsSource, file),
+      path64.join(skillsTarget, file)
+    );
+  }
+  console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
+}
+
+// src/commands/sync/syncPi.ts
+import * as path66 from "path";
+
+// src/commands/sync/syncPiHooks.ts
+import * as fs41 from "fs";
+import * as path65 from "path";
+function piExtensionsDir() {
+  return path65.join(harnesses.pi.homeDir, "extensions");
+}
+function syncPiHooks(sourceDir) {
+  const target = piExtensionsDir();
+  fs41.mkdirSync(target, { recursive: true });
+  const files = fs41.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  for (const file of files) {
+    fs41.copyFileSync(
+      path65.join(sourceDir, file),
+      path65.join(target, `assist-${file}`)
+    );
+  }
+  console.log(
+    `Registered ${files.length} assist extension(s) in ~/.pi/agent/extensions`
+  );
+}
+
+// src/commands/sync/syncPi.ts
+function unquote(value) {
+  return value.trim().replace(/^["']|["']$/g, "");
+}
+function commandToPrompt(name, content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const frontmatter = match ? match[1] : "";
+  const body = match ? content.slice(match[0].length) : content;
+  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
+  const description = descriptionMatch ? unquote(descriptionMatch[1]) : name;
+  const argsMatch = frontmatter.match(/^allowed_args:\s*(.*)$/m);
+  const argumentHint = argsMatch ? unquote(argsMatch[1]) : void 0;
+  const header = [
+    "---",
+    `description: ${description}`,
+    ...argumentHint ? [`argument-hint: ${argumentHint}`] : [],
+    "---",
+    "",
+    ""
+  ].join("\n");
+  return header + body.replace(/^\r?\n+/, "");
+}
+function syncPi(claudeDir, options2) {
+  if (!isHarnessAvailable("pi")) return;
+  const { synced, names } = installHarnessCommands(
+    claudeDir,
+    harnesses.pi,
+    commandToPrompt
+  );
+  syncPiHooks(path66.join(claudeDir, "..", "pi"));
+  console.log(
+    `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
+  );
+  if (!options2?.prune) return;
+  const force = options2.force ?? false;
+  reportPrune(
+    "~/.pi/agent/prompts",
+    pruneCommands(path66.join(harnesses.pi.homeDir, "prompts"), names, { force }),
+    force
+  );
+}
+
+// src/commands/sync/syncSettings.ts
+import * as fs42 from "fs";
+import * as path67 from "path";
+import chalk211 from "chalk";
+async function syncSettings(claudeDir, targetBase, options2) {
+  const source = path67.join(claudeDir, "settings.json");
+  const target = path67.join(targetBase, "settings.json");
+  const sourceContent = fs42.readFileSync(source, "utf8");
+  const sourceSettings = JSON.parse(sourceContent);
+  const targetExists = fs42.existsSync(target);
+  const targetContent = targetExists ? fs42.readFileSync(target, "utf8") : "";
+  const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
+  const mergedContent = JSON.stringify(
+    { ...preservedUserSettings, ...sourceSettings },
+    null,
+    "	"
+  );
+  if (targetExists) {
+    const normalizedTarget = JSON.stringify(preservedUserSettings, null, "	");
+    if (mergedContent !== normalizedTarget) {
+      if (!options2?.yes) {
+        console.log(
+          chalk211.yellow(
+            "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
+          )
+        );
+        console.log();
+        printDiff(targetContent, mergedContent);
+        printAutoConfirmHint();
+        const confirm = await promptConfirm(
+          chalk211.red("Overwrite existing settings.json?"),
+          false
+        );
+        if (!confirm) {
+          console.log("Skipped settings.json");
+          return;
+        }
+      }
+    }
+  }
+  fs42.writeFileSync(target, mergedContent);
+  console.log("Copied settings.json to ~/.claude/settings.json");
+}
+
+// src/commands/sync.ts
+var __filename4 = fileURLToPath7(import.meta.url);
+var __dirname5 = path68.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 = path68.join(__dirname5, "..", "claude");
+  const targetBase = path68.join(os4.homedir(), ".claude");
+  const commandFiles = syncCommands(claudeDir, targetBase);
+  syncDesign(claudeDir, targetBase);
+  await syncSettings(claudeDir, targetBase, { yes });
+  await syncClaudeMd(claudeDir, targetBase, { yes });
+  syncCodex(claudeDir, prune);
+  syncPi(claudeDir, prune);
+  if (!options2?.prune) return;
+  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path68.basename(file, ".md"));
+  const force = options2.force ?? false;
+  reportPrune(
+    "~/.claude/commands",
+    pruneCommands(path68.join(targetBase, "commands"), commandNames, { force }),
+    force
+  );
+}
+function syncCommands(claudeDir, targetBase) {
+  const sourceDir = path68.join(claudeDir, "commands");
+  const targetDir = path68.join(targetBase, "commands");
+  fs43.mkdirSync(targetDir, { recursive: true });
+  const files = fs43.readdirSync(sourceDir);
+  for (const file of files) {
+    fs43.copyFileSync(path68.join(sourceDir, file), path68.join(targetDir, file));
+    console.log(`Copied ${file} to ${targetDir}`);
+  }
+  console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
+  return files;
+}
+
+// src/commands/registerSync.ts
+function registerSync(program2) {
+  const syncCommand = program2.command("sync").description(
+    "Copy command files to ~/.claude/commands; when codex is detected, also install commands as ~/.codex/skills/<name>/SKILL.md, CLAUDE.md as ~/.codex/AGENTS.md, and register the assist codex-hook auto-approval hook in ~/.codex/config.toml; when pi is detected, also install commands as ~/.pi/agent/prompts/<name>.md, CLAUDE.md as ~/.pi/agent/AGENTS.md, and register the assist pi-hook permission-gate extension in ~/.pi/agent/extensions. With --prune, also report commands in those target dirs that sync did not write, and with --prune --force remove them"
+  ).option("-y, --yes", "Overwrite settings.json without prompting").option(
+    "--prune",
+    "After syncing, list commands in the target dirs whose name is not in the repo's claude/commands/*.md set; subdirectories and non-.md files are listed separately and never removed"
+  ).option(
+    "--force",
+    "With --prune, remove the listed orphaned commands; a codex skill directory is removed only when SKILL.md is its sole content. Errors without --prune"
+  ).action((options2) => {
+    if (options2.force && !options2.prune) {
+      console.error("--force requires --prune.");
+      process.exit(1);
+    }
+    return sync(options2);
+  });
+  configHelp(syncCommand, rootConfigHelp.sync);
+}
+
 // src/commands/transcript/shared.ts
 import * as readline2 from "readline";
 function createReadlineInterface() {
@@ -27619,27 +28051,27 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync53, readdirSync as readdirSync11, statSync as statSync9 } from "fs";
-import { join as join61 } from "path";
+import { existsSync as existsSync57, readdirSync as readdirSync17, statSync as statSync9 } from "fs";
+import { join as join71 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync53(vttDir)) return;
-  for (const entry of readdirSync11(vttDir)) {
+  if (!existsSync57(vttDir)) return;
+  for (const entry of readdirSync17(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync9(join61(vttDir, entry)).isDirectory()) continue;
+    if (statSync9(join71(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
 import {
-  existsSync as existsSync54,
-  mkdirSync as mkdirSync20,
-  readFileSync as readFileSync43,
+  existsSync as existsSync58,
+  mkdirSync as mkdirSync25,
+  readFileSync as readFileSync47,
   renameSync as renameSync2,
-  writeFileSync as writeFileSync38
+  writeFileSync as writeFileSync41
 } from "fs";
-import { basename as basename17, join as join62 } from "path";
+import { basename as basename19, join as join72 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text17) {
@@ -27847,14 +28279,14 @@ function formatChatLog(messages) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync43(inputPath, "utf8"));
+  const cues = parseVtt(readFileSync47(inputPath, "utf8"));
   const messages = cuesToChatMessages(deduplicateCues(cues));
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join62(vttDir, "processed");
-  mkdirSync20(processedDir, { recursive: true });
-  renameSync2(sourcePath, join62(processedDir, filename));
+  const processedDir = join72(vttDir, "processed");
+  mkdirSync25(processedDir, { recursive: true });
+  renameSync2(sourcePath, join72(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -27863,20 +28295,20 @@ function move(file, options2) {
     process.exit(1);
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
-  const filename = basename17(file);
-  const sourcePath = join62(vttDir, filename);
-  if (!existsSync54(sourcePath)) {
+  const filename = basename19(file);
+  const sourcePath = join72(vttDir, filename);
+  if (!existsSync58(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
-  const base = basename17(filename, ".vtt").replace(/ Transcription$/, "");
+  const base = basename19(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join62(transcriptsDir, client);
-  mkdirSync20(formattedDir, { recursive: true });
-  const formattedPath = join62(formattedDir, outputName);
-  writeFileSync38(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
+  const formattedDir = join72(transcriptsDir, client);
+  mkdirSync25(formattedDir, { recursive: true });
+  const formattedPath = join72(formattedDir, outputName);
+  writeFileSync41(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join62(summaryDir, client, outputName);
+  const summaryPath = join72(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -27958,50 +28390,50 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { join as join64 } from "path";
+import { join as join74 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir22 } from "os";
-import { dirname as dirname31, join as join63 } from "path";
-import { fileURLToPath as fileURLToPath7 } from "url";
-var __dirname5 = dirname31(fileURLToPath7(import.meta.url));
-var VOICE_DIR = join63(homedir22(), ".assist", "voice");
+import { homedir as homedir23 } from "os";
+import { dirname as dirname34, join as join73 } from "path";
+import { fileURLToPath as fileURLToPath8 } from "url";
+var __dirname6 = dirname34(fileURLToPath8(import.meta.url));
+var VOICE_DIR = join73(homedir23(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join63(VOICE_DIR, "voice.pid"),
-  log: join63(VOICE_DIR, "voice.log"),
-  venv: join63(VOICE_DIR, ".venv"),
-  lock: join63(VOICE_DIR, "voice.lock")
+  pid: join73(VOICE_DIR, "voice.pid"),
+  log: join73(VOICE_DIR, "voice.log"),
+  venv: join73(VOICE_DIR, ".venv"),
+  lock: join73(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join63(__dirname5, "commands", "voice", "python");
+  return join73(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join63(voicePaths.venv, "Scripts", "python.exe") : join63(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join73(voicePaths.venv, "Scripts", "python.exe") : join73(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join63(getLockDir(), "voice.lock");
+  return join73(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join64(getPythonDir(), "list_devices.py");
+  const script = join74(getPythonDir(), "list_devices.py");
   spawnSync6(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync55, readFileSync as readFileSync44 } from "fs";
+import { existsSync as existsSync59, readFileSync as readFileSync48 } from "fs";
 function logs(options2) {
-  if (!existsSync55(voicePaths.log)) {
+  if (!existsSync59(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync44(voicePaths.log, "utf8").trim();
+  const content = readFileSync48(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -28023,13 +28455,13 @@ function logs(options2) {
 
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { mkdirSync as mkdirSync22 } from "fs";
-import { join as join66 } from "path";
+import { mkdirSync as mkdirSync27 } from "fs";
+import { join as join76 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync59 } from "child_process";
-import { existsSync as existsSync56, mkdirSync as mkdirSync21, readFileSync as readFileSync45, writeFileSync as writeFileSync39 } from "fs";
-import { join as join65 } from "path";
+import { existsSync as existsSync60, mkdirSync as mkdirSync26, readFileSync as readFileSync49, writeFileSync as writeFileSync42 } from "fs";
+import { join as join75 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -28040,9 +28472,9 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync56(lockFile)) return;
+  if (!existsSync60(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync45(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync49(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -28053,7 +28485,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync56(getVenvPython())) return;
+  if (existsSync60(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync59(
@@ -28066,8 +28498,8 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync21(join65(lockFile, ".."), { recursive: true });
-  writeFileSync39(
+  mkdirSync26(join75(lockFile, ".."), { recursive: true });
+  writeFileSync42(
     lockFile,
     JSON.stringify({
       pid,
@@ -28079,10 +28511,10 @@ function writeLockFile(pid) {
 
 // src/commands/voice/setup.ts
 function setup() {
-  mkdirSync22(voicePaths.dir, { recursive: true });
+  mkdirSync27(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join66(getPythonDir(), "setup_models.py");
+  const script = join76(getPythonDir(), "setup_models.py");
   const result = spawnSync7(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -28095,8 +28527,8 @@ function setup() {
 
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
-import { mkdirSync as mkdirSync23, writeFileSync as writeFileSync40 } from "fs";
-import { join as join67 } from "path";
+import { mkdirSync as mkdirSync28, writeFileSync as writeFileSync43 } from "fs";
+import { join as join77 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -28124,17 +28556,17 @@ function spawnBackground(python, script, env) {
     console.error("Failed to start voice daemon");
     process.exit(1);
   }
-  writeFileSync40(voicePaths.pid, String(pid));
+  writeFileSync43(voicePaths.pid, String(pid));
   writeLockFile(pid);
   console.log(`Voice daemon started (PID ${pid})`);
 }
 function start2(options2) {
-  mkdirSync23(voicePaths.dir, { recursive: true });
+  mkdirSync28(voicePaths.dir, { recursive: true });
   checkLockFile();
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join67(getPythonDir(), "voice_daemon.py");
+  const script = join77(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -28144,7 +28576,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync57, readFileSync as readFileSync46 } from "fs";
+import { existsSync as existsSync61, readFileSync as readFileSync50 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -28154,16 +28586,16 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync57(voicePaths.log)) return [];
-  const lines2 = readFileSync46(voicePaths.log, "utf8").trim().split("\n");
+  if (!existsSync61(voicePaths.log)) return [];
+  const lines2 = readFileSync50(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync57(voicePaths.pid)) {
+  if (!existsSync61(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync46(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync50(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -28182,13 +28614,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync58, readFileSync as readFileSync47, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync62, readFileSync as readFileSync51, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync58(voicePaths.pid)) {
+  if (!existsSync62(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync47(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync51(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -28201,7 +28633,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync58(lockFile)) unlinkSync20(lockFile);
+    if (existsSync62(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -28220,7 +28652,7 @@ function registerVoice(program2) {
 }
 
 // src/commands/watch/readBuiltVersion.ts
-import { join as join68 } from "path";
+import { join as join78 } from "path";
 
 // src/commands/watch/resolveUpstream.ts
 import { execFileSync as execFileSync10 } from "child_process";
@@ -28266,7 +28698,7 @@ function resolveUpstream(cwd) {
 function readBuiltVersion(cwd) {
   try {
     const root = runGit2(["rev-parse", "--show-toplevel"], cwd);
-    return readPackageJson(join68(root, "package.json")).version ?? "unknown";
+    return readPackageJson(join78(root, "package.json")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -28318,11 +28750,11 @@ var webUiPrefix = "src/commands/sessions/web/ui/";
 var sessionsPrefix = "src/commands/sessions/";
 var rules = [
   {
-    matches: (path71) => path71.startsWith(webUiPrefix),
+    matches: (path73) => path73.startsWith(webUiPrefix),
     advice: "restart the web server, then hard-reload the browser tab"
   },
   {
-    matches: (path71) => path71.startsWith(sessionsPrefix) && !path71.startsWith(webUiPrefix),
+    matches: (path73) => path73.startsWith(sessionsPrefix) && !path73.startsWith(webUiPrefix),
     advice: "restart the daemon"
   }
 ];
@@ -28564,7 +28996,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync59 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import { resolve as resolve17 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -28577,25 +29009,25 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve17(baseDir, config.cwd);
-  if (!existsSync59(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync63(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync61 } from "fs";
+import { existsSync as existsSync65 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import { existsSync as existsSync60 } from "fs";
-import { dirname as dirname32, join as join69, resolve as resolve18 } from "path";
+import { existsSync as existsSync64 } from "fs";
+import { dirname as dirname35, join as join79, resolve as resolve18 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync11("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve18(dirname32(gitPath), "..");
-    const gitBash = join69(gitRoot, "bin", "bash.exe");
-    if (existsSync60(gitBash)) return gitBash;
+    const gitRoot = resolve18(dirname35(gitPath), "..");
+    const gitBash = join79(gitRoot, "bin", "bash.exe");
+    if (existsSync64(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -28605,7 +29037,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync61(cwd)) {
+    if (cwd && !existsSync65(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -28835,7 +29267,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk210 from "chalk";
+import chalk212 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -28966,13 +29398,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk210.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk212.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk210.white("http://localhost:14523/callback\n"));
-  console.log(chalk210.blue("Opening browser for authorization..."));
-  console.log(chalk210.dim("Waiting for authorization callback..."));
+  console.log(chalk212.white("http://localhost:14523/callback\n"));
+  console.log(chalk212.blue("Opening browser for authorization..."));
+  console.log(chalk212.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk210.dim("Exchanging code for tokens..."));
+  console.log(chalk212.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -28988,25 +29420,25 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk210.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk212.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync13 } from "child_process";
-import { readdirSync as readdirSync12, readFileSync as readFileSync48, statSync as statSync10 } from "fs";
-import { join as join70 } from "path";
+import { readdirSync as readdirSync18, readFileSync as readFileSync52, statSync as statSync10 } from "fs";
+import { join as join80 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
-    entries = readdirSync12(roamDir);
+    entries = readdirSync18(roamDir);
   } catch {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path71 = join70(roamDir, name);
+    const path73 = join80(roamDir, name);
     try {
-      return { path: path71, mtimeMs: statSync10(path71).mtimeMs };
+      return { path: path73, mtimeMs: statSync10(path73).mtimeMs };
     } catch {
       return void 0;
     }
@@ -29016,11 +29448,11 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join70(appData, "Roam"));
+  const portFile = findPortFile(join80(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync48(portFile, "utf8").trim();
+    port = readFileSync52(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -29148,8 +29580,8 @@ async function run3(name, args) {
 }
 
 // src/commands/run/add.ts
-import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync41 } from "fs";
-import { join as join71 } from "path";
+import { mkdirSync as mkdirSync29, writeFileSync as writeFileSync44 } from "fs";
+import { join as join81 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -29210,16 +29642,16 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join71(".claude", "commands");
-  mkdirSync24(dir, { recursive: true });
+  const dir = join81(".claude", "commands");
+  mkdirSync29(dir, { recursive: true });
   const content = `---
 description: Run ${name}
 ---
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join71(dir, `${name}.md`);
-  writeFileSync41(filePath, content);
+  const filePath = join81(dir, `${name}.md`);
+  writeFileSync44(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
 function add3() {
@@ -29242,11 +29674,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path71 = process.argv[idx + 1];
+  const path73 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path71, prefix: prefix2 };
+  return { path: path73, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -29274,8 +29706,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync62, unlinkSync as unlinkSync21 } from "fs";
-import { join as join72 } from "path";
+import { existsSync as existsSync66, unlinkSync as unlinkSync21 } from "fs";
+import { join as join82 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -29290,8 +29722,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join72(".claude", "commands", `${name}.md`);
-  if (existsSync62(filePath)) {
+  const filePath = join82(".claude", "commands", `${name}.md`);
+  if (existsSync66(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -29336,10 +29768,10 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync61 } from "child_process";
-import { existsSync as existsSync63, mkdirSync as mkdirSync25, unlinkSync as unlinkSync22, writeFileSync as writeFileSync42 } from "fs";
+import { existsSync as existsSync67, mkdirSync as mkdirSync30, unlinkSync as unlinkSync22, writeFileSync as writeFileSync45 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join73, resolve as resolve19 } from "path";
-import chalk211 from "chalk";
+import { join as join83, resolve as resolve19 } from "path";
+import chalk213 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -29468,15 +29900,15 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync63(outputDir)) {
-    mkdirSync25(outputDir, { recursive: true });
+  if (!existsSync67(outputDir)) {
+    mkdirSync30(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve19(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join73(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
-  writeFileSync42(scriptPath, captureWindowPs1, "utf8");
+  const scriptPath = join83(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
+  writeFileSync45(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync61(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
@@ -29490,13 +29922,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve19(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk211.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk213.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk211.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk213.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk211.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk213.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -29552,7 +29984,7 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/reportStolenSocket.ts
-import { readFileSync as readFileSync49 } from "fs";
+import { readFileSync as readFileSync53 } from "fs";
 function reportStolenSocket(socketPid) {
   if (!socketPid) return;
   const filePid = readPidFile();
@@ -29564,7 +29996,7 @@ function reportStolenSocket(socketPid) {
 function readPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync49(daemonPaths.pid, "utf8").trim(),
+      readFileSync53(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -29699,7 +30131,7 @@ function requestDrain(socket, lines2) {
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
-import { mkdirSync as mkdirSync29 } from "fs";
+import { mkdirSync as mkdirSync34 } from "fs";
 
 // src/commands/sessions/daemon/createAutoExit.ts
 var DEFAULT_GRACE_MS = 6e4;
@@ -29962,42 +30394,42 @@ function serverRunMeta(runName, cwd) {
 }
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs35 from "fs";
-import * as path58 from "path";
-import { fileURLToPath as fileURLToPath8 } from "url";
-var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname6 = path58.dirname(__filename4);
+import * as fs44 from "fs";
+import * as path69 from "path";
+import { fileURLToPath as fileURLToPath9 } from "url";
+var __filename5 = fileURLToPath9(import.meta.url);
+var __dirname7 = path69.dirname(__filename5);
 function readDesignSystemPrompt() {
-  const promptPath = path58.join(
-    __dirname6,
+  const promptPath = path69.join(
+    __dirname7,
     "..",
     "claude",
     "design-system-prompt.md"
   );
-  return fs35.readFileSync(promptPath, "utf8");
+  return fs44.readFileSync(promptPath, "utf8");
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync64, statSync as statSync11 } from "fs";
+import { chmodSync, existsSync as existsSync68, statSync as statSync11 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path59 from "path";
+import path70 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path59.join(path59.dirname(require4.resolve("node-pty")), "..");
-  const helper = path59.join(
+  const ptyRoot = path70.join(path70.dirname(require4.resolve("node-pty")), "..");
+  const helper = path70.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync64(helper)) return;
+  if (!existsSync68(helper)) return;
   const mode = statSync11(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -30033,7 +30465,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync65(cwd)) return;
+  if (!cwd || existsSync69(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -30164,17 +30596,17 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync67 } from "fs";
-import { basename as basename18 } from "path";
+import { existsSync as existsSync71 } from "fs";
+import { basename as basename20 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync66 } from "fs";
-import { join as join76 } from "path";
+import { existsSync as existsSync70 } from "fs";
+import { join as join86 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
 import { statSync as statSync12 } from "fs";
 import { rm as rm2 } from "fs/promises";
-import { join as join75 } from "path";
+import { join as join85 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     const refusal = "it is a clone of its own, not a linked worktree";
@@ -30202,7 +30634,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync12(join75(worktreePath, ".git"), {
+  return statSync12(join85(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -30238,7 +30670,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync66(join76(worktreePath, ".git")))
+  if (!existsSync70(join86(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -30290,7 +30722,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync67(worktreePath)) {
+  if (!existsSync71(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -30308,14 +30740,14 @@ 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, basename18(worktreePath));
+  await deleteWorktreeBranch(clone, basename20(worktreePath));
   forgetWorktree(worktreePath);
   daemonLog(`worktree ${worktreePath} reaped${force ? " (forced)" : ""}`);
   return removal;
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync67(recorded)) return recorded;
+  if (recorded && existsSync71(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -30443,12 +30875,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync68, watch } from "fs";
+import { existsSync as existsSync72, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync68(common)) return void 0;
+  if (!common || !existsSync72(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -30893,10 +31325,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync69 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 import { resolve as resolve20 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync69(session.cwd))
+  if (session.cwd && !existsSync73(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -30910,7 +31342,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve20(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync69(configured)) return void 0;
+  if (existsSync73(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -30927,8 +31359,8 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync70, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
-import { dirname as dirname34 } from "path";
+import { existsSync as existsSync74, mkdirSync as mkdirSync31, watch as watch2 } from "fs";
+import { dirname as dirname37 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
 function applyReviewPause(session, activity2) {
@@ -30981,10 +31413,10 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path71 = activityPath(session.id);
-  const dir = dirname34(path71);
+  const path73 = activityPath(session.id);
+  const dir = dirname37(path73);
   try {
-    mkdirSync26(dir, { recursive: true });
+    mkdirSync31(dir, { recursive: true });
   } catch {
     return;
   }
@@ -30992,7 +31424,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path71);
+    const activity2 = readActivity(path73);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId) {
@@ -31004,11 +31436,11 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     notify2();
   };
   session.activityWatcher = watch2(dir, (_event, filename) => {
-    if (filename && !path71.endsWith(filename)) return;
+    if (filename && !path73.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync70(path71)) read();
+  if (existsSync74(path73)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -31097,56 +31529,56 @@ function reportSilentFailure(session, clients) {
 import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
-import * as fs36 from "fs";
-import * as os4 from "os";
-import * as path60 from "path";
+import * as fs45 from "fs";
+import * as os5 from "os";
+import * as path71 from "path";
 function projectDirForCwd(cwd) {
-  return path60.join(
-    os4.homedir(),
+  return path71.join(
+    os5.homedir(),
     ".claude",
     "projects",
     cwd.replace(/[^a-zA-Z0-9]/g, "-")
   );
 }
 function transcriptPathFor(cwd, claudeSessionId) {
-  return path60.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+  return path71.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
-  if (fs36.existsSync(direct)) return direct;
+  if (fs45.existsSync(direct)) return direct;
   const dir = projectDirForCwd(cwd);
   let files;
   try {
-    files = fs36.readdirSync(dir);
+    files = fs45.readdirSync(dir);
   } catch {
     return null;
   }
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
-    if (headContainsSessionId(path60.join(dir, file), claudeSessionId))
-      return path60.join(dir, file);
+    if (headContainsSessionId(path71.join(dir, file), claudeSessionId))
+      return path71.join(dir, file);
   }
   return null;
 }
 function headContainsSessionId(filePath, claudeSessionId) {
   let fd;
   try {
-    fd = fs36.openSync(filePath, "r");
+    fd = fs45.openSync(filePath, "r");
     const buf = Buffer.alloc(16384);
-    const bytesRead = fs36.readSync(fd, buf, 0, buf.length, 0);
+    const bytesRead = fs45.readSync(fd, buf, 0, buf.length, 0);
     return buf.toString("utf8", 0, bytesRead).includes(claudeSessionId);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) fs36.closeSync(fd);
+    if (fd !== void 0) fs45.closeSync(fd);
   }
 }
 
 // src/commands/sessions/daemon/ensureProjectDirExists.ts
-import { mkdirSync as mkdirSync27 } from "fs";
+import { mkdirSync as mkdirSync32 } from "fs";
 function ensureProjectDirExists(dir, sessionId) {
   try {
-    mkdirSync27(dir, { recursive: true });
+    mkdirSync32(dir, { recursive: true });
     return true;
   } catch (error) {
     daemonLog(
@@ -31253,7 +31685,7 @@ function resolvedToolUseIds(events, afterIdx) {
 }
 
 // src/commands/sessions/shared/readTranscriptTail.ts
-import * as fs37 from "fs";
+import * as fs46 from "fs";
 var DEFAULT_MAX_BYTES = 256 * 1024;
 function parseTailEntries(raw) {
   const entries = [];
@@ -31277,7 +31709,7 @@ function dropPartialFirstLine(raw, sliced) {
 async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let handle;
   try {
-    handle = await fs37.promises.open(filePath, "r");
+    handle = await fs46.promises.open(filePath, "r");
     const { size } = await handle.stat();
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
@@ -31296,20 +31728,20 @@ async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
 function readTranscriptTailSync(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let fd;
   try {
-    fd = fs37.openSync(filePath, "r");
-    const { size } = fs37.fstatSync(fd);
+    fd = fs46.openSync(filePath, "r");
+    const { size } = fs46.fstatSync(fd);
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
     if (length === 0) return [];
     const buf = Buffer.alloc(length);
-    fs37.readSync(fd, buf, 0, length, start3);
+    fs46.readSync(fd, buf, 0, length, start3);
     return parseTailEntries(
       dropPartialFirstLine(buf.toString("utf8"), start3 > 0)
     );
   } catch {
     return [];
   } finally {
-    if (fd !== void 0) fs37.closeSync(fd);
+    if (fd !== void 0) fs46.closeSync(fd);
   }
 }
 
@@ -31674,7 +32106,7 @@ async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
 }
 
 // src/commands/sessions/shared/transcriptUsage.ts
-import * as fs38 from "fs";
+import * as fs47 from "fs";
 function transcriptUsage(lines2) {
   const byId = /* @__PURE__ */ new Map();
   for (const line of lines2) {
@@ -31698,7 +32130,7 @@ function transcriptUsage(lines2) {
   return [...byId.values()];
 }
 async function readTranscriptUsage(transcriptPath2) {
-  const content = await fs38.promises.readFile(transcriptPath2, "utf8");
+  const content = await fs47.promises.readFile(transcriptPath2, "utf8");
   return transcriptUsage(content.split("\n"));
 }
 
@@ -32365,8 +32797,8 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync73 } from "fs";
-import { basename as basename20 } from "path";
+import { existsSync as existsSync77 } from "fs";
+import { basename as basename22 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
 function accountedTrees(sessions) {
@@ -32421,21 +32853,21 @@ function bindResumedWorktree(session, cwd, notify2) {
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path71, reason4) {
-  if (reason4.startsWith("uncommitted")) return await changedFiles(path71);
-  if (reason4.startsWith("unpushed")) return await unpushedCommits(path71, reason4);
+async function describeHeldWork(path73, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path73);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path73, reason4);
   return { summary: reason4, items: [] };
 }
-async function changedFiles(path71) {
-  const status3 = await gitResult(path71, ["status", "--porcelain"]);
+async function changedFiles(path73) {
+  const status3 = await gitResult(path73, ["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(path71, reason4) {
-  const log2 = await gitResult(path71, ["log", "--oneline", "@{upstream}..HEAD"]);
+async function unpushedCommits(path73, reason4) {
+  const log2 = await gitResult(path73, ["log", "--oneline", "@{upstream}..HEAD"]);
   if (!log2.ok) return { summary: reason4, items: [] };
   const lines2 = nonEmptyLines(log2.out);
   return {
@@ -32455,18 +32887,18 @@ function capped(lines2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync76 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync72(clone)) {
-    for (const { path: path71 } of paths) forgetWorktree(path71);
+  if (!existsSync76(clone)) {
+    for (const { path: path73 } of paths) forgetWorktree(path73);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
   await pruneBookkeeping2(clone);
-  for (const { path: path71, branch: branch2 } of paths)
-    if (await reclaimBranch(clone, branch2)) forgetWorktree(path71);
+  for (const { path: path73, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path73);
 }
 async function pruneBookkeeping2(clone) {
   try {
@@ -32493,7 +32925,7 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/resurfaceOrphanedWorktree.ts
-import { basename as basename19 } from "path";
+import { basename as basename21 } from "path";
 function resurfaceOrphanedWorktree(sessions, spawnWith, recovered, notify2) {
   const { orphan, reason: reason4, held } = recovered;
   let id;
@@ -32516,7 +32948,7 @@ function orphanedSession(id, recovered) {
   const { orphan, reason: reason4, held } = recovered;
   return {
     ...sessionBase(id, "stopped"),
-    name: `recovered ${basename19(orphan.path)}`,
+    name: `recovered ${basename21(orphan.path)}`,
     subtitle: `${held.summary} in ${orphan.path}`,
     commandType: "claude",
     pty: null,
@@ -32541,17 +32973,17 @@ function recoveryNotice({ orphan, held }) {
 }
 
 // src/commands/sessions/daemon/worktree/logVanishedTree.ts
-function logVanishedTree(sessions, path71) {
+function logVanishedTree(sessions, path73) {
   const claimants = [...sessions.values()].filter(
-    (s) => s.cwd === path71 || s.worktree?.path === path71
+    (s) => s.cwd === path73 || s.worktree?.path === path73
   );
   if (claimants.length === 0) {
-    daemonLog(`worktree ${path71} gone from disk and unclaimed; reclaiming it`);
+    daemonLog(`worktree ${path73} gone from disk and unclaimed; reclaiming it`);
     return;
   }
   for (const s of claimants)
     daemonLog(
-      `session ${s.id} ("${s.name}") claims worktree ${path71}, which is gone from disk; reclaiming it`
+      `session ${s.id} ("${s.name}") claims worktree ${path73}, which is gone from disk; reclaiming it`
     );
 }
 
@@ -32563,17 +32995,17 @@ function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
 async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
-  for (const { path: path71, clone } of readWorktreeRegistry()) {
-    if (!existsSync73(path71)) {
-      logVanishedTree(sessions, path71);
+  for (const { path: path73, clone } of readWorktreeRegistry()) {
+    if (!existsSync77(path73)) {
+      logVanishedTree(sessions, path73);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path71, branch: basename20(path71) }
+        { path: path73, branch: basename22(path73) }
       ]);
       continue;
     }
-    if (accounted.has(path71)) continue;
-    await recoverOrphan(sessions, spawnWith, { path: path71, clone }, notify2);
+    if (accounted.has(path73)) continue;
+    await recoverOrphan(sessions, spawnWith, { path: path73, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
     await reclaimVanishedWorktrees(clone, paths);
@@ -33152,14 +33584,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync74, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync78, readFileSync as readFileSync55 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync74(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync51(sessionsFile, "utf8"));
+    if (!existsSync78(sessionsFile)) return false;
+    const data = JSON.parse(readFileSync55(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
@@ -33737,7 +34169,7 @@ function addAgentToStream(ctx, targetId, prompt, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/spawnInTree.ts
-import { existsSync as existsSync77 } from "fs";
+import { existsSync as existsSync81 } from "fs";
 
 // src/commands/sessions/daemon/createAssistSession.ts
 function createAssistSession(id, assistArgs, cwd, meta, holdPty) {
@@ -33790,11 +34222,11 @@ function resumeSession(id, sessionId, cwd, name, holdPty) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync76 } from "fs";
+import { existsSync as existsSync80 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync2, existsSync as existsSync75, mkdirSync as mkdirSync28 } from "fs";
-import { join as join78 } from "path";
+import { copyFileSync as copyFileSync7, existsSync as existsSync79, mkdirSync as mkdirSync33 } from "fs";
+import { join as join88 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
   if (dir === projectDirForCwd(fromCwd)) {
@@ -33803,8 +34235,8 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     );
     return;
   }
-  const dest = join78(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync75(dest)) {
+  const dest = join88(dir, `${claudeSessionId}.jsonl`);
+  if (existsSync79(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -33816,8 +34248,8 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     return;
   }
   try {
-    mkdirSync28(dir, { recursive: true });
-    copyFileSync2(source, dest);
+    mkdirSync33(dir, { recursive: true });
+    copyFileSync7(source, dest);
     daemonLog(
       `transcript ${source} copied to ${dest} so ${toCwd} can resume it`
     );
@@ -33848,7 +34280,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name) {
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync76(clone))
+  if (!clone || !existsSync80(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -33880,7 +34312,7 @@ function spawnAssistInTree(ctx, assistArgs, cwd, meta) {
   return id;
 }
 function resumeInTree(ctx, sessionId, cwd, name) {
-  if (!existsSync77(cwd))
+  if (!existsSync81(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name);
   const id = ctx.spawnWith((sid) => resumeSession(sid, sessionId, cwd, name));
   daemonLog(`session ${id} resuming ${sessionId} in ${cwd}`);
@@ -34172,12 +34604,12 @@ function handleSetStatus(client, m, d) {
 }
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs39 from "fs";
+import * as fs48 from "fs";
 async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs39.promises.readFile(filePath, "utf8");
+    const raw = await fs48.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -34201,9 +34633,9 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync78 } from "fs";
+import { existsSync as existsSync82 } from "fs";
 function repoDirExists(cwd) {
-  return existsSync78(toGitCwd(cwd));
+  return existsSync82(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/withRepoGroups.ts
@@ -34404,10 +34836,10 @@ function handleConnection(socket, manager) {
 }
 
 // src/commands/sessions/daemon/onListening.ts
-import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync43 } from "fs";
+import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync46 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync52 } from "fs";
+import { readFileSync as readFileSync56 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -34418,7 +34850,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync52(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync56(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -34426,7 +34858,7 @@ function ownsPidFile() {
 
 // src/commands/sessions/daemon/onListening.ts
 function onListening(manager, checkAutoExit) {
-  writeFileSync43(daemonPaths.pid, String(process.pid));
+  writeFileSync46(daemonPaths.pid, String(process.pid));
   startPidFileWatchdog(() => {
     daemonLog("lost daemon.pid ownership; shutting down sessions and exiting");
     void manager.flushActiveMs().finally(() => {
@@ -34508,7 +34940,7 @@ async function recoverFromAddrInUse(server, manager, checkAutoExit) {
 
 // src/commands/sessions/daemon/runDaemon.ts
 async function runDaemon() {
-  mkdirSync29(daemonPaths.dir, { recursive: true });
+  mkdirSync34(daemonPaths.dir, { recursive: true });
   daemonLog(
     `starting (reason: ${process.env.ASSIST_DAEMON_SPAWN_REASON ?? "manual"})`
   );
@@ -34562,17 +34994,17 @@ function registerSetStatusCommand(cmd) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs41 from "fs";
-import chalk212 from "chalk";
+import * as fs50 from "fs";
+import chalk214 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs40 from "fs";
+import * as fs49 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs40.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs49.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs40.existsSync(summaryPathFor(jsonlPath2));
+  return fs49.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -34622,29 +35054,29 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk212.yellow("No sessions found."));
+    console.log(chalk214.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk212.green("All sessions already summarised."));
+    console.log(chalk214.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk212.cyan(
+    chalk214.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk212.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk212.yellow(`, ${failed2} skipped`) : "")
+    chalk214.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk214.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs41.statSync(b).mtimeMs - fs41.statSync(a).mtimeMs;
+      return fs50.statSync(b).mtimeMs - fs50.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -34657,16 +35089,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk212.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk214.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk212.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk214.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk212.yellow("skip")}
+      process.stdout.write(` ${chalk214.yellow("skip")}
 `);
     }
   }
@@ -34687,7 +35119,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk214 from "chalk";
+import chalk216 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -34697,7 +35129,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk213 from "chalk";
+import chalk215 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -34733,9 +35165,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk213.green,
-  warn: chalk213.yellow,
-  over: chalk213.red
+  ok: chalk215.green,
+  warn: chalk215.yellow,
+  over: chalk215.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -34766,10 +35198,10 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync54, statSync as statSync14 } from "fs";
-import { isAbsolute as isAbsolute4, join as join79, resolve as resolve21 } from "path";
+import { readFileSync as readFileSync58, statSync as statSync14 } from "fs";
+import { isAbsolute as isAbsolute4, join as join89, resolve as resolve21 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join79(cwd, ".git");
+  const dotGit = join89(cwd, ".git");
   let stat4;
   try {
     stat4 = statSync14(dotGit);
@@ -34781,7 +35213,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync54(dotGit, "utf8");
+    contents = readFileSync58(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -34799,7 +35231,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync54(join79(gitDir, "HEAD"), "utf8");
+    head = readFileSync58(join89(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -34831,7 +35263,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk214.level = 3;
+chalk216.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -34839,9 +35271,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk214.red(label2);
+      return chalk216.red(label2);
     case "yellow":
-      return chalk214.yellow(label2);
+      return chalk216.yellow(label2);
     default:
       return label2;
   }
@@ -34854,7 +35286,7 @@ async function statusLine() {
   const usedPct = data.context_window.used_percentage ?? 0;
   const dir = data.workspace?.current_dir ?? data.cwd;
   const branch2 = dir ? readGitBranch(toGitCwd(dir)) : null;
-  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk214.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk216.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -34866,299 +35298,9 @@ async function statusLine() {
   );
 }
 
-// src/commands/sync.ts
-import * as fs48 from "fs";
-import * as os5 from "os";
-import * as path69 from "path";
-import { fileURLToPath as fileURLToPath9 } from "url";
-
-// src/commands/sync/syncClaudeMd.ts
-import * as fs42 from "fs";
-import * as path61 from "path";
-import chalk215 from "chalk";
-async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path61.join(claudeDir, "CLAUDE.md");
-  const target = path61.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs42.readFileSync(source, "utf8");
-  if (fs42.existsSync(target)) {
-    const targetContent = fs42.readFileSync(target, "utf8");
-    if (sourceContent !== targetContent) {
-      console.log(
-        chalk215.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
-      );
-      console.log();
-      printDiff(targetContent, sourceContent);
-      if (!options2?.yes) {
-        printAutoConfirmHint();
-        const confirm = await promptConfirm(
-          chalk215.red("Overwrite existing CLAUDE.md?"),
-          false
-        );
-        if (!confirm) {
-          console.log("Skipped CLAUDE.md");
-          return;
-        }
-      }
-    }
-  }
-  fs42.copyFileSync(source, target);
-  console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
-}
-
-// src/commands/sync/syncCodex.ts
-import * as path64 from "path";
-
-// src/commands/sync/installHarnessCommands.ts
-import * as fs43 from "fs";
-import * as path62 from "path";
-function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path62.join(claudeDir, "commands");
-  const files = fs43.readdirSync(commandsSource);
-  let synced = 0;
-  for (const file of files) {
-    if (!file.endsWith(".md")) continue;
-    const name = file.replace(/\.md$/, "");
-    const content = fs43.readFileSync(path62.join(commandsSource, file), "utf8");
-    const target = path62.join(harness.homeDir, harness.sync.commandDest(name));
-    fs43.mkdirSync(path62.dirname(target), { recursive: true });
-    fs43.writeFileSync(target, transform(name, content));
-    synced++;
-  }
-  const agentsTarget = path62.join(harness.homeDir, harness.sync.agentsFile);
-  fs43.mkdirSync(path62.dirname(agentsTarget), { recursive: true });
-  fs43.copyFileSync(path62.join(claudeDir, "CLAUDE.md"), agentsTarget);
-  return { total: files.length, synced };
-}
-
-// src/commands/sync/syncCodexHooks.ts
-import * as fs44 from "fs";
-import * as path63 from "path";
-var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
-var END = "# <<< assist codex hooks (managed) <<<";
-function upsertManagedBlock(existing, body) {
-  const block = `${BEGIN}
-${body.trim()}
-${END}`;
-  const begin = existing.indexOf(BEGIN);
-  if (begin === -1) {
-    const base = existing.replace(/\s*$/, "");
-    return base ? `${base}
-
-${block}
-` : `${block}
-`;
-  }
-  const endMarker = existing.indexOf(END, begin);
-  const after = endMarker === -1 ? existing.length : endMarker + END.length;
-  const before = existing.slice(0, begin).replace(/\s*$/, "");
-  const rest = existing.slice(after).replace(/^\s*/, "");
-  const head = before ? `${before}
-
-${block}` : block;
-  return rest ? `${head}
-
-${rest}
-` : `${head}
-`;
-}
-function syncCodexHooks(sourcePath) {
-  const body = fs44.readFileSync(sourcePath, "utf8");
-  const configPath = path63.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
-  fs44.mkdirSync(path63.dirname(configPath), { recursive: true });
-  fs44.writeFileSync(configPath, upsertManagedBlock(existing, body));
-  console.log(
-    "Registered assist codex-hook in ~/.codex/config.toml (PreToolUse, PermissionRequest)"
-  );
-}
-
-// src/commands/sync/syncCodex.ts
-function quoteYaml(value) {
-  return `"${value.replace(/\\/g, String.raw`\\`).replace(/"/g, String.raw`\"`)}"`;
-}
-function commandToSkill(name, content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  const frontmatter = match ? match[1] : "";
-  const body = match ? content.slice(match[0].length) : content;
-  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
-  const description = descriptionMatch ? descriptionMatch[1].trim().replace(/^["']|["']$/g, "") : name;
-  const header = `---
-name: ${name}
-description: ${quoteYaml(description)}
----
-
-`;
-  return header + body.replace(/^\r?\n+/, "");
-}
-function syncCodex(claudeDir) {
-  if (!isHarnessAvailable("codex")) return;
-  const { total } = installHarnessCommands(
-    claudeDir,
-    harnesses.codex,
-    commandToSkill
-  );
-  syncCodexHooks(path64.join(claudeDir, "..", "codex", "config.toml"));
-  console.log(
-    `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
-  );
-}
-
-// src/commands/sync/syncDesign.ts
-import * as fs45 from "fs";
-import * as path65 from "path";
-function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path65.join(claudeDir, "design-system-prompt.md");
-  const systemPromptTarget = path65.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 = path65.join(claudeDir, "skills");
-  const skillsTarget = path65.join(targetBase, "skills");
-  fs45.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs45.readdirSync(skillsSource);
-  for (const file of files) {
-    fs45.copyFileSync(
-      path65.join(skillsSource, file),
-      path65.join(skillsTarget, file)
-    );
-  }
-  console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
-}
-
-// src/commands/sync/syncPi.ts
-import * as path67 from "path";
-
-// src/commands/sync/syncPiHooks.ts
-import * as fs46 from "fs";
-import * as path66 from "path";
-function piExtensionsDir() {
-  return path66.join(harnesses.pi.homeDir, "extensions");
-}
-function syncPiHooks(sourceDir) {
-  const target = piExtensionsDir();
-  fs46.mkdirSync(target, { recursive: true });
-  const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
-  for (const file of files) {
-    fs46.copyFileSync(
-      path66.join(sourceDir, file),
-      path66.join(target, `assist-${file}`)
-    );
-  }
-  console.log(
-    `Registered ${files.length} assist extension(s) in ~/.pi/agent/extensions`
-  );
-}
-
-// src/commands/sync/syncPi.ts
-function unquote(value) {
-  return value.trim().replace(/^["']|["']$/g, "");
-}
-function commandToPrompt(name, content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  const frontmatter = match ? match[1] : "";
-  const body = match ? content.slice(match[0].length) : content;
-  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
-  const description = descriptionMatch ? unquote(descriptionMatch[1]) : name;
-  const argsMatch = frontmatter.match(/^allowed_args:\s*(.*)$/m);
-  const argumentHint = argsMatch ? unquote(argsMatch[1]) : void 0;
-  const header = [
-    "---",
-    `description: ${description}`,
-    ...argumentHint ? [`argument-hint: ${argumentHint}`] : [],
-    "---",
-    "",
-    ""
-  ].join("\n");
-  return header + body.replace(/^\r?\n+/, "");
-}
-function syncPi(claudeDir) {
-  if (!isHarnessAvailable("pi")) return;
-  const { synced } = installHarnessCommands(
-    claudeDir,
-    harnesses.pi,
-    commandToPrompt
-  );
-  syncPiHooks(path67.join(claudeDir, "..", "pi"));
-  console.log(
-    `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
-  );
-}
-
-// src/commands/sync/syncSettings.ts
-import * as fs47 from "fs";
-import * as path68 from "path";
-import chalk216 from "chalk";
-async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path68.join(claudeDir, "settings.json");
-  const target = path68.join(targetBase, "settings.json");
-  const sourceContent = fs47.readFileSync(source, "utf8");
-  const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs47.existsSync(target);
-  const targetContent = targetExists ? fs47.readFileSync(target, "utf8") : "";
-  const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
-  const mergedContent = JSON.stringify(
-    { ...preservedUserSettings, ...sourceSettings },
-    null,
-    "	"
-  );
-  if (targetExists) {
-    const normalizedTarget = JSON.stringify(preservedUserSettings, null, "	");
-    if (mergedContent !== normalizedTarget) {
-      if (!options2?.yes) {
-        console.log(
-          chalk216.yellow(
-            "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
-          )
-        );
-        console.log();
-        printDiff(targetContent, mergedContent);
-        printAutoConfirmHint();
-        const confirm = await promptConfirm(
-          chalk216.red("Overwrite existing settings.json?"),
-          false
-        );
-        if (!confirm) {
-          console.log("Skipped settings.json");
-          return;
-        }
-      }
-    }
-  }
-  fs47.writeFileSync(target, mergedContent);
-  console.log("Copied settings.json to ~/.claude/settings.json");
-}
-
-// src/commands/sync.ts
-var __filename5 = fileURLToPath9(import.meta.url);
-var __dirname7 = path69.dirname(__filename5);
-async function sync(options2) {
-  const config = loadConfig();
-  const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path69.join(__dirname7, "..", "claude");
-  const targetBase = path69.join(os5.homedir(), ".claude");
-  syncCommands(claudeDir, targetBase);
-  syncDesign(claudeDir, targetBase);
-  await syncSettings(claudeDir, targetBase, { yes });
-  await syncClaudeMd(claudeDir, targetBase, { yes });
-  syncCodex(claudeDir);
-  syncPi(claudeDir);
-}
-function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path69.join(claudeDir, "commands");
-  const targetDir = path69.join(targetBase, "commands");
-  fs48.mkdirSync(targetDir, { recursive: true });
-  const files = fs48.readdirSync(sourceDir);
-  for (const file of files) {
-    fs48.copyFileSync(path69.join(sourceDir, file), path69.join(targetDir, file));
-    console.log(`Copied ${file} to ${targetDir}`);
-  }
-  console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
-}
-
 // src/commands/update.ts
 import { execSync as execSync62 } from "child_process";
-import * as path70 from "path";
+import * as path72 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -35177,12 +35319,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path70.resolve(dir);
-    if (resolved.split(path70.sep).includes("node_modules")) {
+    const resolved = path72.resolve(dir);
+    if (resolved.split(path72.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync62("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path70.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path72.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -35227,10 +35369,7 @@ function reportCliError(error) {
 // src/index.ts
 var program = new Command();
 program.name("assist").description("CLI application").version(package_default.version).option("--no-open", "Do not open a browser on startup").action((options2) => web({ port: "3100", open: options2.open }));
-var syncCommand = program.command("sync").description(
-  "Copy command files to ~/.claude/commands; when codex is detected, also install commands as ~/.codex/skills/<name>/SKILL.md, CLAUDE.md as ~/.codex/AGENTS.md, and register the assist codex-hook auto-approval hook in ~/.codex/config.toml; when pi is detected, also install commands as ~/.pi/agent/prompts/<name>.md, CLAUDE.md as ~/.pi/agent/AGENTS.md, and register the assist pi-hook permission-gate extension in ~/.pi/agent/extensions"
-).option("-y, --yes", "Overwrite settings.json without prompting").action((options2) => sync(options2));
-configHelp(syncCommand, rootConfigHelp.sync);
+registerSync(program);
 program.command("init").description("Initialize VS Code and verify configurations").action(init5);
 var commitCommand = program.command("commit").description("Create a git commit with validation").argument("<args...>", "status | <message> [files...]").action(commit);
 configHelp(commitCommand, rootConfigHelp.commit);