@staff0rd/assist 0.288.0 → 0.288.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.288.0",
+  version: "0.288.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -124,10 +124,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path54) {
-  if (!existsSync(path54)) return {};
+function loadRawYaml(path56) {
+  if (!existsSync(path56)) return {};
   try {
-    const content = readFileSync(path54, "utf-8");
+    const content = readFileSync(path56, "utf-8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -3110,9 +3110,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path54 = join11(dir, ".assist", name);
-    if (existsSync15(path54)) {
-      renameSync(path54, `${path54}.bak`);
+    const path56 = join11(dir, ".assist", name);
+    if (existsSync15(path56)) {
+      renameSync(path56, `${path56}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -3402,8 +3402,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path54) {
-  const content = readFileSync10(path54, "utf-8").trim();
+function parseBacklogJsonl(path56) {
+  const content = readFileSync10(path56, "utf-8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -3477,9 +3477,9 @@ function findBacklogUp(startDir) {
 }
 
 // src/commands/backlog/getCurrentOrigin.ts
-import { execSync as execSync18 } from "child_process";
-function stripLeadingSlashes(path54) {
-  return path54.replace(/^\/+/, "");
+import { execFileSync } from "child_process";
+function stripLeadingSlashes(path56) {
+  return path56.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -3498,11 +3498,14 @@ function normalizeOrigin(raw) {
   return trimmed.toLowerCase();
 }
 function tryGit(cwd, args) {
+  const windows = /^[A-Za-z]:[\\/]/.test(cwd);
+  const file = windows ? "git.exe" : "git";
+  const argv = windows ? ["-C", cwd, ...args] : args;
   try {
-    const out = execSync18(`git ${args}`, {
-      cwd,
+    const out = execFileSync(file, argv, {
       encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      ...windows ? {} : { cwd }
     }).trim();
     return out || null;
   } catch {
@@ -3510,18 +3513,18 @@ function tryGit(cwd, args) {
   }
 }
 function firstRemoteUrl(cwd) {
-  const remotes = tryGit(cwd, "remote");
+  const remotes = tryGit(cwd, ["remote"]);
   if (!remotes) return null;
   for (const remote of remotes.split("\n").map((r) => r.trim()).filter(Boolean)) {
-    const url = tryGit(cwd, `remote get-url ${remote}`);
+    const url = tryGit(cwd, ["remote", "get-url", remote]);
     if (url) return url;
   }
   return null;
 }
 function getCurrentOrigin(cwd) {
-  const url = tryGit(cwd, "remote get-url origin") ?? firstRemoteUrl(cwd);
+  const url = tryGit(cwd, ["remote", "get-url", "origin"]) ?? firstRemoteUrl(cwd);
   if (url) return normalizeOrigin(url);
-  const root = tryGit(cwd, "rev-parse --show-toplevel");
+  const root = tryGit(cwd, ["rev-parse", "--show-toplevel"]);
   return `local:${root ?? cwd}`;
 }
 
@@ -3743,13 +3746,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path54 = activityPath(sessionId);
-  mkdirSync6(dirname14(path54), { recursive: true });
-  writeFileSync13(path54, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path56 = activityPath(sessionId);
+  mkdirSync6(dirname14(path56), { recursive: true });
+  writeFileSync13(path56, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path54) {
+function readActivity(path56) {
   try {
-    return JSON.parse(readFileSync11(path54, "utf-8"));
+    return JSON.parse(readFileSync11(path56, "utf-8"));
   } catch {
     return void 0;
   }
@@ -3909,10 +3912,10 @@ function writeSignal(event, data) {
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path54 = getSignalPath();
-  if (!existsSync19(path54)) return void 0;
+  const path56 = getSignalPath();
+  if (!existsSync19(path56)) return void 0;
   try {
-    return JSON.parse(readFileSync12(path54, "utf-8"));
+    return JSON.parse(readFileSync12(path56, "utf-8"));
   } catch {
     return void 0;
   }
@@ -4369,7 +4372,7 @@ function printComments(item) {
 import { WebSocketServer } from "ws";
 
 // src/shared/getInstallDir.ts
-import { execSync as execSync19 } from "child_process";
+import { execSync as execSync18 } from "child_process";
 import { dirname as dirname15, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __filename2 = fileURLToPath3(import.meta.url);
@@ -4379,7 +4382,7 @@ function getInstallDir() {
 }
 function isGitRepo(dir) {
   try {
-    const result = execSync19("git rev-parse --show-toplevel", {
+    const result = execSync18("git rev-parse --show-toplevel", {
       cwd: dir,
       stdio: "pipe"
     }).toString().trim();
@@ -4396,11 +4399,11 @@ import {
 import chalk43 from "chalk";
 
 // src/lib/openBrowser.ts
-import { execSync as execSync20 } from "child_process";
+import { execSync as execSync19 } from "child_process";
 function tryExec(commands) {
   for (const cmd of commands) {
     try {
-      execSync20(cmd, { stdio: "ignore" });
+      execSync19(cmd, { stdio: "ignore" });
       return true;
     } catch {
     }
@@ -4932,7 +4935,7 @@ function getHtml() {
 }
 
 // src/commands/prs/getPreferredRemoteRepo.ts
-import { execSync as execSync21 } from "child_process";
+import { execSync as execSync20 } from "child_process";
 var GITHUB_URL_PATTERN = /(?:git@github\.com:|https:\/\/github\.com\/)([^/]+)\/([^/]+?)(?:\.git)?\/?$/;
 function parseGitHubUrl(url) {
   const match = url.match(GITHUB_URL_PATTERN);
@@ -4941,7 +4944,7 @@ function parseGitHubUrl(url) {
 }
 function tryGetRemoteUrl(remote, cwd) {
   try {
-    return execSync21(`git remote get-url ${remote}`, {
+    return execSync20(`git remote get-url ${remote}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       cwd
@@ -4952,7 +4955,7 @@ function tryGetRemoteUrl(remote, cwd) {
 }
 function getCurrentBranchRemote(cwd) {
   try {
-    const ref = execSync21(
+    const ref = execSync20(
       "git rev-parse --abbrev-ref --symbolic-full-name @{u}",
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], cwd }
     ).trim();
@@ -4964,7 +4967,7 @@ function getCurrentBranchRemote(cwd) {
 }
 function listRemotes(cwd) {
   try {
-    return execSync21("git remote", {
+    return execSync20("git remote", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       cwd
@@ -6251,8 +6254,8 @@ import chalk57 from "chalk";
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path54 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path54.split("/").filter(Boolean);
+    const path56 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path56.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -7555,9 +7558,9 @@ var __dirname5 = dirname17(__filename3);
 function packageRoot() {
   return __dirname5;
 }
-function readLines(path54) {
-  if (!existsSync22(path54)) return [];
-  return readFileSync16(path54, "utf-8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path56) {
+  if (!existsSync22(path56)) return [];
+  return readFileSync16(path56, "utf-8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -7888,7 +7891,7 @@ import { homedir as homedir9 } from "os";
 import { join as join22 } from "path";
 
 // src/shared/checkCliAvailable.ts
-import { execSync as execSync22 } from "child_process";
+import { execSync as execSync21 } from "child_process";
 function checkCliAvailable(cli) {
   const binary = cli.split(/\s+/)[0];
   const opts = {
@@ -7896,11 +7899,11 @@ function checkCliAvailable(cli) {
     stdio: ["ignore", "pipe", "pipe"]
   };
   try {
-    execSync22(`command -v ${binary}`, opts);
+    execSync21(`command -v ${binary}`, opts);
     return true;
   } catch {
     try {
-      execSync22(`where ${binary}`, opts);
+      execSync21(`where ${binary}`, opts);
       return true;
     } catch {
       return false;
@@ -8022,14 +8025,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, path54, description, depth, p) {
-  showProgress(p, path54.join(" "));
-  const subHelp = await runHelp([cli, ...path54]);
+async function resolveCommand(cli, path56, description, depth, p) {
+  showProgress(p, path56.join(" "));
+  const subHelp = await runHelp([cli, ...path56]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path54, description }];
+    return [{ path: path56, description }];
   }
-  const children = await discoverAt(cli, path54, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path54, description }];
+  const children = await discoverAt(cli, path56, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path56, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -8177,9 +8180,9 @@ function logPath(cli) {
   return join22(homedir9(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path54 = logPath(cli);
-  if (!existsSync24(path54)) return void 0;
-  return readFileSync18(path54, "utf-8");
+  const path56 = logPath(cli);
+  if (!existsSync24(path56)) return void 0;
+  return readFileSync18(path56, "utf-8");
 }
 function writeCache(cli, output) {
   const dir = join22(homedir9(), ".assist");
@@ -8868,8 +8871,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path54, value) {
-  const keys = path54.split(".");
+function setNestedValue(obj, path56, value) {
+  const keys = path56.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -8949,9 +8952,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path54) {
+function getNestedValue(obj, path56) {
   let current = obj;
-  for (const key of path54.split(".")) current = stepInto(current, key);
+  for (const key of path56.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -9021,7 +9024,7 @@ function registerDeploy(program2) {
 }
 
 // src/commands/devlog/list/index.ts
-import { execFileSync } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { basename as basename4 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
@@ -9036,7 +9039,7 @@ function loadBlogSkipDays(repoName) {
 }
 
 // src/commands/devlog/shared.ts
-import { execSync as execSync23 } from "child_process";
+import { execSync as execSync22 } from "child_process";
 import chalk92 from "chalk";
 
 // src/shared/getRepoName.ts
@@ -9128,7 +9131,7 @@ function loadAllDevlogLatestDates() {
 // src/commands/devlog/shared.ts
 function getCommitFiles(hash) {
   try {
-    const output = execSync23(`git show --name-only --format="" ${hash}`, {
+    const output = execSync22(`git show --name-only --format="" ${hash}`, {
       encoding: "utf-8"
     });
     return output.trim().split("\n").filter(Boolean);
@@ -9201,7 +9204,7 @@ function list3(options2) {
   if (options2.reverse) args.push("--reverse");
   else args.push("-n", "500");
   args.push("--pretty=format:%ad|%h|%s", "--date=short");
-  const output = execFileSync("git", args, { encoding: "utf-8" });
+  const output = execFileSync2("git", args, { encoding: "utf-8" });
   const commitsByDate = parseGitLogCommits(output, ignore2);
   let dateCount = 0;
   let isFirst = true;
@@ -9224,11 +9227,11 @@ function list3(options2) {
 }
 
 // src/commands/devlog/getLastVersionInfo.ts
-import { execFileSync as execFileSync2, execSync as execSync24 } from "child_process";
+import { execFileSync as execFileSync3, execSync as execSync23 } from "child_process";
 import semver from "semver";
 function getVersionAtCommit(hash) {
   try {
-    const content = execSync24(`git show ${hash}:package.json`, {
+    const content = execSync23(`git show ${hash}:package.json`, {
       encoding: "utf-8"
     });
     const pkg = JSON.parse(content);
@@ -9243,7 +9246,7 @@ function stripToMinor(version2) {
 }
 function getLastVersionInfoFromGit() {
   try {
-    const output = execFileSync2(
+    const output = execFileSync3(
       "git",
       ["log", "-1", "--pretty=format:%ad|%h", "--date=short"],
       {
@@ -9288,7 +9291,7 @@ function bumpVersion(version2, type) {
 }
 
 // src/commands/devlog/next/displayNextEntry/index.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync4 } from "child_process";
 import chalk95 from "chalk";
 
 // src/commands/devlog/next/displayNextEntry/displayVersion.ts
@@ -9322,7 +9325,7 @@ function findTargetDate(commitsByDate, skipDays) {
   return Array.from(commitsByDate.keys()).filter((d) => !skipDays.has(d)).sort()[0];
 }
 function fetchCommitsByDate(ignore2, lastDate) {
-  const output = execFileSync3(
+  const output = execFileSync4(
     "git",
     ["log", "--pretty=format:%ad|%h|%s", "--date=short", "-n", "500"],
     { encoding: "utf-8" }
@@ -9401,7 +9404,7 @@ function next2(options2) {
 }
 
 // src/commands/devlog/repos/index.ts
-import { execSync as execSync25 } from "child_process";
+import { execSync as execSync24 } from "child_process";
 
 // src/commands/devlog/repos/printReposTable.ts
 import chalk96 from "chalk";
@@ -9436,7 +9439,7 @@ function getStatus(lastPush, lastDevlog) {
   return lastDevlog < lastPush ? "outdated" : "ok";
 }
 function fetchRepos(days, all) {
-  const json = execSync25(
+  const json = execSync24(
     "gh repo list staff0rd --json name,pushedAt,isArchived --limit 200",
     { encoding: "utf-8" }
   );
@@ -9796,7 +9799,7 @@ async function deps(csprojPath, options2) {
 }
 
 // src/commands/dotnet/getChangedCsFiles.ts
-import { execSync as execSync26 } from "child_process";
+import { execSync as execSync25 } from "child_process";
 var SCOPE_ALL = "all";
 var SCOPE_BASE = "base:";
 var SCOPE_COMMIT = "commit:";
@@ -9820,7 +9823,7 @@ function getChangedCsFiles(scope) {
   } else {
     cmd = "git diff --name-only HEAD";
   }
-  const output = execSync26(cmd, { encoding: "utf-8" }).trim();
+  const output = execSync25(cmd, { encoding: "utf-8" }).trim();
   if (output === "") return [];
   return output.split("\n").filter((f) => f.toLowerCase().endsWith(".cs"));
 }
@@ -10018,14 +10021,14 @@ function parseInspectReport(json) {
 }
 
 // src/commands/dotnet/runInspectCode.ts
-import { execSync as execSync27 } from "child_process";
+import { execSync as execSync26 } from "child_process";
 import { existsSync as existsSync30, readFileSync as readFileSync24, unlinkSync as unlinkSync7 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import path25 from "path";
 import chalk106 from "chalk";
 function assertJbInstalled() {
   try {
-    execSync27("jb inspectcode --version", { stdio: "pipe" });
+    execSync26("jb inspectcode --version", { stdio: "pipe" });
   } catch {
     console.error(chalk106.red("jb is not installed. Install with:"));
     console.error(
@@ -10039,7 +10042,7 @@ function runInspectCode(slnPath, include, swea) {
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
-    execSync27(
+    execSync26(
       `jb inspectcode "${slnPath}" -o="${reportPath}"${includeFlag}${sweaFlag} --verbosity=OFF`,
       { stdio: "pipe" }
     );
@@ -10060,7 +10063,7 @@ function runInspectCode(slnPath, include, swea) {
 }
 
 // src/commands/dotnet/runRoslynInspect.ts
-import { execSync as execSync28 } from "child_process";
+import { execSync as execSync27 } from "child_process";
 import chalk107 from "chalk";
 function resolveMsbuildPath() {
   const { run: run4 } = loadConfig();
@@ -10071,7 +10074,7 @@ function resolveMsbuildPath() {
 function assertMsbuildInstalled() {
   const msbuild = resolveMsbuildPath();
   try {
-    execSync28(`"${msbuild}" -version`, { stdio: "pipe" });
+    execSync27(`"${msbuild}" -version`, { stdio: "pipe" });
   } catch {
     console.error(chalk107.red(`msbuild not found at: ${msbuild}`));
     console.error(
@@ -10097,7 +10100,7 @@ function runRoslynInspect(slnPath) {
   const msbuild = resolveMsbuildPath();
   let output;
   try {
-    output = execSync28(
+    output = execSync27(
       `"${msbuild}" "${slnPath}" -t:Build -v:minimal -maxcpucount -p:EnforceCodeStyleInBuild=true -p:RunAnalyzersDuringBuild=true 2>&1`,
       { encoding: "utf-8", stdio: "pipe", maxBuffer: 50 * 1024 * 1024 }
     );
@@ -10469,7 +10472,7 @@ function resolveLoadOptions(options2) {
 }
 
 // src/commands/handover/summarise.ts
-import { execFileSync as execFileSync4 } from "child_process";
+import { execFileSync as execFileSync5 } from "child_process";
 
 // src/commands/sessions/summarise/iterateUserEntries.ts
 import * as fs16 from "fs";
@@ -10534,7 +10537,7 @@ function summarise(jsonlPath2) {
   const prompt = `${PROMPT_TEMPLATE}
 ${payload}`;
   try {
-    const output = execFileSync4("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync5("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"],
@@ -10675,12 +10678,12 @@ function adfToText(doc) {
 }
 
 // src/commands/jira/fetchIssue.ts
-import { execSync as execSync29 } from "child_process";
+import { execSync as execSync28 } from "child_process";
 import chalk111 from "chalk";
 function fetchIssue(issueKey, fields) {
   let result;
   try {
-    result = execSync29(
+    result = execSync28(
       `acli jira workitem view ${issueKey} -f ${fields} --json`,
       { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -10726,7 +10729,7 @@ function acceptanceCriteria(issueKey) {
 }
 
 // src/commands/jira/jiraAuth.ts
-import { execSync as execSync30 } from "child_process";
+import { execSync as execSync29 } from "child_process";
 
 // src/shared/loadJson.ts
 import { existsSync as existsSync33, mkdirSync as mkdirSync11, readFileSync as readFileSync27, writeFileSync as writeFileSync21 } from "fs";
@@ -10739,10 +10742,10 @@ function getStorePath(filename) {
   return join32(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path54 = getStorePath(filename);
-  if (existsSync33(path54)) {
+  const path56 = getStorePath(filename);
+  if (existsSync33(path56)) {
     try {
-      return JSON.parse(readFileSync27(path54, "utf-8"));
+      return JSON.parse(readFileSync27(path56, "utf-8"));
     } catch {
       return {};
     }
@@ -10790,7 +10793,7 @@ async function jiraAuth() {
       console.error("All fields are required.");
       process.exit(1);
     }
-    execSync30(`acli jira auth login --site ${site} --email "${email}" --token`, {
+    execSync29(`acli jira auth login --site ${site} --email "${email}" --token`, {
       encoding: "utf-8",
       input: token,
       stdio: ["pipe", "inherit", "inherit"]
@@ -10841,12 +10844,12 @@ function registerJira(program2) {
 }
 
 // src/commands/reviewComments.ts
-import { execFileSync as execFileSync5 } from "child_process";
+import { execFileSync as execFileSync6 } from "child_process";
 import chalk114 from "chalk";
 async function reviewComments(number) {
   if (number) {
     try {
-      execFileSync5("gh", ["pr", "checkout", number], { stdio: "inherit" });
+      execFileSync6("gh", ["pr", "checkout", number], { stdio: "inherit" });
     } catch {
       console.error(chalk114.red(`gh pr checkout ${number} failed; aborting.`));
       process.exit(1);
@@ -11085,7 +11088,7 @@ function registerPrompts(program2) {
 }
 
 // src/commands/prs/shared.ts
-import { execSync as execSync31 } from "child_process";
+import { execSync as execSync30 } from "child_process";
 function isGhNotInstalled(error) {
   if (error instanceof Error) {
     const msg = error.message.toLowerCase();
@@ -11103,12 +11106,12 @@ function getRepoInfo() {
   const preferred = getPreferredRemoteRepo();
   if (preferred) return preferred;
   const repoInfo = JSON.parse(
-    execSync31("gh repo view --json owner,name", { encoding: "utf-8" })
+    execSync30("gh repo view --json owner,name", { encoding: "utf-8" })
   );
   return { org: repoInfo.owner.login, repo: repoInfo.name };
 }
 function getCurrentBranch() {
-  return execSync31("git rev-parse --abbrev-ref HEAD", {
+  return execSync30("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf-8"
   }).trim();
 }
@@ -11116,7 +11119,7 @@ function viewCurrentPr(fields) {
   const { org, repo } = getRepoInfo();
   const branch = getCurrentBranch();
   return JSON.parse(
-    execSync31(`gh pr view ${branch} --json ${fields} -R ${org}/${repo}`, {
+    execSync30(`gh pr view ${branch} --json ${fields} -R ${org}/${repo}`, {
       encoding: "utf-8"
     })
   );
@@ -11200,15 +11203,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path54, line, body, startLine) {
+function comment2(path56, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path54, line, startLine });
+    postComment({ prId, body, path: path56, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path54}:${range}`);
+    console.log(`Added review comment on ${path56}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -11220,7 +11223,7 @@ function comment2(path54, line, body, startLine) {
 }
 
 // src/commands/prs/edit.ts
-import { execSync as execSync32 } from "child_process";
+import { execSync as execSync31 } from "child_process";
 
 // src/commands/prs/buildPrBody.ts
 function jiraBrowseUrl(key) {
@@ -11346,17 +11349,17 @@ function edit(options2) {
   if (options2.title) args.push(`--title ${shellQuote(options2.title)}`);
   args.push(`--body ${shellQuote(newBody)}`);
   try {
-    execSync32(args.join(" "), { stdio: "inherit" });
+    execSync31(args.join(" "), { stdio: "inherit" });
   } catch (_error) {
     process.exit(1);
   }
 }
 
 // src/commands/prs/fixed.ts
-import { execSync as execSync34 } from "child_process";
+import { execSync as execSync33 } from "child_process";
 
 // src/commands/prs/resolveCommentWithReply.ts
-import { execSync as execSync33 } from "child_process";
+import { execSync as execSync32 } from "child_process";
 import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
 import { join as join34 } from "path";
@@ -11386,7 +11389,7 @@ function deleteCommentsCache(prNumber) {
 
 // src/commands/prs/resolveCommentWithReply.ts
 function replyToComment(org, repo, prNumber, commentId, message) {
-  execSync33(
+  execSync32(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/comments -f body="${message.replace(/"/g, '\\"')}" -F in_reply_to=${commentId}`,
     { stdio: ["inherit", "pipe", "inherit"] }
   );
@@ -11396,7 +11399,7 @@ function resolveThread(threadId) {
   const queryFile = join34(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync23(queryFile, mutation);
   try {
-    execSync33(
+    execSync32(
       `gh api graphql -F query=@${queryFile} -f threadId="${threadId}"`,
       { stdio: ["inherit", "pipe", "inherit"] }
     );
@@ -11448,7 +11451,7 @@ function resolveCommentWithReply(commentId, message) {
 // src/commands/prs/fixed.ts
 function verifySha(sha) {
   try {
-    return execSync34(`git rev-parse --verify ${sha}`, {
+    return execSync33(`git rev-parse --verify ${sha}`, {
       encoding: "utf-8"
     }).trim();
   } catch {
@@ -11462,7 +11465,7 @@ function fixed(commentId, sha) {
     const { org, repo } = getRepoInfo();
     const repoUrl = `https://github.com/${org}/${repo}`;
     const message = `Fixed in [${fullSha}](${repoUrl}/commit/${fullSha})`;
-    execSync34("git push", { stdio: "inherit" });
+    execSync33("git push", { stdio: "inherit" });
     resolveCommentWithReply(commentId, message);
   } catch (error) {
     if (isGhNotInstalled(error)) {
@@ -11480,7 +11483,7 @@ import { join as join36 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
-import { execSync as execSync35 } from "child_process";
+import { execSync as execSync34 } from "child_process";
 import { unlinkSync as unlinkSync11, writeFileSync as writeFileSync24 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
 import { join as join35 } from "path";
@@ -11489,7 +11492,7 @@ function fetchThreadIds(org, repo, prNumber) {
   const queryFile = join35(tmpdir6(), `gh-query-${Date.now()}.graphql`);
   writeFileSync24(queryFile, THREAD_QUERY);
   try {
-    const result = execSync35(
+    const result = execSync34(
       `gh api graphql -F query=@${queryFile} -F owner="${org}" -F repo="${repo}" -F prNumber=${prNumber}`,
       { encoding: "utf-8" }
     );
@@ -11511,9 +11514,9 @@ function fetchThreadIds(org, repo, prNumber) {
 }
 
 // src/commands/prs/listComments/fetchReviewComments.ts
-import { execSync as execSync36 } from "child_process";
+import { execSync as execSync35 } from "child_process";
 function fetchJson(endpoint) {
-  const result = execSync36(`gh api --paginate ${endpoint}`, {
+  const result = execSync35(`gh api --paginate ${endpoint}`, {
     encoding: "utf-8"
   });
   if (!result.trim()) return [];
@@ -11652,7 +11655,7 @@ async function listComments() {
 }
 
 // src/commands/prs/prs/index.ts
-import { execSync as execSync37 } from "child_process";
+import { execSync as execSync36 } from "child_process";
 
 // src/commands/prs/prs/displayPaginated/index.ts
 import enquirer9 from "enquirer";
@@ -11759,7 +11762,7 @@ async function prs(options2) {
   const state = options2.open ? "open" : options2.closed ? "closed" : "all";
   try {
     const { org, repo } = getRepoInfo();
-    const result = execSync37(
+    const result = execSync36(
       `gh pr list --state ${state} --json number,title,url,author,createdAt,mergedAt,closedAt,state,changedFiles --limit 100 -R ${org}/${repo}`,
       { encoding: "utf-8" }
     );
@@ -11782,7 +11785,7 @@ async function prs(options2) {
 }
 
 // src/commands/prs/raise.ts
-import { execSync as execSync38 } from "child_process";
+import { execSync as execSync37 } from "child_process";
 
 // src/commands/prs/buildCreateArgs.ts
 function buildCreateArgs(title, body, options2) {
@@ -11842,14 +11845,14 @@ function raise(options2) {
     `--body ${shellQuote(body)}`
   ] : buildCreateArgs(options2.title, body, options2);
   try {
-    execSync38(args.join(" "), { stdio: "inherit" });
+    execSync37(args.join(" "), { stdio: "inherit" });
   } catch (_error) {
     process.exit(1);
   }
 }
 
 // src/commands/prs/wontfix.ts
-import { execSync as execSync39 } from "child_process";
+import { execSync as execSync38 } from "child_process";
 function validateReason(reason) {
   const lowerReason = reason.toLowerCase();
   if (lowerReason.includes("claude") || lowerReason.includes("opus")) {
@@ -11866,7 +11869,7 @@ function validateShaReferences(reason) {
   const invalidShas = [];
   for (const sha of shas) {
     try {
-      execSync39(`git cat-file -t ${sha}`, { stdio: "pipe" });
+      execSync38(`git cat-file -t ${sha}`, { stdio: "pipe" });
     } catch {
       invalidShas.push(sha);
     }
@@ -11950,8 +11953,8 @@ function registerPrs(program2) {
   prsCommand.command("wontfix <comment-id> <reason>").description("Reply with reason and resolve thread").action((commentId, reason) => {
     wontfix(Number.parseInt(commentId, 10), reason);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path54, line, body) => {
-    comment2(path54, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path56, line, body) => {
+    comment2(path56, Number.parseInt(line, 10), body);
   });
 }
 
@@ -12025,10 +12028,10 @@ import chalk124 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
-import { execSync as execSync40 } from "child_process";
+import { execSync as execSync39 } from "child_process";
 import chalk123 from "chalk";
 function opExec(args) {
-  return execSync40(`op ${args}`, {
+  return execSync39(`op ${args}`, {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"]
   }).trim();
@@ -12180,7 +12183,7 @@ ${errorText}`
 }
 
 // src/commands/ravendb/resolveOpSecret.ts
-import { execSync as execSync41 } from "child_process";
+import { execSync as execSync40 } from "child_process";
 import chalk128 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
@@ -12188,7 +12191,7 @@ function resolveOpSecret(reference) {
     process.exit(1);
   }
   try {
-    return execSync41(`op read "${reference}"`, {
+    return execSync40(`op read "${reference}"`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -12203,10 +12206,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path54) {
+async function ravenFetch(connection, path56) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path54}`;
+  const url = `${connection.url}${path56}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -12296,16 +12299,16 @@ import chalk132 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path54;
+  let path56;
   if (opts.collection) {
-    path54 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path56 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path54 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path56 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path54 += `&query=${encodeURIComponent(opts.query)}`;
+    path56 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path54;
+  return path56;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -12314,7 +12317,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 path54 = buildQueryPath({
+    const path56 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -12322,7 +12325,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path54);
+    const data = await ravenFetch(connection, path56);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -12437,7 +12440,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync42 } from "child_process";
+import { execSync as execSync41 } from "child_process";
 import fs18 from "fs";
 import { minimatch as minimatch5 } from "minimatch";
 
@@ -12487,7 +12490,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync42("git diff --cached --name-only", {
+    const staged = execSync41("git diff --cached --name-only", {
       encoding: "utf-8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -12495,7 +12498,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync42("git diff --name-only", { encoding: "utf-8" });
+    const unstaged = execSync41("git diff --name-only", { encoding: "utf-8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -13326,99 +13329,130 @@ function ignore(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import path34 from "path";
+import fs23 from "fs";
+import path38 from "path";
+import chalk141 from "chalk";
+
+// src/commands/refactor/rename/applyRename.ts
+import fs22 from "fs";
+import path35 from "path";
 import chalk139 from "chalk";
-async function rename(source, destination, options2 = {}) {
-  const destPath = path34.resolve(destination);
-  const cwd = process.cwd();
-  const relSource = path34.relative(cwd, path34.resolve(source));
-  const relDest = path34.relative(cwd, destPath);
-  const { project, sourceFile } = loadProjectFile(source);
-  console.log(chalk139.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  if (options2.apply) {
-    sourceFile.move(destPath);
-    await project.save();
-    console.log(chalk139.green("Done"));
-  } else {
-    console.log(chalk139.dim("Dry run. Use --apply to execute."));
-  }
-}
 
-// src/commands/refactor/renameSymbol/index.ts
-import chalk140 from "chalk";
+// src/commands/refactor/restructure/computeRewrites/index.ts
+import path34 from "path";
 
-// src/commands/refactor/renameSymbol/findSymbol.ts
-import { SyntaxKind as SyntaxKind14 } from "ts-morph";
-var declarationKinds = [
-  SyntaxKind14.VariableDeclaration,
-  SyntaxKind14.FunctionDeclaration,
-  SyntaxKind14.ClassDeclaration,
-  SyntaxKind14.InterfaceDeclaration,
-  SyntaxKind14.TypeAliasDeclaration,
-  SyntaxKind14.EnumDeclaration,
-  SyntaxKind14.PropertyDeclaration,
-  SyntaxKind14.MethodDeclaration,
-  SyntaxKind14.Parameter
-];
-function isDeclaration(identifier) {
-  const parent = identifier.getParent();
-  return parent !== void 0 && declarationKinds.includes(parent.getKind());
+// src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
+import fs21 from "fs";
+function getOrCreateList(map, key) {
+  const list4 = map.get(key) ?? [];
+  if (!map.has(key)) map.set(key, list4);
+  return list4;
 }
-function findSymbol(sourceFile, symbolName) {
-  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind14.Identifier)) {
-    if (id.getText() === symbolName && isDeclaration(id)) return id;
+function groupByFile2(rewrites) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const rewrite of rewrites) {
+    getOrCreateList(grouped, rewrite.file).push(rewrite);
   }
-  return void 0;
+  return grouped;
+}
+function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
+  const escaped = oldSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern2 = new RegExp(`(from\\s+["'])${escaped}(["'])`, "g");
+  return content.replace(pattern2, `$1${newSpecifier}$2`);
+}
+function applyFileRewrites(file, fileRewrites) {
+  let content = fs21.readFileSync(file, "utf-8");
+  for (const { oldSpecifier, newSpecifier } of fileRewrites) {
+    content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
+  }
+  return content;
+}
+function applyRewrites(rewrites) {
+  const updatedContents = /* @__PURE__ */ new Map();
+  for (const [file, fileRewrites] of groupByFile2(rewrites)) {
+    updatedContents.set(file, applyFileRewrites(file, fileRewrites));
+  }
+  return updatedContents;
 }
 
-// src/commands/refactor/renameSymbol/groupReferences.ts
-import path35 from "path";
-function groupReferences(symbol, cwd) {
-  const refs = symbol.findReferencesAsNodes();
-  const grouped = /* @__PURE__ */ new Map();
-  for (const ref of refs) {
-    const refFile = path35.relative(cwd, ref.getSourceFile().getFilePath());
-    const lines = grouped.get(refFile) ?? [];
-    if (!grouped.has(refFile)) grouped.set(refFile, lines);
-    lines.push(ref.getStartLineNumber());
+// src/commands/refactor/restructure/computeRewrites/index.ts
+function buildMoveMap(moves) {
+  const map = /* @__PURE__ */ new Map();
+  for (const move of moves) map.set(move.from, move.to);
+  return map;
+}
+function stripTrailingIndex(specifier) {
+  return specifier.endsWith("/index") ? specifier.slice(0, -"/index".length) : specifier;
+}
+function ensureRelative(specifier) {
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function normalizeSpecifier(rel) {
+  return ensureRelative(
+    stripTrailingIndex(rel.replace(/\\/g, "/").replace(/\.tsx?$/, ""))
+  );
+}
+function computeSpecifier(fromFile, toFile) {
+  return normalizeSpecifier(path34.relative(path34.dirname(fromFile), toFile));
+}
+function isAffected(edge, moveMap) {
+  return moveMap.has(edge.target) || moveMap.has(edge.source);
+}
+function resolveTarget(edge, moveMap) {
+  return moveMap.get(edge.target) ?? edge.target;
+}
+function createRewrite(edge, newSpecifier) {
+  return { file: edge.source, oldSpecifier: edge.specifier, newSpecifier };
+}
+function rewriteIfChanged(edge, newSpecifier) {
+  return newSpecifier === edge.specifier ? null : createRewrite(edge, newSpecifier);
+}
+function rewriteEdge(edge, newFile, moveMap) {
+  if (!isAffected(edge, moveMap)) return null;
+  return rewriteIfChanged(
+    edge,
+    computeSpecifier(newFile, resolveTarget(edge, moveMap))
+  );
+}
+function fileEdges(edges, file) {
+  return edges.filter((e) => e.source === file);
+}
+function collectRewrites(edges, newFile, moveMap) {
+  const rewrites = [];
+  for (const edge of edges) {
+    const rewrite = rewriteEdge(edge, newFile, moveMap);
+    if (rewrite) rewrites.push(rewrite);
   }
-  return grouped;
+  return rewrites;
+}
+function rewriteEdgesForFile(file, edges, moveMap) {
+  const newFile = moveMap.get(file) ?? file;
+  return collectRewrites(fileEdges(edges, file), newFile, moveMap);
+}
+function computeRewrites(moves, edges, allProjectFiles) {
+  const moveMap = buildMoveMap(moves);
+  return [...allProjectFiles].flatMap(
+    (file) => rewriteEdgesForFile(file, edges, moveMap)
+  );
 }
 
-// src/commands/refactor/renameSymbol/index.ts
-async function renameSymbol(file, oldName, newName, options2 = {}) {
-  const cwd = process.cwd();
-  const { project, sourceFile } = loadProjectFile(file);
-  const symbol = findSymbol(sourceFile, oldName);
-  if (!symbol) {
-    console.log(chalk140.red(`Symbol "${oldName}" not found in ${file}`));
-    process.exit(1);
+// src/commands/refactor/rename/applyRename.ts
+function applyRename(rewrites, sourcePath, destPath, cwd) {
+  const updatedContents = applyRewrites(rewrites);
+  for (const [file, content] of updatedContents) {
+    fs22.writeFileSync(file, content, "utf-8");
+    console.log(chalk139.cyan(`  Updated imports in ${path35.relative(cwd, file)}`));
   }
-  const grouped = groupReferences(symbol, cwd);
-  const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
+  const destDir = path35.dirname(destPath);
+  if (!fs22.existsSync(destDir)) fs22.mkdirSync(destDir, { recursive: true });
+  fs22.renameSync(sourcePath, destPath);
   console.log(
-    chalk140.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
-`)
+    chalk139.white(
+      `  Moved ${path35.relative(cwd, sourcePath)} \u2192 ${path35.relative(cwd, destPath)}`
+    )
   );
-  for (const [refFile, lines] of grouped) {
-    console.log(
-      `  ${chalk140.dim(refFile)}: lines ${chalk140.cyan(lines.join(", "))}`
-    );
-  }
-  if (options2.apply) {
-    symbol.rename(newName);
-    await project.save();
-    console.log(chalk140.green(`
-Renamed ${oldName} \u2192 ${newName}`));
-  } else {
-    console.log(chalk140.dim("\nDry run. Use --apply to execute."));
-  }
 }
 
-// src/commands/refactor/restructure/index.ts
-import path44 from "path";
-import chalk143 from "chalk";
-
 // src/commands/refactor/restructure/buildImportGraph/index.ts
 import path36 from "path";
 import ts7 from "typescript";
@@ -13485,54 +13519,189 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   return { files: candidateFiles, edges, importedBy, imports };
 }
 
-// src/commands/refactor/restructure/clusterDirectories.ts
+// src/commands/refactor/rename/computeRenameRewrites.ts
+function computeRenameRewrites(sourcePath, destPath) {
+  const tsConfigPath = findTsConfig(sourcePath);
+  const graph = buildImportGraph(/* @__PURE__ */ new Set([sourcePath]), tsConfigPath);
+  const allProjectFiles = /* @__PURE__ */ new Set([
+    ...graph.importedBy.keys(),
+    ...graph.imports.keys(),
+    sourcePath
+  ]);
+  const move = { from: sourcePath, to: destPath, reason: "rename" };
+  return computeRewrites([move], graph.edges, allProjectFiles);
+}
+
+// src/commands/refactor/rename/printRenamePreview.ts
 import path37 from "path";
-function clusterDirectories(graph) {
-  const dirImportedBy = /* @__PURE__ */ new Map();
-  for (const edge of graph.edges) {
-    const sourceDir = path37.dirname(edge.source);
-    const targetDir = path37.dirname(edge.target);
-    if (sourceDir === targetDir) continue;
-    if (!graph.files.has(edge.target)) continue;
-    const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
-    if (!dirImportedBy.has(targetDir)) dirImportedBy.set(targetDir, existing);
-    existing.add(sourceDir);
-  }
-  const clusters = /* @__PURE__ */ new Map();
-  for (const [dir, importers] of dirImportedBy) {
-    if (importers.size !== 1) continue;
-    const parentDir = [...importers][0];
-    if (isAncestor(dir, parentDir)) continue;
-    if (isAncestor(parentDir, dir)) continue;
-    const cluster = clusters.get(parentDir) ?? [];
-    if (!clusters.has(parentDir)) clusters.set(parentDir, cluster);
-    cluster.push(dir);
-  }
-  for (const [parentDir, children] of clusters) {
-    const filtered = children.filter((child) => !clusters.has(child));
-    if (filtered.length === 0) {
-      clusters.delete(parentDir);
-    } else {
-      clusters.set(parentDir, filtered);
-    }
+import chalk140 from "chalk";
+function printRenamePreview(rewrites, cwd) {
+  for (const rewrite of rewrites) {
+    console.log(
+      chalk140.dim(
+        `  ${path37.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+      )
+    );
   }
-  return clusters;
+  console.log(chalk140.dim("Dry run. Use --apply to execute."));
 }
-function isAncestor(ancestor, descendant) {
-  const rel = path37.relative(ancestor, descendant);
+
+// src/commands/refactor/rename/index.ts
+async function rename(source, destination, options2 = {}) {
+  const sourcePath = path38.resolve(source);
+  const destPath = path38.resolve(destination);
+  const cwd = process.cwd();
+  const relSource = path38.relative(cwd, sourcePath);
+  const relDest = path38.relative(cwd, destPath);
+  if (!fs23.existsSync(sourcePath)) {
+    console.log(chalk141.red(`File not found: ${source}`));
+    process.exit(1);
+  }
+  if (destPath !== sourcePath && fs23.existsSync(destPath)) {
+    console.log(chalk141.red(`Destination already exists: ${destination}`));
+    process.exit(1);
+  }
+  console.log(chalk141.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk141.dim("Loading project..."));
+  console.log(chalk141.dim("Scanning imports across the project..."));
+  const rewrites = computeRenameRewrites(sourcePath, destPath);
+  const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
+  console.log(
+    chalk141.dim(
+      `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
+    )
+  );
+  if (!options2.apply) {
+    printRenamePreview(rewrites, cwd);
+    return;
+  }
+  applyRename(rewrites, sourcePath, destPath, cwd);
+  console.log(chalk141.green("Done"));
+}
+
+// src/commands/refactor/renameSymbol/index.ts
+import chalk142 from "chalk";
+
+// src/commands/refactor/renameSymbol/findSymbol.ts
+import { SyntaxKind as SyntaxKind14 } from "ts-morph";
+var declarationKinds = [
+  SyntaxKind14.VariableDeclaration,
+  SyntaxKind14.FunctionDeclaration,
+  SyntaxKind14.ClassDeclaration,
+  SyntaxKind14.InterfaceDeclaration,
+  SyntaxKind14.TypeAliasDeclaration,
+  SyntaxKind14.EnumDeclaration,
+  SyntaxKind14.PropertyDeclaration,
+  SyntaxKind14.MethodDeclaration,
+  SyntaxKind14.Parameter
+];
+function isDeclaration(identifier) {
+  const parent = identifier.getParent();
+  return parent !== void 0 && declarationKinds.includes(parent.getKind());
+}
+function findSymbol(sourceFile, symbolName) {
+  for (const id of sourceFile.getDescendantsOfKind(SyntaxKind14.Identifier)) {
+    if (id.getText() === symbolName && isDeclaration(id)) return id;
+  }
+  return void 0;
+}
+
+// src/commands/refactor/renameSymbol/groupReferences.ts
+import path39 from "path";
+function groupReferences(symbol, cwd) {
+  const refs = symbol.findReferencesAsNodes();
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const refFile = path39.relative(cwd, ref.getSourceFile().getFilePath());
+    const lines = grouped.get(refFile) ?? [];
+    if (!grouped.has(refFile)) grouped.set(refFile, lines);
+    lines.push(ref.getStartLineNumber());
+  }
+  return grouped;
+}
+
+// src/commands/refactor/renameSymbol/index.ts
+async function renameSymbol(file, oldName, newName, options2 = {}) {
+  const cwd = process.cwd();
+  const { project, sourceFile } = loadProjectFile(file);
+  const symbol = findSymbol(sourceFile, oldName);
+  if (!symbol) {
+    console.log(chalk142.red(`Symbol "${oldName}" not found in ${file}`));
+    process.exit(1);
+  }
+  const grouped = groupReferences(symbol, cwd);
+  const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
+  console.log(
+    chalk142.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+`)
+  );
+  for (const [refFile, lines] of grouped) {
+    console.log(
+      `  ${chalk142.dim(refFile)}: lines ${chalk142.cyan(lines.join(", "))}`
+    );
+  }
+  if (options2.apply) {
+    symbol.rename(newName);
+    await project.save();
+    console.log(chalk142.green(`
+Renamed ${oldName} \u2192 ${newName}`));
+  } else {
+    console.log(chalk142.dim("\nDry run. Use --apply to execute."));
+  }
+}
+
+// src/commands/refactor/restructure/index.ts
+import path46 from "path";
+import chalk145 from "chalk";
+
+// src/commands/refactor/restructure/clusterDirectories.ts
+import path40 from "path";
+function clusterDirectories(graph) {
+  const dirImportedBy = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    const sourceDir = path40.dirname(edge.source);
+    const targetDir = path40.dirname(edge.target);
+    if (sourceDir === targetDir) continue;
+    if (!graph.files.has(edge.target)) continue;
+    const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
+    if (!dirImportedBy.has(targetDir)) dirImportedBy.set(targetDir, existing);
+    existing.add(sourceDir);
+  }
+  const clusters = /* @__PURE__ */ new Map();
+  for (const [dir, importers] of dirImportedBy) {
+    if (importers.size !== 1) continue;
+    const parentDir = [...importers][0];
+    if (isAncestor(dir, parentDir)) continue;
+    if (isAncestor(parentDir, dir)) continue;
+    const cluster = clusters.get(parentDir) ?? [];
+    if (!clusters.has(parentDir)) clusters.set(parentDir, cluster);
+    cluster.push(dir);
+  }
+  for (const [parentDir, children] of clusters) {
+    const filtered = children.filter((child) => !clusters.has(child));
+    if (filtered.length === 0) {
+      clusters.delete(parentDir);
+    } else {
+      clusters.set(parentDir, filtered);
+    }
+  }
+  return clusters;
+}
+function isAncestor(ancestor, descendant) {
+  const rel = path40.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path38 from "path";
+import path41 from "path";
 function findRootParent(file, importedBy, visited) {
   const importers = importedBy.get(file);
   if (!importers || importers.size !== 1) return file;
   const parent = [...importers][0];
-  const parentDir = path38.dirname(parent);
-  const fileDir = path38.dirname(file);
+  const parentDir = path41.dirname(parent);
+  const fileDir = path41.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path38.basename(parent, path38.extname(parent)) === "index") return file;
+  if (path41.basename(parent, path41.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -13540,16 +13709,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename12 = path38.basename(file, path38.extname(file));
+    const basename12 = path41.basename(file, path41.extname(file));
     if (basename12 === "index") continue;
     const importers = graph.importedBy.get(file);
     if (!importers || importers.size !== 1) continue;
     const parent = [...importers][0];
     if (!graph.files.has(parent)) continue;
-    const parentDir = path38.dirname(parent);
-    const fileDir = path38.dirname(file);
+    const parentDir = path41.dirname(parent);
+    const fileDir = path41.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path38.basename(parent, path38.extname(parent));
+    const parentBasename = path41.basename(parent, path41.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -13560,150 +13729,52 @@ function clusterFiles(graph) {
   return clusters;
 }
 
-// src/commands/refactor/restructure/computeRewrites/index.ts
-import path39 from "path";
-
-// src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs21 from "fs";
-function getOrCreateList(map, key) {
-  const list4 = map.get(key) ?? [];
-  if (!map.has(key)) map.set(key, list4);
-  return list4;
-}
-function groupByFile2(rewrites) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const rewrite of rewrites) {
-    getOrCreateList(grouped, rewrite.file).push(rewrite);
-  }
-  return grouped;
-}
-function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
-  const escaped = oldSpecifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const pattern2 = new RegExp(`(from\\s+["'])${escaped}(["'])`, "g");
-  return content.replace(pattern2, `$1${newSpecifier}$2`);
-}
-function applyFileRewrites(file, fileRewrites) {
-  let content = fs21.readFileSync(file, "utf-8");
-  for (const { oldSpecifier, newSpecifier } of fileRewrites) {
-    content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
-  }
-  return content;
-}
-function applyRewrites(rewrites) {
-  const updatedContents = /* @__PURE__ */ new Map();
-  for (const [file, fileRewrites] of groupByFile2(rewrites)) {
-    updatedContents.set(file, applyFileRewrites(file, fileRewrites));
-  }
-  return updatedContents;
-}
-
-// src/commands/refactor/restructure/computeRewrites/index.ts
-function buildMoveMap(moves) {
-  const map = /* @__PURE__ */ new Map();
-  for (const move of moves) map.set(move.from, move.to);
-  return map;
-}
-function stripTrailingIndex(specifier) {
-  return specifier.endsWith("/index") ? specifier.slice(0, -"/index".length) : specifier;
-}
-function ensureRelative(specifier) {
-  return specifier.startsWith(".") ? specifier : `./${specifier}`;
-}
-function normalizeSpecifier(rel) {
-  return ensureRelative(
-    stripTrailingIndex(rel.replace(/\\/g, "/").replace(/\.tsx?$/, ""))
-  );
-}
-function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path39.relative(path39.dirname(fromFile), toFile));
-}
-function isAffected(edge, moveMap) {
-  return moveMap.has(edge.target) || moveMap.has(edge.source);
-}
-function resolveTarget(edge, moveMap) {
-  return moveMap.get(edge.target) ?? edge.target;
-}
-function createRewrite(edge, newSpecifier) {
-  return { file: edge.source, oldSpecifier: edge.specifier, newSpecifier };
-}
-function rewriteIfChanged(edge, newSpecifier) {
-  return newSpecifier === edge.specifier ? null : createRewrite(edge, newSpecifier);
-}
-function rewriteEdge(edge, newFile, moveMap) {
-  if (!isAffected(edge, moveMap)) return null;
-  return rewriteIfChanged(
-    edge,
-    computeSpecifier(newFile, resolveTarget(edge, moveMap))
-  );
-}
-function fileEdges(edges, file) {
-  return edges.filter((e) => e.source === file);
-}
-function collectRewrites(edges, newFile, moveMap) {
-  const rewrites = [];
-  for (const edge of edges) {
-    const rewrite = rewriteEdge(edge, newFile, moveMap);
-    if (rewrite) rewrites.push(rewrite);
-  }
-  return rewrites;
-}
-function rewriteEdgesForFile(file, edges, moveMap) {
-  const newFile = moveMap.get(file) ?? file;
-  return collectRewrites(fileEdges(edges, file), newFile, moveMap);
-}
-function computeRewrites(moves, edges, allProjectFiles) {
-  const moveMap = buildMoveMap(moves);
-  return [...allProjectFiles].flatMap(
-    (file) => rewriteEdgesForFile(file, edges, moveMap)
-  );
-}
-
 // src/commands/refactor/restructure/displayPlan.ts
-import path40 from "path";
-import chalk141 from "chalk";
+import path42 from "path";
+import chalk143 from "chalk";
 function relPath(filePath) {
-  return path40.relative(process.cwd(), filePath);
+  return path42.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk141.bold("\nFile moves:"));
+  console.log(chalk143.bold("\nFile moves:"));
   for (const move of plan2.moves) {
     console.log(
-      `  ${chalk141.red(relPath(move.from))} \u2192 ${chalk141.green(relPath(move.to))}`
+      `  ${chalk143.red(relPath(move.from))} \u2192 ${chalk143.green(relPath(move.to))}`
     );
-    console.log(chalk141.dim(`    ${move.reason}`));
+    console.log(chalk143.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk141.bold(`
+  console.log(chalk143.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk141.cyan(relPath(file))}:`);
+    console.log(`  ${chalk143.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk141.red(`"${oldSpecifier}"`)} \u2192 ${chalk141.green(`"${newSpecifier}"`)}`
+        `    ${chalk143.red(`"${oldSpecifier}"`)} \u2192 ${chalk143.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk141.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk141.yellow(`  ${w}`));
+    console.log(chalk143.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk143.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk141.bold("\nNew directories:"));
+    console.log(chalk143.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk141.green(`  ${dir}/`));
+      console.log(chalk143.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk141.dim(
+    chalk143.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -13711,45 +13782,45 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs22 from "fs";
-import path41 from "path";
-import chalk142 from "chalk";
+import fs24 from "fs";
+import path43 from "path";
+import chalk144 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs22.writeFileSync(file, content, "utf-8");
+    fs24.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk142.cyan(`  Rewrote imports in ${path41.relative(process.cwd(), file)}`)
+      chalk144.cyan(`  Rewrote imports in ${path43.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs22.mkdirSync(dir, { recursive: true });
-    console.log(chalk142.green(`  Created ${path41.relative(process.cwd(), dir)}/`));
+    fs24.mkdirSync(dir, { recursive: true });
+    console.log(chalk144.green(`  Created ${path43.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan2.moves) {
-    const targetDir = path41.dirname(move.to);
-    if (!fs22.existsSync(targetDir)) {
-      fs22.mkdirSync(targetDir, { recursive: true });
+    const targetDir = path43.dirname(move.to);
+    if (!fs24.existsSync(targetDir)) {
+      fs24.mkdirSync(targetDir, { recursive: true });
     }
-    fs22.renameSync(move.from, move.to);
+    fs24.renameSync(move.from, move.to);
     console.log(
-      chalk142.white(
-        `  Moved ${path41.relative(process.cwd(), move.from)} \u2192 ${path41.relative(process.cwd(), move.to)}`
+      chalk144.white(
+        `  Moved ${path43.relative(process.cwd(), move.from)} \u2192 ${path43.relative(process.cwd(), move.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path41.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path43.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs22.existsSync(dir)) continue;
-    const entries = fs22.readdirSync(dir);
+    if (!fs24.existsSync(dir)) continue;
+    const entries = fs24.readdirSync(dir);
     if (entries.length === 0) {
-      fs22.rmdirSync(dir);
+      fs24.rmdirSync(dir);
       console.log(
-        chalk142.dim(
-          `  Removed empty directory ${path41.relative(process.cwd(), dir)}`
+        chalk144.dim(
+          `  Removed empty directory ${path43.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -13757,46 +13828,46 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path43 from "path";
+import path45 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs23 from "fs";
+import fs25 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs23.existsSync(dir)) return false;
+  if (!fs25.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs24 from "fs";
-import path42 from "path";
+import fs26 from "fs";
+import path44 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path42.join(dir, entry.name);
+  const full = path44.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
 function listFilesRecursive(dir) {
-  if (!fs24.existsSync(dir)) return [];
+  if (!fs26.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs24.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs26.readdirSync(dir, { withFileTypes: true })) {
     collectEntry(results, dir, entry);
   }
   return results;
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path42.relative(childDir, file);
-    moves.push({ from: file, to: path42.join(newLocation, rel), reason });
+    const rel = path44.relative(childDir, file);
+    moves.push({ from: file, to: path44.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path42.join(parentDir, path42.basename(childDir));
+  return path44.join(parentDir, path44.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path42.basename(parentDir)}/`;
+  return `Directory only imported from ${path44.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -13821,7 +13892,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path43.join(newDir, path43.basename(child));
+  const to = path45.join(newDir, path45.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -13829,15 +13900,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path43.basename(filePath, path43.extname(filePath));
+  return path45.basename(filePath, path45.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path43.join(path43.dirname(parent), getBaseName(parent));
+  return path45.join(path45.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path43.join(newDir, `index${path43.extname(parent)}`),
+    to: path45.join(newDir, `index${path45.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -13861,7 +13932,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path44.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path46.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -13881,22 +13952,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk143.yellow("No files found matching pattern"));
+    console.log(chalk145.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path44.resolve("tsconfig.json");
+  const tsConfigPath = path46.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk143.green("No restructuring needed"));
+    console.log(chalk145.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk143.bold("\nApplying changes..."));
+    console.log(chalk145.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk143.green("\nRestructuring complete"));
+    console.log(chalk145.green("\nRestructuring complete"));
   } else {
-    console.log(chalk143.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk145.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -13936,7 +14007,7 @@ function registerRefactor(program2) {
 }
 
 // src/commands/review/review.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 
 // src/commands/review/annotateDiffWithLineNumbers.ts
 var FILE_HEADER2 = /^\+\+\+ (?:b\/)?(.+)$/;
@@ -14071,9 +14142,9 @@ function buildReviewPaths(repoRoot, key) {
 }
 
 // src/commands/review/fetchExistingComments.ts
-import { execSync as execSync43 } from "child_process";
+import { execSync as execSync42 } from "child_process";
 function fetchRawComments(org, repo, prNumber) {
-  const out = execSync43(
+  const out = execSync42(
     `gh api --paginate repos/${org}/${repo}/pulls/${prNumber}/comments`,
     { encoding: "utf-8", maxBuffer: 64 * 1024 * 1024 }
   );
@@ -14104,14 +14175,14 @@ function fetchExistingComments() {
 }
 
 // src/commands/review/gatherContext.ts
-import { execSync as execSync46 } from "child_process";
+import { execSync as execSync45 } from "child_process";
 
 // src/commands/review/fetchPrDiff.ts
-import { execSync as execSync44 } from "child_process";
+import { execSync as execSync43 } from "child_process";
 function fetchPrDiff(prNumber, baseSha, headSha) {
   const { org, repo } = getRepoInfo();
   try {
-    return execSync44(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
+    return execSync43(`gh pr diff ${prNumber} -R ${org}/${repo}`, {
       encoding: "utf-8",
       maxBuffer: 256 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"]
@@ -14126,19 +14197,19 @@ function isDiffTooLarge(error) {
 }
 function fetchDiffViaGit(baseSha, headSha) {
   try {
-    execSync44(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
+    execSync43(`git fetch origin ${baseSha} ${headSha}`, { stdio: "ignore" });
   } catch {
   }
-  return execSync44(`git diff ${baseSha}...${headSha}`, {
+  return execSync43(`git diff ${baseSha}...${headSha}`, {
     encoding: "utf-8",
     maxBuffer: 256 * 1024 * 1024
   });
 }
 
 // src/commands/review/fetchPrDiffInfo.ts
-import { execSync as execSync45 } from "child_process";
+import { execSync as execSync44 } from "child_process";
 function getCurrentBranch2() {
-  return execSync45("git rev-parse --abbrev-ref HEAD", {
+  return execSync44("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf-8"
   }).trim();
 }
@@ -14148,7 +14219,7 @@ function fetchPrDiffInfo() {
   const fields = "number,baseRefName,baseRefOid,headRefName,headRefOid";
   let raw;
   try {
-    raw = execSync45(`gh pr view ${branch} --json ${fields} -R ${org}/${repo}`, {
+    raw = execSync44(`gh pr view ${branch} --json ${fields} -R ${org}/${repo}`, {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -14172,7 +14243,7 @@ function fetchPrDiffInfo() {
 }
 function fetchPrChangedFiles(prNumber) {
   const { org, repo } = getRepoInfo();
-  const out = execSync45(
+  const out = execSync44(
     `gh api repos/${org}/${repo}/pulls/${prNumber}/files --paginate --jq ".[].filename"`,
     {
       encoding: "utf-8",
@@ -14184,11 +14255,11 @@ function fetchPrChangedFiles(prNumber) {
 
 // src/commands/review/gatherContext.ts
 function gatherContext() {
-  const branch = execSync46("git rev-parse --abbrev-ref HEAD", {
+  const branch = execSync45("git rev-parse --abbrev-ref HEAD", {
     encoding: "utf-8"
   }).trim();
-  const sha = execSync46("git rev-parse HEAD", { encoding: "utf-8" }).trim();
-  const shortSha = execSync46("git rev-parse --short=7 HEAD", {
+  const sha = execSync45("git rev-parse HEAD", { encoding: "utf-8" }).trim();
+  const shortSha = execSync45("git rev-parse --short=7 HEAD", {
     encoding: "utf-8"
   }).trim();
   const prInfo = fetchPrDiffInfo();
@@ -14465,18 +14536,18 @@ function partitionFindingsByDiff(findings, index2) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk144 from "chalk";
+import chalk146 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk144.yellow(
+    chalk146.yellow(
       `Skipped ${outOfDiff.length} finding(s) whose lines fall outside the PR diff (GitHub would silently drop these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk144.yellow("\xB7")} ${finding.title} ${chalk144.dim(
+      `  ${chalk146.yellow("\xB7")} ${finding.title} ${chalk146.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -14495,18 +14566,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk145 from "chalk";
+import chalk147 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk145.yellow(
+    chalk147.yellow(
       `Skipped ${unlocated.length} finding(s) without a parseable file:line:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk145.dim("missing");
+    const where = finding.location || chalk147.dim("missing");
     console.warn(
-      `  ${chalk145.yellow("\xB7")} ${finding.title} ${chalk145.dim(`(${where})`)}`
+      `  ${chalk147.yellow("\xB7")} ${finding.title} ${chalk147.dim(`(${where})`)}`
     );
   }
 }
@@ -14603,8 +14674,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync36, mkdirSync as mkdirSync14, unlinkSync as unlinkSync12, writeFileSync as writeFileSync26 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path54 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync36(path54)) unlinkSync12(path54);
+  for (const path56 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync36(path56)) unlinkSync12(path56);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -15632,7 +15703,7 @@ function validateOptions(options2) {
 }
 function checkoutPr(number) {
   try {
-    execFileSync6("gh", ["pr", "checkout", number], { stdio: "inherit" });
+    execFileSync7("gh", ["pr", "checkout", number], { stdio: "inherit" });
   } catch {
     console.error(`gh pr checkout ${number} failed; aborting.`);
     process.exit(1);
@@ -15679,7 +15750,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk147 from "chalk";
+import chalk149 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -15708,10 +15779,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk146 from "chalk";
+import chalk148 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk146.red(`Connection "${name}" already exists.`));
+    console.error(chalk148.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -15729,18 +15800,18 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk147.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk149.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk151 from "chalk";
+import chalk153 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk148 from "chalk";
-async function fetchSeq(conn, path54, params) {
-  const url = `${conn.url}${path54}?${params}`;
+import chalk150 from "chalk";
+async function fetchSeq(conn, path56, params) {
+  const url = `${conn.url}${path56}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -15749,7 +15820,7 @@ async function fetchSeq(conn, path54, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk148.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk150.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -15804,23 +15875,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk149 from "chalk";
+import chalk151 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk149.bgRed.white;
+      return chalk151.bgRed.white;
     case "Error":
-      return chalk149.red;
+      return chalk151.red;
     case "Warning":
-      return chalk149.yellow;
+      return chalk151.yellow;
     case "Information":
-      return chalk149.cyan;
+      return chalk151.cyan;
     case "Debug":
-      return chalk149.gray;
+      return chalk151.gray;
     case "Verbose":
-      return chalk149.dim;
+      return chalk151.dim;
     default:
-      return chalk149.white;
+      return chalk151.white;
   }
 }
 function levelAbbrev(level) {
@@ -15861,12 +15932,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk149.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk151.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines.push(chalk149.red(`  ${line}`));
+      lines.push(chalk151.red(`  ${line}`));
     }
   }
   return lines.join("\n");
@@ -15899,11 +15970,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk150 from "chalk";
+import chalk152 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk150.red(
+      chalk152.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -15912,7 +15983,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk150.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk152.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -15941,7 +16012,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count6) })
   );
   if (events.length === 0) {
-    console.log(chalk151.yellow("No events found."));
+    console.log(chalk153.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -15952,11 +16023,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk151.dim(`
+  console.log(chalk153.dim(`
 ${events.length} events`));
   if (events.length >= count6) {
     console.log(
-      chalk151.yellow(
+      chalk153.yellow(
         `Results limited to ${count6}. Use --count to retrieve more.`
       )
     );
@@ -15964,10 +16035,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk152 from "chalk";
+import chalk154 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk152.red(`Connection "${name}" not found.`));
+    console.error(chalk154.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -16015,7 +16086,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk154 from "chalk";
+import chalk156 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -16044,7 +16115,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk153 from "chalk";
+import chalk155 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -16052,7 +16123,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk153.red(`Invalid port "${portStr}".`));
+    console.error(chalk155.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -16065,13 +16136,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk154.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk156.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk155 from "chalk";
+import chalk157 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -16080,7 +16151,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk155.yellow("(no rows)"));
+    console.log(chalk157.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -16088,13 +16159,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk155.dim(header));
-  console.log(chalk155.dim("-".repeat(header.length)));
+  console.log(chalk157.dim(header));
+  console.log(chalk157.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk155.dim(`
+  console.log(chalk157.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -16154,7 +16225,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk156 from "chalk";
+import chalk158 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -16188,7 +16259,7 @@ function isMutation(sql4) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk156.red(
+      chalk158.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -16198,18 +16269,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk156.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk158.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk157 from "chalk";
+import chalk159 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk157.red(
+      chalk159.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -16224,7 +16295,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk157.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk159.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -16804,14 +16875,14 @@ import {
 import { dirname as dirname22, join as join42 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk158 from "chalk";
+import chalk160 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk158.red(
+      chalk160.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -16820,7 +16891,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk158.red(
+      chalk160.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -17024,7 +17095,7 @@ import { mkdirSync as mkdirSync18 } from "fs";
 import { join as join47 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync47 } from "child_process";
+import { execSync as execSync46 } from "child_process";
 import { existsSync as existsSync45, mkdirSync as mkdirSync17, readFileSync as readFileSync35, writeFileSync as writeFileSync29 } from "fs";
 import { join as join46 } from "path";
 function isProcessAlive2(pid) {
@@ -17053,7 +17124,7 @@ function bootstrapVenv() {
   if (existsSync45(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync47(
+  execSync46(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -17217,7 +17288,7 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk159 from "chalk";
+import chalk161 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer2 } from "http";
@@ -17348,13 +17419,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk159.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk161.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk159.white("http://localhost:14523/callback\n"));
-  console.log(chalk159.blue("Opening browser for authorization..."));
-  console.log(chalk159.dim("Waiting for authorization callback..."));
+  console.log(chalk161.white("http://localhost:14523/callback\n"));
+  console.log(chalk161.blue("Opening browser for authorization..."));
+  console.log(chalk161.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk159.dim("Exchanging code for tokens..."));
+  console.log(chalk161.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -17370,12 +17441,12 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk159.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk161.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
-import { execFileSync as execFileSync7 } from "child_process";
+import { execFileSync as execFileSync8 } from "child_process";
 import { readdirSync as readdirSync7, readFileSync as readFileSync38, statSync as statSync5 } from "fs";
 import { join as join49 } from "path";
 function findPortFile(roamDir) {
@@ -17386,9 +17457,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path54 = join49(roamDir, name);
+    const path56 = join49(roamDir, name);
     try {
-      return { path: path54, mtimeMs: statSync5(path54).mtimeMs };
+      return { path: path56, mtimeMs: statSync5(path56).mtimeMs };
     } catch {
       return void 0;
     }
@@ -17408,7 +17479,7 @@ function postRoamActivity(app, event) {
   }
   const url = `http://127.0.0.1:${port}/api/v1/activity/${app}/${event}?pid=${app === "codex" ? 99998 : 99999}`;
   try {
-    execFileSync7("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
+    execFileSync8("curl", ["-sf", "--max-time", "0.2", "-X", "POST", url], {
       stdio: "ignore"
     });
   } catch {
@@ -17530,11 +17601,11 @@ function resolveParams(params, cliArgs) {
 }
 
 // src/commands/run/runPreCommands.ts
-import { execSync as execSync48 } from "child_process";
+import { execSync as execSync47 } from "child_process";
 function runPreCommands(pre, cwd) {
   for (const cmd of pre) {
     try {
-      execSync48(cmd, { stdio: "inherit", cwd });
+      execSync47(cmd, { stdio: "inherit", cwd });
     } catch (err) {
       const code = err && typeof err === "object" && "status" in err ? err.status : 1;
       process.exit(code);
@@ -17543,13 +17614,13 @@ function runPreCommands(pre, cwd) {
 }
 
 // src/commands/run/spawnRunCommand.ts
-import { execFileSync as execFileSync8, spawn as spawn8 } from "child_process";
+import { execFileSync as execFileSync9, spawn as spawn8 } from "child_process";
 import { existsSync as existsSync48 } from "fs";
 import { dirname as dirname25, join as join50, resolve as resolve11 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
-    const gitPath = execFileSync8("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
+    const gitPath = execFileSync9("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve11(dirname25(gitPath), "..");
     const gitBash = join50(gitRoot, "bin", "bash.exe");
     if (existsSync48(gitBash)) return gitBash;
@@ -17731,11 +17802,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path54 = process.argv[idx + 1];
+  const path56 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path54, prefix: prefix2 };
+  return { path: path56, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -17818,11 +17889,11 @@ function registerRun(program2) {
 }
 
 // src/commands/screenshot/index.ts
-import { execSync as execSync49 } from "child_process";
+import { execSync as execSync48 } from "child_process";
 import { existsSync as existsSync50, mkdirSync as mkdirSync21, unlinkSync as unlinkSync17, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join53, resolve as resolve13 } from "path";
-import chalk160 from "chalk";
+import chalk162 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -17961,7 +18032,7 @@ function runPowerShellScript(processName, outputPath) {
   const scriptPath = join53(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync32(scriptPath, captureWindowPs1, "utf-8");
   try {
-    execSync49(
+    execSync48(
       `powershell -NoProfile -ExecutionPolicy Bypass -File "${scriptPath}" -ProcessName "${processName}" -OutputPath "${outputPath}"`,
       { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }
     );
@@ -17973,23 +18044,23 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve13(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk160.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk162.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk160.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk162.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk160.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk162.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
 
 // src/commands/sessions/daemon/listDaemonPids.ts
-import { execFileSync as execFileSync9 } from "child_process";
+import { execFileSync as execFileSync10 } from "child_process";
 function listDaemonPids() {
   if (process.platform === "win32") return [];
   try {
-    const out = execFileSync9("ps", ["-eo", "pid=,args="], {
+    const out = execFileSync10("ps", ["-eo", "pid=,args="], {
       encoding: "utf-8"
     });
     return out.split("\n").filter((line) => line.includes("assist") && / daemon run\b/.test(line)).map((line) => Number.parseInt(line.trim(), 10)).filter((pid) => Number.isInteger(pid));
@@ -18212,14 +18283,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync51, statSync as statSync6 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path45 from "path";
+import path47 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path45.join(path45.dirname(require4.resolve("node-pty")), "..");
-  const helper = path45.join(
+  const ptyRoot = path47.join(path47.dirname(require4.resolve("node-pty")), "..");
+  const helper = path47.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -18462,8 +18533,8 @@ import { dirname as dirname26 } from "path";
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path54 = activityPath(session.id);
-  const dir = dirname26(path54);
+  const path56 = activityPath(session.id);
+  const dir = dirname26(path56);
   try {
     mkdirSync22(dir, { recursive: true });
   } catch {
@@ -18472,7 +18543,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path54);
+    const activity2 = readActivity(path56);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -18480,11 +18551,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path54.endsWith(filename)) return;
+    if (filename && !path56.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync52(path54)) read();
+  if (existsSync52(path56)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -19004,17 +19075,17 @@ var WindowsProxy = class {
 };
 
 // src/commands/sessions/daemon/watchClaudeSessionId.ts
-import * as fs27 from "fs";
-import * as path48 from "path";
+import * as fs29 from "fs";
+import * as path50 from "path";
 
 // src/commands/sessions/shared/discoverSessions.ts
-import * as fs26 from "fs";
+import * as fs28 from "fs";
 import * as os from "os";
-import * as path47 from "path";
+import * as path49 from "path";
 
 // src/commands/sessions/shared/parseSessionFile.ts
-import * as fs25 from "fs";
-import * as path46 from "path";
+import * as fs27 from "fs";
+import * as path48 from "path";
 
 // src/commands/sessions/shared/deriveHistoryFields.ts
 var KNOWN = ["draft", "next", "bug", "refine", "run"];
@@ -19103,10 +19174,10 @@ function matchMarker(text3, tag) {
 async function parseSessionFile(filePath, origin = "wsl") {
   let handle;
   try {
-    handle = await fs25.promises.open(filePath, "r");
+    handle = await fs27.promises.open(filePath, "r");
     const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
-    const timestamp = meta.timestamp || (await fs25.promises.stat(filePath)).mtime.toISOString();
+    const timestamp = meta.timestamp || (await fs27.promises.stat(filePath)).mtime.toISOString();
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
@@ -19129,10 +19200,10 @@ async function readHeadLines(handle) {
 }
 function deriveProject(cwd, filePath, origin) {
   if (!cwd) return dirNameToProject(filePath);
-  return origin === "windows" ? path46.win32.basename(cwd) : path46.basename(cwd);
+  return origin === "windows" ? path48.win32.basename(cwd) : path48.basename(cwd);
 }
 function dirNameToProject(filePath) {
-  const dirName = path46.basename(path46.dirname(filePath));
+  const dirName = path48.basename(path48.dirname(filePath));
   const parts = dirName.split("--");
   return parts[parts.length - 1].replace(/-/g, "/");
 }
@@ -19140,7 +19211,7 @@ function dirNameToProject(filePath) {
 // src/commands/sessions/shared/discoverSessions.ts
 function sessionRoots() {
   const roots = [
-    { dir: path47.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
+    { dir: path49.join(os.homedir(), ".claude", "projects"), origin: "wsl" }
   ];
   const windowsRoot = loadConfig().sessions?.windowsProjectsRoot;
   if (windowsRoot) roots.push({ dir: windowsRoot, origin: "windows" });
@@ -19152,22 +19223,22 @@ async function discoverSessionJsonlPaths() {
     sessionRoots().map(async ({ dir, origin }) => {
       let projectDirs;
       try {
-        projectDirs = await fs26.promises.readdir(dir);
+        projectDirs = await fs28.promises.readdir(dir);
       } catch {
         return;
       }
       await Promise.all(
         projectDirs.map(async (dirName) => {
-          const dirPath = path47.join(dir, dirName);
+          const dirPath = path49.join(dir, dirName);
           let entries;
           try {
-            entries = await fs26.promises.readdir(dirPath);
+            entries = await fs28.promises.readdir(dirPath);
           } catch {
             return;
           }
           for (const file of entries) {
             if (file.endsWith(".jsonl"))
-              results.push({ path: path47.join(dirPath, file), origin });
+              results.push({ path: path49.join(dirPath, file), origin });
           }
         })
       );
@@ -19214,7 +19285,7 @@ async function findLatestSessionId(options2) {
     if (createdMs === null) continue;
     const meta = await parseSessionFile(filePath, origin);
     if (!meta?.cwd || options2.isClaimed(meta.sessionId)) continue;
-    if (path48.resolve(meta.cwd) !== path48.resolve(options2.cwd)) continue;
+    if (path50.resolve(meta.cwd) !== path50.resolve(options2.cwd)) continue;
     if (!latest || createdMs > latest.createdMs)
       latest = { sessionId: meta.sessionId, createdMs };
   }
@@ -19222,7 +19293,7 @@ async function findLatestSessionId(options2) {
 }
 async function createdSince(filePath, sinceMs) {
   try {
-    const stat = await fs27.promises.stat(filePath);
+    const stat = await fs29.promises.stat(filePath);
     const createdMs = stat.birthtimeMs || stat.mtimeMs;
     return createdMs >= sinceMs ? createdMs : null;
   } catch {
@@ -19400,7 +19471,7 @@ import * as net3 from "net";
 import { createInterface as createInterface7 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs28 from "fs";
+import * as fs30 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -19448,11 +19519,11 @@ function cleanUserText(value) {
 }
 
 // src/commands/sessions/shared/findSessionJsonlPath.ts
-import * as path49 from "path";
+import * as path51 from "path";
 async function findSessionJsonlPath(sessionId) {
   const paths = await discoverSessionJsonlPaths();
   const direct = paths.find(
-    (p) => path49.basename(p.path, ".jsonl") === sessionId
+    (p) => path51.basename(p.path, ".jsonl") === sessionId
   );
   if (direct) return direct.path;
   for (const p of paths) {
@@ -19467,7 +19538,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs28.promises.readFile(filePath, "utf8");
+    const raw = await fs30.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -19729,37 +19800,37 @@ function registerDaemon(program2) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs31 from "fs";
-import chalk161 from "chalk";
+import * as fs33 from "fs";
+import chalk163 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs29 from "fs";
+import * as fs31 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs29.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs31.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs29.existsSync(summaryPathFor(jsonlPath2));
+  return fs31.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
 }
 
 // src/commands/sessions/summarise/summariseSession.ts
-import { execFileSync as execFileSync10 } from "child_process";
+import { execFileSync as execFileSync11 } from "child_process";
 
 // src/commands/sessions/summarise/iterateUserMessages.ts
-import * as fs30 from "fs";
+import * as fs32 from "fs";
 function* iterateUserMessages(filePath, maxBytes = 65536) {
   let content;
   try {
-    const fd = fs30.openSync(filePath, "r");
+    const fd = fs32.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs30.readSync(fd, buf, 0, buf.length, 0);
+      const bytesRead = fs32.readSync(fd, buf, 0, buf.length, 0);
       content = buf.toString("utf8", 0, bytesRead);
     } finally {
-      fs30.closeSync(fd);
+      fs32.closeSync(fd);
     }
   } catch {
     return;
@@ -19823,7 +19894,7 @@ function summariseSession(jsonlPath2) {
   }
   const prompt = buildPrompt2(firstMessage, backlogIds);
   try {
-    const output = execFileSync10("claude", ["-p", "--model", "haiku", prompt], {
+    const output = execFileSync11("claude", ["-p", "--model", "haiku", prompt], {
       encoding: "utf8",
       timeout: 3e4,
       stdio: ["ignore", "pipe", "ignore"]
@@ -19857,29 +19928,29 @@ ${firstMessage}`);
 async function summarise4(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk161.yellow("No sessions found."));
+    console.log(chalk163.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk161.green("All sessions already summarised."));
+    console.log(chalk163.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk161.cyan(
+    chalk163.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk161.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk161.yellow(`, ${failed2} skipped`) : "")
+    chalk163.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk163.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs31.statSync(b).mtimeMs - fs31.statSync(a).mtimeMs;
+      return fs33.statSync(b).mtimeMs - fs33.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -19892,16 +19963,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk161.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk163.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk161.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk163.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk161.yellow("skip")}
+      process.stdout.write(` ${chalk163.yellow("skip")}
 `);
     }
   }
@@ -19916,10 +19987,10 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk163 from "chalk";
+import chalk165 from "chalk";
 
 // src/commands/buildLimitsSegment.ts
-import chalk162 from "chalk";
+import chalk164 from "chalk";
 var FIVE_HOUR_SECONDS = 5 * 3600;
 var SEVEN_DAY_SECONDS = 7 * 86400;
 function formatTimeLeft(resetsAt) {
@@ -19942,10 +20013,10 @@ function projectUsage(pct, resetsAt, windowSeconds) {
 function colorizeRateLimit(pct, resetsAt, windowSeconds) {
   const label2 = `${Math.round(pct)}%`;
   const projected = projectUsage(pct, resetsAt, windowSeconds);
-  if (projected == null) return chalk162.green(label2);
-  if (projected > 100) return chalk162.red(label2);
-  if (projected > 75) return chalk162.yellow(label2);
-  return chalk162.green(label2);
+  if (projected == null) return chalk164.green(label2);
+  if (projected > 100) return chalk164.red(label2);
+  if (projected > 75) return chalk164.yellow(label2);
+  return chalk164.green(label2);
 }
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel) {
   const timeLabel = resetsAt ? formatTimeLeft(resetsAt) : fallbackLabel;
@@ -19971,14 +20042,14 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/statusLine.ts
-chalk163.level = 3;
+chalk165.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
-  if (pct > 80) return chalk163.red(label2);
-  if (pct > 40) return chalk163.yellow(label2);
+  if (pct > 80) return chalk165.red(label2);
+  if (pct > 40) return chalk165.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -19993,29 +20064,29 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs34 from "fs";
+import * as fs36 from "fs";
 import * as os2 from "os";
-import * as path52 from "path";
+import * as path54 from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs32 from "fs";
-import * as path50 from "path";
-import chalk164 from "chalk";
+import * as fs34 from "fs";
+import * as path52 from "path";
+import chalk166 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path50.join(claudeDir, "CLAUDE.md");
-  const target = path50.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs32.readFileSync(source, "utf-8");
-  if (fs32.existsSync(target)) {
-    const targetContent = fs32.readFileSync(target, "utf-8");
+  const source = path52.join(claudeDir, "CLAUDE.md");
+  const target = path52.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs34.readFileSync(source, "utf-8");
+  if (fs34.existsSync(target)) {
+    const targetContent = fs34.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk164.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk166.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = options2?.yes || await promptConfirm(
-        chalk164.red("Overwrite existing CLAUDE.md?"),
+        chalk166.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -20024,21 +20095,21 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs32.copyFileSync(source, target);
+  fs34.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs33 from "fs";
-import * as path51 from "path";
-import chalk165 from "chalk";
+import * as fs35 from "fs";
+import * as path53 from "path";
+import chalk167 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path51.join(claudeDir, "settings.json");
-  const target = path51.join(targetBase, "settings.json");
-  const sourceContent = fs33.readFileSync(source, "utf-8");
+  const source = path53.join(claudeDir, "settings.json");
+  const target = path53.join(targetBase, "settings.json");
+  const sourceContent = fs35.readFileSync(source, "utf-8");
   const mergedContent = JSON.stringify(JSON.parse(sourceContent), null, "	");
-  if (fs33.existsSync(target)) {
-    const targetContent = fs33.readFileSync(target, "utf-8");
+  if (fs35.existsSync(target)) {
+    const targetContent = fs35.readFileSync(target, "utf-8");
     const normalizedTarget = JSON.stringify(
       JSON.parse(targetContent),
       null,
@@ -20047,14 +20118,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk165.yellow(
+          chalk167.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk165.red("Overwrite existing settings.json?"),
+          chalk167.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -20064,45 +20135,45 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs33.writeFileSync(target, mergedContent);
+  fs35.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename4 = fileURLToPath7(import.meta.url);
-var __dirname7 = path52.dirname(__filename4);
+var __dirname7 = path54.dirname(__filename4);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path52.join(__dirname7, "..", "claude");
-  const targetBase = path52.join(os2.homedir(), ".claude");
+  const claudeDir = path54.join(__dirname7, "..", "claude");
+  const targetBase = path54.join(os2.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path52.join(claudeDir, "commands");
-  const targetDir = path52.join(targetBase, "commands");
-  fs34.mkdirSync(targetDir, { recursive: true });
-  const files = fs34.readdirSync(sourceDir);
+  const sourceDir = path54.join(claudeDir, "commands");
+  const targetDir = path54.join(targetBase, "commands");
+  fs36.mkdirSync(targetDir, { recursive: true });
+  const files = fs36.readdirSync(sourceDir);
   for (const file of files) {
-    fs34.copyFileSync(path52.join(sourceDir, file), path52.join(targetDir, file));
+    fs36.copyFileSync(path54.join(sourceDir, file), path54.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
 }
 
 // src/commands/update.ts
-import { execSync as execSync50 } from "child_process";
-import * as path53 from "path";
+import { execSync as execSync49 } from "child_process";
+import * as path55 from "path";
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path53.resolve(dir);
-    if (resolved.split(path53.sep).includes("node_modules")) {
+    const resolved = path55.resolve(dir);
+    if (resolved.split(path55.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync50("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path53.resolve(globalPrefix).toLowerCase());
+    const globalPrefix = execSync49("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    return resolved.toLowerCase().startsWith(path55.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -20112,18 +20183,18 @@ async function update2() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync50("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync49("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync50("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync49("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync50("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync49("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync50("assist sync", { stdio: "inherit" });
+    execSync49("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync50("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync49("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync50("assist sync", { stdio: "inherit" });
+    execSync49("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."