@staff0rd/assist 0.390.0 → 0.391.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.390.0",
+  version: "0.391.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -43,7 +43,9 @@ var package_default = {
     url: "https://github.com/staff0rd/assist"
   },
   dependencies: {
+    "@xterm/addon-fit": "^0.11.0",
     "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/xterm": "^6.0.0",
     "better-sqlite3": "^12.8.0",
     blessed: "^0.1.81",
     "blessed-contrib": "^4.11.0",
@@ -95,8 +97,6 @@ var package_default = {
     "@types/shell-quote": "^1.7.5",
     "@types/ws": "^8.18.1",
     "@vitest/coverage-v8": "^4.1.2",
-    "@xterm/addon-fit": "^0.11.0",
-    "@xterm/xterm": "^6.0.0",
     esbuild: "^0.27.3",
     jscpd: "^4.0.5",
     jsdom: "^29.1.1",
@@ -140,10 +140,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path61) {
-  if (!existsSync(path61)) return {};
+function loadRawYaml(path63) {
+  if (!existsSync(path63)) return {};
   try {
-    const content = readFileSync(path61, "utf8");
+    const content = readFileSync(path63, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -342,6 +342,10 @@ var assistConfigSchema = z2.strictObject({
   sync: z2.strictObject({
     autoConfirm: z2.boolean().default(false)
   }).default({ autoConfirm: false }),
+  harness: z2.strictObject({
+    engine: z2.enum(["claude", "codex"]).default("claude"),
+    exposeCodexActions: z2.boolean().optional()
+  }).default({ engine: "claude" }),
   voice: z2.strictObject({
     wakeWords: z2.array(z2.string()).default(DEFAULT_WAKE_WORDS),
     mic: z2.string().optional(),
@@ -1356,8 +1360,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path61 = line.split("	")[1];
-    if (path61) found.add(path61.trim());
+    const path63 = line.split("	")[1];
+    if (path63) found.add(path63.trim());
   }
   return [...found];
 }
@@ -1456,8 +1460,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path61 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path61}/${ref}`;
+  const path63 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path63}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -3228,9 +3232,9 @@ import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
-function resolveStringsAtPath(data, path61) {
+function resolveStringsAtPath(data, path63) {
   let current = data;
-  for (const segment of path61.split(".")) {
+  for (const segment of path63.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3243,10 +3247,10 @@ function resolveStringsAtPath(data, path61) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path61 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path61)) {
+  for (const path63 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path63)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path61, value });
+        violations.push({ file: rule.file, path: path63, value });
     }
   }
   return violations;
@@ -3285,8 +3289,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path61, value } of violations) {
-    console.log(`  ${file} ${path61}: ${value}`);
+  for (const { file, path: path63, value } of violations) {
+    console.log(`  ${file} ${path63}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -3578,15 +3582,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path61) => MIGRATION_FILE3.test(basename(path61)));
-  for (const path61 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path63) => MIGRATION_FILE3.test(basename(path63)));
+  for (const path63 of paths) {
     try {
-      const content = execSync12(`git show "${ref}:${path61}"`, {
+      const content = execSync12(`git show "${ref}:${path63}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename(path61), content);
+      baseline.set(basename(path63), content);
     } catch {
     }
   }
@@ -4906,9 +4910,6 @@ function findUnblockedTodos(items2) {
 // src/commands/backlog/run.ts
 import chalk44 from "chalk";
 
-// src/shared/spawnClaude.ts
-import { spawn as spawn3 } from "child_process";
-
 // src/commands/sessions/daemon/ensureHooksSettings.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname12 } from "path";
@@ -4954,10 +4955,29 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path61 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path61), { recursive: true });
-  writeFileSync15(path61, JSON.stringify(hooksSettings, null, 2));
-  return path61;
+  const path63 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path63), { recursive: true });
+  writeFileSync15(path63, JSON.stringify(hooksSettings, null, 2));
+  return path63;
+}
+
+// src/shared/spawnInherit.ts
+import { spawn as spawn3 } from "child_process";
+function spawnInherit(command, args) {
+  const {
+    ASSIST_ACTIVITY_ID: _activityId,
+    CLAUDE_CODE_CHILD_SESSION: _childSession,
+    ...env
+  } = process.env;
+  const child = spawn3(command, args, {
+    stdio: "inherit",
+    env
+  });
+  const done2 = new Promise((resolve18, reject) => {
+    child.on("close", (code) => resolve18(code ?? 0));
+    child.on("error", reject);
+  });
+  return { child, done: done2 };
 }
 
 // src/shared/spawnClaude.ts
@@ -4976,20 +4996,7 @@ function spawnClaude(prompt, options2 = {}) {
   if (permissionMode) {
     args.push("--permission-mode", permissionMode);
   }
-  const {
-    ASSIST_ACTIVITY_ID: _activityId,
-    CLAUDE_CODE_CHILD_SESSION: _childSession,
-    ...env
-  } = process.env;
-  const child = spawn3("claude", args, {
-    stdio: "inherit",
-    env
-  });
-  const done2 = new Promise((resolve18, reject) => {
-    child.on("close", (code) => resolve18(code ?? 0));
-    child.on("error", reject);
-  });
-  return { child, done: done2 };
+  return spawnInherit("claude", args);
 }
 function buildArgs(prompt, options2) {
   if (options2.resumeSessionId) {
@@ -5215,9 +5222,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path61 = join15(dir, ".assist", name);
-    if (existsSync18(path61)) {
-      renameSync(path61, `${path61}.bak`);
+    const path63 = join15(dir, ".assist", name);
+    if (existsSync18(path63)) {
+      renameSync(path63, `${path63}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -5656,8 +5663,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path61) {
-  const content = readFileSync14(path61, "utf8").trim();
+function parseBacklogJsonl(path63) {
+  const content = readFileSync14(path63, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -5739,8 +5746,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path61) {
-  return path61.replace(/^\/+/, "");
+function stripLeadingSlashes(path63) {
+  return path63.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -6280,24 +6287,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path61 = getOwnerPath(itemId2);
-  mkdirSync7(dirname14(path61), { recursive: true });
-  writeFileSync17(path61, JSON.stringify({ sessionId }));
+  const path63 = getOwnerPath(itemId2);
+  mkdirSync7(dirname14(path63), { recursive: true });
+  writeFileSync17(path63, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path61 = getOwnerPath(itemId2);
-  if (!existsSync21(path61)) return void 0;
+  const path63 = getOwnerPath(itemId2);
+  if (!existsSync21(path63)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync15(path61, "utf8"));
+    const parsed = JSON.parse(readFileSync15(path63, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path61 = getOwnerPath(itemId2);
+  const path63 = getOwnerPath(itemId2);
   try {
-    rmSync(path61);
+    rmSync(path63);
   } catch {
   }
 }
@@ -6334,19 +6341,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path61 = getSignalPath(target);
-  if (!path61) return;
+  const path63 = getSignalPath(target);
+  if (!path63) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname15(path61), { recursive: true });
-  writeFileSync18(path61, JSON.stringify(signal));
+  mkdirSync8(dirname15(path63), { recursive: true });
+  writeFileSync18(path63, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path61 = getSignalPath();
-  if (!path61 || !existsSync22(path61)) return void 0;
+  const path63 = getSignalPath();
+  if (!path63 || !existsSync22(path63)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path61, "utf8"));
+    return JSON.parse(readFileSync16(path63, "utf8"));
   } catch {
     return void 0;
   }
@@ -6441,13 +6448,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path61 = activityPath(sessionId);
-  mkdirSync9(dirname16(path61), { recursive: true });
-  writeFileSync19(path61, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path63 = activityPath(sessionId);
+  mkdirSync9(dirname16(path63), { recursive: true });
+  writeFileSync19(path63, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path61) {
+function readActivity(path63) {
   try {
-    return JSON.parse(readFileSync17(path61, "utf8"));
+    return JSON.parse(readFileSync17(path63, "utf8"));
   } catch {
     return void 0;
   }
@@ -6457,9 +6464,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path61 = activityPath(sessionId);
-  mkdirSync9(dirname16(path61), { recursive: true });
-  writeFileSync19(path61, JSON.stringify(activity2));
+  const path63 = activityPath(sessionId);
+  mkdirSync9(dirname16(path63), { recursive: true });
+  writeFileSync19(path63, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -7690,8 +7697,8 @@ async function getBacklogExists(req, res) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path61 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path61.split("/").filter(Boolean);
+    const path63 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path63.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -8082,7 +8089,7 @@ function findSynthesisForBranch(repoReviewsDir, branch2) {
   const parent = dirname20(branchKeyPath);
   const branchPrefix = basename5(branchKeyPath);
   if (!existsSync25(parent)) return null;
-  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join23(parent, name, "synthesis.md")).filter((path61) => existsSync25(path61)).map((path61) => ({ path: path61, mtime: statSync2(path61).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const synthesisFiles = readdirSync2(parent).filter((name) => name.startsWith(branchPrefix)).map((name) => join23(parent, name, "synthesis.md")).filter((path63) => existsSync25(path63)).map((path63) => ({ path: path63, mtime: statSync2(path63).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -8131,12 +8138,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path61 = await resolveSynthesisPath(cwd);
-    if (!path61) {
+    const path63 = await resolveSynthesisPath(cwd);
+    if (!path63) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync19(path61, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync19(path63, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -8203,21 +8210,78 @@ function runGitStatus(cwd) {
   }).then((r) => r.stdout);
 }
 
+// src/shared/harnesses.ts
+import * as os2 from "os";
+import * as path25 from "path";
+
+// src/shared/checkCliAvailable.ts
+import { execSync as execSync29 } from "child_process";
+function checkCliAvailable(cli) {
+  const binary = cli.split(/\s+/)[0];
+  const opts = {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  };
+  try {
+    execSync29(`command -v ${binary}`, opts);
+    return true;
+  } catch {
+    try {
+      execSync29(`where ${binary}`, opts);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// src/shared/harnesses.ts
+var harnesses = {
+  claude: {
+    kind: "claude",
+    command: "claude",
+    homeDir: path25.join(os2.homedir(), ".claude"),
+    sync: {
+      agentsFile: "CLAUDE.md",
+      commandDest: (name) => path25.join("commands", `${name}.md`)
+    }
+  },
+  codex: {
+    kind: "codex",
+    command: "codex",
+    homeDir: path25.join(os2.homedir(), ".codex"),
+    sync: {
+      agentsFile: "AGENTS.md",
+      commandDest: (name) => path25.join("skills", name, "SKILL.md")
+    }
+  }
+};
+function isHarnessAvailable(kind) {
+  return checkCliAvailable(harnesses[kind].command);
+}
+
+// src/commands/sessions/web/harnessCapabilities.ts
+function harnessCapabilities(_req, res) {
+  const forcedOff = loadConfig().harness.exposeCodexActions === false;
+  const exposeCodexActions = !forcedOff && isHarnessAvailable("codex");
+  respondJson(res, 200, { exposeCodexActions });
+}
+
 // src/shared/loadJson.ts
 import { existsSync as existsSync26, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync20 } from "fs";
-import { homedir as homedir12 } from "os";
-import { join as join25 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join26 } from "path";
 function getStoreDir() {
-  return join25(homedir12(), ".assist");
+  return join26(homedir13(), ".assist");
 }
 function getStorePath(filename) {
-  return join25(getStoreDir(), filename);
+  return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path61 = getStorePath(filename);
-  if (existsSync26(path61)) {
+  const path63 = getStorePath(filename);
+  if (existsSync26(path63)) {
     try {
-      return JSON.parse(readFileSync20(path61, "utf8"));
+      return JSON.parse(readFileSync20(path63, "utf8"));
     } catch {
       return {};
     }
@@ -8689,6 +8753,7 @@ var routes2 = {
   "GET /api/github-url": githubUrl,
   "GET /api/git-status": gitStatus,
   "GET /api/jira-site": jiraSite,
+  "GET /api/harness": harnessCapabilities,
   "GET /api/pr-status": prStatus,
   "GET /api/pr-list": prList,
   "GET /api/news/items": listNewsItems,
@@ -9139,12 +9204,12 @@ import chalk64 from "chalk";
 import { eq as eq18 } from "drizzle-orm";
 
 // src/commands/jira/fetchIssue.ts
-import { execSync as execSync29 } from "child_process";
+import { execSync as execSync30 } from "child_process";
 import chalk63 from "chalk";
 function fetchIssue(issueKey, fields) {
   let result;
   try {
-    result = execSync29(
+    result = execSync30(
       `acli jira workitem view ${issueKey} -f ${fields} --json`,
       { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
     );
@@ -9563,7 +9628,7 @@ function ensureRemoteOrigin() {
 import { spawnSync as spawnSync2 } from "child_process";
 import { mkdtempSync, readFileSync as readFileSync22, unlinkSync as unlinkSync6, writeFileSync as writeFileSync21 } from "fs";
 import { tmpdir } from "os";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 import enquirer6 from "enquirer";
 async function promptType() {
   const { type } = await enquirer6.prompt({
@@ -9603,8 +9668,8 @@ async function promptDescription() {
 }
 function openEditor() {
   const editor = process.env.EDITOR || process.env.VISUAL || "vi";
-  const dir = mkdtempSync(join26(tmpdir(), "assist-"));
-  const filePath = join26(dir, "description.md");
+  const dir = mkdtempSync(join27(tmpdir(), "assist-"));
+  const filePath = join27(dir, "description.md");
   writeFileSync21(filePath, "");
   const result = spawnSync2(editor, [filePath], { stdio: "inherit" });
   if (result.status !== 0) {
@@ -10003,6 +10068,24 @@ import enquirer7 from "enquirer";
 // src/commands/backlog/launchMode.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
+// src/shared/spawnCodex.ts
+function spawnCodex(prompt, options2 = {}) {
+  const cwd = options2.cwd ?? process.cwd();
+  return spawnInherit(harnesses.codex.command, ["-C", cwd, prompt]);
+}
+
+// src/shared/spawnHarness.ts
+function spawnHarness(harness, prompt, options2 = {}) {
+  if (harness === "codex") {
+    return spawnCodex(prompt, { cwd: options2.cwd });
+  }
+  return spawnClaude(prompt, {
+    allowEdits: true,
+    sessionId: options2.sessionId,
+    resumeSessionId: options2.resumeSessionId
+  });
+}
+
 // src/commands/backlog/handleLaunchSignal.ts
 import chalk81 from "chalk";
 
@@ -10103,10 +10186,12 @@ async function launchMode(slashCommand, options2) {
     itemName: options2?.itemName,
     claudeSessionId
   });
-  const { child, done: done2 } = spawnClaude(
-    resumeSessionId ? resumeNudge() : buildSlashCommand(slashCommand, options2?.description),
-    { allowEdits: true, sessionId: claudeSessionId, resumeSessionId }
-  );
+  const prompt = resumeSessionId ? resumeNudge() : buildSlashCommand(slashCommand, options2?.description);
+  const { child, done: done2 } = spawnHarness(options2?.harness ?? "claude", prompt, {
+    sessionId: claudeSessionId,
+    resumeSessionId,
+    cwd: process.cwd()
+  });
   const marker = watchForMarker(child, { actOnDone: options2?.once });
   const exitCode = await awaitClaude(done2, `/${slashCommand}`);
   stopWatching();
@@ -10156,10 +10241,22 @@ async function refine(id, options2) {
   });
 }
 
+// src/commands/backlog/resolveHarness.ts
+function resolveHarness(value) {
+  if (value === "claude" || value === "codex") return value;
+  return loadConfig().harness.engine;
+}
+
 // src/commands/backlog/registerRefineCommand.ts
 function registerRefineCommand(cmd) {
-  cmd.command("refine").argument("[id]", "Backlog item ID").description("Alias for refine").option("--once", "Exit when the initial task completes").action(
-    (id, opts) => refine(id, { once: opts.once })
+  cmd.command("refine").argument("[id]", "Backlog item ID").description("Alias for refine").option("--once", "Exit when the initial task completes").option(
+    "--harness <kind>",
+    "Coding harness to launch (claude|codex); defaults to the configured harness.engine"
+  ).action(
+    (id, opts) => refine(id, {
+      once: opts.once,
+      harness: resolveHarness(opts.harness)
+    })
   );
 }
 
@@ -11335,12 +11432,12 @@ function findBuiltinDenyRaw(rawCommand) {
 
 // src/commands/cliHook/logDeniedToolCall.ts
 import { mkdirSync as mkdirSync12 } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join27 } from "path";
+import { homedir as homedir14 } from "os";
+import { join as join28 } from "path";
 import Database from "better-sqlite3";
 var _db;
 function getDbDir() {
-  return join27(homedir13(), ".assist");
+  return join28(homedir14(), ".assist");
 }
 function initSchema(db) {
   db.exec(`
@@ -11359,7 +11456,7 @@ function openPromptsDb(dir) {
   if (_db) return _db;
   const dbDir = dir ?? getDbDir();
   mkdirSync12(dbDir, { recursive: true });
-  const db = new Database(join27(dbDir, "assist.db"));
+  const db = new Database(join28(dbDir, "assist.db"));
   db.pragma("journal_mode = WAL");
   initSchema(db);
   _db = db;
@@ -11469,9 +11566,9 @@ var __dirname4 = dirname21(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path61) {
-  if (!existsSync27(path61)) return [];
-  return readFileSync23(path61, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path63) {
+  if (!existsSync27(path63)) return [];
+  return readFileSync23(path63, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -11518,13 +11615,13 @@ function findCliWrite(command) {
 
 // src/shared/readSettingsPerms.ts
 import { existsSync as existsSync28, readFileSync as readFileSync24 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join28 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join29 } from "path";
 function readSettingsPerms(key) {
   const paths = [
-    join28(homedir14(), ".claude", "settings.json"),
-    join28(process.cwd(), ".claude", "settings.json"),
-    join28(process.cwd(), ".claude", "settings.local.json")
+    join29(homedir15(), ".claude", "settings.json"),
+    join29(process.cwd(), ".claude", "settings.json"),
+    join29(process.cwd(), ".claude", "settings.local.json")
   ];
   const entries = [];
   for (const p of paths) {
@@ -11798,29 +11895,8 @@ ${reasons.join("\n")}`);
 
 // src/commands/permitCliReads/index.ts
 import { existsSync as existsSync29, mkdirSync as mkdirSync13, readFileSync as readFileSync25, writeFileSync as writeFileSync23 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join29 } from "path";
-
-// src/shared/checkCliAvailable.ts
-import { execSync as execSync30 } from "child_process";
-function checkCliAvailable(cli) {
-  const binary = cli.split(/\s+/)[0];
-  const opts = {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  };
-  try {
-    execSync30(`command -v ${binary}`, opts);
-    return true;
-  } catch {
-    try {
-      execSync30(`where ${binary}`, opts);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
+import { homedir as homedir16 } from "os";
+import { join as join30 } from "path";
 
 // src/commands/permitCliReads/assertCliExists.ts
 function assertCliExists(cli) {
@@ -11936,14 +12012,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, path61, description, depth, p) {
-  showProgress(p, path61.join(" "));
-  const subHelp = await runHelp([cli, ...path61]);
+async function resolveCommand(cli, path63, description, depth, p) {
+  showProgress(p, path63.join(" "));
+  const subHelp = await runHelp([cli, ...path63]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path61, description }];
+    return [{ path: path63, description }];
   }
-  const children = await discoverAt(cli, path61, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path61, description }];
+  const children = await discoverAt(cli, path63, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path63, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -12088,15 +12164,15 @@ function updateSettings(cli, commands) {
 // src/commands/permitCliReads/index.ts
 function logPath(cli) {
   const safeName = cli.replace(/\s+/g, "-");
-  return join29(homedir15(), ".assist", `cli-discover-${safeName}.log`);
+  return join30(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path61 = logPath(cli);
-  if (!existsSync29(path61)) return void 0;
-  return readFileSync25(path61, "utf8");
+  const path63 = logPath(cli);
+  if (!existsSync29(path63)) return void 0;
+  return readFileSync25(path63, "utf8");
 }
 function writeCache(cli, output) {
-  const dir = join29(homedir15(), ".assist");
+  const dir = join30(homedir16(), ".assist");
   mkdirSync13(dir, { recursive: true });
   writeFileSync23(logPath(cli), output);
 }
@@ -12243,18 +12319,18 @@ import { existsSync as existsSync31, readFileSync as readFileSync27, unlinkSync
 import chalk109 from "chalk";
 
 // src/commands/codeComment/getRestrictedDir.ts
-import { homedir as homedir16 } from "os";
-import { join as join30 } from "path";
+import { homedir as homedir17 } from "os";
+import { join as join31 } from "path";
 function getRestrictedDir() {
-  return join30(homedir16(), ".assist", "restricted");
+  return join31(homedir17(), ".assist", "restricted");
 }
 function getPinStatePath(pin) {
-  return join30(getRestrictedDir(), `code-comment-${pin}.json`);
+  return join31(getRestrictedDir(), `code-comment-${pin}.json`);
 }
 
 // src/commands/codeComment/sweepRestrictedDir.ts
 import { readdirSync as readdirSync3, statSync as statSync3, unlinkSync as unlinkSync7 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var STALE_AFTER_MS = 30 * 60 * 1e3;
 function sweepRestrictedDir(dir = getRestrictedDir()) {
   let entries;
@@ -12265,9 +12341,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path61 = join31(dir, entry);
+    const path63 = join32(dir, entry);
     try {
-      if (statSync3(path61).mtimeMs < cutoff) unlinkSync7(path61);
+      if (statSync3(path63).mtimeMs < cutoff) unlinkSync7(path63);
     } catch {
       continue;
     }
@@ -12277,10 +12353,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
 function readPinState(pin) {
-  const path61 = getPinStatePath(pin);
-  if (!existsSync30(path61)) return void 0;
+  const path63 = getPinStatePath(pin);
+  if (!existsSync30(path63)) return void 0;
   try {
-    const state = JSON.parse(readFileSync26(path61, "utf8"));
+    const state = JSON.parse(readFileSync26(path63, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -12437,13 +12513,13 @@ import chalk112 from "chalk";
 
 // src/commands/complexity/shared/index.ts
 import fs19 from "fs";
-import path26 from "path";
+import path27 from "path";
 import chalk111 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
 import fs18 from "fs";
-import path25 from "path";
+import path26 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
   const { complexity } = loadConfig();
@@ -12457,7 +12533,7 @@ function walk(dir, results) {
   const extensions = [".ts", ".tsx"];
   const entries = fs18.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path25.join(dir, entry.name);
+    const fullPath = path26.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name !== "node_modules" && entry.name !== ".git") {
         walk(fullPath, results);
@@ -12679,7 +12755,7 @@ function countSloc(content) {
 function createSourceFromFile(filePath) {
   const content = fs19.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
-    path26.basename(filePath),
+    path27.basename(filePath),
     content,
     ts5.ScriptTarget.Latest,
     true,
@@ -13046,8 +13122,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path61, value) {
-  const keys = path61.split(".");
+function setNestedValue(obj, path63, value) {
+  const keys = path63.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -13127,9 +13203,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path61) {
+function getNestedValue(obj, path63) {
   let current = obj;
-  for (const key of path61.split(".")) current = stepInto(current, key);
+  for (const key of path63.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -13271,11 +13347,11 @@ import { execFileSync as execFileSync2 } from "child_process";
 import { basename as basename9 } from "path";
 
 // src/commands/devlog/loadBlogSkipDays.ts
-import { homedir as homedir17 } from "os";
-import { join as join32 } from "path";
-var BLOG_REPO_ROOT = join32(homedir17(), "git/blog");
+import { homedir as homedir18 } from "os";
+import { join as join33 } from "path";
+var BLOG_REPO_ROOT = join33(homedir18(), "git/blog");
 function loadBlogSkipDays(repoName) {
-  const config = loadRawYaml(join32(BLOG_REPO_ROOT, "assist.yml"));
+  const config = loadRawYaml(join33(BLOG_REPO_ROOT, "assist.yml"));
   const devlog = config.devlog;
   const skip2 = devlog?.skip;
   return new Set(skip2?.[repoName]);
@@ -13287,13 +13363,13 @@ import chalk124 from "chalk";
 
 // src/shared/getRepoName.ts
 import { existsSync as existsSync33, readFileSync as readFileSync29 } from "fs";
-import { basename as basename8, join as join33 } from "path";
+import { basename as basename8, join as join34 } from "path";
 function getRepoName() {
   const config = loadConfig();
   if (config.devlog?.name) {
     return config.devlog.name;
   }
-  const packageJsonPath = join33(process.cwd(), "package.json");
+  const packageJsonPath = join34(process.cwd(), "package.json");
   if (existsSync33(packageJsonPath)) {
     try {
       const content = readFileSync29(packageJsonPath, "utf8");
@@ -13309,8 +13385,8 @@ function getRepoName() {
 
 // src/commands/devlog/loadDevlogEntries.ts
 import { readdirSync as readdirSync4, readFileSync as readFileSync30 } from "fs";
-import { join as join34 } from "path";
-var DEVLOG_DIR = join34(BLOG_REPO_ROOT, "src/content/devlog");
+import { join as join35 } from "path";
+var DEVLOG_DIR = join35(BLOG_REPO_ROOT, "src/content/devlog");
 function extractFrontmatter(content) {
   const fm = content.match(/^---\n([\s\S]*?)\n---/);
   return fm?.[1] ?? null;
@@ -13338,7 +13414,7 @@ function readDevlogFiles(callback) {
   try {
     const files = readdirSync4(DEVLOG_DIR).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync30(join34(DEVLOG_DIR, file), "utf8");
+      const content = readFileSync30(join35(DEVLOG_DIR, file), "utf8");
       const parsed = parseFrontmatter(content, file);
       if (parsed) callback(parsed);
     }
@@ -13726,11 +13802,11 @@ function repos(options2) {
 
 // src/commands/devlog/skip.ts
 import { writeFileSync as writeFileSync27 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import chalk129 from "chalk";
 import { stringify as stringifyYaml3 } from "yaml";
 function getBlogConfigPath() {
-  return join35(BLOG_REPO_ROOT, "assist.yml");
+  return join36(BLOG_REPO_ROOT, "assist.yml");
 }
 function skip(date) {
   if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
@@ -13811,19 +13887,19 @@ function registerDevlog(program2) {
 
 // src/commands/dotnet/checkBuildLocks.ts
 import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync5 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 import chalk131 from "chalk";
 
 // src/shared/findRepoRoot.ts
 import { existsSync as existsSync34 } from "fs";
-import path27 from "path";
+import path28 from "path";
 function findRepoRoot(dir) {
   let current = dir;
-  while (current !== path27.dirname(current)) {
-    if (existsSync34(path27.join(current, ".git"))) {
+  while (current !== path28.dirname(current)) {
+    if (existsSync34(path28.join(current, ".git"))) {
       return current;
     }
-    current = path27.dirname(current);
+    current = path28.dirname(current);
   }
   return null;
 }
@@ -13839,7 +13915,7 @@ function isLockedDll(debugDir) {
   }
   for (const file of files) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
-    const dllPath = join36(debugDir, file);
+    const dllPath = join37(debugDir, file);
     try {
       const fd = openSync2(dllPath, "r+");
       closeSync2(fd);
@@ -13857,13 +13933,13 @@ function findFirstLockedDll(dir) {
     return null;
   }
   if (entries.includes("bin")) {
-    const locked = isLockedDll(join36(dir, "bin", "Debug"));
+    const locked = isLockedDll(join37(dir, "bin", "Debug"));
     if (locked) return locked;
   }
   for (const entry of entries) {
     if (SKIP_DIRS.has(entry) || entry === "bin" || entry.startsWith("."))
       continue;
-    const found = findFirstLockedDll(join36(dir, entry));
+    const found = findFirstLockedDll(join37(dir, entry));
     if (found) return found;
   }
   return null;
@@ -13887,7 +13963,7 @@ async function checkBuildLocksCommand() {
 
 // src/commands/dotnet/buildTree.ts
 import { readFileSync as readFileSync31 } from "fs";
-import path28 from "path";
+import path29 from "path";
 var PROJECT_REF_RE = /<ProjectReference\s+Include="([^"]+)"/g;
 function getProjectRefs(csprojPath) {
   const content = readFileSync31(csprojPath, "utf8");
@@ -13898,14 +13974,14 @@ function getProjectRefs(csprojPath) {
   return refs;
 }
 function buildTree(csprojPath, repoRoot, visited = /* @__PURE__ */ new Set()) {
-  const abs = path28.resolve(csprojPath);
-  const rel = path28.relative(repoRoot, abs);
+  const abs = path29.resolve(csprojPath);
+  const rel = path29.relative(repoRoot, abs);
   const node = { path: abs, relativePath: rel, children: [] };
   if (visited.has(abs)) return node;
   visited.add(abs);
-  const dir = path28.dirname(abs);
+  const dir = path29.dirname(abs);
   for (const ref of getProjectRefs(abs)) {
-    const childAbs = path28.resolve(dir, ref);
+    const childAbs = path29.resolve(dir, ref);
     try {
       readFileSync31(childAbs);
       node.children.push(buildTree(childAbs, repoRoot, visited));
@@ -13933,7 +14009,7 @@ function collectAllDeps(node) {
 
 // src/commands/dotnet/findContainingSolutions.ts
 import { readdirSync as readdirSync6, readFileSync as readFileSync32, statSync as statSync4 } from "fs";
-import path29 from "path";
+import path30 from "path";
 function findSlnFiles(dir, maxDepth, depth = 0) {
   if (depth > maxDepth) return [];
   const results = [];
@@ -13946,7 +14022,7 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "node_modules" || entry === "packages")
       continue;
-    const full = path29.join(dir, entry);
+    const full = path30.join(dir, entry);
     try {
       const stat2 = statSync4(full);
       if (stat2.isFile() && entry.endsWith(".sln")) {
@@ -13960,8 +14036,8 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
   return results;
 }
 function findContainingSolutions(csprojPath, repoRoot) {
-  const csprojAbs = path29.resolve(csprojPath);
-  const csprojBasename = path29.basename(csprojAbs);
+  const csprojAbs = path30.resolve(csprojPath);
+  const csprojBasename = path30.basename(csprojAbs);
   const slnFiles = findSlnFiles(repoRoot, 3);
   const matches = [];
   const pattern2 = new RegExp(`[\\\\"/]${escapeRegex(csprojBasename)}"`);
@@ -13969,7 +14045,7 @@ function findContainingSolutions(csprojPath, repoRoot) {
     try {
       const content = readFileSync32(sln, "utf8");
       if (pattern2.test(content)) {
-        matches.push(path29.relative(repoRoot, sln));
+        matches.push(path30.relative(repoRoot, sln));
       }
     } catch {
     }
@@ -14032,15 +14108,15 @@ function printJson(tree, totalCount, solutions) {
 
 // src/commands/dotnet/resolveCsproj.ts
 import { existsSync as existsSync35 } from "fs";
-import path30 from "path";
+import path31 from "path";
 import chalk133 from "chalk";
 function resolveCsproj(csprojPath) {
-  const resolved = path30.resolve(csprojPath);
+  const resolved = path31.resolve(csprojPath);
   if (!existsSync35(resolved)) {
     console.error(chalk133.red(`File not found: ${resolved}`));
     process.exit(1);
   }
-  const repoRoot = findRepoRoot(path30.dirname(resolved));
+  const repoRoot = findRepoRoot(path31.dirname(resolved));
   if (!repoRoot) {
     console.error(chalk133.red("Could not find git repository root"));
     process.exit(1);
@@ -14205,16 +14281,16 @@ function filterIssues(issues, all, cliOnly, cliSuppress) {
 
 // src/commands/dotnet/resolveSolution.ts
 import { existsSync as existsSync36 } from "fs";
-import path31 from "path";
+import path32 from "path";
 import chalk137 from "chalk";
 
 // src/commands/dotnet/findSolution.ts
 import { readdirSync as readdirSync7 } from "fs";
-import { dirname as dirname22, join as join37 } from "path";
+import { dirname as dirname22, join as join38 } from "path";
 import chalk136 from "chalk";
 function findSlnInDir(dir) {
   try {
-    return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join37(dir, f));
+    return readdirSync7(dir).filter((f) => f.endsWith(".sln")).map((f) => join38(dir, f));
   } catch {
     return [];
   }
@@ -14244,7 +14320,7 @@ function findSolution() {
 // src/commands/dotnet/resolveSolution.ts
 function resolveSolution(sln) {
   if (sln) {
-    const resolved = path31.resolve(sln);
+    const resolved = path32.resolve(sln);
     if (!existsSync36(resolved)) {
       console.error(chalk137.red(`Solution file not found: ${resolved}`));
       process.exit(1);
@@ -14287,7 +14363,7 @@ function parseInspectReport(json) {
 import { execSync as execSync35 } from "child_process";
 import { existsSync as existsSync37, readFileSync as readFileSync33, unlinkSync as unlinkSync9 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import path32 from "path";
+import path33 from "path";
 import chalk138 from "chalk";
 function assertJbInstalled() {
   try {
@@ -14301,7 +14377,7 @@ function assertJbInstalled() {
   }
 }
 function runInspectCode(slnPath, include, swea) {
-  const reportPath = path32.join(tmpdir3(), `inspect-${Date.now()}.xml`);
+  const reportPath = path33.join(tmpdir3(), `inspect-${Date.now()}.xml`);
   const includeFlag = include ? ` --include="${include}"` : "";
   const sweaFlag = swea ? " --swea" : "";
   try {
@@ -14668,7 +14744,7 @@ function aggregateCommitters(authorLists) {
 import { spawnSync as spawnSync3 } from "child_process";
 import { unlinkSync as unlinkSync10, writeFileSync as writeFileSync28 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 function buildArgs2(queryFile, vars) {
   const args = ["api", "graphql", "-F", `query=@${queryFile}`];
   for (const [key, value] of Object.entries(vars)) {
@@ -14693,7 +14769,7 @@ function throwOnGraphqlErrors(stdout) {
   throw new Error(messages || "GraphQL request returned errors");
 }
 function runGhGraphql(mutation, vars) {
-  const queryFile = join38(tmpdir4(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join39(tmpdir4(), `gh-query-${Date.now()}.graphql`);
   writeFileSync28(queryFile, mutation);
   try {
     const result = spawnSync3("gh", buildArgs2(queryFile, vars), {
@@ -14886,18 +14962,18 @@ import {
   rmSync as rmSync3,
   statSync as statSync5
 } from "fs";
-import { basename as basename10, join as join41 } from "path";
+import { basename as basename10, join as join42 } from "path";
 
 // src/commands/handover/getHandoverPath.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function getHandoverPath(cwd = process.cwd()) {
-  return join39(cwd, ".assist", "HANDOVER.md");
+  return join40(cwd, ".assist", "HANDOVER.md");
 }
 
 // src/commands/handover/getHandoversDir.ts
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 function getHandoversDir(cwd = process.cwd()) {
-  return join40(cwd, ".assist", "handovers");
+  return join41(cwd, ".assist", "handovers");
 }
 
 // src/commands/handover/parseArchiveTimestamp.ts
@@ -14938,7 +15014,7 @@ function collectMarkdown(dir) {
   if (!existsSync38(dir)) return [];
   const out = [];
   for (const entry of readdirSync8(dir, { withFileTypes: true })) {
-    const full = join41(dir, entry.name);
+    const full = join42(dir, entry.name);
     if (entry.isDirectory()) out.push(...collectMarkdown(full));
     else if (entry.isFile() && entry.name.endsWith(".md")) out.push(full);
   }
@@ -15267,6 +15343,34 @@ function registerJira(program2) {
   ]);
 }
 
+// src/commands/backlog/registerRefineLaunch.ts
+var HARNESS_FLAG = "Coding harness to launch (claude|codex); defaults to the configured harness.engine";
+var HARNESS_CONFIG_HELP = [
+  {
+    key: "harness.engine",
+    setter: "assist config set harness.engine <claude|codex>",
+    note: "default coding harness launched by refine and other flows"
+  },
+  {
+    key: "harness.exposeCodexActions",
+    setter: "assist config set harness.exposeCodexActions <true|false>",
+    note: "force the web UI 'with Codex' actions off even when codex is on PATH"
+  }
+];
+function runRefine(id, opts) {
+  return refine(id, {
+    once: opts.once,
+    resumeSessionId: opts.resumeSession,
+    harness: resolveHarness(opts.harness)
+  });
+}
+function registerRefineLaunch(program2, resumeFlag) {
+  const command = program2.command("refine").argument("[id]", "Backlog item ID").description(
+    "Launch a coding harness in /refine mode to refine a backlog item"
+  ).option("--once", "Exit when the initial task completes").option("--resume-session <id>", resumeFlag).option("--harness <kind>", HARNESS_FLAG).action(runRefine);
+  configHelp(command, HARNESS_CONFIG_HELP);
+}
+
 // src/commands/reviewComments.ts
 import { execFileSync as execFileSync5 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
@@ -15312,11 +15416,6 @@ function registerDescriptionLaunch(program2, name, slashCommand, description, al
 function registerReviewComments(program2) {
   program2.command("review-comments").argument("[number]", "PR number to check out first").description("Launch Claude in /review-comments mode (single session)").action((number) => reviewComments(number));
 }
-function registerRefine(program2) {
-  program2.command("refine").argument("[id]", "Backlog item ID").description("Launch Claude in /refine mode to refine a backlog item").option("--once", "Exit when the initial task completes").option("--resume-session <id>", RESUME_SESSION_FLAG).action(
-    (id, opts) => refine(id, { once: opts.once, resumeSessionId: opts.resumeSession })
-  );
-}
 function registerLaunch(program2) {
   registerNext(program2);
   registerDescriptionLaunch(
@@ -15333,7 +15432,7 @@ function registerLaunch(program2) {
     "Launch Claude in /bug mode, chain into next on /next signal"
   );
   registerReviewComments(program2);
-  registerRefine(program2);
+  registerRefineLaunch(program2, RESUME_SESSION_FLAG);
 }
 
 // src/commands/registerList.ts
@@ -15543,15 +15642,15 @@ function createNetcapHandler(options2) {
 // src/commands/netcap/prepareExtensionForLoad.ts
 import { cp, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { networkInterfaces } from "os";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 import chalk149 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
-import { dirname as dirname23, join as join42 } from "path";
+import { dirname as dirname23, join as join43 } from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 var moduleDir = dirname23(fileURLToPath6(import.meta.url));
 function netcapExtensionDir() {
-  return join42(moduleDir, "commands", "netcap", "netcap-extension");
+  return join43(moduleDir, "commands", "netcap", "netcap-extension");
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
@@ -15566,7 +15665,7 @@ function lanIPv4() {
   return void 0;
 }
 async function configureBackground(dir, host, port, filter) {
-  const file = join43(dir, "background.js");
+  const file = join44(dir, "background.js");
   const source = await readFile2(file, "utf8");
   await writeFile2(
     file,
@@ -15606,20 +15705,20 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute, join as join45, resolve as resolve12 } from "path";
+import { isAbsolute, join as join46, resolve as resolve12 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
-import { homedir as homedir18 } from "os";
-import { join as join44 } from "path";
+import { homedir as homedir19 } from "os";
+import { join as join45 } from "path";
 function defaultCapturePath() {
-  return join44(homedir18(), ".assist", "netcap", "capture.jsonl");
+  return join45(homedir19(), ".assist", "netcap", "capture.jsonl");
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
   const dir = isAbsolute(out) ? out : resolve12(process.cwd(), out);
-  return join45(dir, "capture.jsonl");
+  return join46(dir, "capture.jsonl");
 }
 
 // src/commands/netcap/netcap.ts
@@ -15666,7 +15765,7 @@ netcap stopped \u2014 captured ${count7} ${count7 === 1 ? "entry" : "entries"} t
 
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync30 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 import chalk151 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
@@ -15692,9 +15791,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path61] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path63] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path61) {
+    for (const key of path63) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -16111,7 +16210,7 @@ function extractPostsFromCapture(captureFile) {
 function netcapExtract(file) {
   const captureFile = file ?? defaultCapturePath();
   const posts = extractPostsFromCapture(captureFile);
-  const outFile = join46(captureFile, "..", "posts.json");
+  const outFile = join47(captureFile, "..", "posts.json");
   writeFileSync30(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
@@ -16341,15 +16440,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path61, line, body, startLine) {
+function comment2(path63, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path61, line, startLine });
+    postComment({ prId, body, path: path63, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path61}:${range}`);
+    console.log(`Added review comment on ${path63}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -16547,14 +16646,14 @@ import { execSync as execSync41 } from "child_process";
 import { execSync as execSync40 } from "child_process";
 import { unlinkSync as unlinkSync12, writeFileSync as writeFileSync31 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
 import { existsSync as existsSync39, readFileSync as readFileSync37, unlinkSync as unlinkSync11 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 import { parse as parse2 } from "yaml";
 function getCachePath(prNumber) {
-  return join47(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
+  return join48(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`);
 }
 function loadCommentsCache(prNumber) {
   const cachePath = getCachePath(prNumber);
@@ -16584,7 +16683,7 @@ function replyToComment(org, repo, prNumber, commentId, message) {
 // src/commands/prs/resolveCommentWithReply.ts
 function resolveThread(threadId) {
   const mutation = `mutation($threadId: ID!) { resolveReviewThread(input: {threadId: $threadId}) { thread { isResolved } } }`;
-  const queryFile = join48(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
+  const queryFile = join49(tmpdir5(), `gh-mutation-${Date.now()}.graphql`);
   writeFileSync31(queryFile, mutation);
   try {
     execSync40(
@@ -16667,17 +16766,17 @@ function fixed(commentId, sha) {
 
 // src/commands/prs/listComments/index.ts
 import { existsSync as existsSync40, mkdirSync as mkdirSync16, writeFileSync as writeFileSync33 } from "fs";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 import { stringify } from "yaml";
 
 // src/commands/prs/fetchThreadIds.ts
 import { execSync as execSync42 } from "child_process";
 import { unlinkSync as unlinkSync13, writeFileSync as writeFileSync32 } from "fs";
 import { tmpdir as tmpdir6 } from "os";
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 var THREAD_QUERY = `query($owner: String!, $repo: String!, $prNumber: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $prNumber) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 100) { nodes { databaseId } } } } } } }`;
 function fetchThreadIds(org, repo, prNumber) {
-  const queryFile = join49(tmpdir6(), `gh-query-${Date.now()}.graphql`);
+  const queryFile = join50(tmpdir6(), `gh-query-${Date.now()}.graphql`);
   writeFileSync32(queryFile, THREAD_QUERY);
   try {
     const result = execSync42(
@@ -16791,7 +16890,7 @@ function printComments2(result) {
 
 // src/commands/prs/listComments/index.ts
 function writeCommentsCache(prNumber, comments3) {
-  const assistDir = join50(process.cwd(), ".assist");
+  const assistDir = join51(process.cwd(), ".assist");
   if (!existsSync40(assistDir)) {
     mkdirSync16(assistDir, { recursive: true });
   }
@@ -16800,7 +16899,7 @@ function writeCommentsCache(prNumber, comments3) {
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  const cachePath = join50(assistDir, `pr-${prNumber}-comments.yaml`);
+  const cachePath = join51(assistDir, `pr-${prNumber}-comments.yaml`);
   writeFileSync33(cachePath, stringify(cacheData));
 }
 function handleKnownErrors(error) {
@@ -16833,7 +16932,7 @@ async function listComments() {
     ];
     updateCache(prNumber, allComments);
     const hasLineComments = allComments.some((c) => c.type === "line");
-    const cachePath = hasLineComments ? join50(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
+    const cachePath = hasLineComments ? join51(process.cwd(), ".assist", `pr-${prNumber}-comments.yaml`) : null;
     return { comments: allComments, cachePath };
   } catch (error) {
     const handled = handleKnownErrors(error);
@@ -17210,8 +17309,8 @@ function registerPrs(program2) {
   prsCommand.command("reply <comment-id> <body>").description("Reply to a comment thread without resolving it").action((commentId, body) => {
     reply(Number.parseInt(commentId, 10), body);
   });
-  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path61, line, body) => {
-    comment2(path61, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path63, line, body) => {
+    comment2(path63, Number.parseInt(line, 10), body);
   });
   configHelp(prsCommand, prsConfigHelp);
 }
@@ -17464,10 +17563,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path61) {
+async function ravenFetch(connection, path63) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path61}`;
+  const url = `${connection.url}${path63}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -17571,16 +17670,16 @@ import chalk166 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path61;
+  let path63;
   if (opts.collection) {
-    path61 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path63 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path61 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path63 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path61 += `&query=${encodeURIComponent(opts.query)}`;
+    path63 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path61;
+  return path63;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -17589,7 +17688,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 path61 = buildQueryPath({
+    const path63 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -17597,7 +17696,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path61);
+    const data = await ravenFetch(connection, path63);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -17655,7 +17754,7 @@ function registerRavendb(program2) {
 
 // src/commands/refactor/check/index.ts
 import { spawn as spawn5 } from "child_process";
-import * as path33 from "path";
+import * as path34 from "path";
 
 // src/commands/refactor/logViolations.ts
 import chalk168 from "chalk";
@@ -17832,7 +17931,7 @@ ${failed2.length} verify script(s) failed:`);
 async function runVerifyQuietly() {
   const result = findPackageJsonWithVerifyScripts(process.cwd());
   if (!result) return true;
-  const packageDir = path33.dirname(result.packageJsonPath);
+  const packageDir = path34.dirname(result.packageJsonPath);
   const results = await Promise.all(
     result.verifyScripts.map((script) => runScript(script, packageDir))
   );
@@ -17858,7 +17957,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path40 from "path";
+import path41 from "path";
 import chalk171 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -18335,9 +18434,9 @@ function buildDestinationContent(functionTexts, imports, sourceRelativePath, sou
 }
 
 // src/commands/refactor/extract/getRelativeImportPath.ts
-import path34 from "path";
+import path35 from "path";
 function getRelativeImportPath(from, to) {
-  let rel = path34.relative(path34.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
+  let rel = path35.relative(path35.dirname(from), to).replace(/\.tsx?$/, "").replace(/\\/g, "/");
   if (!rel.startsWith(".")) rel = `./${rel}`;
   return rel;
 }
@@ -18361,9 +18460,9 @@ function findImporters(functionName, sourceFile, destPath, project) {
 }
 
 // src/commands/refactor/extract/resolveBarrel.ts
-import path35 from "path";
+import path36 from "path";
 function resolveBarrel(functionName, sourcePath, destPath, project) {
-  const indexPath = path35.join(path35.dirname(destPath), "index.ts");
+  const indexPath = path36.join(path36.dirname(destPath), "index.ts");
   const barrel = project.getSourceFile(indexPath);
   if (!barrel) return { barrel: void 0, barrelRelPath: "" };
   const sourceRelFromBarrel = getRelativeImportPath(indexPath, sourcePath);
@@ -18381,15 +18480,15 @@ function resolveBarrel(functionName, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/rewriteImportPaths.ts
-import path36 from "path";
+import path37 from "path";
 function rewriteImportPaths(imports, sourcePath, destPath) {
-  const sourceDir = path36.dirname(sourcePath);
-  const destDir = path36.dirname(destPath);
+  const sourceDir = path37.dirname(sourcePath);
+  const destDir = path37.dirname(destPath);
   return imports.map((imp) => {
     if (!imp.moduleSpecifier.startsWith(".")) return imp;
-    const absolute = path36.resolve(sourceDir, imp.moduleSpecifier);
-    let rel = path36.relative(destDir, absolute).replace(/\\/g, "/");
-    if (rel === "") rel = `../${path36.basename(absolute)}`;
+    const absolute = path37.resolve(sourceDir, imp.moduleSpecifier);
+    let rel = path37.relative(destDir, absolute).replace(/\\/g, "/");
+    if (rel === "") rel = `../${path37.basename(absolute)}`;
     else if (!rel.startsWith(".")) rel = `./${rel}`;
     return { ...imp, moduleSpecifier: rel };
   });
@@ -18457,7 +18556,7 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 }
 
 // src/commands/refactor/extract/displayPlan.ts
-import path37 from "path";
+import path38 from "path";
 import chalk169 from "chalk";
 function section2(title) {
   return `
@@ -18467,7 +18566,7 @@ function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section2("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
-    const rel = path37.relative(cwd, imp.file.getFilePath());
+    const rel = path38.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk169.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
@@ -18507,16 +18606,16 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
-import path39 from "path";
+import path40 from "path";
 import chalk170 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
 import fs25 from "fs";
-import path38 from "path";
+import path39 from "path";
 import { Project as Project3 } from "ts-morph";
 function findTsConfig(sourcePath) {
-  const rootConfig = path38.resolve("tsconfig.json");
+  const rootConfig = path39.resolve("tsconfig.json");
   if (!fs25.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
@@ -18525,7 +18624,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludes(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs25.readdirSync(path38.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path38.resolve(path38.dirname(rootConfig), f));
+  const siblings = fs25.readdirSync(path39.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path39.resolve(path39.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -18544,10 +18643,10 @@ function readReferences(configPath) {
     return [];
   }
   if (!parsed.references?.length) return [];
-  const cwd = path38.dirname(configPath);
+  const cwd = path39.dirname(configPath);
   return parsed.references.map((ref) => {
-    const refPath = path38.resolve(cwd, ref.path);
-    return fs25.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path38.join(refPath, "tsconfig.json") : refPath;
+    const refPath = path39.resolve(cwd, ref.path);
+    return fs25.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path39.join(refPath, "tsconfig.json") : refPath;
   }).filter((p) => fs25.existsSync(p));
 }
 function projectIncludes(configPath, sourcePath) {
@@ -18561,7 +18660,7 @@ function projectIncludes(configPath, sourcePath) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 function loadProjectFile(file) {
-  const sourcePath = path39.resolve(file);
+  const sourcePath = path40.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project4({
     tsConfigFilePath: tsConfigPath
@@ -18576,10 +18675,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path40.resolve(file);
-  const destPath = path40.resolve(destination);
+  const sourcePath = path41.resolve(file);
+  const destPath = path41.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path40.relative(cwd, destPath);
+  const relDest = path41.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan2(
     functionName,
@@ -18627,16 +18726,16 @@ function ignore2(file) {
 
 // src/commands/refactor/rename/index.ts
 import fs29 from "fs";
-import path45 from "path";
+import path46 from "path";
 import chalk175 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs28 from "fs";
-import path42 from "path";
+import path43 from "path";
 import chalk173 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path41 from "path";
+import path42 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
 import fs27 from "fs";
@@ -18690,7 +18789,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path41.relative(path41.dirname(fromFile), toFile));
+  return normalizeSpecifier(path42.relative(path42.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -18738,20 +18837,20 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs28.writeFileSync(file, content, "utf8");
-    console.log(chalk173.cyan(`  Updated imports in ${path42.relative(cwd, file)}`));
+    console.log(chalk173.cyan(`  Updated imports in ${path43.relative(cwd, file)}`));
   }
-  const destDir = path42.dirname(destPath);
+  const destDir = path43.dirname(destPath);
   if (!fs28.existsSync(destDir)) fs28.mkdirSync(destDir, { recursive: true });
   fs28.renameSync(sourcePath, destPath);
   console.log(
     chalk173.white(
-      `  Moved ${path42.relative(cwd, sourcePath)} \u2192 ${path42.relative(cwd, destPath)}`
+      `  Moved ${path43.relative(cwd, sourcePath)} \u2192 ${path43.relative(cwd, destPath)}`
     )
   );
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path43 from "path";
+import path44 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -18778,7 +18877,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path43.dirname(tsConfigPath)
+    path44.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -18794,7 +18893,7 @@ function resolveImport(specifier, filePath, options2) {
   const resolved = ts7.resolveModuleName(specifier, filePath, options2, ts7.sys);
   const resolvedPath = resolved.resolvedModule?.resolvedFileName;
   if (!resolvedPath || resolvedPath.includes("node_modules")) return null;
-  return path43.resolve(resolvedPath);
+  return path44.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -18803,7 +18902,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path43.resolve(sourceFile.fileName);
+    const filePath = path44.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -18830,13 +18929,13 @@ function computeRenameRewrites(sourcePath, destPath) {
 }
 
 // src/commands/refactor/rename/printRenamePreview.ts
-import path44 from "path";
+import path45 from "path";
 import chalk174 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
       chalk174.dim(
-        `  ${path44.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+        `  ${path45.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
@@ -18845,11 +18944,11 @@ function printRenamePreview(rewrites, cwd) {
 
 // src/commands/refactor/rename/index.ts
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path45.resolve(source);
-  const destPath = path45.resolve(destination);
+  const sourcePath = path46.resolve(source);
+  const destPath = path46.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path45.relative(cwd, sourcePath);
-  const relDest = path45.relative(cwd, destPath);
+  const relSource = path46.relative(cwd, sourcePath);
+  const relDest = path46.relative(cwd, destPath);
   if (!fs29.existsSync(sourcePath)) {
     console.log(chalk175.red(`File not found: ${source}`));
     process.exit(1);
@@ -18904,12 +19003,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path46 from "path";
+import path47 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path46.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path47.relative(cwd, ref.getSourceFile().getFilePath());
     const lines = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines);
     lines.push(ref.getStartLineNumber());
@@ -18948,16 +19047,16 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path53 from "path";
+import path54 from "path";
 import chalk179 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path47 from "path";
+import path48 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path47.dirname(edge.source);
-    const targetDir = path47.dirname(edge.target);
+    const sourceDir = path48.dirname(edge.source);
+    const targetDir = path48.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -18985,20 +19084,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path47.relative(ancestor, descendant);
+  const rel = path48.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path48 from "path";
+import path49 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 = path48.dirname(parent);
-  const fileDir = path48.dirname(file);
+  const parentDir = path49.dirname(parent);
+  const fileDir = path49.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path48.basename(parent, path48.extname(parent)) === "index") return file;
+  if (path49.basename(parent, path49.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -19006,16 +19105,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename14 = path48.basename(file, path48.extname(file));
+    const basename14 = path49.basename(file, path49.extname(file));
     if (basename14 === "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 = path48.dirname(parent);
-    const fileDir = path48.dirname(file);
+    const parentDir = path49.dirname(parent);
+    const fileDir = path49.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path48.basename(parent, path48.extname(parent));
+    const parentBasename = path49.basename(parent, path49.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -19027,10 +19126,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path49 from "path";
+import path50 from "path";
 import chalk177 from "chalk";
 function relPath(filePath) {
-  return path49.relative(process.cwd(), filePath);
+  return path50.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -19080,33 +19179,33 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 
 // src/commands/refactor/restructure/executePlan.ts
 import fs30 from "fs";
-import path50 from "path";
+import path51 from "path";
 import chalk178 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs30.writeFileSync(file, content, "utf8");
     console.log(
-      chalk178.cyan(`  Rewrote imports in ${path50.relative(process.cwd(), file)}`)
+      chalk178.cyan(`  Rewrote imports in ${path51.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs30.mkdirSync(dir, { recursive: true });
-    console.log(chalk178.green(`  Created ${path50.relative(process.cwd(), dir)}/`));
+    console.log(chalk178.green(`  Created ${path51.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
-    const targetDir = path50.dirname(move2.to);
+    const targetDir = path51.dirname(move2.to);
     if (!fs30.existsSync(targetDir)) {
       fs30.mkdirSync(targetDir, { recursive: true });
     }
     fs30.renameSync(move2.from, move2.to);
     console.log(
       chalk178.white(
-        `  Moved ${path50.relative(process.cwd(), move2.from)} \u2192 ${path50.relative(process.cwd(), move2.to)}`
+        `  Moved ${path51.relative(process.cwd(), move2.from)} \u2192 ${path51.relative(process.cwd(), move2.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path50.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path51.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
@@ -19117,7 +19216,7 @@ function removeEmptyDirectories(dirs) {
       fs30.rmdirSync(dir);
       console.log(
         chalk178.dim(
-          `  Removed empty directory ${path50.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path51.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -19125,7 +19224,7 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path52 from "path";
+import path53 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
 import fs31 from "fs";
@@ -19140,9 +19239,9 @@ function checkDirConflict(result, label2, dir) {
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
 import fs32 from "fs";
-import path51 from "path";
+import path52 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path51.join(dir, entry.name);
+  const full = path52.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
@@ -19156,15 +19255,15 @@ function listFilesRecursive(dir) {
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path51.relative(childDir, file);
-    moves.push({ from: file, to: path51.join(newLocation, rel), reason });
+    const rel = path52.relative(childDir, file);
+    moves.push({ from: file, to: path52.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path51.join(parentDir, path51.basename(childDir));
+  return path52.join(parentDir, path52.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path51.basename(parentDir)}/`;
+  return `Directory only imported from ${path52.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -19189,7 +19288,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path52.join(newDir, path52.basename(child));
+  const to = path53.join(newDir, path53.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -19197,15 +19296,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path52.basename(filePath, path52.extname(filePath));
+  return path53.basename(filePath, path53.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path52.join(path52.dirname(parent), getBaseName(parent));
+  return path53.join(path53.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path52.join(newDir, `index${path52.extname(parent)}`),
+    to: path53.join(newDir, `index${path53.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -19229,7 +19328,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path53.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path54.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -19252,7 +19351,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk179.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path53.resolve("tsconfig.json");
+  const tsConfigPath = path54.resolve("tsconfig.json");
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk179.green("No restructuring needed"));
@@ -19429,11 +19528,11 @@ ${annotateDiffWithLineNumbers(context.diff.trimEnd())}
 }
 
 // src/commands/review/buildReviewPaths.ts
-import { homedir as homedir19 } from "os";
-import { basename as basename12, join as join51 } from "path";
+import { homedir as homedir20 } from "os";
+import { basename as basename12, join as join52 } from "path";
 function buildReviewPaths(repoRoot, key) {
-  const reviewDir = join51(
-    homedir19(),
+  const reviewDir = join52(
+    homedir20(),
     ".assist",
     "reviews",
     basename12(repoRoot),
@@ -19441,10 +19540,10 @@ function buildReviewPaths(repoRoot, key) {
   );
   return {
     reviewDir,
-    requestPath: join51(reviewDir, "request.md"),
-    claudePath: join51(reviewDir, "claude.md"),
-    codexPath: join51(reviewDir, "codex.md"),
-    synthesisPath: join51(reviewDir, "synthesis.md")
+    requestPath: join52(reviewDir, "request.md"),
+    claudePath: join52(reviewDir, "claude.md"),
+    codexPath: join52(reviewDir, "codex.md"),
+    synthesisPath: join52(reviewDir, "synthesis.md")
   };
 }
 
@@ -19985,8 +20084,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync41, mkdirSync as mkdirSync17, unlinkSync as unlinkSync14, writeFileSync as writeFileSync34 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path61 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync41(path61)) unlinkSync14(path61);
+  for (const path63 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync41(path63)) unlinkSync14(path63);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -21134,8 +21233,8 @@ import chalk187 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk184 from "chalk";
-async function fetchSeq(conn, path61, params) {
-  const url = `${conn.url}${path61}?${params}`;
+async function fetchSeq(conn, path63, params) {
+  const url = `${conn.url}${path63}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -21770,13 +21869,13 @@ async function configure() {
 
 // src/commands/transcript/list.ts
 import { existsSync as existsSync44, readdirSync as readdirSync10, statSync as statSync7 } from "fs";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 function list4() {
   const { vttDir } = getTranscriptConfig();
   if (!existsSync44(vttDir)) return;
   for (const entry of readdirSync10(vttDir)) {
     if (!entry.endsWith(".vtt")) continue;
-    if (statSync7(join52(vttDir, entry)).isDirectory()) continue;
+    if (statSync7(join53(vttDir, entry)).isDirectory()) continue;
     console.log(entry);
   }
 }
@@ -21789,7 +21888,7 @@ import {
   renameSync as renameSync2,
   writeFileSync as writeFileSync36
 } from "fs";
-import { basename as basename13, join as join53 } from "path";
+import { basename as basename13, join as join54 } from "path";
 
 // src/commands/transcript/cleanText.ts
 function cleanText(text16) {
@@ -22002,9 +22101,9 @@ function convertVttToMarkdown(inputPath) {
   return formatChatLog(messages);
 }
 function archiveRawVtt(vttDir, sourcePath, filename) {
-  const processedDir = join53(vttDir, "processed");
+  const processedDir = join54(vttDir, "processed");
   mkdirSync18(processedDir, { recursive: true });
-  renameSync2(sourcePath, join53(processedDir, filename));
+  renameSync2(sourcePath, join54(processedDir, filename));
 }
 function move(file, options2) {
   const { date, client } = options2;
@@ -22014,19 +22113,19 @@ function move(file, options2) {
   }
   const { vttDir, transcriptsDir, summaryDir } = getTranscriptConfig();
   const filename = basename13(file);
-  const sourcePath = join53(vttDir, filename);
+  const sourcePath = join54(vttDir, filename);
   if (!existsSync45(sourcePath)) {
     console.error(`Error: VTT file not found: ${sourcePath}`);
     process.exit(1);
   }
   const base = basename13(filename, ".vtt").replace(/ Transcription$/, "");
   const outputName = `${date} ${base}.md`;
-  const formattedDir = join53(transcriptsDir, client);
+  const formattedDir = join54(transcriptsDir, client);
   mkdirSync18(formattedDir, { recursive: true });
-  const formattedPath = join53(formattedDir, outputName);
+  const formattedPath = join54(formattedDir, outputName);
   writeFileSync36(formattedPath, convertVttToMarkdown(sourcePath), "utf8");
   archiveRawVtt(vttDir, sourcePath, filename);
-  const summaryPath = join53(summaryDir, client, outputName);
+  const summaryPath = join54(summaryDir, client, outputName);
   console.log(`Formatted transcript: ${formattedPath}`);
   console.log(`Summary target:       ${summaryPath}`);
 }
@@ -22146,38 +22245,38 @@ function registerVerify(program2) {
 
 // src/commands/voice/devices.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 
 // src/commands/voice/shared.ts
-import { homedir as homedir20 } from "os";
-import { dirname as dirname26, join as join54 } from "path";
+import { homedir as homedir21 } from "os";
+import { dirname as dirname26, join as join55 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 var __dirname5 = dirname26(fileURLToPath7(import.meta.url));
-var VOICE_DIR = join54(homedir20(), ".assist", "voice");
+var VOICE_DIR = join55(homedir21(), ".assist", "voice");
 var voicePaths = {
   dir: VOICE_DIR,
-  pid: join54(VOICE_DIR, "voice.pid"),
-  log: join54(VOICE_DIR, "voice.log"),
-  venv: join54(VOICE_DIR, ".venv"),
-  lock: join54(VOICE_DIR, "voice.lock")
+  pid: join55(VOICE_DIR, "voice.pid"),
+  log: join55(VOICE_DIR, "voice.log"),
+  venv: join55(VOICE_DIR, ".venv"),
+  lock: join55(VOICE_DIR, "voice.lock")
 };
 function getPythonDir() {
-  return join54(__dirname5, "commands", "voice", "python");
+  return join55(__dirname5, "commands", "voice", "python");
 }
 function getVenvPython() {
-  return process.platform === "win32" ? join54(voicePaths.venv, "Scripts", "python.exe") : join54(voicePaths.venv, "bin", "python");
+  return process.platform === "win32" ? join55(voicePaths.venv, "Scripts", "python.exe") : join55(voicePaths.venv, "bin", "python");
 }
 function getLockDir() {
   const config = loadConfig();
   return config.voice?.lockDir ?? VOICE_DIR;
 }
 function getLockFile() {
-  return join54(getLockDir(), "voice.lock");
+  return join55(getLockDir(), "voice.lock");
 }
 
 // src/commands/voice/devices.ts
 function devices() {
-  const script = join55(getPythonDir(), "list_devices.py");
+  const script = join56(getPythonDir(), "list_devices.py");
   spawnSync5(getVenvPython(), [script], { stdio: "inherit" });
 }
 
@@ -22212,12 +22311,12 @@ function logs(options2) {
 // src/commands/voice/setup.ts
 import { spawnSync as spawnSync6 } from "child_process";
 import { mkdirSync as mkdirSync20 } from "fs";
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync54 } from "child_process";
 import { existsSync as existsSync47, mkdirSync as mkdirSync19, readFileSync as readFileSync42, writeFileSync as writeFileSync37 } from "fs";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -22254,7 +22353,7 @@ function bootstrapVenv() {
 }
 function writeLockFile(pid) {
   const lockFile = getLockFile();
-  mkdirSync19(join56(lockFile, ".."), { recursive: true });
+  mkdirSync19(join57(lockFile, ".."), { recursive: true });
   writeFileSync37(
     lockFile,
     JSON.stringify({
@@ -22270,7 +22369,7 @@ function setup() {
   mkdirSync20(voicePaths.dir, { recursive: true });
   bootstrapVenv();
   console.log("\nDownloading models...\n");
-  const script = join57(getPythonDir(), "setup_models.py");
+  const script = join58(getPythonDir(), "setup_models.py");
   const result = spawnSync6(getVenvPython(), [script], {
     stdio: "inherit",
     env: { ...process.env, VOICE_LOG_FILE: voicePaths.log }
@@ -22284,7 +22383,7 @@ function setup() {
 // src/commands/voice/start.ts
 import { spawn as spawn7 } from "child_process";
 import { mkdirSync as mkdirSync21, writeFileSync as writeFileSync38 } from "fs";
-import { join as join58 } from "path";
+import { join as join59 } from "path";
 
 // src/commands/voice/buildDaemonEnv.ts
 function buildDaemonEnv(options2) {
@@ -22322,7 +22421,7 @@ function start2(options2) {
   bootstrapVenv();
   const debug = options2.debug || options2.foreground || process.platform === "win32";
   const env = buildDaemonEnv({ debug });
-  const script = join58(getPythonDir(), "voice_daemon.py");
+  const script = join59(getPythonDir(), "voice_daemon.py");
   const python = getVenvPython();
   if (options2.foreground) {
     spawnForeground(python, script, env);
@@ -22613,7 +22712,7 @@ async function auth() {
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync9 } from "child_process";
 import { readdirSync as readdirSync11, readFileSync as readFileSync45, statSync as statSync8 } from "fs";
-import { join as join59 } from "path";
+import { join as join60 } from "path";
 function findPortFile(roamDir) {
   let entries;
   try {
@@ -22622,9 +22721,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path61 = join59(roamDir, name);
+    const path63 = join60(roamDir, name);
     try {
-      return { path: path61, mtimeMs: statSync8(path61).mtimeMs };
+      return { path: path63, mtimeMs: statSync8(path63).mtimeMs };
     } catch {
       return void 0;
     }
@@ -22634,7 +22733,7 @@ function findPortFile(roamDir) {
 function postRoamActivity(app, event) {
   const appData = process.env.APPDATA;
   if (!appData) return;
-  const portFile = findPortFile(join59(appData, "Roam"));
+  const portFile = findPortFile(join60(appData, "Roam"));
   if (!portFile) return;
   let port;
   try {
@@ -22855,13 +22954,13 @@ function runPreCommands(pre, cwd) {
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync10, spawn as spawn8 } from "child_process";
 import { existsSync as existsSync50 } from "fs";
-import { dirname as dirname27, join as join60, resolve as resolve13 } from "path";
+import { dirname as dirname27, join as join61, resolve as resolve13 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync10("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
     const gitRoot = resolve13(dirname27(gitPath), "..");
-    const gitBash = join60(gitRoot, "bin", "bash.exe");
+    const gitBash = join61(gitRoot, "bin", "bash.exe");
     if (existsSync50(gitBash)) return gitBash;
   } catch {
   }
@@ -22950,7 +23049,7 @@ async function run3(name, args) {
 
 // src/commands/run/add.ts
 import { mkdirSync as mkdirSync22, writeFileSync as writeFileSync39 } from "fs";
-import { join as join61 } from "path";
+import { join as join62 } from "path";
 
 // src/commands/run/extractOption.ts
 function extractOption(args, flag) {
@@ -23011,7 +23110,7 @@ function saveNewRunConfig(name, command, args, cwd) {
   saveConfig(config);
 }
 function createCommandFile(name) {
-  const dir = join61(".claude", "commands");
+  const dir = join62(".claude", "commands");
   mkdirSync22(dir, { recursive: true });
   const content = `---
 description: Run ${name}
@@ -23019,7 +23118,7 @@ description: Run ${name}
 
 Run \`assist run ${name} $ARGUMENTS 2>&1\`.
 `;
-  const filePath = join61(dir, `${name}.md`);
+  const filePath = join62(dir, `${name}.md`);
   writeFileSync39(filePath, content);
   console.log(`Created command file: ${filePath}`);
 }
@@ -23043,11 +23142,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path61 = process.argv[idx + 1];
+  const path63 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path61, prefix: prefix2 };
+  return { path: path63, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -23076,7 +23175,7 @@ function link2() {
 
 // src/commands/run/remove.ts
 import { existsSync as existsSync51, unlinkSync as unlinkSync18 } from "fs";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 function findRemoveIndex() {
   const idx = process.argv.indexOf("remove");
   if (idx === -1 || idx + 1 >= process.argv.length) return -1;
@@ -23091,7 +23190,7 @@ function parseRemoveName() {
   return process.argv[idx + 1];
 }
 function deleteCommandFile(name) {
-  const filePath = join62(".claude", "commands", `${name}.md`);
+  const filePath = join63(".claude", "commands", `${name}.md`);
   if (existsSync51(filePath)) {
     unlinkSync18(filePath);
     console.log(`Deleted command file: ${filePath}`);
@@ -23148,7 +23247,7 @@ function registerRun(program2) {
 import { execSync as execSync56 } from "child_process";
 import { existsSync as existsSync52, mkdirSync as mkdirSync23, unlinkSync as unlinkSync19, writeFileSync as writeFileSync40 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join63, resolve as resolve15 } from "path";
+import { join as join64, resolve as resolve15 } from "path";
 import chalk195 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -23285,7 +23384,7 @@ function buildOutputPath(outputDir, processName) {
   return resolve15(outputDir, `${processName}-${timestamp5}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
-  const scriptPath = join63(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
+  const scriptPath = join64(tmpdir7(), `assist-screenshot-${Date.now()}.ps1`);
   writeFileSync40(scriptPath, captureWindowPs1, "utf8");
   try {
     execSync56(
@@ -23755,14 +23854,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync53, statSync as statSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path54 from "path";
+import path55 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path54.join(path54.dirname(require4.resolve("node-pty")), "..");
-  const helper = path54.join(
+  const ptyRoot = path55.join(path55.dirname(require4.resolve("node-pty")), "..");
+  const helper = path55.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -23824,12 +23923,12 @@ import { randomUUID as randomUUID4 } from "crypto";
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
 import * as fs33 from "fs";
-import * as path55 from "path";
+import * as path56 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname6 = path55.dirname(__filename4);
+var __dirname6 = path56.dirname(__filename4);
 function readDesignSystemPrompt() {
-  const promptPath = path55.join(__dirname6, "..", "claude", "system-prompt.md");
+  const promptPath = path56.join(__dirname6, "..", "claude", "system-prompt.md");
   return fs33.readFileSync(promptPath, "utf8");
 }
 
@@ -24327,8 +24426,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path61 = activityPath(session.id);
-  const dir = dirname29(path61);
+  const path63 = activityPath(session.id);
+  const dir = dirname29(path63);
   try {
     mkdirSync24(dir, { recursive: true });
   } catch {
@@ -24338,7 +24437,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path61);
+    const activity2 = readActivity(path63);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -24348,11 +24447,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path61.endsWith(filename)) return;
+    if (filename && !path63.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync54(path61)) read();
+  if (existsSync54(path63)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -26313,9 +26412,9 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync50, statSync as statSync11 } from "fs";
-import { isAbsolute as isAbsolute2, join as join65, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute2, join as join66, resolve as resolve16 } from "path";
 function resolveGitDir(cwd) {
-  const dotGit = join65(cwd, ".git");
+  const dotGit = join66(cwd, ".git");
   let stat2;
   try {
     stat2 = statSync11(dotGit);
@@ -26345,7 +26444,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync50(join65(gitDir, "HEAD"), "utf8");
+    head = readFileSync50(join66(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -26408,18 +26507,18 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs42 from "fs";
-import * as os2 from "os";
-import * as path59 from "path";
+import * as fs43 from "fs";
+import * as os3 from "os";
+import * as path61 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
 import * as fs39 from "fs";
-import * as path56 from "path";
+import * as path57 from "path";
 import chalk199 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path56.join(claudeDir, "CLAUDE.md");
-  const target = path56.join(targetBase, "CLAUDE.md");
+  const source = path57.join(claudeDir, "CLAUDE.md");
+  const target = path57.join(targetBase, "CLAUDE.md");
   const sourceContent = fs39.readFileSync(source, "utf8");
   if (fs39.existsSync(target)) {
     const targetContent = fs39.readFileSync(target, "utf8");
@@ -26443,38 +26542,79 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
-// src/commands/sync/syncDesign.ts
+// src/commands/sync/syncCodex.ts
 import * as fs40 from "fs";
-import * as path57 from "path";
+import * as path58 from "path";
+function quoteYaml(value) {
+  return `"${value.replace(/\\/g, String.raw`\\`).replace(/"/g, String.raw`\"`)}"`;
+}
+function commandToSkill(name, content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  const frontmatter = match ? match[1] : "";
+  const body = match ? content.slice(match[0].length) : content;
+  const descriptionMatch = frontmatter.match(/^description:\s*(.*)$/m);
+  const description = descriptionMatch ? descriptionMatch[1].trim().replace(/^["']|["']$/g, "") : name;
+  const header = `---
+name: ${name}
+description: ${quoteYaml(description)}
+---
+
+`;
+  return header + body.replace(/^\r?\n+/, "");
+}
+function syncCodex(claudeDir) {
+  if (!isHarnessAvailable("codex")) return;
+  const codex = harnesses.codex;
+  const commandsSource = path58.join(claudeDir, "commands");
+  const files = fs40.readdirSync(commandsSource);
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const name = file.replace(/\.md$/, "");
+    const content = fs40.readFileSync(path58.join(commandsSource, file), "utf8");
+    const target = path58.join(codex.homeDir, codex.sync.commandDest(name));
+    fs40.mkdirSync(path58.dirname(target), { recursive: true });
+    fs40.writeFileSync(target, commandToSkill(name, content));
+  }
+  const agentsTarget = path58.join(codex.homeDir, codex.sync.agentsFile);
+  fs40.mkdirSync(path58.dirname(agentsTarget), { recursive: true });
+  fs40.copyFileSync(path58.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  console.log(
+    `Synced ${files.length} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
+  );
+}
+
+// src/commands/sync/syncDesign.ts
+import * as fs41 from "fs";
+import * as path59 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path57.join(claudeDir, "system-prompt.md");
-  const systemPromptTarget = path57.join(targetBase, "system-prompt.md");
-  fs40.copyFileSync(systemPromptSource, systemPromptTarget);
+  const systemPromptSource = path59.join(claudeDir, "system-prompt.md");
+  const systemPromptTarget = path59.join(targetBase, "system-prompt.md");
+  fs41.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log("Copied system-prompt.md to ~/.claude/system-prompt.md");
-  const skillsSource = path57.join(claudeDir, "skills");
-  const skillsTarget = path57.join(targetBase, "skills");
-  fs40.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs40.readdirSync(skillsSource);
+  const skillsSource = path59.join(claudeDir, "skills");
+  const skillsTarget = path59.join(targetBase, "skills");
+  fs41.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs41.readdirSync(skillsSource);
   for (const file of files) {
-    fs40.copyFileSync(
-      path57.join(skillsSource, file),
-      path57.join(skillsTarget, file)
+    fs41.copyFileSync(
+      path59.join(skillsSource, file),
+      path59.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs41 from "fs";
-import * as path58 from "path";
+import * as fs42 from "fs";
+import * as path60 from "path";
 import chalk200 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path58.join(claudeDir, "settings.json");
-  const target = path58.join(targetBase, "settings.json");
-  const sourceContent = fs41.readFileSync(source, "utf8");
+  const source = path60.join(claudeDir, "settings.json");
+  const target = path60.join(targetBase, "settings.json");
+  const sourceContent = fs42.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs41.existsSync(target);
-  const targetContent = targetExists ? fs41.readFileSync(target, "utf8") : "";
+  const targetExists = fs42.existsSync(target);
+  const targetContent = targetExists ? fs42.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -26503,30 +26643,31 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs41.writeFileSync(target, mergedContent);
+  fs42.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename5 = fileURLToPath9(import.meta.url);
-var __dirname7 = path59.dirname(__filename5);
+var __dirname7 = path61.dirname(__filename5);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path59.join(__dirname7, "..", "claude");
-  const targetBase = path59.join(os2.homedir(), ".claude");
+  const claudeDir = path61.join(__dirname7, "..", "claude");
+  const targetBase = path61.join(os3.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
   await syncClaudeMd(claudeDir, targetBase, { yes });
+  syncCodex(claudeDir);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path59.join(claudeDir, "commands");
-  const targetDir = path59.join(targetBase, "commands");
-  fs42.mkdirSync(targetDir, { recursive: true });
-  const files = fs42.readdirSync(sourceDir);
+  const sourceDir = path61.join(claudeDir, "commands");
+  const targetDir = path61.join(targetBase, "commands");
+  fs43.mkdirSync(targetDir, { recursive: true });
+  const files = fs43.readdirSync(sourceDir);
   for (const file of files) {
-    fs42.copyFileSync(path59.join(sourceDir, file), path59.join(targetDir, file));
+    fs43.copyFileSync(path61.join(sourceDir, file), path61.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -26534,7 +26675,7 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync57 } from "child_process";
-import * as path60 from "path";
+import * as path62 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -26553,12 +26694,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path60.resolve(dir);
-    if (resolved.split(path60.sep).includes("node_modules")) {
+    const resolved = path62.resolve(dir);
+    if (resolved.split(path62.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync57("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path60.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path62.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }
@@ -26603,7 +26744,9 @@ function reportCliError(error) {
 // src/index.ts
 var program = new Command();
 program.name("assist").description("CLI application").version(package_default.version).option("--no-open", "Do not open a browser on startup").action((options2) => web({ port: "3100", open: options2.open }));
-var syncCommand = program.command("sync").description("Copy command files to ~/.claude/commands").option("-y, --yes", "Overwrite settings.json without prompting").action((options2) => sync(options2));
+var syncCommand = program.command("sync").description(
+  "Copy command files to ~/.claude/commands; when codex is detected, also install commands as ~/.codex/skills/<name>/SKILL.md and CLAUDE.md as ~/.codex/AGENTS.md"
+).option("-y, --yes", "Overwrite settings.json without prompting").action((options2) => sync(options2));
 configHelp(syncCommand, rootConfigHelp.sync);
 program.command("init").description("Initialize VS Code and verify configurations").action(init5);
 var commitCommand = program.command("commit").description("Create a git commit with validation").argument("<args...>", "status | <message> [files...]").action(commit);