@staff0rd/assist 0.655.0 → 0.657.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.655.0",
+  version: "0.657.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -307,8 +307,8 @@ function getRemoteOriginUrl(cwd) {
 }
 
 // src/commands/backlog/getCurrentOrigin.ts
-function stripLeadingSlashes(path90) {
-  return path90.replace(/^\/+/, "");
+function stripLeadingSlashes(path91) {
+  return path91.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -358,9 +358,9 @@ function findGitLink(dir) {
   }
   return null;
 }
-function isFile(path90) {
+function isFile(path91) {
   try {
-    return statSync(path90).isFile();
+    return statSync(path91).isFile();
   } catch {
     return false;
   }
@@ -379,9 +379,9 @@ function linkedGitDirParent(gitDir) {
   const match = /^(.*)[/\\]worktrees[/\\][^/\\]+[/\\]?$/.exec(gitDir);
   return match ? match[1] : null;
 }
-function readTrimmed(path90) {
+function readTrimmed(path91) {
   try {
-    const content = readFileSync2(path90, "utf8").trim();
+    const content = readFileSync2(path91, "utf8").trim();
     return content === "" ? null : content;
   } catch {
     return null;
@@ -394,10 +394,10 @@ function absolute(target, from) {
 // src/shared/loadRawYaml.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path90) {
-  if (!existsSync3(path90)) return {};
+function loadRawYaml(path91) {
+  if (!existsSync3(path91)) return {};
   try {
-    const content = readFileSync3(path90, "utf8");
+    const content = readFileSync3(path91, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -469,8 +469,8 @@ function mergeRawConfigs(globalRaw, projectRaw) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path90 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path90.split("/").filter(Boolean);
+    const path91 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path91.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -2874,11 +2874,11 @@ function enumValues(node) {
 function opaqueConfigNode(inner, base) {
   return { ...base, kind: "other", type: leafTypeOf(inner) };
 }
-function build(node, path90) {
+function build(node, path91) {
   const { inner, defaultValue, optional } = unwrapSchemaNode(node);
   const secret = isSecretSchemaNode(node) || isSecretSchemaNode(inner);
   const base = {
-    path: path90,
+    path: path91,
     ...optional ? { optional: true } : {},
     ...defaultValue === void 0 ? {} : { defaultValue },
     ...secret ? { secret: true } : {}
@@ -2897,9 +2897,9 @@ function segmentText(segment) {
   if (segment.kind === "index") return `[${segment.index}]`;
   return "[]";
 }
-function formatConfigPath(path90) {
+function formatConfigPath(path91) {
   let text18 = "";
-  for (const segment of path90) {
+  for (const segment of path91) {
     const dotted = segment.kind === "key" || segment.kind === "entry";
     const rendered = segmentText(segment);
     text18 += dotted && text18 ? `.${rendered}` : rendered;
@@ -3627,9 +3627,9 @@ import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
-function resolveStringsAtPath(data, path90) {
+function resolveStringsAtPath(data, path91) {
   let current = data;
-  for (const segment of path90.split(".")) {
+  for (const segment of path91.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3642,10 +3642,10 @@ function resolveStringsAtPath(data, path90) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path90 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path90)) {
+  for (const path91 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path91)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path90, value });
+        violations.push({ file: rule.file, path: path91, value });
     }
   }
   return violations;
@@ -3684,8 +3684,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path90, value } of violations) {
-    console.log(`  ${file} ${path90}: ${value}`);
+  for (const { file, path: path91, value } of violations) {
+    console.log(`  ${file} ${path91}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -4288,15 +4288,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path90) => MIGRATION_FILE3.test(basename2(path90)));
-  for (const path90 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path91) => MIGRATION_FILE3.test(basename2(path91)));
+  for (const path91 of paths) {
     try {
-      const content = execSync6(`git show "${ref}:${path90}"`, {
+      const content = execSync6(`git show "${ref}:${path91}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path90), content);
+      baseline.set(basename2(path91), content);
     } catch {
     }
   }
@@ -5281,6 +5281,18 @@ ${extra}`);
   return [heading, ...sections].join("\n\n");
 }
 
+// src/commands/advise/adviceHookPayload.ts
+function adviceHookPayload(cwd) {
+  const markdown = composeAdvice(adviceContextFor(cwd));
+  if (!markdown) return void 0;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: markdown
+    }
+  };
+}
+
 // src/commands/advise/explainAdvice.ts
 import chalk28 from "chalk";
 function explainAdvice(context, fragments = loadAdviceFragments()) {
@@ -5308,22 +5320,22 @@ async function hookCwd(options2) {
 async function advise(options2 = {}) {
   const fallback = options2.cwdFallback ?? process.cwd();
   const cwd = options2.hook ? await hookCwd(options2) ?? fallback : fallback;
-  const context = adviceContextFor(cwd);
   if (options2.explain) {
-    const explanation = explainAdvice(context);
+    const explanation = explainAdvice(adviceContextFor(cwd));
     console.log(explanation);
     return explanation;
   }
-  const markdown = composeAdvice(context);
+  if (options2.hook) {
+    const payload = adviceHookPayload(cwd);
+    if (!payload) return "";
+    const output = JSON.stringify(payload);
+    console.log(output);
+    return output;
+  }
+  const markdown = composeAdvice(adviceContextFor(cwd));
   if (!markdown) return "";
-  const output = options2.hook ? JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: "SessionStart",
-      additionalContext: markdown
-    }
-  }) : markdown;
-  console.log(output);
-  return output;
+  console.log(markdown);
+  return markdown;
 }
 
 // src/commands/registerAdvise.ts
@@ -6568,10 +6580,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path90 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname14(path90), { recursive: true });
-  writeFileSync15(path90, JSON.stringify(hooksSettings, null, 2));
-  return path90;
+  const path91 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname14(path91), { recursive: true });
+  writeFileSync15(path91, JSON.stringify(hooksSettings, null, 2));
+  return path91;
 }
 
 // src/shared/spawnInherit.ts
@@ -6749,8 +6761,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path90 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path90}/${ref}`;
+  const path91 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path91}/${ref}`;
 }
 
 // src/commands/branch/buildBranchName.ts
@@ -6993,9 +7005,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path90 = join18(dir, ".assist", name);
-    if (existsSync21(path90)) {
-      renameSync(path90, `${path90}.bak`);
+    const path91 = join18(dir, ".assist", name);
+    if (existsSync21(path91)) {
+      renameSync(path91, `${path91}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -7479,8 +7491,8 @@ var backlogItemSchema = z4.strictObject({
 var backlogFileSchema = z4.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path90) {
-  const content = readFileSync16(path90, "utf8").trim();
+function parseBacklogJsonl(path91) {
+  const content = readFileSync16(path91, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -8200,7 +8212,6 @@ var harnesses = {
     command: "claude",
     homeDir: path23.join(os.homedir(), ".claude"),
     sync: {
-      agentsFile: "CLAUDE.md",
       commandDest: (name) => path23.join("commands", `${name}.md`)
     }
   },
@@ -8209,7 +8220,6 @@ var harnesses = {
     command: "codex",
     homeDir: path23.join(os.homedir(), ".codex"),
     sync: {
-      agentsFile: "AGENTS.md",
       commandDest: (name) => path23.join("skills", name, "SKILL.md")
     }
   },
@@ -8218,7 +8228,6 @@ var harnesses = {
     command: "pi",
     homeDir: path23.join(os.homedir(), ".pi", "agent"),
     sync: {
-      agentsFile: "AGENTS.md",
       commandDest: (name) => path23.join("prompts", `${name}.md`)
     }
   }
@@ -8291,24 +8300,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path90 = getOwnerPath(itemId2);
-  mkdirSync7(dirname16(path90), { recursive: true });
-  writeFileSync17(path90, JSON.stringify({ sessionId }));
+  const path91 = getOwnerPath(itemId2);
+  mkdirSync7(dirname16(path91), { recursive: true });
+  writeFileSync17(path91, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path90 = getOwnerPath(itemId2);
-  if (!existsSync25(path90)) return void 0;
+  const path91 = getOwnerPath(itemId2);
+  if (!existsSync25(path91)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync17(path90, "utf8"));
+    const parsed = JSON.parse(readFileSync17(path91, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path90 = getOwnerPath(itemId2);
+  const path91 = getOwnerPath(itemId2);
   try {
-    rmSync(path90);
+    rmSync(path91);
   } catch {
   }
 }
@@ -8345,19 +8354,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path90 = getSignalPath(target);
-  if (!path90) return;
+  const path91 = getSignalPath(target);
+  if (!path91) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname17(path90), { recursive: true });
-  writeFileSync18(path90, JSON.stringify(signal));
+  mkdirSync8(dirname17(path91), { recursive: true });
+  writeFileSync18(path91, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path90 = getSignalPath();
-  if (!path90 || !existsSync26(path90)) return void 0;
+  const path91 = getSignalPath();
+  if (!path91 || !existsSync26(path91)) return void 0;
   try {
-    return JSON.parse(readFileSync18(path90, "utf8"));
+    return JSON.parse(readFileSync18(path91, "utf8"));
   } catch {
     return void 0;
   }
@@ -8555,13 +8564,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path90 = activityPath(sessionId);
-  mkdirSync9(dirname18(path90), { recursive: true });
-  writeFileSync19(path90, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path91 = activityPath(sessionId);
+  mkdirSync9(dirname18(path91), { recursive: true });
+  writeFileSync19(path91, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path90) {
+function readActivity(path91) {
   try {
-    return JSON.parse(readFileSync19(path90, "utf8"));
+    return JSON.parse(readFileSync19(path91, "utf8"));
   } catch {
     return void 0;
   }
@@ -8571,9 +8580,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path90 = activityPath(sessionId);
-  mkdirSync9(dirname18(path90), { recursive: true });
-  writeFileSync19(path90, JSON.stringify(activity2));
+  const path91 = activityPath(sessionId);
+  mkdirSync9(dirname18(path91), { recursive: true });
+  writeFileSync19(path91, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -10038,10 +10047,10 @@ function getStorePath(filename) {
   return join29(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path90 = getStorePath(filename);
-  if (existsSync31(path90)) {
+  const path91 = getStorePath(filename);
+  if (existsSync31(path91)) {
     try {
-      return JSON.parse(readFileSync20(path90, "utf8"));
+      return JSON.parse(readFileSync20(path91, "utf8"));
     } catch {
       return {};
     }
@@ -10060,22 +10069,22 @@ function saveJson(filename, data) {
 var REGISTRY_FILE = "worktrees.json";
 function readWorktreeRegistry() {
   const data = loadJson(REGISTRY_FILE);
-  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path90, record]) => ({ path: path90, ...record }));
+  return Object.entries(data).filter(([, record]) => !record.reaped).map(([path91, record]) => ({ path: path91, ...record }));
 }
-function worktreeAttributionIncludingReaped(path90) {
-  const record = loadJson(REGISTRY_FILE)[path90];
+function worktreeAttributionIncludingReaped(path91) {
+  const record = loadJson(REGISTRY_FILE)[path91];
   return record ? { clone: record.clone, origin: record.origin } : void 0;
 }
-function recordWorktree(path90, clone, origin) {
+function recordWorktree(path91, clone, origin) {
   const data = loadJson(REGISTRY_FILE);
-  data[path90] = { clone, origin };
+  data[path91] = { clone, origin };
   saveJson(REGISTRY_FILE, data);
 }
-function forgetWorktree(path90) {
+function forgetWorktree(path91) {
   const data = loadJson(REGISTRY_FILE);
-  const record = data[path90];
+  const record = data[path91];
   if (!record || record.reaped) return;
-  data[path90] = { ...record, reaped: true };
+  data[path91] = { ...record, reaped: true };
   saveJson(REGISTRY_FILE, data);
 }
 
@@ -10903,8 +10912,8 @@ async function loadCommittedPaths(cwd, sessionId) {
   for (const commit2 of commits2) {
     const resolved = await resolveCommit(cwd, commit2.sha);
     if (!resolved) continue;
-    for (const path90 of resolved.paths) {
-      if (!bases.has(path90)) bases.set(path90, resolved.base);
+    for (const path91 of resolved.paths) {
+      if (!bases.has(path91)) bases.set(path91, resolved.base);
     }
   }
   return { commits: commits2, bases };
@@ -10922,16 +10931,16 @@ async function itemChangeSet(cwd, sessionId) {
 }
 function groupByBase(bases) {
   const groups = /* @__PURE__ */ new Map();
-  for (const [path90, base] of bases) {
+  for (const [path91, base] of bases) {
     const paths = groups.get(base);
-    if (paths) paths.push(path90);
-    else groups.set(base, [path90]);
+    if (paths) paths.push(path91);
+    else groups.set(base, [path91]);
   }
   return [...groups].map(([base, paths]) => ({ base, paths: paths.sort() }));
 }
 async function dirtyPaths(cwd, bases) {
   const output = await execGit(cwd, ["diff", "--name-only", "HEAD"]);
-  return output.split("\n").filter((path90) => path90 && !bases.has(path90)).sort();
+  return output.split("\n").filter((path91) => path91 && !bases.has(path91)).sort();
 }
 
 // src/commands/sessions/web/scopedDiff.ts
@@ -10940,8 +10949,8 @@ async function scopedDiff(cwd, session, scope) {
   if (scope.kind === "commit") return commitDiff(cwd, scope.sha);
   return await trackedScopeDiff(cwd, session, scope) + await untrackedDiff(cwd);
 }
-async function untrackedFileDiff(cwd, path90) {
-  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path90], {
+async function untrackedFileDiff(cwd, path91) {
+  return execGit(cwd, ["diff", "--no-index", "--", "/dev/null", path91], {
     maxBuffer: MAX_DIFF_BYTES,
     allowFailure: true
   });
@@ -10954,7 +10963,7 @@ async function untrackedDiff(cwd) {
   ]);
   const paths = list5.split("\n").filter(Boolean);
   const diffs = await Promise.all(
-    paths.map((path90) => untrackedFileDiff(cwd, path90))
+    paths.map((path91) => untrackedFileDiff(cwd, path91))
   );
   return diffs.join("");
 }
@@ -11047,9 +11056,9 @@ import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve10
 function repoRoot(cwd) {
   return resolve10(toGitCwd(cwd));
 }
-function resolveWithinCwd(cwd, path90) {
+function resolveWithinCwd(cwd, path91) {
   const root = repoRoot(cwd);
-  const target = resolve10(root, path90);
+  const target = resolve10(root, path91);
   const rel = relative2(root, target);
   if (rel === "" || rel.startsWith("..") || isAbsolute2(rel)) return null;
   return target;
@@ -11059,14 +11068,14 @@ function resolveWithinCwd(cwd, path90) {
 function getFileTarget(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return null;
-  const path90 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+  const path91 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
     "path"
   );
-  if (!path90) {
+  if (!path91) {
     respondJson(res, 400, { error: "Missing path" });
     return null;
   }
-  const target = resolveWithinCwd(cwd, path90);
+  const target = resolveWithinCwd(cwd, path91);
   if (!target) {
     respondJson(res, 400, { error: "Path outside cwd" });
     return null;
@@ -11141,11 +11150,11 @@ function globalConfigTargetFor(cwd) {
 
 // src/commands/config/globalConfigFileLabel.ts
 var WINDOWS_MOUNT_PREFIX = "/mnt/";
-function globalConfigFileLabel(path90) {
-  if (path90 === getGlobalConfigPath()) return "~/.assist.yml";
-  if (path90.startsWith(WINDOWS_MOUNT_PREFIX))
-    return `${path90} on the Windows host`;
-  return path90;
+function globalConfigFileLabel(path91) {
+  if (path91 === getGlobalConfigPath()) return "~/.assist.yml";
+  if (path91.startsWith(WINDOWS_MOUNT_PREFIX))
+    return `${path91} on the Windows host`;
+  return path91;
 }
 
 // src/commands/config/readRawConfigLayers.ts
@@ -11202,35 +11211,35 @@ function isPlainRecord(value) {
 }
 
 // src/shared/mapConfigSecrets.ts
-function mapChildren(value, path90, childNode, map) {
+function mapChildren(value, path91, childNode, map) {
   if (!isPlainRecord(value)) return value;
   return Object.fromEntries(
     Object.entries(value).map(([name, child]) => [
       name,
-      walk(child, [...path90, name], childNode(name), map)
+      walk(child, [...path91, name], childNode(name), map)
     ])
   );
 }
-function mapItems(value, path90, item, map) {
+function mapItems(value, path91, item, map) {
   if (!Array.isArray(value)) return value;
-  return value.map((entry, index3) => walk(entry, [...path90, index3], item, map));
+  return value.map((entry, index3) => walk(entry, [...path91, index3], item, map));
 }
-function walk(value, path90, node, map) {
+function walk(value, path91, node, map) {
   if (!node || value === void 0 || value === null) return value;
-  if (node.secret) return map(value, path90);
+  if (node.secret) return map(value, path91);
   switch (node.kind) {
     case "object":
     case "unionOfObjects":
       return mapChildren(
         value,
-        path90,
+        path91,
         (name) => configNodeField(node, name),
         map
       );
     case "objectList":
-      return mapItems(value, path90, node.item, map);
+      return mapItems(value, path91, node.item, map);
     case "record":
-      return mapChildren(value, path90, () => node.value, map);
+      return mapChildren(value, path91, () => node.value, map);
     default:
       return value;
   }
@@ -11255,9 +11264,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path90) {
+function getNestedValue(obj, path91) {
   let current = obj;
-  for (const key of path90.split(".")) current = stepInto(current, key);
+  for (const key of path91.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -11307,9 +11316,9 @@ function step(node, segment) {
       return void 0;
   }
 }
-function findConfigNode(root, path90) {
+function findConfigNode(root, path91) {
   let current = root;
-  for (const segment of path90) {
+  for (const segment of path91) {
     if (!current) return void 0;
     current = step(current, segment);
   }
@@ -11326,34 +11335,34 @@ function nameSegment(name) {
   return name === RECORD_ENTRY_TOKEN ? { kind: "entry" } : { kind: "key", name };
 }
 function parseConfigPath(text18) {
-  const path90 = [];
+  const path91 = [];
   let at2 = 0;
   while (at2 < text18.length) {
     if (text18[at2] === "[") {
       const close = text18.indexOf("]", at2);
       const segment = close === -1 ? void 0 : bracketSegment(text18.slice(at2 + 1, close));
       if (!segment) return void 0;
-      path90.push(segment);
+      path91.push(segment);
       at2 = close + 1;
       continue;
     }
     if (text18[at2] === ".") {
-      if (path90.length === 0) return void 0;
+      if (path91.length === 0) return void 0;
       at2 += 1;
     }
     const start3 = at2;
     while (at2 < text18.length && text18[at2] !== "." && text18[at2] !== "[") at2 += 1;
     const name = text18.slice(start3, at2);
     if (!name) return void 0;
-    path90.push(nameSegment(name));
+    path91.push(nameSegment(name));
   }
-  return path90;
+  return path91;
 }
 
 // src/commands/config/configEntryNode.ts
 function configEntryNode(root, key) {
-  const path90 = parseConfigPath(key);
-  return path90 ? findConfigNode(root, path90) : void 0;
+  const path91 = parseConfigPath(key);
+  return path91 ? findConfigNode(root, path91) : void 0;
 }
 
 // src/commands/config/configHelpForKey.ts
@@ -11488,7 +11497,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname22(branchKeyPath);
   const branchPrefix = basename10(branchKeyPath);
   if (!existsSync34(parent)) return null;
-  const synthesisFiles = readdirSync3(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join32(parent, name, "synthesis.md")).filter((path90) => existsSync34(path90)).map((path90) => ({ path: path90, mtime: statSync4(path90).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync3(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join32(parent, name, "synthesis.md")).filter((path91) => existsSync34(path91)).map((path91) => ({ path: path91, mtime: statSync4(path91).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -11518,12 +11527,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path90 = await resolveSynthesisPath(cwd);
-    if (!path90) {
+    const path91 = await resolveSynthesisPath(cwd);
+    if (!path91) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync22(path90, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync22(path91, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -11606,8 +11615,8 @@ function parseDiffNameStatus(output) {
     if (!status3 || fields.length < 2) continue;
     const category = categorize(status3[0]);
     if (!category) continue;
-    const path90 = fields[fields.length - 1];
-    if (path90) result[category].push(path90);
+    const path91 = fields[fields.length - 1];
+    if (path91) result[category].push(path91);
   }
   return result;
 }
@@ -11743,21 +11752,21 @@ function subsequenceScore(text18, query) {
   }
   return score - Math.min(text18.length, MAX_LENGTH_PENALTY);
 }
-function scoreFilePath(path90, query) {
+function scoreFilePath(path91, query) {
   const needle = query.trim().toLowerCase();
   if (!needle) return 0;
-  const basename29 = path90.slice(path90.lastIndexOf("/") + 1);
+  const basename29 = path91.slice(path91.lastIndexOf("/") + 1);
   const inBasename = subsequenceScore(basename29, needle);
   if (inBasename !== null) return BASENAME_WEIGHT + inBasename;
-  return subsequenceScore(path90, needle);
+  return subsequenceScore(path91, needle);
 }
 
 // src/commands/sessions/web/rankFilePaths.ts
 function rankFilePaths(paths, query, limit) {
   const scored = [];
-  for (const path90 of paths) {
-    const score = scoreFilePath(path90, query);
-    if (score !== null) scored.push({ path: path90, score });
+  for (const path91 of paths) {
+    const score = scoreFilePath(path91, query);
+    if (score !== null) scored.push({ path: path91, score });
   }
   scored.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
   return scored.slice(0, limit).map((entry) => entry.path);
@@ -12498,38 +12507,38 @@ async function restartWeb(req, res, deps2 = {}) {
 import { relative as relative3 } from "path";
 
 // src/commands/sessions/web/revertPathChanges.ts
-async function isTracked(cwd, path90) {
+async function isTracked(cwd, path91) {
   try {
-    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path90]);
+    await execGit(cwd, ["ls-files", "--error-unmatch", "--", path91]);
     return true;
   } catch {
     return false;
   }
 }
-async function isInHead(cwd, path90) {
-  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path90]);
+async function isInHead(cwd, path91) {
+  const listing = await execGit(cwd, ["ls-tree", "HEAD", "--", path91]);
   return listing.trim().length > 0;
 }
-async function revertPathChanges(cwd, path90) {
-  if (!await isTracked(cwd, path90)) {
-    await execGit(cwd, ["clean", "-f", "--", path90]);
+async function revertPathChanges(cwd, path91) {
+  if (!await isTracked(cwd, path91)) {
+    await execGit(cwd, ["clean", "-f", "--", path91]);
     return;
   }
-  if (await isInHead(cwd, path90)) {
-    await execGit(cwd, ["checkout", "HEAD", "--", path90]);
+  if (await isInHead(cwd, path91)) {
+    await execGit(cwd, ["checkout", "HEAD", "--", path91]);
     return;
   }
-  await execGit(cwd, ["rm", "-f", "--", path90]);
+  await execGit(cwd, ["rm", "-f", "--", path91]);
 }
 
 // src/commands/sessions/web/revertDiffFile.ts
 async function revertDiffFile(req, res) {
   const resolved = getFileTarget(req, res);
   if (!resolved) return;
-  const path90 = relative3(repoRoot(resolved.cwd), resolved.target);
+  const path91 = relative3(repoRoot(resolved.cwd), resolved.target);
   try {
-    await revertPathChanges(resolved.cwd, path90);
-    respondJson(res, 200, { reverted: path90 });
+    await revertPathChanges(resolved.cwd, path91);
+    respondJson(res, 200, { reverted: path91 });
   } catch (error) {
     respondJson(res, 500, {
       error: error instanceof Error ? error.message : "Failed to revert file"
@@ -12551,7 +12560,7 @@ async function readJsonBody(req) {
 function requestedPaths(body) {
   const paths = body.paths;
   if (!Array.isArray(paths)) return null;
-  if (paths.some((path90) => typeof path90 !== "string")) return null;
+  if (paths.some((path91) => typeof path91 !== "string")) return null;
   return paths;
 }
 async function revertDiffPaths(req, res) {
@@ -12571,10 +12580,10 @@ async function revertDiffPaths(req, res) {
   const root = repoRoot(cwd);
   const reverted = [];
   const failed2 = [];
-  for (const path90 of paths) {
-    const target = resolveWithinCwd(cwd, path90);
+  for (const path91 of paths) {
+    const target = resolveWithinCwd(cwd, path91);
     if (!target) {
-      failed2.push({ path: path90, error: "Path outside cwd" });
+      failed2.push({ path: path91, error: "Path outside cwd" });
       continue;
     }
     const relativePath = relative4(root, target);
@@ -12664,11 +12673,11 @@ function coerceStructuredConfigValue(key, raw) {
   };
 }
 function formatIssue(key, issue) {
-  const path90 = formatConfigPath([
+  const path91 = formatConfigPath([
     { kind: "key", name: key },
     ...issue.path.map(toSegment)
   ]);
-  return `${path90}: ${issue.message}`;
+  return `${path91}: ${issue.message}`;
 }
 function toSegment(part) {
   return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
@@ -12763,9 +12772,9 @@ function coerceUnion(key, raw, types) {
 }
 
 // src/shared/valueAtConfigPath.ts
-function valueAtConfigPath(value, path90) {
+function valueAtConfigPath(value, path91) {
   let current = value;
-  for (const key of path90) {
+  for (const key of path91) {
     if (typeof key === "number") {
       if (!Array.isArray(current)) return void 0;
       current = current[key];
@@ -12782,7 +12791,7 @@ function restoreConfigSecrets(value, stored, node) {
   return mapConfigSecrets(
     value,
     node,
-    (secret, path90) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path90) : secret
+    (secret, path91) => isRedactedSecret(secret) ? valueAtConfigPath(stored, path91) : secret
   );
 }
 
@@ -12831,8 +12840,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path90, value) {
-  const keys = path90.split(".");
+function setNestedValue(obj, path91, value) {
+  const keys = path91.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -12859,8 +12868,8 @@ function formatIssue2(issue, key) {
     return issue.keys.map(
       (unrecognized) => `${[...issue.path, unrecognized].join(".")}: Unrecognized key`
     );
-  const path90 = issue.path.length > 0 ? issue.path.join(".") : key;
-  return [`${path90}: ${issue.message}`];
+  const path91 = issue.path.length > 0 ? issue.path.join(".") : key;
+  return [`${path91}: ${issue.message}`];
 }
 
 // src/commands/config/applyConfigSet.ts
@@ -13117,8 +13126,8 @@ function removeAt(container, keys) {
   }
   return removeFromChild(container, key, rest);
 }
-function unsetNestedValue(obj, path90) {
-  const { container, removed } = removeAt(obj, path90.split("."));
+function unsetNestedValue(obj, path91) {
+  const { container, removed } = removeAt(obj, path91.split("."));
   return { config: container, removed };
 }
 
@@ -14278,9 +14287,9 @@ function originToSshUrl(origin) {
   const firstSlash = origin.indexOf("/");
   if (firstSlash <= 0) return null;
   const host = origin.slice(0, firstSlash);
-  const path90 = origin.slice(firstSlash + 1);
-  if (!path90) return null;
-  return `git@${host}:${path90}.git`;
+  const path91 = origin.slice(firstSlash + 1);
+  if (!path91) return null;
+  return `git@${host}:${path91}.git`;
 }
 
 // src/commands/backlog/cloneRepo.ts
@@ -17318,13 +17327,13 @@ function findBuiltinDenyRaw(rawCommand) {
 
 // src/commands/cliHook/findRestrictedPathDeny.ts
 var RESTRICTED_PATHS = [".assist/restricted"];
-function restrictedPathRegex(path90) {
-  const pattern2 = path90.split("/").map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join(String.raw`[/\\]`);
+function restrictedPathRegex(path91) {
+  const pattern2 = path91.split("/").map((segment) => segment.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join(String.raw`[/\\]`);
   return new RegExp(pattern2);
 }
-var RESTRICTED_PATH_RULES = RESTRICTED_PATHS.map((path90) => ({
-  path: path90,
-  regex: restrictedPathRegex(path90)
+var RESTRICTED_PATH_RULES = RESTRICTED_PATHS.map((path91) => ({
+  path: path91,
+  regex: restrictedPathRegex(path91)
 }));
 function findRestrictedPathDenyRaw(rawCommand) {
   const rule = RESTRICTED_PATH_RULES.find(
@@ -17495,9 +17504,9 @@ var __dirname4 = dirname24(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path90) {
-  if (!existsSync40(path90)) return [];
-  return readFileSync27(path90, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path91) {
+  if (!existsSync40(path91)) return [];
+  return readFileSync27(path91, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -18021,14 +18030,14 @@ function showProgress(p, label2) {
   const pct = Math.round(p.done / p.total * 100);
   process.stderr.write(`\r\x1B[K[${pct}%] Scanning ${label2}...`);
 }
-async function resolveCommand(cli, path90, description, depth, p) {
-  showProgress(p, path90.join(" "));
-  const subHelp = await runHelp([cli, ...path90]);
+async function resolveCommand(cli, path91, description, depth, p) {
+  showProgress(p, path91.join(" "));
+  const subHelp = await runHelp([cli, ...path91]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path90, description }];
+    return [{ path: path91, description }];
   }
-  const children = await discoverAt(cli, path90, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path90, description }];
+  const children = await discoverAt(cli, path91, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path91, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -18176,9 +18185,9 @@ function logPath(cli) {
   return join42(homedir17(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path90 = logPath(cli);
-  if (!existsSync42(path90)) return void 0;
-  return readFileSync29(path90, "utf8");
+  const path91 = logPath(cli);
+  if (!existsSync42(path91)) return void 0;
+  return readFileSync29(path91, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join42(homedir17(), ".assist");
@@ -18338,9 +18347,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path90 = join44(dir, entry);
+    const path91 = join44(dir, entry);
     try {
-      if (statSync7(path90).mtimeMs < cutoff) unlinkSync7(path90);
+      if (statSync7(path91).mtimeMs < cutoff) unlinkSync7(path91);
     } catch {
       continue;
     }
@@ -18350,10 +18359,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync43, readFileSync as readFileSync30 } from "fs";
 function readPinState(pin) {
-  const path90 = getPinStatePath(pin);
-  if (!existsSync43(path90)) return void 0;
+  const path91 = getPinStatePath(pin);
+  if (!existsSync43(path91)) return void 0;
   try {
-    const state = JSON.parse(readFileSync30(path90, "utf8"));
+    const state = JSON.parse(readFileSync30(path91, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -18502,6 +18511,23 @@ function registerCodeComment(parent) {
   codeComment.command("confirm").description("Confirm a pin to insert its comment and clear the pin state").argument("<pin>", "Pin issued by 'code-comment set'").action(codeCommentConfirm);
 }
 
+// src/commands/codexHook/parseCodexHookInput.ts
+var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Bash", "PowerShell"]);
+function parseCodexHookInput(raw) {
+  try {
+    const data = JSON.parse(raw);
+    const event = data.hook_event_name ?? "PreToolUse";
+    const cwd = typeof data.cwd === "string" ? data.cwd : void 0;
+    const command = data.tool_input?.command;
+    if (typeof command !== "string" || !command.trim()) return { event, cwd };
+    if (!data.tool_name || !SUPPORTED_TOOLS.has(data.tool_name))
+      return { event, cwd };
+    return { event, cwd, toolName: data.tool_name, command: command.trim() };
+  } catch {
+    return void 0;
+  }
+}
+
 // src/commands/codexHook/codexStatusFor.ts
 function codexStatusFor(event, autoDecided) {
   if (event === "UserPromptSubmit")
@@ -18521,20 +18547,6 @@ async function reportCodexStatus(event, autoDecided) {
 }
 
 // src/commands/codexHook/index.ts
-var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Bash", "PowerShell"]);
-function parseInput(raw) {
-  try {
-    const data = JSON.parse(raw);
-    const event = data.hook_event_name ?? "PreToolUse";
-    const command = data.tool_input?.command;
-    if (typeof command !== "string" || !command.trim()) return { event };
-    if (!data.tool_name || !SUPPORTED_TOOLS.has(data.tool_name))
-      return { event };
-    return { event, toolName: data.tool_name, command: command.trim() };
-  } catch {
-    return void 0;
-  }
-}
 function preToolUseOutput(decision) {
   if (decision.permissionDecision === "allow") return void 0;
   return {
@@ -18560,16 +18572,19 @@ function decide2(input) {
   if (!input.toolName || !input.command) return void 0;
   return decideCommand(input.toolName, input.command);
 }
-function outputFor(event, decision) {
+function outputFor(input, decision) {
+  if (input.event === "SessionStart")
+    return adviceHookPayload(input.cwd ?? process.cwd());
   if (!decision) return void 0;
-  if (event === "PermissionRequest") return permissionRequestOutput(decision);
+  if (input.event === "PermissionRequest")
+    return permissionRequestOutput(decision);
   return preToolUseOutput(decision);
 }
 async function codexHook() {
-  const input = parseInput(await readStdin());
+  const input = parseCodexHookInput(await readStdin());
   if (!input) return;
   const decision = decide2(input);
-  const output = outputFor(input.event, decision);
+  const output = outputFor(input, decision);
   if (output) console.log(JSON.stringify(output));
   await reportCodexStatus(input.event, decision !== void 0);
 }
@@ -18685,8 +18700,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path90 = line.split("	")[1];
-    if (path90) found.add(path90.trim());
+    const path91 = line.split("	")[1];
+    if (path91) found.add(path91.trim());
   }
   return [...found];
 }
@@ -19911,11 +19926,11 @@ async function loadPath(source) {
   }
 }
 async function criteriaExtension() {
-  const path90 = await loadPath(criteriaExtensionDir());
+  const path91 = await loadPath(criteriaExtensionDir());
   console.log(
     chalk140.bold("acceptance criteria outliner \u2014 GitHub browser extension")
   );
-  console.log(chalk140.dim(`load the unpacked extension from ${path90}`));
+  console.log(chalk140.dim(`load the unpacked extension from ${path91}`));
 }
 
 // src/commands/criteriaExtension/signCriteriaExtension.ts
@@ -20040,10 +20055,10 @@ async function signCriteriaExtension() {
     process.exitCode = 1;
     return;
   }
-  const path90 = await signedAddonInstallPath(
+  const path91 = await signedAddonInstallPath(
     await copySignedXpi(xpi, ARTIFACTS_DIR)
   );
-  console.log(chalk142.dim(`install the signed add-on from ${path90}`));
+  console.log(chalk142.dim(`install the signed add-on from ${path91}`));
 }
 
 // src/commands/registerCriteriaExtension.ts
@@ -20141,10 +20156,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync48, readFileSync as readFileSync32 } from "fs";
 function readMigrationPinState(pin) {
-  const path90 = getMigrationPinPath(pin);
-  if (!existsSync48(path90)) return void 0;
+  const path91 = getMigrationPinPath(pin);
+  if (!existsSync48(path91)) return void 0;
   try {
-    const state = JSON.parse(readFileSync32(path90, "utf8"));
+    const state = JSON.parse(readFileSync32(path91, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -21574,10 +21589,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync54, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path90 = getMigrationApprovalPath(migrationId);
-  if (!existsSync54(path90)) return false;
+  const path91 = getMigrationApprovalPath(migrationId);
+  if (!existsSync54(path91)) return false;
   try {
-    unlinkSync11(path90);
+    unlinkSync11(path91);
     return true;
   } catch {
     return false;
@@ -23813,11 +23828,11 @@ function recentDaemonLogLines() {
 // src/commands/sessions/daemon/worktree/canonicalTreePath.ts
 import { realpathSync as realpathSync2 } from "fs";
 import { resolve as resolve14 } from "path";
-function canonicalTreePath(path90) {
+function canonicalTreePath(path91) {
   try {
-    return realpathSync2(path90);
+    return realpathSync2(path91);
   } catch {
-    return resolve14(path90);
+    return resolve14(path91);
   }
 }
 
@@ -23870,22 +23885,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) || existsSync57(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename18(candidate));
-  const path90 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
+  const path91 = preferredPath && !isTaken(preferredPath) ? preferredPath : nextWorktreePath(clone, base, isTaken);
   const start3 = worktreeStartPoint(clone, strategy.trunk);
   gitSync(clone, [
     "worktree",
     "add",
     start3.track ? "--track" : "--no-track",
     "-b",
-    basename18(path90),
-    path90,
+    basename18(path91),
+    path91,
     start3.ref
   ]);
-  recordWorktree(path90, clone, getCurrentOrigin(clone));
+  recordWorktree(path91, clone, getCurrentOrigin(clone));
   daemonLog(
-    start3.track ? `worktree allocated ${path90} (branch ${basename18(path90)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path90} (branch ${basename18(path90)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
+    start3.track ? `worktree allocated ${path91} (branch ${basename18(path91)} tracking ${start3.ref}) for clone ${clone}` : `worktree allocated ${path91} (branch ${basename18(path91)} off ${start3.ref}, no mainline tracking) for clone ${clone}`
   );
-  return path90;
+  return path91;
 }
 
 // src/commands/sessions/daemon/worktree/keptInTree.ts
@@ -24026,13 +24041,13 @@ function allocateTree(requestedCwd, boundTreeRoots2, options2 = {}) {
   if (forcedSpill) daemonLog(forcedSpill);
   else if (reusesClone(clone, boundTreeRoots2, reuse))
     return { cwd: clone, kind: "primary", created: false, clone };
-  const path90 = createWorktree(
+  const path91 = createWorktree(
     clone,
     { root: cfg.root, trunk: cfg.trunk },
     boundTreeRoots2,
     options2.replacesTree
   );
-  return { cwd: path90, kind: "worktree", created: true, clone };
+  return { cwd: path91, kind: "worktree", created: true, clone };
 }
 
 // src/commands/sessions/daemon/describePersistedSession.ts
@@ -24365,13 +24380,13 @@ function worktreeHoldingBranch(cwd, branch2) {
   const listing = gitSyncOrNull(cwd, ["worktree", "list", "--porcelain"]);
   if (!listing) return null;
   const here = gitSyncOrNull(cwd, ["rev-parse", "--show-toplevel"]);
-  let path90 = null;
+  let path91 = null;
   for (const line of listing.split("\n")) {
     const trimmed = line.trim();
     if (trimmed.startsWith("worktree "))
-      path90 = trimmed.slice("worktree ".length).trim();
+      path91 = trimmed.slice("worktree ".length).trim();
     else if (trimmed === `branch refs/heads/${branch2}`)
-      return path90 && path90 !== here ? path90 : null;
+      return path91 && path91 !== here ? path91 : null;
   }
   return null;
 }
@@ -25489,9 +25504,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path90] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path91] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path90) {
+    for (const key of path91) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -25973,7 +25988,7 @@ var TOOL_MAP = {
   bash: "Bash",
   powershell: "PowerShell"
 };
-function parseInput2(raw) {
+function parseInput(raw) {
   try {
     const data = JSON.parse(raw);
     const command = data.command;
@@ -25986,7 +26001,7 @@ function parseInput2(raw) {
   }
 }
 async function piHook() {
-  const input = parseInput2(await readStdin());
+  const input = parseInput(await readStdin());
   if (!input) return;
   const decision = decideCommand(input.toolName, input.command);
   const output = decision ? {
@@ -26111,18 +26126,18 @@ function validateLine(line) {
     process.exit(1);
   }
 }
-async function comment2(path90, line, body, options2 = {}) {
+async function comment2(path91, line, body, options2 = {}) {
   const { startLine, skipPreview } = options2;
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
   if (!skipPreview)
-    await reviewProposedPrComment(`Comment on ${path90}:${range}`, body, null);
+    await reviewProposedPrComment(`Comment on ${path91}:${range}`, body, null);
   try {
     const prId = getCurrentPrNodeId();
-    postReviewComment({ prId, body, path: path90, line, startLine });
-    console.log(`Added review comment on ${path90}:${range}`);
+    postReviewComment({ prId, body, path: path91, line, startLine });
+    console.log(`Added review comment on ${path91}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -27339,9 +27354,9 @@ function registerPrsComments(prsCommand) {
   });
   prsCommand.command("comment <path> <line> <body>").description(
     "Add a line comment to the pending review (body of - reads it from stdin)"
-  ).action(async (path90, line, body) => {
+  ).action(async (path91, line, body) => {
     await comment2(
-      path90,
+      path91,
       Number.parseInt(line, 10),
       await readBodyArgument(body)
     );
@@ -27733,11 +27748,11 @@ async function loadBody(target) {
   if (target.kind === "file") return readDraftFile(target.path);
   return fetchPrBody(target.number, target.repo);
 }
-function readDraftFile(path90) {
+function readDraftFile(path91) {
   try {
-    return readFileSync46(path90, "utf8");
+    return readFileSync46(path91, "utf8");
   } catch {
-    console.error(`Error: Could not read \`${path90}\`.`);
+    console.error(`Error: Could not read \`${path91}\`.`);
     console.error(
       "Pass a pull request number, a GitHub pull request URL, - for stdin, or a path to a file."
     );
@@ -28016,10 +28031,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path90) {
+async function ravenFetch(connection, path91) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path90}`;
+  const url = `${connection.url}${path91}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -28109,16 +28124,16 @@ import chalk196 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path90;
+  let path91;
   if (opts.collection) {
-    path90 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path91 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path90 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path91 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path90 += `&query=${encodeURIComponent(opts.query)}`;
+    path91 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path90;
+  return path91;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -28127,7 +28142,7 @@ async function fetchAllPages(connection, opts) {
   let start3 = 0;
   while (true) {
     const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
-    const path90 = buildQueryPath({
+    const path91 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -28135,7 +28150,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path90);
+    const data = await ravenFetch(connection, path91);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -30746,8 +30761,8 @@ async function handlePostSynthesis(synthesisPath, prInfo, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync63, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync38 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path90 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync63(path90)) unlinkSync17(path90);
+  for (const path91 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync63(path91)) unlinkSync17(path91);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -32227,8 +32242,8 @@ import chalk220 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk217 from "chalk";
-async function fetchSeq(conn, path90, params) {
-  const url = `${conn.url}${path90}?${params}`;
+async function fetchSeq(conn, path91, params) {
+  const url = `${conn.url}${path91}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -32878,9 +32893,9 @@ function registerSql(program2) {
 }
 
 // src/commands/sync.ts
-import * as fs47 from "fs";
+import * as fs48 from "fs";
 import * as os5 from "os";
-import * as path84 from "path";
+import * as path85 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/pruneCommands.ts
@@ -32959,35 +32974,52 @@ function reportPrune(label2, result, force) {
   }
 }
 
+// src/commands/sync/reportRetiredAgentsFiles.ts
+import * as fs41 from "fs";
+import * as path77 from "path";
+var retired = [
+  path77.join(harnesses.claude.homeDir, "CLAUDE.md"),
+  path77.join(harnesses.codex.homeDir, "AGENTS.md"),
+  path77.join(harnesses.pi.homeDir, "AGENTS.md")
+];
+function reportRetiredAgentsFiles() {
+  const leftovers = retired.filter((file) => fs41.existsSync(file));
+  if (leftovers.length === 0) return;
+  console.log(
+    "No longer written by sync \u2014 each harness now composes its own advice at session start:"
+  );
+  for (const file of leftovers) console.log(`  ${file}`);
+  console.log(
+    "  Delete them, or they keep injecting the retired global instructions."
+  );
+}
+
 // src/commands/sync/syncCodex.ts
-import * as path79 from "path";
+import * as path80 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
-import * as fs41 from "fs";
-import * as path77 from "path";
+import * as fs42 from "fs";
+import * as path78 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path77.join(claudeDir, "commands");
-  const files = fs41.readdirSync(commandsSource);
+  const commandsSource = path78.join(claudeDir, "commands");
+  const files = fs42.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 = fs41.readFileSync(path77.join(commandsSource, file), "utf8");
-    const target = path77.join(harness.homeDir, harness.sync.commandDest(name));
-    fs41.mkdirSync(path77.dirname(target), { recursive: true });
-    fs41.writeFileSync(target, transform(name, content));
+    const content = fs42.readFileSync(path78.join(commandsSource, file), "utf8");
+    const target = path78.join(harness.homeDir, harness.sync.commandDest(name));
+    fs42.mkdirSync(path78.dirname(target), { recursive: true });
+    fs42.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path77.join(harness.homeDir, harness.sync.agentsFile);
-  fs41.mkdirSync(path77.dirname(agentsTarget), { recursive: true });
-  fs41.copyFileSync(path77.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced, names };
 }
 
 // src/commands/sync/pruneSkills.ts
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 function pruneSkills(targetDir, skillNames, options2) {
   return pruneTarget(
     targetDir,
@@ -33000,15 +33032,15 @@ function pruneSkills(targetDir, skillNames, options2) {
   );
 }
 function unexpectedContent(skillDir) {
-  const entries = fs42.readdirSync(skillDir);
+  const entries = fs43.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 fs43 from "fs";
-import * as path78 from "path";
+import * as fs44 from "fs";
+import * as path79 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -33038,13 +33070,13 @@ ${rest}
 `;
 }
 function syncCodexHooks(sourcePath) {
-  const body = fs43.readFileSync(sourcePath, "utf8");
-  const configPath = path78.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs43.existsSync(configPath) ? fs43.readFileSync(configPath, "utf8") : "";
-  fs43.mkdirSync(path78.dirname(configPath), { recursive: true });
-  fs43.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  const body = fs44.readFileSync(sourcePath, "utf8");
+  const configPath = path79.join(harnesses.codex.homeDir, "config.toml");
+  const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
+  fs44.mkdirSync(path79.dirname(configPath), { recursive: true });
+  fs44.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
-    "Registered assist codex-hook in ~/.codex/config.toml (UserPromptSubmit, PreToolUse, PostToolUse, PermissionRequest, Stop)"
+    "Registered assist codex-hook in ~/.codex/config.toml (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PermissionRequest, Stop)"
   );
 }
 
@@ -33073,59 +33105,57 @@ function syncCodex(claudeDir, options2) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path79.join(claudeDir, "..", "codex", "config.toml"));
-  console.log(
-    `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
-  );
+  syncCodexHooks(path80.join(claudeDir, "..", "codex", "config.toml"));
+  console.log(`Synced ${total} skill(s) to ~/.codex/skills`);
   if (!options2?.prune) return;
   const force = options2.force ?? false;
   reportPrune(
     "~/.codex/skills",
-    pruneSkills(path79.join(harnesses.codex.homeDir, "skills"), names, { force }),
+    pruneSkills(path80.join(harnesses.codex.homeDir, "skills"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncDesign.ts
-import * as fs44 from "fs";
-import * as path80 from "path";
+import * as fs45 from "fs";
+import * as path81 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path80.join(claudeDir, "design-system-prompt.md");
-  const systemPromptTarget = path80.join(targetBase, "design-system-prompt.md");
-  fs44.copyFileSync(systemPromptSource, systemPromptTarget);
+  const systemPromptSource = path81.join(claudeDir, "design-system-prompt.md");
+  const systemPromptTarget = path81.join(targetBase, "design-system-prompt.md");
+  fs45.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log(
     "Copied design-system-prompt.md to ~/.claude/design-system-prompt.md"
   );
-  const skillsSource = path80.join(claudeDir, "skills");
-  const skillsTarget = path80.join(targetBase, "skills");
-  fs44.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs44.readdirSync(skillsSource);
+  const skillsSource = path81.join(claudeDir, "skills");
+  const skillsTarget = path81.join(targetBase, "skills");
+  fs45.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs45.readdirSync(skillsSource);
   for (const file of files) {
-    fs44.copyFileSync(
-      path80.join(skillsSource, file),
-      path80.join(skillsTarget, file)
+    fs45.copyFileSync(
+      path81.join(skillsSource, file),
+      path81.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path82 from "path";
+import * as path83 from "path";
 
 // src/commands/sync/syncPiHooks.ts
-import * as fs45 from "fs";
-import * as path81 from "path";
+import * as fs46 from "fs";
+import * as path82 from "path";
 function piExtensionsDir() {
-  return path81.join(harnesses.pi.homeDir, "extensions");
+  return path82.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
-  fs45.mkdirSync(target, { recursive: true });
-  const files = fs45.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  fs46.mkdirSync(target, { recursive: true });
+  const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    fs45.copyFileSync(
-      path81.join(sourceDir, file),
-      path81.join(target, `assist-${file}`)
+    fs46.copyFileSync(
+      path82.join(sourceDir, file),
+      path82.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -33162,30 +33192,28 @@ function syncPi(claudeDir, options2) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path82.join(claudeDir, "..", "pi"));
-  console.log(
-    `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
-  );
+  syncPiHooks(path83.join(claudeDir, "..", "pi"));
+  console.log(`Synced ${synced} prompt(s) to ~/.pi/agent/prompts`);
   if (!options2?.prune) return;
   const force = options2.force ?? false;
   reportPrune(
     "~/.pi/agent/prompts",
-    pruneCommands(path82.join(harnesses.pi.homeDir, "prompts"), names, { force }),
+    pruneCommands(path83.join(harnesses.pi.homeDir, "prompts"), names, { force }),
     force
   );
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs46 from "fs";
-import * as path83 from "path";
+import * as fs47 from "fs";
+import * as path84 from "path";
 import chalk227 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path83.join(claudeDir, "settings.json");
-  const target = path83.join(targetBase, "settings.json");
-  const sourceContent = fs46.readFileSync(source, "utf8");
+  const source = path84.join(claudeDir, "settings.json");
+  const target = path84.join(targetBase, "settings.json");
+  const sourceContent = fs47.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs46.existsSync(target);
-  const targetContent = targetExists ? fs46.readFileSync(target, "utf8") : "";
+  const targetExists = fs47.existsSync(target);
+  const targetContent = targetExists ? fs47.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -33215,40 +33243,41 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs46.writeFileSync(target, mergedContent);
+  fs47.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath9(import.meta.url);
-var __dirname5 = path84.dirname(__filename4);
+var __dirname5 = path85.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
   const prune = { prune: options2?.prune, force: options2?.force };
-  const claudeDir = path84.join(__dirname5, "..", "claude");
-  const targetBase = path84.join(os5.homedir(), ".claude");
+  const claudeDir = path85.join(__dirname5, "..", "claude");
+  const targetBase = path85.join(os5.homedir(), ".claude");
   const commandFiles = syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   syncCodex(claudeDir, prune);
   syncPi(claudeDir, prune);
+  reportRetiredAgentsFiles();
   if (!options2?.prune) return;
-  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path84.basename(file, ".md"));
+  const commandNames = commandFiles.filter((file) => file.endsWith(".md")).map((file) => path85.basename(file, ".md"));
   const force = options2.force ?? false;
   reportPrune(
     "~/.claude/commands",
-    pruneCommands(path84.join(targetBase, "commands"), commandNames, { force }),
+    pruneCommands(path85.join(targetBase, "commands"), commandNames, { force }),
     force
   );
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path84.join(claudeDir, "commands");
-  const targetDir = path84.join(targetBase, "commands");
-  fs47.mkdirSync(targetDir, { recursive: true });
-  const files = fs47.readdirSync(sourceDir);
+  const sourceDir = path85.join(claudeDir, "commands");
+  const targetDir = path85.join(targetBase, "commands");
+  fs48.mkdirSync(targetDir, { recursive: true });
+  const files = fs48.readdirSync(sourceDir);
   for (const file of files) {
-    fs47.copyFileSync(path84.join(sourceDir, file), path84.join(targetDir, file));
+    fs48.copyFileSync(path85.join(sourceDir, file), path85.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -33258,7 +33287,7 @@ function syncCommands(claudeDir, targetBase) {
 // 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"
+    "Copy command files to ~/.claude/commands; when codex is detected, also install commands as ~/.codex/skills/<name>/SKILL.md and register the assist codex-hook in ~/.codex/config.toml, which auto-approves read-only commands and injects the repo's composed advice on SessionStart; when pi is detected, also install commands as ~/.pi/agent/prompts/<name>.md and install the assist extensions into ~/.pi/agent/extensions, which gate permissions and inject the same advice. No global instructions file is written \u2014 every harness composes its own from assist advise at session start, and any ~/.claude/CLAUDE.md, ~/.codex/AGENTS.md or ~/.pi/agent/AGENTS.md an earlier sync left behind is named so you can remove it. 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"
@@ -33276,7 +33305,7 @@ function registerSync(program2) {
 }
 
 // src/commands/transcript/clean.ts
-import { existsSync as existsSync72 } from "fs";
+import { existsSync as existsSync73 } from "fs";
 
 // src/commands/transcript/convert/formatTimestamp.ts
 function pad(value, width) {
@@ -33554,7 +33583,7 @@ function clean(file, options2 = {}) {
     );
     process.exit(1);
   }
-  if (!existsSync72(file)) {
+  if (!existsSync73(file)) {
     console.error(`Error: VTT file not found: ${file}`);
     process.exit(1);
   }
@@ -33637,21 +33666,21 @@ async function configure() {
 }
 
 // src/commands/transcript/list.ts
-import { existsSync as existsSync73, readdirSync as readdirSync21, statSync as statSync11 } from "fs";
-import { join as join87 } from "path";
+import { existsSync as existsSync74, readdirSync as readdirSync21, statSync as statSync11 } from "fs";
+import { join as join88 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
-  if (!existsSync73(vttDir)) return;
+  if (!existsSync74(vttDir)) return;
   for (const entry of readdirSync21(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync11(join87(vttDir, entry)).isDirectory()) continue;
+    if (statSync11(join88(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
 
 // src/commands/transcript/move.ts
-import { existsSync as existsSync74, mkdirSync as mkdirSync29, renameSync as renameSync2, writeFileSync as writeFileSync46 } from "fs";
-import { basename as basename23, join as join88 } from "path";
+import { existsSync as existsSync75, mkdirSync as mkdirSync29, renameSync as renameSync2, writeFileSync as writeFileSync46 } from "fs";
+import { basename as basename23, join as join89 } from "path";
 
 // src/commands/transcript/convertVttToMarkdown.ts
 function convertVttToMarkdown(inputPath) {
@@ -33661,9 +33690,9 @@ function convertVttToMarkdown(inputPath) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join88(vttDir, "processed");
+  const processedDir = join89(vttDir, "processed");
   mkdirSync29(processedDir, { recursive: true });
-  renameSync2(sourcePath, join88(processedDir, filename));
+  renameSync2(sourcePath, join89(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -33673,25 +33702,25 @@ function move(file, options2) {
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename23(file);
-  const sourcePath = join88(vttDir, filename);
-  if (!existsSync74(sourcePath)) {
+  const sourcePath = join89(vttDir, filename);
+  if (!existsSync75(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
   const base = basename23(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join88(transcriptsDir, client);
+  const formattedDir = join89(transcriptsDir, client);
   mkdirSync29(formattedDir, { recursive: true });
-  const formattedPath = join88(formattedDir, outputName);
+  const formattedPath = join89(formattedDir, outputName);
   writeFileSync46(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join88(summaryDir, client, outputName);
+  const summaryPath = join89(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
 
 // src/commands/transcript/merge.ts
-import { existsSync as existsSync75, writeFileSync as writeFileSync47 } from "fs";
+import { existsSync as existsSync76, writeFileSync as writeFileSync47 } from "fs";
 import { basename as basename24 } from "path";
 
 // src/commands/transcript/failTranscript.ts
@@ -33835,7 +33864,7 @@ function widenAudience(passages) {
 
 // src/commands/transcript/merge.ts
 function readSource2(file) {
-  if (!existsSync75(file)) failTranscript(`VTT file not found: ${file}`);
+  if (!existsSync76(file)) failTranscript(`VTT file not found: ${file}`);
   const cues = readCleanedCues(file);
   if (cues.length === 0) failTranscript(`no cues found in: ${file}`);
   return { path: file, name: basename24(file), cues };
@@ -33999,45 +34028,45 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync9 } from "child_process";
-import { join as join90 } from "path";
+import { join as join91 } from "path";
 
 // src/commands/voice/shared.ts
 import { homedir as homedir25 } from "os";
-import { dirname as dirname37, join as join89 } from "path";
+import { dirname as dirname37, join as join90 } from "path";
 import { fileURLToPath as fileURLToPath10 } from "url";
 var __dirname6 = dirname37(fileURLToPath10(import.meta.url));
-var VOICE_DIR = join89(homedir25(), ".assist", "voice");
+var VOICE_DIR = join90(homedir25(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join89(VOICE_DIR, "voice.pid"),
-  log: join89(VOICE_DIR, "voice.log"),
-  venv: join89(VOICE_DIR, ".venv"),
-  lock: join89(VOICE_DIR, "voice.lock")
+  pid: join90(VOICE_DIR, "voice.pid"),
+  log: join90(VOICE_DIR, "voice.log"),
+  venv: join90(VOICE_DIR, ".venv"),
+  lock: join90(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join89(__dirname6, "commands", "voice", "python");
+  return join90(__dirname6, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join89(voicePaths.venv, "Scripts", "python.exe") : join89(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join90(voicePaths.venv, "Scripts", "python.exe") : join90(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join89(getLockDir(), "voice.lock");
+  return join90(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join90(getPythonDir(), "list_devices.py");
+  const script = join91(getPythonDir(), "list_devices.py");
   spawnSync9(getVenvPython(), [script], { stdio: "inherit" });
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync76, readFileSync as readFileSync57 } from "fs";
+import { existsSync as existsSync77, readFileSync as readFileSync57 } from "fs";
 function logs(options2) {
-  if (!existsSync76(voicePaths.log)) {
+  if (!existsSync77(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
@@ -34065,12 +34094,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync10 } from "child_process";
 import { mkdirSync as mkdirSync31 } from "fs";
-import { join as join92 } from "path";
+import { join as join93 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync60 } from "child_process";
-import { existsSync as existsSync77, mkdirSync as mkdirSync30, readFileSync as readFileSync58, writeFileSync as writeFileSync48 } from "fs";
-import { join as join91 } from "path";
+import { existsSync as existsSync78, mkdirSync as mkdirSync30, readFileSync as readFileSync58, writeFileSync as writeFileSync48 } from "fs";
+import { join as join92 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -34081,7 +34110,7 @@ function isProcessAlive2(pid) {
 }
 function checkLockFile() {
   const lockFile = getLockFile();
-  if (!existsSync77(lockFile)) return;
+  if (!existsSync78(lockFile)) return;
   try {
     const lock2 = JSON.parse(readFileSync58(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
@@ -34094,7 +34123,7 @@ function checkLockFile() {
   }
 }
 function bootstrapVenv() {
-  if (existsSync77(getVenvPython())) return;
+  if (existsSync78(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
   execSync60(
@@ -34107,7 +34136,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync30(join91(lockFile, ".."), { recursive: true });
+  mkdirSync30(join92(lockFile, ".."), { recursive: true });
   writeFileSync48(
     lockFile,
     JSON.stringify({
@@ -34123,7 +34152,7 @@ function setup() {
   mkdirSync31(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join92(getPythonDir(), "setup_models.py");
+  const script = join93(getPythonDir(), "setup_models.py");
   const result = spawnSync10(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -34137,7 +34166,7 @@ function setup() {
 // src/commands/voice/start.ts
 import { spawn as spawn8 } from "child_process";
 import { mkdirSync as mkdirSync32, writeFileSync as writeFileSync49 } from "fs";
-import { join as join93 } from "path";
+import { join as join94 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -34175,7 +34204,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join93(getPythonDir(), "voice_daemon.py");
+  const script = join94(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -34185,7 +34214,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync78, readFileSync as readFileSync59 } from "fs";
+import { existsSync as existsSync79, readFileSync as readFileSync59 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -34195,12 +34224,12 @@ function isProcessAlive3(pid) {
   }
 }
 function readRecentLogs(count8) {
-  if (!existsSync78(voicePaths.log)) return [];
+  if (!existsSync79(voicePaths.log)) return [];
   const lines2 = readFileSync59(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
-  if (!existsSync78(voicePaths.pid)) {
+  if (!existsSync79(voicePaths.pid)) {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
@@ -34223,9 +34252,9 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync79, readFileSync as readFileSync60, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync80, readFileSync as readFileSync60, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
-  if (!existsSync79(voicePaths.pid)) {
+  if (!existsSync80(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
@@ -34242,7 +34271,7 @@ function stop2() {
   }
   try {
     const lockFile = getLockFile();
-    if (existsSync79(lockFile)) unlinkSync20(lockFile);
+    if (existsSync80(lockFile)) unlinkSync20(lockFile);
   } catch {
   }
   console.log("Voice daemon stopped");
@@ -34306,11 +34335,11 @@ function changedPaths(from, cwd) {
 }
 
 // src/commands/watch/readBuiltVersion.ts
-import { join as join94 } from "path";
+import { join as join95 } from "path";
 function readBuiltVersion(cwd) {
   try {
     const root = runGit3(["rev-parse", "--show-toplevel"], cwd);
-    return readPackageJson(join94(root, "package.json")).version ?? "unknown";
+    return readPackageJson(join95(root, "package.json")).version ?? "unknown";
   } catch {
     return "unknown";
   }
@@ -34367,11 +34396,11 @@ var webUiPrefix = "src/commands/sessions/web/ui/";
 var sessionsPrefix = "src/commands/sessions/";
 var rules = [
   {
-    matches: (path90) => path90.startsWith(webUiPrefix),
+    matches: (path91) => path91.startsWith(webUiPrefix),
     advice: "restart the web server, then hard-reload the browser tab"
   },
   {
-    matches: (path90) => path90.startsWith(sessionsPrefix) && !path90.startsWith(webUiPrefix),
+    matches: (path91) => path91.startsWith(sessionsPrefix) && !path91.startsWith(webUiPrefix),
     advice: "restart the daemon"
   }
 ];
@@ -34382,31 +34411,27 @@ function restartAdvice(paths) {
 // src/commands/watch/syncAdvice.ts
 var rules2 = [
   {
-    matches: (path90) => path90.startsWith("claude/commands/"),
+    matches: (path91) => path91.startsWith("claude/commands/"),
     reason: "claude/commands changed"
   },
   {
-    matches: (path90) => path90.startsWith("claude/skills/"),
+    matches: (path91) => path91.startsWith("claude/skills/"),
     reason: "claude/skills changed"
   },
   {
-    matches: (path90) => path90 === "claude/settings.json",
+    matches: (path91) => path91 === "claude/settings.json",
     reason: "claude/settings.json changed"
   },
   {
-    matches: (path90) => path90 === "claude/CLAUDE.md",
-    reason: "claude/CLAUDE.md changed"
-  },
-  {
-    matches: (path90) => path90 === "claude/design-system-prompt.md",
+    matches: (path91) => path91 === "claude/design-system-prompt.md",
     reason: "claude/design-system-prompt.md changed"
   },
   {
-    matches: (path90) => path90.startsWith("codex/"),
+    matches: (path91) => path91.startsWith("codex/"),
     reason: "codex sources changed"
   },
   {
-    matches: (path90) => path90.startsWith("pi/"),
+    matches: (path91) => path91.startsWith("pi/"),
     reason: "pi sources changed"
   }
 ];
@@ -34647,7 +34672,7 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/resolveRunCwd.ts
-import { existsSync as existsSync80 } from "fs";
+import { existsSync as existsSync81 } from "fs";
 import { resolve as resolve19 } from "path";
 var MissingRunCwdError = class extends Error {
   constructor(runName, cwd) {
@@ -34660,25 +34685,25 @@ var MissingRunCwdError = class extends Error {
 function resolveRunCwd(config, baseDir = runConfigBaseDir()) {
   if (!config.cwd) return void 0;
   const cwd = resolve19(baseDir, config.cwd);
-  if (!existsSync80(cwd)) throw new MissingRunCwdError(config.name, cwd);
+  if (!existsSync81(cwd)) throw new MissingRunCwdError(config.name, cwd);
   return cwd;
 }
 
 // src/commands/run/runCommandToCompletion.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync82 } from "fs";
+import { existsSync as existsSync83 } from "fs";
 
 // src/commands/run/resolveCommand.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import { existsSync as existsSync81 } from "fs";
-import { dirname as dirname38, join as join95, resolve as resolve20 } from "path";
+import { existsSync as existsSync82 } from "fs";
+import { dirname as dirname38, join as join96, resolve as resolve20 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync18("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve20(dirname38(gitPath), "..");
-    const gitBash = join95(gitRoot, "bin", "bash.exe");
-    if (existsSync81(gitBash)) return gitBash;
+    const gitBash = join96(gitRoot, "bin", "bash.exe");
+    if (existsSync82(gitBash)) return gitBash;
   } catch {
     return command;
   }
@@ -34688,7 +34713,7 @@ function resolveCommand2(command) {
 // src/commands/run/runCommandToCompletion.ts
 function runCommandToCompletion(command, args, env, cwd, quiet) {
   return new Promise((resolveResult) => {
-    if (cwd && !existsSync82(cwd)) {
+    if (cwd && !existsSync83(cwd)) {
       resolveResult({
         kind: "failed",
         message: `Failed to execute command: cwd ${cwd} does not exist`
@@ -35105,7 +35130,7 @@ async function auth() {
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync20 } from "child_process";
 import { readdirSync as readdirSync22, readFileSync as readFileSync61, statSync as statSync12 } from "fs";
-import { join as join96 } from "path";
+import { join as join97 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -35114,9 +35139,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path90 = join96(roamDir, name);
+    const path91 = join97(roamDir, name);
     try {
-      return { path: path90, mtimeMs: statSync12(path90).mtimeMs };
+      return { path: path91, mtimeMs: statSync12(path91).mtimeMs };
     } catch {
       return void 0;
     }
@@ -35131,7 +35156,7 @@ var PID_BY_APP = {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join96(appData, "Roam"));
+  const portFile = findPortFile(join97(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -35267,7 +35292,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync33, writeFileSync as writeFileSync50 } from "fs";
-import { join as join97 } from "path";
+import { join as join98 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -35328,7 +35353,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join97(".claude", "commands");
+  const dir = join98(".claude", "commands");
   mkdirSync33(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -35336,7 +35361,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join97(dir, `${name}.md`);
+  const filePath = join98(dir, `${name}.md`);
   writeFileSync50(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -35360,11 +35385,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path90 = process.argv[idx + 1];
+  const path91 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path90, prefix: prefix2 };
+  return { path: path91, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -35392,8 +35417,8 @@ function link2() {
 }
 
 // src/commands/run/remove.ts
-import { existsSync as existsSync83, unlinkSync as unlinkSync21 } from "fs";
-import { join as join98 } from "path";
+import { existsSync as existsSync84, unlinkSync as unlinkSync21 } from "fs";
+import { join as join99 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -35408,8 +35433,8 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join98(".claude", "commands", `${name}.md`);
-  if (existsSync83(filePath)) {
+  const filePath = join99(".claude", "commands", `${name}.md`);
+  if (existsSync84(filePath)) {
     unlinkSync21(filePath);
     console.log(`Deleted command file: ${filePath}`);
   }
@@ -35454,9 +35479,9 @@ function registerRun(program2) {
 
 // src/commands/screenshot/index.ts
 import { execSync as execSync62 } from "child_process";
-import { existsSync as existsSync84, mkdirSync as mkdirSync34, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
+import { existsSync as existsSync85, mkdirSync as mkdirSync34, unlinkSync as unlinkSync22, writeFileSync as writeFileSync51 } from "fs";
 import { tmpdir as tmpdir9 } from "os";
-import { join as join99, resolve as resolve21 } from "path";
+import { join as join100, resolve as resolve21 } from "path";
 import chalk229 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -35586,14 +35611,14 @@ Write-Output $OutputPath
 
 // src/commands/screenshot/index.ts
 function buildOutputPath(outputDir, processName) {
-  if (!existsSync84(outputDir)) {
+  if (!existsSync85(outputDir)) {
     mkdirSync34(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return resolve21(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join99(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join100(tmpdir9(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync51(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync62(
@@ -35937,12 +35962,12 @@ function toSessionRunInfo({
 }
 
 // src/commands/sessions/daemon/worktree/joinRefusal.ts
-import { existsSync as existsSync85 } from "fs";
+import { existsSync as existsSync86 } from "fs";
 function joinRefusal(session) {
   if (session.commandType === "run") return "a server run has no agent stream";
   if (session.closing === true) return "the session is closing";
   if (!session.cwd) return "the session has no working directory";
-  if (!existsSync85(session.cwd))
+  if (!existsSync86(session.cwd))
     return "the session's workspace no longer exists";
   return void 0;
 }
@@ -36106,26 +36131,26 @@ function sessionBase(id, status3) {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
-import { existsSync as existsSync87 } from "fs";
+import { existsSync as existsSync88 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
-import { chmodSync, existsSync as existsSync86, statSync as statSync13 } from "fs";
+import { chmodSync, existsSync as existsSync87, statSync as statSync13 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path85 from "path";
+import path86 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path85.join(path85.dirname(require4.resolve("node-pty")), "..");
-  const helper = path85.join(
+  const ptyRoot = path86.join(path86.dirname(require4.resolve("node-pty")), "..");
+  const helper = path86.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
     "spawn-helper"
   );
-  if (!existsSync86(helper)) return;
+  if (!existsSync87(helper)) return;
   const mode = statSync13(helper).mode;
   if ((mode & 73) === 0) chmodSync(helper, mode | 493);
 }
@@ -36161,7 +36186,7 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
   });
 }
 function refuseMissingCwd(cwd, sessionId) {
-  if (!cwd || existsSync87(cwd)) return;
+  if (!cwd || existsSync88(cwd)) return;
   daemonLog(
     `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
   );
@@ -36239,19 +36264,19 @@ function serverRunMeta(runName, cwd) {
 }
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs48 from "fs";
-import * as path86 from "path";
+import * as fs49 from "fs";
+import * as path87 from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
 var __filename5 = fileURLToPath11(import.meta.url);
-var __dirname7 = path86.dirname(__filename5);
+var __dirname7 = path87.dirname(__filename5);
 function readDesignSystemPrompt() {
-  const promptPath = path86.join(
+  const promptPath = path87.join(
     __dirname7,
     "..",
     "claude",
     "design-system-prompt.md"
   );
-  return fs48.readFileSync(promptPath, "utf8");
+  return fs49.readFileSync(promptPath, "utf8");
 }
 
 // src/commands/sessions/daemon/spawnClaude.ts
@@ -36343,17 +36368,17 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync89 } from "fs";
+import { existsSync as existsSync90 } from "fs";
 import { basename as basename25 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync88 } from "fs";
-import { join as join102 } from "path";
+import { existsSync as existsSync89 } from "fs";
+import { join as join103 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
 import { statSync as statSync14 } from "fs";
 import { rm as rm4 } from "fs/promises";
-import { join as join101 } from "path";
+import { join as join102 } from "path";
 async function deleteTreeDirectly(clone, worktreePath, why) {
   if (holdsAGitDirectoryRatherThanALink(worktreePath)) {
     const refusal = "it is a clone of its own, not a linked worktree";
@@ -36381,7 +36406,7 @@ async function deleteTreeDirectly(clone, worktreePath, why) {
   return { removed: true };
 }
 function holdsAGitDirectoryRatherThanALink(worktreePath) {
-  return statSync14(join101(worktreePath, ".git"), {
+  return statSync14(join102(worktreePath, ".git"), {
     throwIfNoEntry: false
   })?.isDirectory() === true;
 }
@@ -36417,7 +36442,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync88(join102(worktreePath, ".git")))
+  if (!existsSync89(join103(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";
@@ -36469,7 +36494,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync89(worktreePath)) {
+  if (!existsSync90(worktreePath)) {
     forgetWorktree(worktreePath);
     daemonLog(
       `worktree ${worktreePath} already gone; its record was forgotten`
@@ -36494,7 +36519,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync89(recorded)) return recorded;
+  if (recorded && existsSync90(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -36625,12 +36650,12 @@ function closeGateApplies(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync90, watch } from "fs";
+import { existsSync as existsSync91, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync90(common)) return void 0;
+  if (!common || !existsSync91(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -37121,10 +37146,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync91 } from "fs";
+import { existsSync as existsSync92 } from "fs";
 import { resolve as resolve22 } from "path";
 function exitDetail(session) {
-  if (session.cwd && !existsSync91(session.cwd))
+  if (session.cwd && !existsSync92(session.cwd))
     return `working directory ${session.cwd} no longer exists`;
   return missingRunConfigCwd(session);
 }
@@ -37138,7 +37163,7 @@ function missingRunConfigCwd(session) {
   const config = resolveRunConfig(session.runName, dir);
   if (!config?.cwd) return void 0;
   const configured = resolve22(runConfigBaseDirFrom(dir), config.cwd);
-  if (existsSync91(configured)) return void 0;
+  if (existsSync92(configured)) return void 0;
   return `run config "${config.name}": cwd ${configured} does not exist`;
 }
 
@@ -37175,7 +37200,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync92, mkdirSync as mkdirSync35, watch as watch2 } from "fs";
+import { existsSync as existsSync93, mkdirSync as mkdirSync35, watch as watch2 } from "fs";
 import { dirname as dirname40 } from "path";
 
 // src/commands/sessions/daemon/applyActivityToSession.ts
@@ -37237,8 +37262,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS2 = 50;
 function watchActivity(session, notify2, onClaudeSessionId) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path90 = activityPath(session.id);
-  const dir = dirname40(path90);
+  const path91 = activityPath(session.id);
+  const dir = dirname40(path91);
   try {
     mkdirSync35(dir, { recursive: true });
   } catch {
@@ -37248,7 +37273,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
   let timer = null;
   const read3 = () => {
     timer = null;
-    const activity2 = readActivity(path90);
+    const activity2 = readActivity(path91);
     if (!activity2) return;
     applyActivityToSession(session, activity2);
     if (activity2.claudeSessionId) onClaudeSessionId?.(session);
@@ -37257,11 +37282,11 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     notify2();
   };
   session.activityWatcher = watch2(dir, (_event, filename) => {
-    if (filename && !path90.endsWith(filename)) return;
+    if (filename && !path91.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read3, DEBOUNCE_MS2);
   });
-  if (existsSync92(path90)) read3();
+  if (existsSync93(path91)) read3();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -37340,7 +37365,7 @@ function reportSilentFailure(session, clients) {
 }
 
 // src/commands/sessions/shared/codex/resolveCodexSessionId.ts
-import * as fs49 from "fs";
+import * as fs50 from "fs";
 var META_LINES = 5;
 async function resolveCodexSessionId(cwd, sinceMs) {
   if (!cwd) return null;
@@ -37369,7 +37394,7 @@ async function startedIn(file, cwd, sinceMs) {
 }
 async function touchedSince(file, sinceMs) {
   try {
-    return (await fs49.promises.stat(file)).mtimeMs >= sinceMs;
+    return (await fs50.promises.stat(file)).mtimeMs >= sinceMs;
   } catch {
     return false;
   }
@@ -37403,42 +37428,42 @@ function bindCodexSession(session, notify2) {
 import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
-import * as fs50 from "fs";
-import * as path87 from "path";
+import * as fs51 from "fs";
+import * as path88 from "path";
 function projectDirForCwd(cwd) {
-  return path87.join(claudeProjectsRoot(), projectSlug(cwd));
+  return path88.join(claudeProjectsRoot(), projectSlug(cwd));
 }
 function transcriptPathFor(cwd, claudeSessionId) {
-  return path87.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
+  return path88.join(projectDirForCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
-  if (fs50.existsSync(direct)) return direct;
+  if (fs51.existsSync(direct)) return direct;
   const dir = projectDirForCwd(cwd);
   let files;
   try {
-    files = fs50.readdirSync(dir);
+    files = fs51.readdirSync(dir);
   } catch {
     return null;
   }
   for (const file of files) {
     if (!file.endsWith(".jsonl")) continue;
-    if (headContainsSessionId(path87.join(dir, file), claudeSessionId))
-      return path87.join(dir, file);
+    if (headContainsSessionId(path88.join(dir, file), claudeSessionId))
+      return path88.join(dir, file);
   }
   return null;
 }
 function headContainsSessionId(filePath, claudeSessionId) {
   let fd;
   try {
-    fd = fs50.openSync(filePath, "r");
+    fd = fs51.openSync(filePath, "r");
     const buf = Buffer.alloc(16384);
-    const bytesRead = fs50.readSync(fd, buf, 0, buf.length, 0);
+    const bytesRead = fs51.readSync(fd, buf, 0, buf.length, 0);
     return buf.toString("utf8", 0, bytesRead).includes(claudeSessionId);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) fs50.closeSync(fd);
+    if (fd !== void 0) fs51.closeSync(fd);
   }
 }
 
@@ -37608,7 +37633,7 @@ function asRecord3(value) {
 }
 
 // src/commands/sessions/shared/readTranscriptTail.ts
-import * as fs51 from "fs";
+import * as fs52 from "fs";
 var DEFAULT_MAX_BYTES = 256 * 1024;
 function parseTailEntries(raw) {
   const entries = [];
@@ -37632,7 +37657,7 @@ function dropPartialFirstLine(raw, sliced) {
 async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let handle;
   try {
-    handle = await fs51.promises.open(filePath, "r");
+    handle = await fs52.promises.open(filePath, "r");
     const { size } = await handle.stat();
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
@@ -37651,20 +37676,20 @@ async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
 function readTranscriptTailSync(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let fd;
   try {
-    fd = fs51.openSync(filePath, "r");
-    const { size } = fs51.fstatSync(fd);
+    fd = fs52.openSync(filePath, "r");
+    const { size } = fs52.fstatSync(fd);
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
     if (length === 0) return [];
     const buf = Buffer.alloc(length);
-    fs51.readSync(fd, buf, 0, length, start3);
+    fs52.readSync(fd, buf, 0, length, start3);
     return parseTailEntries(
       dropPartialFirstLine(buf.toString("utf8"), start3 > 0)
     );
   } catch {
     return [];
   } finally {
-    if (fd !== void 0) fs51.closeSync(fd);
+    if (fd !== void 0) fs52.closeSync(fd);
   }
 }
 
@@ -38043,7 +38068,7 @@ async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
 }
 
 // src/commands/sessions/shared/transcriptUsage.ts
-import * as fs52 from "fs";
+import * as fs53 from "fs";
 function transcriptUsage(lines2) {
   const byId = /* @__PURE__ */ new Map();
   for (const line of lines2) {
@@ -38067,7 +38092,7 @@ function transcriptUsage(lines2) {
   return [...byId.values()];
 }
 async function readTranscriptUsage(transcriptPath2) {
-  const content = await fs52.promises.readFile(transcriptPath2, "utf8");
+  const content = await fs53.promises.readFile(transcriptPath2, "utf8");
   return transcriptUsage(content.split("\n"));
 }
 
@@ -38598,9 +38623,9 @@ function tempRoots() {
   }
   return [...roots];
 }
-function underTempRoot(path90) {
+function underTempRoot(path91) {
   return tempRoots().some(
-    (root) => path90.startsWith(root.endsWith(sep2) ? root : root + sep2)
+    (root) => path91.startsWith(root.endsWith(sep2) ? root : root + sep2)
   );
 }
 
@@ -38984,7 +39009,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync95 } from "fs";
+import { existsSync as existsSync96 } from "fs";
 import { basename as basename27 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -39039,18 +39064,18 @@ function bindResumedWorktree(session, cwd, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync94 } from "fs";
+import { existsSync as existsSync95 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync94(clone)) {
-    for (const { path: path90 } of paths) forgetWorktree(path90);
+  if (!existsSync95(clone)) {
+    for (const { path: path91 } of paths) forgetWorktree(path91);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
     );
     return;
   }
   await pruneBookkeeping2(clone);
-  for (const { path: path90, branch: branch2 } of paths)
-    if (await reclaimBranch(clone, branch2)) forgetWorktree(path90);
+  for (const { path: path91, branch: branch2 } of paths)
+    if (await reclaimBranch(clone, branch2)) forgetWorktree(path91);
 }
 async function pruneBookkeeping2(clone) {
   try {
@@ -39077,37 +39102,37 @@ async function reclaimBranch(clone, branch2) {
 }
 
 // src/commands/sessions/daemon/worktree/logVanishedTree.ts
-function logVanishedTree(sessions, path90) {
+function logVanishedTree(sessions, path91) {
   const claimants = [...sessions.values()].filter(
-    (s) => s.cwd === path90 || s.worktree?.path === path90
+    (s) => s.cwd === path91 || s.worktree?.path === path91
   );
   if (claimants.length === 0) {
-    daemonLog(`worktree ${path90} gone from disk and unclaimed; reclaiming it`);
+    daemonLog(`worktree ${path91} gone from disk and unclaimed; reclaiming it`);
     return;
   }
   for (const s of claimants)
     daemonLog(
-      `session ${s.id} ("${s.name}") claims worktree ${path90}, which is gone from disk; reclaiming it`
+      `session ${s.id} ("${s.name}") claims worktree ${path91}, which is gone from disk; reclaiming it`
     );
 }
 
 // src/commands/sessions/daemon/worktree/describeHeldWork.ts
 var MAX_ITEMS = 20;
-async function describeHeldWork(path90, reason4) {
-  if (reason4.startsWith("uncommitted")) return await changedFiles(path90);
-  if (reason4.startsWith("unpushed")) return await unpushedCommits(path90, reason4);
+async function describeHeldWork(path91, reason4) {
+  if (reason4.startsWith("uncommitted")) return await changedFiles(path91);
+  if (reason4.startsWith("unpushed")) return await unpushedCommits(path91, reason4);
   return { summary: reason4, items: [] };
 }
-async function changedFiles(path90) {
-  const status3 = await gitResult(path90, ["status", "--porcelain"]);
+async function changedFiles(path91) {
+  const status3 = await gitResult(path91, ["status", "--porcelain"]);
   const lines2 = status3.ok ? nonEmptyLines(status3.out) : [];
   return {
     summary: `${lines2.length} uncommitted ${lines2.length === 1 ? "file" : "files"}`,
     items: capped(lines2)
   };
 }
-async function unpushedCommits(path90, reason4) {
-  const log2 = await gitResult(path90, ["log", "--oneline", "@{upstream}..HEAD"]);
+async function unpushedCommits(path91, reason4) {
+  const log2 = await gitResult(path91, ["log", "--oneline", "@{upstream}..HEAD"]);
   if (!log2.ok) return { summary: reason4, items: [] };
   const lines2 = nonEmptyLines(log2.out);
   return {
@@ -39199,24 +39224,24 @@ function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
 async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
-  for (const { path: path90, clone } of readWorktreeRegistry()) {
-    if (underTempRoot(path90)) {
-      forgetWorktree(path90);
+  for (const { path: path91, clone } of readWorktreeRegistry()) {
+    if (underTempRoot(path91)) {
+      forgetWorktree(path91);
       daemonLog(
-        `worktree ${path90} lies outside any project root; pruned from the registry rather than recovered`
+        `worktree ${path91} lies outside any project root; pruned from the registry rather than recovered`
       );
       continue;
     }
-    if (!existsSync95(path90)) {
-      logVanishedTree(sessions, path90);
+    if (!existsSync96(path91)) {
+      logVanishedTree(sessions, path91);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
-        { path: path90, branch: basename27(path90) }
+        { path: path91, branch: basename27(path91) }
       ]);
       continue;
     }
-    if (accounted.has(path90)) continue;
-    await recoverOrphan(sessions, spawnWith, { path: path90, clone }, notify2);
+    if (accounted.has(path91)) continue;
+    await recoverOrphan(sessions, spawnWith, { path: path91, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
     await reclaimVanishedWorktrees(clone, paths);
@@ -39391,7 +39416,6 @@ function createWatcherSession(id, cwd) {
     claudeSessionId,
     initialPrompt: WATCH_PROMPT,
     auto: true,
-    starred: true,
     watcher: true
   };
 }
@@ -39852,13 +39876,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync96, readFileSync as readFileSync64 } from "fs";
+import { existsSync as existsSync97, readFileSync as readFileSync64 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync96(sessionsFile)) return false;
+    if (!existsSync97(sessionsFile)) return false;
     const data = JSON.parse(readFileSync64(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -40593,7 +40617,7 @@ function setAutoAdvance(sessions, id, enabled) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
-import { existsSync as existsSync99 } from "fs";
+import { existsSync as existsSync100 } from "fs";
 
 // src/commands/sessions/daemon/resumeSession.ts
 function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
@@ -40624,11 +40648,11 @@ function resumeSession(id, sessionId, cwd, name, holdPty, harness) {
 }
 
 // src/commands/sessions/daemon/worktree/resumeInReplacementTree.ts
-import { existsSync as existsSync98 } from "fs";
+import { existsSync as existsSync99 } from "fs";
 
 // src/commands/sessions/daemon/worktree/carryTranscriptToTree.ts
-import { copyFileSync as copyFileSync6, existsSync as existsSync97, mkdirSync as mkdirSync37 } from "fs";
-import { join as join104 } from "path";
+import { copyFileSync as copyFileSync5, existsSync as existsSync98, mkdirSync as mkdirSync37 } from "fs";
+import { join as join105 } from "path";
 function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   const dir = projectDirForCwd(toCwd);
   if (dir === projectDirForCwd(fromCwd)) {
@@ -40637,8 +40661,8 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
     );
     return;
   }
-  const dest = join104(dir, `${claudeSessionId}.jsonl`);
-  if (existsSync97(dest)) {
+  const dest = join105(dir, `${claudeSessionId}.jsonl`);
+  if (existsSync98(dest)) {
     daemonLog(`transcript ${claudeSessionId} already present in ${dir}`);
     return;
   }
@@ -40651,7 +40675,7 @@ function carryTranscriptToTree(claudeSessionId, fromCwd, toCwd) {
   }
   try {
     mkdirSync37(dir, { recursive: true });
-    copyFileSync6(source, dest);
+    copyFileSync5(source, dest);
     daemonLog(
       `transcript ${source} copied to ${dest} so ${toCwd} can resume it`
     );
@@ -40689,7 +40713,7 @@ function resumeInReplacementTree(ctx, claudeSessionId, missingCwd, name, harness
 }
 function cloneForReapedTree(missingCwd) {
   const clone = worktreeAttributionIncludingReaped(missingCwd)?.clone;
-  if (!clone || !existsSync98(clone))
+  if (!clone || !existsSync99(clone))
     throw new Error(
       `working directory no longer exists and no clone is recorded to re-allocate from: ${missingCwd}`
     );
@@ -40698,7 +40722,7 @@ function cloneForReapedTree(missingCwd) {
 
 // src/commands/sessions/daemon/worktree/resumeInTree.ts
 function resumeInTree(ctx, sessionId, cwd, name, harness) {
-  if (!existsSync99(cwd))
+  if (!existsSync100(cwd))
     return resumeInReplacementTree(ctx, sessionId, cwd, name, harness);
   const id = ctx.spawnWith(
     (sid) => resumeSession(sid, sessionId, cwd, name, void 0, harness)
@@ -40965,15 +40989,15 @@ function handleSetStatus(client, m, d) {
 }
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs53 from "fs";
+import * as fs54 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
-import * as path88 from "path";
+import * as path89 from "path";
 async function findCodexRolloutPath(sessionId) {
   if (!sessionId) return null;
   const paths = await discoverCodexRolloutPaths();
   const suffix = `-${sessionId}.jsonl`;
-  return paths.find((file) => path88.basename(file).endsWith(suffix)) ?? null;
+  return paths.find((file) => path89.basename(file).endsWith(suffix)) ?? null;
 }
 
 // src/commands/sessions/shared/codex/codexToolTarget.ts
@@ -41048,7 +41072,7 @@ async function parseTranscript(sessionId) {
 }
 async function readMessages(filePath, parse4) {
   try {
-    const raw = await fs53.promises.readFile(filePath, "utf8");
+    const raw = await fs54.promises.readFile(filePath, "utf8");
     return parse4(raw.split("\n"));
   } catch {
     return [];
@@ -41576,17 +41600,17 @@ async function renameSession(title) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs55 from "fs";
+import * as fs56 from "fs";
 import chalk230 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs54 from "fs";
+import * as fs55 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs54.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs55.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs54.existsSync(summaryPathFor(jsonlPath2));
+  return fs55.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -41658,7 +41682,7 @@ function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs55.statSync(b).mtimeMs - fs55.statSync(a).mtimeMs;
+      return fs56.statSync(b).mtimeMs - fs56.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -41789,9 +41813,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync67, statSync as statSync16 } from "fs";
-import { isAbsolute as isAbsolute5, join as join105, resolve as resolve23 } from "path";
+import { isAbsolute as isAbsolute5, join as join106, resolve as resolve23 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join105(cwd, ".git");
+  const dotGit = join106(cwd, ".git");
   let stat4;
   try {
     stat4 = statSync16(dotGit);
@@ -41821,7 +41845,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync67(join105(gitDir, "HEAD"), "utf8");
+    head = readFileSync67(join106(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -41890,7 +41914,7 @@ async function statusLine() {
 
 // src/commands/update.ts
 import { execSync as execSync63 } from "child_process";
-import * as path89 from "path";
+import * as path90 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -41909,12 +41933,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path89.resolve(dir);
-    if (resolved.split(path89.sep).includes("node_modules")) {
+    const resolved = path90.resolve(dir);
+    if (resolved.split(path90.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync63("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path89.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path90.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }