@staff0rd/assist 0.408.0 → 0.408.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.408.0",
+  version: "0.408.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -142,10 +142,10 @@ import { stringify as stringifyYaml } from "yaml";
 // src/shared/loadRawYaml.ts
 import { existsSync, readFileSync } from "fs";
 import { parse as parseYaml } from "yaml";
-function loadRawYaml(path69) {
-  if (!existsSync(path69)) return {};
+function loadRawYaml(path70) {
+  if (!existsSync(path70)) return {};
   try {
-    const content = readFileSync(path69, "utf8");
+    const content = readFileSync(path70, "utf8");
     return parseYaml(content) || {};
   } catch {
     return {};
@@ -796,7 +796,8 @@ async function openReset(c, active, usedPercentage) {
 var lock = ({ tx, window, resetsAt }) => tx.execute(
   sql`SELECT pg_advisory_xact_lock(hashtextextended(${`${window}:${resetsAt}`}, 0))`
 );
-async function recordWindowPeak(db, window, resetsAt, usedPercentage) {
+async function recordWindowPeak(db, window, resetsAt, usedPercentage, now = Math.floor(Date.now() / 1e3)) {
+  if (now >= resetsAt) return;
   await db.transaction(async (tx) => {
     const c = { tx, window, resetsAt };
     await lock(c);
@@ -1436,8 +1437,8 @@ function findUnmergedPaths() {
   }
   const found = /* @__PURE__ */ new Set();
   for (const line of output.split("\n")) {
-    const path69 = line.split("	")[1];
-    if (path69) found.add(path69.trim());
+    const path70 = line.split("	")[1];
+    if (path70) found.add(path70.trim());
   }
   return [...found];
 }
@@ -1536,8 +1537,8 @@ function getPreferredRemoteRepo(cwd) {
 function gitRefUrl(kind, ref, cwd) {
   const repo = getPreferredRemoteRepo(cwd);
   if (!repo) return void 0;
-  const path69 = kind === "branch" ? "tree" : "commit";
-  return `https://github.com/${repo.org}/${repo.repo}/${path69}/${ref}`;
+  const path70 = kind === "branch" ? "tree" : "commit";
+  return `https://github.com/${repo.org}/${repo.repo}/${path70}/${ref}`;
 }
 
 // src/commands/commit/collectCommitRefs.ts
@@ -3404,9 +3405,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, path69) {
+function resolveStringsAtPath(data, path70) {
   let current = data;
-  for (const segment of path69.split(".")) {
+  for (const segment of path70.split(".")) {
     if (current === null || typeof current !== "object") return [];
     current = current[segment];
   }
@@ -3419,10 +3420,10 @@ function resolveStringsAtPath(data, path69) {
 }
 function findRuleViolations(data, rule) {
   const violations = [];
-  for (const path69 of rule.paths) {
-    for (const value of resolveStringsAtPath(data, path69)) {
+  for (const path70 of rule.paths) {
+    for (const value of resolveStringsAtPath(data, path70)) {
       if (minimatch2(value, rule.disallowed))
-        violations.push({ file: rule.file, path: path69, value });
+        violations.push({ file: rule.file, path: path70, value });
     }
   }
   return violations;
@@ -3461,8 +3462,8 @@ function forbiddenStrings() {
     process.exit(0);
   }
   console.log("Forbidden strings found:\n");
-  for (const { file, path: path69, value } of violations) {
-    console.log(`  ${file} ${path69}: ${value}`);
+  for (const { file, path: path70, value } of violations) {
+    console.log(`  ${file} ${path70}: ${value}`);
   }
   console.log(`
 Total: ${violations.length} forbidden string(s).`);
@@ -3754,15 +3755,15 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path69) => MIGRATION_FILE3.test(basename(path69)));
-  for (const path69 of paths) {
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path70) => MIGRATION_FILE3.test(basename(path70)));
+  for (const path70 of paths) {
     try {
-      const content = execSync12(`git show "${ref}:${path69}"`, {
+      const content = execSync12(`git show "${ref}:${path70}"`, {
         encoding: "utf8",
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename(path69), content);
+      baseline.set(basename(path70), content);
     } catch {
     }
   }
@@ -5127,10 +5128,10 @@ var hooksSettings = {
   }
 };
 function ensureHooksSettings() {
-  const path69 = daemonPaths.hooksSettings;
-  mkdirSync5(dirname12(path69), { recursive: true });
-  writeFileSync15(path69, JSON.stringify(hooksSettings, null, 2));
-  return path69;
+  const path70 = daemonPaths.hooksSettings;
+  mkdirSync5(dirname12(path70), { recursive: true });
+  writeFileSync15(path70, JSON.stringify(hooksSettings, null, 2));
+  return path70;
 }
 
 // src/shared/spawnInherit.ts
@@ -5395,9 +5396,9 @@ var LOCAL_FILES = ["backlog.jsonl", "backlog.db"];
 function backupLocalBacklogFiles(dir) {
   const moved = [];
   for (const name of LOCAL_FILES) {
-    const path69 = join15(dir, ".assist", name);
-    if (existsSync18(path69)) {
-      renameSync(path69, `${path69}.bak`);
+    const path70 = join15(dir, ".assist", name);
+    if (existsSync18(path70)) {
+      renameSync(path70, `${path70}.bak`);
       moved.push(`${name} \u2192 ${name}.bak`);
     }
   }
@@ -5869,8 +5870,8 @@ var backlogItemSchema = z3.strictObject({
 var backlogFileSchema = z3.array(backlogItemSchema);
 
 // src/commands/backlog/parseBacklogJsonl.ts
-function parseBacklogJsonl(path69) {
-  const content = readFileSync14(path69, "utf8").trim();
+function parseBacklogJsonl(path70) {
+  const content = readFileSync14(path70, "utf8").trim();
   if (content.length === 0) return [];
   return content.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => backlogItemSchema.parse(JSON.parse(line)));
 }
@@ -5952,8 +5953,8 @@ function findBacklogUp(startDir) {
 
 // src/commands/backlog/getCurrentOrigin.ts
 import { execFileSync } from "child_process";
-function stripLeadingSlashes(path69) {
-  return path69.replace(/^\/+/, "");
+function stripLeadingSlashes(path70) {
+  return path70.replace(/^\/+/, "");
 }
 function normalizeOrigin(raw) {
   const trimmed = raw.trim().replace(/\.git$/i, "").replace(/\/+$/, "");
@@ -6493,24 +6494,24 @@ function getOwnerPath(itemId2) {
 function recordSignalOwner(itemId2) {
   const sessionId = process.env.ASSIST_SESSION_ID;
   if (!sessionId) return;
-  const path69 = getOwnerPath(itemId2);
-  mkdirSync7(dirname14(path69), { recursive: true });
-  writeFileSync17(path69, JSON.stringify({ sessionId }));
+  const path70 = getOwnerPath(itemId2);
+  mkdirSync7(dirname14(path70), { recursive: true });
+  writeFileSync17(path70, JSON.stringify({ sessionId }));
 }
 function readSignalOwner(itemId2) {
-  const path69 = getOwnerPath(itemId2);
-  if (!existsSync21(path69)) return void 0;
+  const path70 = getOwnerPath(itemId2);
+  if (!existsSync21(path70)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync15(path69, "utf8"));
+    const parsed = JSON.parse(readFileSync15(path70, "utf8"));
     return parsed.sessionId;
   } catch {
     return void 0;
   }
 }
 function clearSignalOwner(itemId2) {
-  const path69 = getOwnerPath(itemId2);
+  const path70 = getOwnerPath(itemId2);
   try {
-    rmSync(path69);
+    rmSync(path70);
   } catch {
   }
 }
@@ -6547,19 +6548,19 @@ function resolveSignalTarget(event, data) {
 function writeSignal(event, data) {
   const target = resolveSignalTarget(event, data);
   if (!target) return;
-  const path69 = getSignalPath(target);
-  if (!path69) return;
+  const path70 = getSignalPath(target);
+  if (!path70) return;
   const signal = { event, sessionId: target, ...data };
-  mkdirSync8(dirname15(path69), { recursive: true });
-  writeFileSync18(path69, JSON.stringify(signal));
+  mkdirSync8(dirname15(path70), { recursive: true });
+  writeFileSync18(path70, JSON.stringify(signal));
 }
 
 // src/commands/backlog/readSignal.ts
 function readSignal() {
-  const path69 = getSignalPath();
-  if (!path69 || !existsSync22(path69)) return void 0;
+  const path70 = getSignalPath();
+  if (!path70 || !existsSync22(path70)) return void 0;
   try {
-    return JSON.parse(readFileSync16(path69, "utf8"));
+    return JSON.parse(readFileSync16(path70, "utf8"));
   } catch {
     return void 0;
   }
@@ -6692,13 +6693,13 @@ function activityPath(sessionId) {
 function emitActivity(activity2) {
   const sessionId = process.env.ASSIST_ACTIVITY_ID;
   if (!sessionId) return;
-  const path69 = activityPath(sessionId);
-  mkdirSync9(dirname16(path69), { recursive: true });
-  writeFileSync19(path69, JSON.stringify({ ...activity2, startedAt: Date.now() }));
+  const path70 = activityPath(sessionId);
+  mkdirSync9(dirname16(path70), { recursive: true });
+  writeFileSync19(path70, JSON.stringify({ ...activity2, startedAt: Date.now() }));
 }
-function readActivity(path69) {
+function readActivity(path70) {
   try {
-    return JSON.parse(readFileSync17(path69, "utf8"));
+    return JSON.parse(readFileSync17(path70, "utf8"));
   } catch {
     return void 0;
   }
@@ -6708,9 +6709,9 @@ function reconcileActivity(sessionId, activity2) {
     removeActivity(sessionId);
     return;
   }
-  const path69 = activityPath(sessionId);
-  mkdirSync9(dirname16(path69), { recursive: true });
-  writeFileSync19(path69, JSON.stringify(activity2));
+  const path70 = activityPath(sessionId);
+  mkdirSync9(dirname16(path70), { recursive: true });
+  writeFileSync19(path70, JSON.stringify(activity2));
 }
 function removeActivity(sessionId) {
   try {
@@ -7949,8 +7950,8 @@ async function loadItemSummaries(orm, origin) {
 // src/commands/backlog/originDisplayName.ts
 function originDisplayName(origin) {
   if (origin.startsWith("local:")) {
-    const path69 = origin.slice("local:".length).replace(/\/+$/, "");
-    const segments = path69.split("/").filter(Boolean);
+    const path70 = origin.slice("local:".length).replace(/\/+$/, "");
+    const segments = path70.split("/").filter(Boolean);
     return segments[segments.length - 1] ?? origin;
   }
   const firstSlash = origin.indexOf("/");
@@ -8354,7 +8355,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((path69) => existsSync25(path69)).map((path69) => ({ path: path69, mtime: statSync2(path69).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((path70) => existsSync25(path70)).map((path70) => ({ path: path70, mtime: statSync2(path70).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return synthesisFiles[0]?.path ?? null;
 }
 
@@ -8408,12 +8409,12 @@ async function getReviewSynthesis(req, res) {
   const cwd = getCwdParam(req, res);
   if (!cwd) return;
   try {
-    const path69 = await resolveSynthesisPath(cwd);
-    if (!path69) {
+    const path70 = await resolveSynthesisPath(cwd);
+    if (!path70) {
       respondJson(res, 404, { error: "No synthesis found" });
       return;
     }
-    respondJson(res, 200, { synthesis: readFileSync19(path69, "utf8") });
+    respondJson(res, 200, { synthesis: readFileSync19(path70, "utf8") });
   } catch {
     respondJson(res, 404, { error: "No synthesis found" });
   }
@@ -8560,10 +8561,10 @@ function getStorePath(filename) {
   return join26(getStoreDir(), filename);
 }
 function loadJson(filename) {
-  const path69 = getStorePath(filename);
-  if (existsSync26(path69)) {
+  const path70 = getStorePath(filename);
+  if (existsSync26(path70)) {
     try {
-      return JSON.parse(readFileSync20(path69, "utf8"));
+      return JSON.parse(readFileSync20(path70, "utf8"));
     } catch {
       return {};
     }
@@ -11914,9 +11915,9 @@ var __dirname4 = dirname21(__filename3);
 function packageRoot() {
   return __dirname4;
 }
-function readLines(path69) {
-  if (!existsSync27(path69)) return [];
-  return readFileSync23(path69, "utf8").split("\n").filter((line) => line.trim() !== "");
+function readLines(path70) {
+  if (!existsSync27(path70)) return [];
+  return readFileSync23(path70, "utf8").split("\n").filter((line) => line.trim() !== "");
 }
 var cachedReads;
 var cachedWrites;
@@ -12408,14 +12409,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, path69, description, depth, p) {
-  showProgress(p, path69.join(" "));
-  const subHelp = await runHelp([cli, ...path69]);
+async function resolveCommand(cli, path70, description, depth, p) {
+  showProgress(p, path70.join(" "));
+  const subHelp = await runHelp([cli, ...path70]);
   if (!subHelp || !hasSubcommands(subHelp)) {
-    return [{ path: path69, description }];
+    return [{ path: path70, description }];
   }
-  const children = await discoverAt(cli, path69, depth + 1, p);
-  return children.length > 0 ? children : [{ path: path69, description }];
+  const children = await discoverAt(cli, path70, depth + 1, p);
+  return children.length > 0 ? children : [{ path: path70, description }];
 }
 async function discoverAt(cli, parentPath, depth, p) {
   if (depth > SAFETY_DEPTH) return [];
@@ -12563,9 +12564,9 @@ function logPath(cli) {
   return join30(homedir16(), ".assist", `cli-discover-${safeName}.log`);
 }
 function readCache(cli) {
-  const path69 = logPath(cli);
-  if (!existsSync29(path69)) return void 0;
-  return readFileSync25(path69, "utf8");
+  const path70 = logPath(cli);
+  if (!existsSync29(path70)) return void 0;
+  return readFileSync25(path70, "utf8");
 }
 function writeCache(cli, output) {
   const dir = join30(homedir16(), ".assist");
@@ -12737,9 +12738,9 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
   }
   const cutoff = Date.now() - STALE_AFTER_MS;
   for (const entry of entries) {
-    const path69 = join32(dir, entry);
+    const path70 = join32(dir, entry);
     try {
-      if (statSync3(path69).mtimeMs < cutoff) unlinkSync7(path69);
+      if (statSync3(path70).mtimeMs < cutoff) unlinkSync7(path70);
     } catch {
       continue;
     }
@@ -12749,10 +12750,10 @@ function sweepRestrictedDir(dir = getRestrictedDir()) {
 // src/commands/codeComment/readPinState.ts
 import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
 function readPinState(pin) {
-  const path69 = getPinStatePath(pin);
-  if (!existsSync30(path69)) return void 0;
+  const path70 = getPinStatePath(pin);
+  if (!existsSync30(path70)) return void 0;
   try {
-    const state = JSON.parse(readFileSync26(path69, "utf8"));
+    const state = JSON.parse(readFileSync26(path70, "utf8"));
     if (state.pin !== pin) return void 0;
     return state;
   } catch {
@@ -13648,8 +13649,8 @@ function stepIntoNested(container, key, nextKey) {
   }
   return ensureObject(container, resolved);
 }
-function setNestedValue(obj, path69, value) {
-  const keys = path69.split(".");
+function setNestedValue(obj, path70, value) {
+  const keys = path70.split(".");
   const result = { ...obj };
   let current = result;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -13729,9 +13730,9 @@ function isTraversable(value) {
 function stepInto(current, key) {
   return isTraversable(current) ? current[key] : void 0;
 }
-function getNestedValue(obj, path69) {
+function getNestedValue(obj, path70) {
   let current = obj;
-  for (const key of path69.split(".")) current = stepInto(current, key);
+  for (const key of path70.split(".")) current = stepInto(current, key);
   return current;
 }
 
@@ -13847,10 +13848,10 @@ function getMigrationApprovalPath(migrationId) {
 // src/commands/dbMigration/readMigrationPinState.ts
 import { existsSync as existsSync32, readFileSync as readFileSync28 } from "fs";
 function readMigrationPinState(pin) {
-  const path69 = getMigrationPinPath(pin);
-  if (!existsSync32(path69)) return void 0;
+  const path70 = getMigrationPinPath(pin);
+  if (!existsSync32(path70)) return void 0;
   try {
-    const state = JSON.parse(readFileSync28(path69, "utf8"));
+    const state = JSON.parse(readFileSync28(path70, "utf8"));
     if (state.pin !== pin) return void 0;
     if (!Number.isInteger(state.migrationId)) return void 0;
     return state;
@@ -15289,10 +15290,10 @@ function decideCommentGuard(input, existingContent) {
 import { existsSync as existsSync39, unlinkSync as unlinkSync11 } from "fs";
 function consumeMigrationApproval(migrationId) {
   sweepRestrictedDir();
-  const path69 = getMigrationApprovalPath(migrationId);
-  if (!existsSync39(path69)) return false;
+  const path70 = getMigrationApprovalPath(migrationId);
+  if (!existsSync39(path70)) return false;
   try {
-    unlinkSync11(path69);
+    unlinkSync11(path70);
     return true;
   } catch {
     return false;
@@ -16466,9 +16467,9 @@ function parseRscRows(flight) {
 }
 function makeRscResolver(rows) {
   return (ref) => {
-    const [id, ...path69] = ref.slice(1).replace(/^[L@]/, "").split(":");
+    const [id, ...path70] = ref.slice(1).replace(/^[L@]/, "").split(":");
     let v = rows[id];
-    for (const key of path69) {
+    for (const key of path70) {
       if (v == null || typeof v !== "object") return void 0;
       v = v[key];
     }
@@ -17152,15 +17153,15 @@ function postComment(vars) {
   const stdout = startLine === void 0 ? runGhGraphql(MUTATION_SINGLE, base) : runGhGraphql(MUTATION_MULTI, { ...base, startLine });
   assertThreadCreated(stdout);
 }
-function comment2(path69, line, body, startLine) {
+function comment2(path70, line, body, startLine) {
   validateBody(body);
   validateLine(line);
   if (startLine !== void 0) validateLine(startLine);
   try {
     const prId = getCurrentPrNodeId();
-    postComment({ prId, body, path: path69, line, startLine });
+    postComment({ prId, body, path: path70, line, startLine });
     const range = startLine !== void 0 ? `${startLine}-${line}` : `${line}`;
-    console.log(`Added review comment on ${path69}:${range}`);
+    console.log(`Added review comment on ${path70}:${range}`);
   } catch (error) {
     if (isGhNotInstalled(error)) {
       console.error("Error: GitHub CLI (gh) is not installed.");
@@ -18039,8 +18040,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((path69, line, body) => {
-    comment2(path69, Number.parseInt(line, 10), body);
+  prsCommand.command("comment <path> <line> <body>").description("Add a line comment to the pending review").action((path70, line, body) => {
+    comment2(path70, Number.parseInt(line, 10), body);
   });
   configHelp(prsCommand, prsConfigHelp);
 }
@@ -18293,10 +18294,10 @@ function resolveOpSecret(reference) {
 }
 
 // src/commands/ravendb/ravenFetch.ts
-async function ravenFetch(connection, path69) {
+async function ravenFetch(connection, path70) {
   const apiKey = resolveOpSecret(connection.apiKeyRef);
   let accessToken = await getAccessToken(apiKey);
-  const url = `${connection.url}${path69}`;
+  const url = `${connection.url}${path70}`;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json"
@@ -18400,16 +18401,16 @@ import chalk169 from "chalk";
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
   const db = encodeURIComponent(opts.db);
-  let path69;
+  let path70;
   if (opts.collection) {
-    path69 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+    path70 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
   } else {
-    path69 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+    path70 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
   }
   if (opts.query) {
-    path69 += `&query=${encodeURIComponent(opts.query)}`;
+    path70 += `&query=${encodeURIComponent(opts.query)}`;
   }
-  return path69;
+  return path70;
 }
 
 // src/commands/ravendb/fetchAllPages.ts
@@ -18418,7 +18419,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 path69 = buildQueryPath({
+    const path70 = buildQueryPath({
       db: connection.database,
       collection: opts.collection,
       start: start3,
@@ -18426,7 +18427,7 @@ async function fetchAllPages(connection, opts) {
       sort: opts.sort,
       query: opts.query
     });
-    const data = await ravenFetch(connection, path69);
+    const data = await ravenFetch(connection, path70);
     const results = data.Results ?? [];
     const totalResults = data.TotalResults ?? 0;
     if (results.length === 0) break;
@@ -18687,7 +18688,7 @@ async function check(pattern2, options2) {
 }
 
 // src/commands/refactor/extract/index.ts
-import path43 from "path";
+import path44 from "path";
 import chalk174 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
@@ -19336,35 +19337,75 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
-import path42 from "path";
+import path43 from "path";
 import chalk173 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
+import fs27 from "fs";
+import path42 from "path";
+
+// src/commands/refactor/extract/findEnclosingTsConfig.ts
 import fs26 from "fs";
 import path41 from "path";
+
+// src/commands/refactor/extract/projectIncludesFile.ts
 import { Project as Project3 } from "ts-morph";
+function projectIncludesFile(configPath, sourcePath) {
+  try {
+    const project = new Project3({ tsConfigFilePath: configPath });
+    return !!project.getSourceFile(sourcePath);
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/refactor/extract/findEnclosingTsConfig.ts
+function findEnclosingTsConfig(sourcePath, rootDir, tried) {
+  let dir = path41.dirname(sourcePath);
+  while (dir.startsWith(rootDir + path41.sep) && dir !== rootDir) {
+    const nested = path41.join(dir, "tsconfig.json");
+    if (!tried.has(nested)) {
+      tried.add(nested);
+      if (fs26.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
+        return nested;
+      }
+    }
+    const parent = path41.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+
+// src/commands/refactor/extract/findTsConfig.ts
 function findTsConfig(sourcePath) {
-  const rootConfig = path41.resolve("tsconfig.json");
-  if (!fs26.existsSync(rootConfig)) return rootConfig;
+  const rootConfig = path42.resolve("tsconfig.json");
+  if (!fs27.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
   for (const candidate of candidates) {
     if (tried.has(candidate)) continue;
     tried.add(candidate);
-    if (projectIncludes(candidate, sourcePath)) return candidate;
+    if (projectIncludesFile(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs26.readdirSync(path41.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path41.resolve(path41.dirname(rootConfig), f));
+  const siblings = fs27.readdirSync(path42.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path42.resolve(path42.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
-    if (projectIncludes(sibling, sourcePath)) return sibling;
+    if (projectIncludesFile(sibling, sourcePath)) return sibling;
   }
+  const nested = findEnclosingTsConfig(
+    sourcePath,
+    path42.dirname(rootConfig),
+    tried
+  );
+  if (nested) return nested;
   return rootConfig;
 }
 function readReferences(configPath) {
-  if (!fs26.existsSync(configPath)) return [];
-  const raw = fs26.readFileSync(configPath, "utf8");
+  if (!fs27.existsSync(configPath)) return [];
+  const raw = fs27.readFileSync(configPath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   let parsed;
   try {
@@ -19373,24 +19414,16 @@ function readReferences(configPath) {
     return [];
   }
   if (!parsed.references?.length) return [];
-  const cwd = path41.dirname(configPath);
+  const cwd = path42.dirname(configPath);
   return parsed.references.map((ref) => {
-    const refPath = path41.resolve(cwd, ref.path);
-    return fs26.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path41.join(refPath, "tsconfig.json") : refPath;
-  }).filter((p) => fs26.existsSync(p));
-}
-function projectIncludes(configPath, sourcePath) {
-  try {
-    const project = new Project3({ tsConfigFilePath: configPath });
-    return !!project.getSourceFile(sourcePath);
-  } catch {
-    return false;
-  }
+    const refPath = path42.resolve(cwd, ref.path);
+    return fs27.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path42.join(refPath, "tsconfig.json") : refPath;
+  }).filter((p) => fs27.existsSync(p));
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
 function loadProjectFile(file) {
-  const sourcePath = path42.resolve(file);
+  const sourcePath = path43.resolve(file);
   const tsConfigPath = findTsConfig(sourcePath);
   const project = new Project4({
     tsConfigFilePath: tsConfigPath
@@ -19405,10 +19438,10 @@ function loadProjectFile(file) {
 
 // src/commands/refactor/extract/index.ts
 async function extract(file, functionName, destination, options2 = {}) {
-  const sourcePath = path43.resolve(file);
-  const destPath = path43.resolve(destination);
+  const sourcePath = path44.resolve(file);
+  const destPath = path44.resolve(destination);
   const cwd = process.cwd();
-  const relDest = path43.relative(cwd, destPath);
+  const relDest = path44.relative(cwd, destPath);
   const { project, sourceFile } = loadProjectFile(file);
   const plan2 = buildPlan2(
     functionName,
@@ -19427,25 +19460,25 @@ async function extract(file, functionName, destination, options2 = {}) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs27 from "fs";
+import fs28 from "fs";
 import chalk175 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
-  if (!fs27.existsSync(file)) {
+  if (!fs28.existsSync(file)) {
     console.error(chalk175.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs27.readFileSync(file, "utf8");
+  const content = fs28.readFileSync(file, "utf8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs27.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs27.readFileSync(REFACTOR_YML_PATH2, "utf8");
-    fs27.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs28.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs28.readFileSync(REFACTOR_YML_PATH2, "utf8");
+    fs28.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs27.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs28.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk175.green(
@@ -19455,20 +19488,20 @@ function ignore2(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import fs30 from "fs";
-import path48 from "path";
+import fs31 from "fs";
+import path49 from "path";
 import chalk178 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
-import fs29 from "fs";
-import path45 from "path";
+import fs30 from "fs";
+import path46 from "path";
 import chalk176 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
-import path44 from "path";
+import path45 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs28 from "fs";
+import fs29 from "fs";
 function getOrCreateList(map, key) {
   const list5 = map.get(key) ?? [];
   if (!map.has(key)) map.set(key, list5);
@@ -19487,7 +19520,7 @@ function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
   return content.replace(pattern2, `$1${newSpecifier}$2`);
 }
 function applyFileRewrites(file, fileRewrites) {
-  let content = fs28.readFileSync(file, "utf8");
+  let content = fs29.readFileSync(file, "utf8");
   for (const { oldSpecifier, newSpecifier } of fileRewrites) {
     content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
@@ -19519,7 +19552,7 @@ function normalizeSpecifier(rel) {
   );
 }
 function computeSpecifier(fromFile, toFile) {
-  return normalizeSpecifier(path44.relative(path44.dirname(fromFile), toFile));
+  return normalizeSpecifier(path45.relative(path45.dirname(fromFile), toFile));
 }
 function isAffected(edge, moveMap) {
   return moveMap.has(edge.target) || moveMap.has(edge.source);
@@ -19566,21 +19599,21 @@ function computeRewrites(moves, edges, allProjectFiles) {
 function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
-    fs29.writeFileSync(file, content, "utf8");
-    console.log(chalk176.cyan(`  Updated imports in ${path45.relative(cwd, file)}`));
+    fs30.writeFileSync(file, content, "utf8");
+    console.log(chalk176.cyan(`  Updated imports in ${path46.relative(cwd, file)}`));
   }
-  const destDir = path45.dirname(destPath);
-  if (!fs29.existsSync(destDir)) fs29.mkdirSync(destDir, { recursive: true });
-  fs29.renameSync(sourcePath, destPath);
+  const destDir = path46.dirname(destPath);
+  if (!fs30.existsSync(destDir)) fs30.mkdirSync(destDir, { recursive: true });
+  fs30.renameSync(sourcePath, destPath);
   console.log(
     chalk176.white(
-      `  Moved ${path45.relative(cwd, sourcePath)} \u2192 ${path45.relative(cwd, destPath)}`
+      `  Moved ${path46.relative(cwd, sourcePath)} \u2192 ${path46.relative(cwd, destPath)}`
     )
   );
 }
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
-import path46 from "path";
+import path47 from "path";
 import ts7 from "typescript";
 
 // src/commands/refactor/restructure/buildImportGraph/getImportSpecifiers.ts
@@ -19607,7 +19640,7 @@ function loadParsedConfig(tsConfigPath) {
   return ts7.parseJsonConfigFileContent(
     configFile.config,
     ts7.sys,
-    path46.dirname(tsConfigPath)
+    path47.dirname(tsConfigPath)
   );
 }
 function addToSetMap(map, key, value) {
@@ -19623,7 +19656,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 path46.resolve(resolvedPath);
+  return path47.resolve(resolvedPath);
 }
 function buildImportGraph(candidateFiles, tsConfigPath) {
   const parsed = loadParsedConfig(tsConfigPath);
@@ -19632,7 +19665,7 @@ function buildImportGraph(candidateFiles, tsConfigPath) {
   const importedBy = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
   for (const sourceFile of program2.getSourceFiles()) {
-    const filePath = path46.resolve(sourceFile.fileName);
+    const filePath = path47.resolve(sourceFile.fileName);
     if (filePath.includes("node_modules")) continue;
     for (const specifier of getImportSpecifiers(sourceFile)) {
       const absTarget = resolveImport(specifier, filePath, parsed.options);
@@ -19659,13 +19692,13 @@ function computeRenameRewrites(sourcePath, destPath) {
 }
 
 // src/commands/refactor/rename/printRenamePreview.ts
-import path47 from "path";
+import path48 from "path";
 import chalk177 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
       chalk177.dim(
-        `  ${path47.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
+        `  ${path48.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
@@ -19674,16 +19707,16 @@ function printRenamePreview(rewrites, cwd) {
 
 // src/commands/refactor/rename/index.ts
 async function rename(source, destination, options2 = {}) {
-  const sourcePath = path48.resolve(source);
-  const destPath = path48.resolve(destination);
+  const sourcePath = path49.resolve(source);
+  const destPath = path49.resolve(destination);
   const cwd = process.cwd();
-  const relSource = path48.relative(cwd, sourcePath);
-  const relDest = path48.relative(cwd, destPath);
-  if (!fs30.existsSync(sourcePath)) {
+  const relSource = path49.relative(cwd, sourcePath);
+  const relDest = path49.relative(cwd, destPath);
+  if (!fs31.existsSync(sourcePath)) {
     console.log(chalk178.red(`File not found: ${source}`));
     process.exit(1);
   }
-  if (destPath !== sourcePath && fs30.existsSync(destPath)) {
+  if (destPath !== sourcePath && fs31.existsSync(destPath)) {
     console.log(chalk178.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
@@ -19733,12 +19766,12 @@ function findSymbol(sourceFile, symbolName) {
 }
 
 // src/commands/refactor/renameSymbol/groupReferences.ts
-import path49 from "path";
+import path50 from "path";
 function groupReferences(symbol, cwd) {
   const refs = symbol.findReferencesAsNodes();
   const grouped = /* @__PURE__ */ new Map();
   for (const ref of refs) {
-    const refFile = path49.relative(cwd, ref.getSourceFile().getFilePath());
+    const refFile = path50.relative(cwd, ref.getSourceFile().getFilePath());
     const lines = grouped.get(refFile) ?? [];
     if (!grouped.has(refFile)) grouped.set(refFile, lines);
     lines.push(ref.getStartLineNumber());
@@ -19777,16 +19810,16 @@ Renamed ${oldName} \u2192 ${newName}`));
 }
 
 // src/commands/refactor/restructure/index.ts
-import path56 from "path";
+import path57 from "path";
 import chalk182 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
-import path50 from "path";
+import path51 from "path";
 function clusterDirectories(graph) {
   const dirImportedBy = /* @__PURE__ */ new Map();
   for (const edge of graph.edges) {
-    const sourceDir = path50.dirname(edge.source);
-    const targetDir = path50.dirname(edge.target);
+    const sourceDir = path51.dirname(edge.source);
+    const targetDir = path51.dirname(edge.target);
     if (sourceDir === targetDir) continue;
     if (!graph.files.has(edge.target)) continue;
     const existing = dirImportedBy.get(targetDir) ?? /* @__PURE__ */ new Set();
@@ -19814,20 +19847,20 @@ function clusterDirectories(graph) {
   return clusters;
 }
 function isAncestor(ancestor, descendant) {
-  const rel = path50.relative(ancestor, descendant);
+  const rel = path51.relative(ancestor, descendant);
   return !rel.startsWith("..") && rel !== "";
 }
 
 // src/commands/refactor/restructure/clusterFiles.ts
-import path51 from "path";
+import path52 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 = path51.dirname(parent);
-  const fileDir = path51.dirname(file);
+  const parentDir = path52.dirname(parent);
+  const fileDir = path52.dirname(file);
   if (parentDir !== fileDir) return file;
-  if (path51.basename(parent, path51.extname(parent)) === "index") return file;
+  if (path52.basename(parent, path52.extname(parent)) === "index") return file;
   if (visited.has(parent)) return file;
   visited.add(parent);
   return findRootParent(parent, importedBy, visited);
@@ -19835,16 +19868,16 @@ function findRootParent(file, importedBy, visited) {
 function clusterFiles(graph) {
   const clusters = /* @__PURE__ */ new Map();
   for (const file of graph.files) {
-    const basename14 = path51.basename(file, path51.extname(file));
+    const basename14 = path52.basename(file, path52.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 = path51.dirname(parent);
-    const fileDir = path51.dirname(file);
+    const parentDir = path52.dirname(parent);
+    const fileDir = path52.dirname(file);
     if (parentDir !== fileDir) continue;
-    const parentBasename = path51.basename(parent, path51.extname(parent));
+    const parentBasename = path52.basename(parent, path52.extname(parent));
     if (parentBasename === "index") continue;
     const root = findRootParent(parent, graph.importedBy, /* @__PURE__ */ new Set([file]));
     if (!root || root === file) continue;
@@ -19856,10 +19889,10 @@ function clusterFiles(graph) {
 }
 
 // src/commands/refactor/restructure/displayPlan.ts
-import path52 from "path";
+import path53 from "path";
 import chalk180 from "chalk";
 function relPath(filePath) {
-  return path52.relative(process.cwd(), filePath);
+  return path53.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
@@ -19908,45 +19941,45 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs31 from "fs";
-import path53 from "path";
+import fs32 from "fs";
+import path54 from "path";
 import chalk181 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs31.writeFileSync(file, content, "utf8");
+    fs32.writeFileSync(file, content, "utf8");
     console.log(
-      chalk181.cyan(`  Rewrote imports in ${path53.relative(process.cwd(), file)}`)
+      chalk181.cyan(`  Rewrote imports in ${path54.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs31.mkdirSync(dir, { recursive: true });
-    console.log(chalk181.green(`  Created ${path53.relative(process.cwd(), dir)}/`));
+    fs32.mkdirSync(dir, { recursive: true });
+    console.log(chalk181.green(`  Created ${path54.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
-    const targetDir = path53.dirname(move2.to);
-    if (!fs31.existsSync(targetDir)) {
-      fs31.mkdirSync(targetDir, { recursive: true });
+    const targetDir = path54.dirname(move2.to);
+    if (!fs32.existsSync(targetDir)) {
+      fs32.mkdirSync(targetDir, { recursive: true });
     }
-    fs31.renameSync(move2.from, move2.to);
+    fs32.renameSync(move2.from, move2.to);
     console.log(
       chalk181.white(
-        `  Moved ${path53.relative(process.cwd(), move2.from)} \u2192 ${path53.relative(process.cwd(), move2.to)}`
+        `  Moved ${path54.relative(process.cwd(), move2.from)} \u2192 ${path54.relative(process.cwd(), move2.to)}`
       )
     );
   }
-  removeEmptyDirectories(plan2.moves.map((m) => path53.dirname(m.from)));
+  removeEmptyDirectories(plan2.moves.map((m) => path54.dirname(m.from)));
 }
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs31.existsSync(dir)) continue;
-    const entries = fs31.readdirSync(dir);
+    if (!fs32.existsSync(dir)) continue;
+    const entries = fs32.readdirSync(dir);
     if (entries.length === 0) {
-      fs31.rmdirSync(dir);
+      fs32.rmdirSync(dir);
       console.log(
         chalk181.dim(
-          `  Removed empty directory ${path53.relative(process.cwd(), dir)}`
+          `  Removed empty directory ${path54.relative(process.cwd(), dir)}`
         )
       );
     }
@@ -19954,46 +19987,46 @@ function removeEmptyDirectories(dirs) {
 }
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
-import path55 from "path";
+import path56 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs32 from "fs";
+import fs33 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs32.existsSync(dir)) return false;
+  if (!fs33.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs33 from "fs";
-import path54 from "path";
+import fs34 from "fs";
+import path55 from "path";
 function collectEntry(results, dir, entry) {
-  const full = path54.join(dir, entry.name);
+  const full = path55.join(dir, entry.name);
   const items2 = entry.isDirectory() ? listFilesRecursive(full) : [full];
   results.push(...items2);
 }
 function listFilesRecursive(dir) {
-  if (!fs33.existsSync(dir)) return [];
+  if (!fs34.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs33.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs34.readdirSync(dir, { withFileTypes: true })) {
     collectEntry(results, dir, entry);
   }
   return results;
 }
 function addDirectoryFileMoves(moves, childDir, newLocation, reason) {
   for (const file of listFilesRecursive(childDir)) {
-    const rel = path54.relative(childDir, file);
-    moves.push({ from: file, to: path54.join(newLocation, rel), reason });
+    const rel = path55.relative(childDir, file);
+    moves.push({ from: file, to: path55.join(newLocation, rel), reason });
   }
 }
 function resolveChildDest(parentDir, childDir) {
-  return path54.join(parentDir, path54.basename(childDir));
+  return path55.join(parentDir, path55.basename(childDir));
 }
 function childMoveReason(parentDir) {
-  return `Directory only imported from ${path54.basename(parentDir)}/`;
+  return `Directory only imported from ${path55.basename(parentDir)}/`;
 }
 function registerDirectoryMove(result, childDir, dest, parentDir) {
   result.directories.push(dest);
@@ -20018,7 +20051,7 @@ function planDirectoryMoves(clusters) {
 
 // src/commands/refactor/restructure/planFileMoves/index.ts
 function childMoveData(child, newDir, parentBase) {
-  const to = path55.join(newDir, path55.basename(child));
+  const to = path56.join(newDir, path56.basename(child));
   return { from: child, to, reason: `Only imported by ${parentBase}` };
 }
 function addChildMoves(moves, children, newDir, parentBase) {
@@ -20026,15 +20059,15 @@ function addChildMoves(moves, children, newDir, parentBase) {
     moves.push(childMoveData(child, newDir, parentBase));
 }
 function getBaseName(filePath) {
-  return path55.basename(filePath, path55.extname(filePath));
+  return path56.basename(filePath, path56.extname(filePath));
 }
 function resolveClusterDir(parent) {
-  return path55.join(path55.dirname(parent), getBaseName(parent));
+  return path56.join(path56.dirname(parent), getBaseName(parent));
 }
 function createParentMove(parent, newDir) {
   return {
     from: parent,
-    to: path55.join(newDir, `index${path55.extname(parent)}`),
+    to: path56.join(newDir, `index${path56.extname(parent)}`),
     reason: `Main module of new ${getBaseName(parent)}/ directory`
   };
 }
@@ -20058,7 +20091,7 @@ function planFileMoves(clusters) {
 
 // src/commands/refactor/restructure/index.ts
 function buildPlan3(candidateFiles, tsConfigPath) {
-  const candidates = new Set(candidateFiles.map((f) => path56.resolve(f)));
+  const candidates = new Set(candidateFiles.map((f) => path57.resolve(f)));
   const graph = buildImportGraph(candidates, tsConfigPath);
   const allProjectFiles = /* @__PURE__ */ new Set([
     ...graph.importedBy.keys(),
@@ -20081,7 +20114,7 @@ async function restructure(pattern2, options2 = {}) {
     console.log(chalk182.yellow("No files found matching pattern"));
     return;
   }
-  const tsConfigPath = path56.resolve("tsconfig.json");
+  const tsConfigPath = findTsConfig(path57.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
     console.log(chalk182.green("No restructuring needed"));
@@ -20814,8 +20847,8 @@ async function handlePostSynthesis(synthesisPath, options2) {
 // src/commands/review/prepareReviewDir.ts
 import { existsSync as existsSync43, mkdirSync as mkdirSync18, unlinkSync as unlinkSync16, writeFileSync as writeFileSync36 } from "fs";
 function clearReviewFiles(paths) {
-  for (const path69 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
-    if (existsSync43(path69)) unlinkSync16(path69);
+  for (const path70 of [paths.claudePath, paths.codexPath, paths.synthesisPath]) {
+    if (existsSync43(path70)) unlinkSync16(path70);
   }
 }
 function prepareReviewDir(paths, requestBody, force) {
@@ -21963,8 +21996,8 @@ import chalk190 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
 import chalk187 from "chalk";
-async function fetchSeq(conn, path69, params) {
-  const url = `${conn.url}${path69}?${params}`;
+async function fetchSeq(conn, path70, params) {
+  const url = `${conn.url}${path70}?${params}`;
   const response = await fetch(url, {
     headers: {
       Accept: "application/json",
@@ -23451,9 +23484,9 @@ function findPortFile(roamDir) {
     return void 0;
   }
   const candidates = entries.filter((name) => /^roam-local-api(-[^.]+)?\.port$/.test(name)).map((name) => {
-    const path69 = join61(roamDir, name);
+    const path70 = join61(roamDir, name);
     try {
-      return { path: path69, mtimeMs: statSync8(path69).mtimeMs };
+      return { path: path70, mtimeMs: statSync8(path70).mtimeMs };
     } catch {
       return void 0;
     }
@@ -23872,11 +23905,11 @@ function findLinkIndex() {
 function parseLinkArgs() {
   const idx = findLinkIndex();
   if (idx === -1) return null;
-  const path69 = process.argv[idx + 1];
+  const path70 = process.argv[idx + 1];
   const rest = process.argv.slice(idx + 2);
   const { value: prefix2 } = extractOption(rest, "--prefix");
   if (!prefix2) return null;
-  return { path: path69, prefix: prefix2 };
+  return { path: path70, prefix: prefix2 };
 }
 function hasDuplicateLink(runList, linkPath) {
   return runList.some(
@@ -24525,12 +24558,12 @@ function activeWindows(rateLimits) {
 
 // src/shared/db/recordUsagePeak.ts
 var WINDOWS2 = ["five_hour", "seven_day"];
-async function recordUsagePeak(db, rateLimits) {
+async function recordUsagePeak(db, rateLimits, now = Math.floor(Date.now() / 1e3)) {
   for (const window of WINDOWS2) {
     const w = rateLimits[window];
     if (!w || typeof w.resets_at !== "number" || typeof w.used_percentage !== "number")
       continue;
-    await recordWindowPeak(db, window, w.resets_at, w.used_percentage);
+    await recordWindowPeak(db, window, w.resets_at, w.used_percentage, now);
   }
 }
 
@@ -24592,14 +24625,14 @@ import * as pty from "node-pty";
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
 import { chmodSync, existsSync as existsSync55, statSync as statSync9 } from "fs";
 import { createRequire as createRequire3 } from "module";
-import path57 from "path";
+import path58 from "path";
 var require4 = createRequire3(import.meta.url);
 var ensured = false;
 function ensureSpawnHelperExecutable() {
   if (ensured || process.platform !== "darwin") return;
   ensured = true;
-  const ptyRoot = path57.join(path57.dirname(require4.resolve("node-pty")), "..");
-  const helper = path57.join(
+  const ptyRoot = path58.join(path58.dirname(require4.resolve("node-pty")), "..");
+  const helper = path58.join(
     ptyRoot,
     "prebuilds",
     `${process.platform}-${process.arch}`,
@@ -24660,14 +24693,14 @@ function createAssistSession(id, assistArgs, cwd, meta) {
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs34 from "fs";
-import * as path58 from "path";
+import * as fs35 from "fs";
+import * as path59 from "path";
 import { fileURLToPath as fileURLToPath8 } from "url";
 var __filename4 = fileURLToPath8(import.meta.url);
-var __dirname6 = path58.dirname(__filename4);
+var __dirname6 = path59.dirname(__filename4);
 function readDesignSystemPrompt() {
-  const promptPath = path58.join(__dirname6, "..", "claude", "system-prompt.md");
-  return fs34.readFileSync(promptPath, "utf8");
+  const promptPath = path59.join(__dirname6, "..", "claude", "system-prompt.md");
+  return fs35.readFileSync(promptPath, "utf8");
 }
 
 // src/commands/sessions/daemon/spawnClaude.ts
@@ -25046,7 +25079,7 @@ async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
 }
 
 // src/commands/sessions/shared/transcriptUsage.ts
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 function transcriptUsage(lines) {
   const byId = /* @__PURE__ */ new Map();
   for (const line of lines) {
@@ -25070,7 +25103,7 @@ function transcriptUsage(lines) {
   return [...byId.values()];
 }
 async function readTranscriptUsage(transcriptPath) {
-  const content = await fs35.promises.readFile(transcriptPath, "utf8");
+  const content = await fs36.promises.readFile(transcriptPath, "utf8");
   return transcriptUsage(content.split("\n"));
 }
 
@@ -25203,8 +25236,8 @@ async function seedRunningMsFromUsage(session, notify2) {
 var DEBOUNCE_MS = 50;
 function watchActivity(session, notify2) {
   if (session.commandType !== "assist" || !session.cwd) return;
-  const path69 = activityPath(session.id);
-  const dir = dirname29(path69);
+  const path70 = activityPath(session.id);
+  const dir = dirname29(path70);
   try {
     mkdirSync25(dir, { recursive: true });
   } catch {
@@ -25214,7 +25247,7 @@ function watchActivity(session, notify2) {
   let timer = null;
   const read = () => {
     timer = null;
-    const activity2 = readActivity(path69);
+    const activity2 = readActivity(path70);
     if (!activity2) return;
     session.activity = activity2;
     if (activity2.claudeSessionId)
@@ -25224,11 +25257,11 @@ function watchActivity(session, notify2) {
     notify2();
   };
   session.activityWatcher = watch(dir, (_event, filename) => {
-    if (filename && !path69.endsWith(filename)) return;
+    if (filename && !path70.endsWith(filename)) return;
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS);
   });
-  if (existsSync56(path69)) read();
+  if (existsSync56(path70)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -26559,7 +26592,7 @@ import * as net3 from "net";
 import { createInterface as createInterface9 } from "readline";
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 
 // src/commands/sessions/shared/toolTarget.ts
 function toolTarget(input) {
@@ -26611,7 +26644,7 @@ async function parseTranscript(sessionId) {
   const filePath = await findSessionJsonlPath(sessionId);
   if (!filePath) return [];
   try {
-    const raw = await fs36.promises.readFile(filePath, "utf8");
+    const raw = await fs37.promises.readFile(filePath, "utf8");
     return parseTranscriptLines(raw.split("\n"));
   } catch {
     return [];
@@ -26940,17 +26973,17 @@ function registerDaemon(program2) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import chalk199 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs37 from "fs";
+import * as fs38 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs37.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs38.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs37.existsSync(summaryPathFor(jsonlPath2));
+  return fs38.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -27037,7 +27070,7 @@ function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs38.statSync(b).mtimeMs - fs38.statSync(a).mtimeMs;
+      return fs39.statSync(b).mtimeMs - fs39.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -27278,21 +27311,21 @@ async function statusLine() {
 }
 
 // src/commands/sync.ts
-import * as fs45 from "fs";
+import * as fs46 from "fs";
 import * as os4 from "os";
-import * as path67 from "path";
+import * as path68 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
 
 // src/commands/sync/syncClaudeMd.ts
-import * as fs39 from "fs";
-import * as path59 from "path";
+import * as fs40 from "fs";
+import * as path60 from "path";
 import chalk202 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
-  const source = path59.join(claudeDir, "CLAUDE.md");
-  const target = path59.join(targetBase, "CLAUDE.md");
-  const sourceContent = fs39.readFileSync(source, "utf8");
-  if (fs39.existsSync(target)) {
-    const targetContent = fs39.readFileSync(target, "utf8");
+  const source = path60.join(claudeDir, "CLAUDE.md");
+  const target = path60.join(targetBase, "CLAUDE.md");
+  const sourceContent = fs40.readFileSync(source, "utf8");
+  if (fs40.existsSync(target)) {
+    const targetContent = fs40.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
         chalk202.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
@@ -27309,38 +27342,38 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs39.copyFileSync(source, target);
+  fs40.copyFileSync(source, target);
   console.log("Copied CLAUDE.md to ~/.claude/CLAUDE.md");
 }
 
 // src/commands/sync/syncCodex.ts
-import * as path62 from "path";
+import * as path63 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
-import * as fs40 from "fs";
-import * as path60 from "path";
+import * as fs41 from "fs";
+import * as path61 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
-  const commandsSource = path60.join(claudeDir, "commands");
-  const files = fs40.readdirSync(commandsSource);
+  const commandsSource = path61.join(claudeDir, "commands");
+  const files = fs41.readdirSync(commandsSource);
   let synced = 0;
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
-    const content = fs40.readFileSync(path60.join(commandsSource, file), "utf8");
-    const target = path60.join(harness.homeDir, harness.sync.commandDest(name));
-    fs40.mkdirSync(path60.dirname(target), { recursive: true });
-    fs40.writeFileSync(target, transform(name, content));
+    const content = fs41.readFileSync(path61.join(commandsSource, file), "utf8");
+    const target = path61.join(harness.homeDir, harness.sync.commandDest(name));
+    fs41.mkdirSync(path61.dirname(target), { recursive: true });
+    fs41.writeFileSync(target, transform(name, content));
     synced++;
   }
-  const agentsTarget = path60.join(harness.homeDir, harness.sync.agentsFile);
-  fs40.mkdirSync(path60.dirname(agentsTarget), { recursive: true });
-  fs40.copyFileSync(path60.join(claudeDir, "CLAUDE.md"), agentsTarget);
+  const agentsTarget = path61.join(harness.homeDir, harness.sync.agentsFile);
+  fs41.mkdirSync(path61.dirname(agentsTarget), { recursive: true });
+  fs41.copyFileSync(path61.join(claudeDir, "CLAUDE.md"), agentsTarget);
   return { total: files.length, synced };
 }
 
 // src/commands/sync/syncCodexHooks.ts
-import * as fs41 from "fs";
-import * as path61 from "path";
+import * as fs42 from "fs";
+import * as path62 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
 function upsertManagedBlock(existing, body) {
@@ -27370,11 +27403,11 @@ ${rest}
 `;
 }
 function syncCodexHooks(sourcePath) {
-  const body = fs41.readFileSync(sourcePath, "utf8");
-  const configPath = path61.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs41.existsSync(configPath) ? fs41.readFileSync(configPath, "utf8") : "";
-  fs41.mkdirSync(path61.dirname(configPath), { recursive: true });
-  fs41.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  const body = fs42.readFileSync(sourcePath, "utf8");
+  const configPath = path62.join(harnesses.codex.homeDir, "config.toml");
+  const existing = fs42.existsSync(configPath) ? fs42.readFileSync(configPath, "utf8") : "";
+  fs42.mkdirSync(path62.dirname(configPath), { recursive: true });
+  fs42.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (PreToolUse, PermissionRequest)"
   );
@@ -27405,50 +27438,50 @@ function syncCodex(claudeDir) {
     harnesses.codex,
     commandToSkill
   );
-  syncCodexHooks(path62.join(claudeDir, "..", "codex", "config.toml"));
+  syncCodexHooks(path63.join(claudeDir, "..", "codex", "config.toml"));
   console.log(
     `Synced ${total} skill(s) to ~/.codex/skills and CLAUDE.md to ~/.codex/AGENTS.md`
   );
 }
 
 // src/commands/sync/syncDesign.ts
-import * as fs42 from "fs";
-import * as path63 from "path";
+import * as fs43 from "fs";
+import * as path64 from "path";
 function syncDesign(claudeDir, targetBase) {
-  const systemPromptSource = path63.join(claudeDir, "system-prompt.md");
-  const systemPromptTarget = path63.join(targetBase, "system-prompt.md");
-  fs42.copyFileSync(systemPromptSource, systemPromptTarget);
+  const systemPromptSource = path64.join(claudeDir, "system-prompt.md");
+  const systemPromptTarget = path64.join(targetBase, "system-prompt.md");
+  fs43.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log("Copied system-prompt.md to ~/.claude/system-prompt.md");
-  const skillsSource = path63.join(claudeDir, "skills");
-  const skillsTarget = path63.join(targetBase, "skills");
-  fs42.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs42.readdirSync(skillsSource);
+  const skillsSource = path64.join(claudeDir, "skills");
+  const skillsTarget = path64.join(targetBase, "skills");
+  fs43.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs43.readdirSync(skillsSource);
   for (const file of files) {
-    fs42.copyFileSync(
-      path63.join(skillsSource, file),
-      path63.join(skillsTarget, file)
+    fs43.copyFileSync(
+      path64.join(skillsSource, file),
+      path64.join(skillsTarget, file)
     );
   }
   console.log(`Synced ${files.length} design skill(s) to ~/.claude/skills`);
 }
 
 // src/commands/sync/syncPi.ts
-import * as path65 from "path";
+import * as path66 from "path";
 
 // src/commands/sync/syncPiHooks.ts
-import * as fs43 from "fs";
-import * as path64 from "path";
+import * as fs44 from "fs";
+import * as path65 from "path";
 function piExtensionsDir() {
-  return path64.join(harnesses.pi.homeDir, "extensions");
+  return path65.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
-  fs43.mkdirSync(target, { recursive: true });
-  const files = fs43.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  fs44.mkdirSync(target, { recursive: true });
+  const files = fs44.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    fs43.copyFileSync(
-      path64.join(sourceDir, file),
-      path64.join(target, `assist-${file}`)
+    fs44.copyFileSync(
+      path65.join(sourceDir, file),
+      path65.join(target, `assist-${file}`)
     );
   }
   console.log(
@@ -27485,23 +27518,23 @@ function syncPi(claudeDir) {
     harnesses.pi,
     commandToPrompt
   );
-  syncPiHooks(path65.join(claudeDir, "..", "pi"));
+  syncPiHooks(path66.join(claudeDir, "..", "pi"));
   console.log(
     `Synced ${synced} prompt(s) to ~/.pi/agent/prompts and CLAUDE.md to ~/.pi/agent/AGENTS.md`
   );
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs44 from "fs";
-import * as path66 from "path";
+import * as fs45 from "fs";
+import * as path67 from "path";
 import chalk203 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
-  const source = path66.join(claudeDir, "settings.json");
-  const target = path66.join(targetBase, "settings.json");
-  const sourceContent = fs44.readFileSync(source, "utf8");
+  const source = path67.join(claudeDir, "settings.json");
+  const target = path67.join(targetBase, "settings.json");
+  const sourceContent = fs45.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs44.existsSync(target);
-  const targetContent = targetExists ? fs44.readFileSync(target, "utf8") : "";
+  const targetExists = fs45.existsSync(target);
+  const targetContent = targetExists ? fs45.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -27530,18 +27563,18 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs44.writeFileSync(target, mergedContent);
+  fs45.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
 // src/commands/sync.ts
 var __filename5 = fileURLToPath9(import.meta.url);
-var __dirname7 = path67.dirname(__filename5);
+var __dirname7 = path68.dirname(__filename5);
 async function sync(options2) {
   const config = loadConfig();
   const yes = options2?.yes ?? config.sync.autoConfirm;
-  const claudeDir = path67.join(__dirname7, "..", "claude");
-  const targetBase = path67.join(os4.homedir(), ".claude");
+  const claudeDir = path68.join(__dirname7, "..", "claude");
+  const targetBase = path68.join(os4.homedir(), ".claude");
   syncCommands(claudeDir, targetBase);
   syncDesign(claudeDir, targetBase);
   await syncSettings(claudeDir, targetBase, { yes });
@@ -27550,12 +27583,12 @@ async function sync(options2) {
   syncPi(claudeDir);
 }
 function syncCommands(claudeDir, targetBase) {
-  const sourceDir = path67.join(claudeDir, "commands");
-  const targetDir = path67.join(targetBase, "commands");
-  fs45.mkdirSync(targetDir, { recursive: true });
-  const files = fs45.readdirSync(sourceDir);
+  const sourceDir = path68.join(claudeDir, "commands");
+  const targetDir = path68.join(targetBase, "commands");
+  fs46.mkdirSync(targetDir, { recursive: true });
+  const files = fs46.readdirSync(sourceDir);
   for (const file of files) {
-    fs45.copyFileSync(path67.join(sourceDir, file), path67.join(targetDir, file));
+    fs46.copyFileSync(path68.join(sourceDir, file), path68.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -27563,7 +27596,7 @@ function syncCommands(claudeDir, targetBase) {
 
 // src/commands/update.ts
 import { execSync as execSync59 } from "child_process";
-import * as path68 from "path";
+import * as path69 from "path";
 
 // src/commands/restartDaemonAfterUpdate.ts
 async function restartDaemonAfterUpdate() {
@@ -27582,12 +27615,12 @@ async function restartDaemonAfterUpdate() {
 // src/commands/update.ts
 function isGlobalNpmInstall(dir) {
   try {
-    const resolved = path68.resolve(dir);
-    if (resolved.split(path68.sep).includes("node_modules")) {
+    const resolved = path69.resolve(dir);
+    if (resolved.split(path69.sep).includes("node_modules")) {
       return true;
     }
     const globalPrefix = execSync59("npm prefix -g", { stdio: "pipe" }).toString().trim();
-    return resolved.toLowerCase().startsWith(path68.resolve(globalPrefix).toLowerCase());
+    return resolved.toLowerCase().startsWith(path69.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
   }