@staff0rd/assist 0.657.0 → 0.658.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.657.0",
+  version: "0.658.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -5019,28 +5019,45 @@ async function notify() {
   console.log(`Notification sent: ${notification_type} for ${projectName}`);
 }
 
-// src/commands/activity/activityChart.ts
+// src/lib/renderLineChart.ts
+import * as fs16 from "fs";
+import * as tty from "tty";
 import blessed from "blessed";
 import contrib from "blessed-contrib";
-function activityChart(data, range) {
+var keyboardInput = () => {
+  if (process.stdin.isTTY) return void 0;
+  try {
+    return new tty.ReadStream(fs16.openSync("/dev/tty", "r"));
+  } catch {
+    return void 0;
+  }
+};
+function renderLineChart({
+  title,
+  label: label2,
+  seriesTitle,
+  labels,
+  values,
+  wholeNumbersOnly = false
+}) {
+  const input = keyboardInput();
   const screen = blessed.screen({
     smartCSR: true,
-    title: "Commit Activity"
+    title,
+    input
   });
   const grid = new contrib.grid({ rows: 1, cols: 1, screen });
-  const labels = data.map((d) => d.date.slice(5));
-  const values = data.map((d) => d.count);
   const line = grid.set(0, 0, 1, 1, contrib.line, {
-    label: ` Commits per week \xB7 ${range.since} \u2192 ${range.until} (press q to close) `,
+    label: ` ${label2} (press q to close) `,
     showLegend: true,
-    legend: { width: 12 },
+    legend: { width: Math.max(12, seriesTitle.length + 2) },
     xLabelPadding: 3,
     xPadding: 5,
-    wholeNumbersOnly: true
+    wholeNumbersOnly
   });
   line.setData([
     {
-      title: "Commits",
+      title: seriesTitle,
       x: labels,
       y: values,
       style: { line: "green" }
@@ -5048,6 +5065,7 @@ function activityChart(data, range) {
   ]);
   screen.key(["q", "C-c", "escape"], () => {
     screen.destroy();
+    input?.destroy();
   });
   screen.render();
 }
@@ -5107,7 +5125,14 @@ async function activity(options2) {
   }
   const weeklyData = [...weekly.entries()].map(([date, count8]) => ({ date, count: count8 })).sort((a, b) => a.date.localeCompare(b.date));
   const until = data[data.length - 1].date;
-  activityChart(weeklyData, { since, until });
+  renderLineChart({
+    title: "Commit Activity",
+    label: `Commits per week \xB7 ${since} \u2192 ${until}`,
+    seriesTitle: "Commits",
+    labels: weeklyData.map((d) => d.date.slice(5)),
+    values: weeklyData.map((d) => d.count),
+    wholeNumbersOnly: true
+  });
 }
 
 // src/commands/registerActivity.ts
@@ -6337,6 +6362,72 @@ function registerBackup(program2) {
   configHelp(backupCommand, backupConfigHelp);
 }
 
+// src/commands/chart/parseChartSeries.ts
+function parseChartSeries(lines2) {
+  const points = [];
+  for (const line of lines2) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const parts = trimmed.split(/[,\t ]+/).filter((part) => part !== "");
+    if (parts.length < 2) {
+      throw new Error(`Expected a label and a value, got: ${trimmed}`);
+    }
+    const label2 = parts.slice(0, -1).join(" ");
+    const raw = parts[parts.length - 1];
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+      throw new Error(`Value "${raw}" is not numeric, on line: ${trimmed}`);
+    }
+    points.push({ label: label2, value });
+  }
+  return points;
+}
+
+// src/commands/chart/readStdinLines.ts
+import * as readline2 from "readline";
+async function readStdinLines() {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    terminal: false
+  });
+  const lines2 = [];
+  for await (const line of rl) {
+    lines2.push(line);
+  }
+  return lines2;
+}
+
+// src/commands/chart.ts
+async function chart(options2) {
+  const lines2 = await readStdinLines();
+  let points;
+  try {
+    points = parseChartSeries(lines2);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (points.length < 2) {
+    console.log("Not enough data points to chart.");
+    return;
+  }
+  const title = options2.title ?? "Chart";
+  renderLineChart({
+    title,
+    label: title,
+    seriesTitle: title,
+    labels: points.map((p) => p.label),
+    values: points.map((p) => p.value)
+  });
+}
+
+// src/commands/registerChart.ts
+function registerChart(program2) {
+  program2.command("chart").description(
+    "Chart a label/value series read from stdin, one pair per line (comma, tab or whitespace separated)"
+  ).option("--title <title>", "Chart title").action(chart);
+}
+
 // src/commands/backlog/next.ts
 import chalk47 from "chalk";
 import enquirer5 from "enquirer";
@@ -8631,12 +8722,12 @@ import chalk44 from "chalk";
 import * as path29 from "path";
 
 // src/commands/sessions/shared/discoverSessions.ts
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 import * as os3 from "os";
 import * as path28 from "path";
 
 // src/commands/sessions/shared/codex/discoverCodexRolloutPaths.ts
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path25 from "path";
 
 // src/commands/sessions/shared/codex/codexSessionsDir.ts
@@ -8661,7 +8752,7 @@ async function discoverCodexRolloutPaths() {
 async function collect(dir, depth) {
   let entries;
   try {
-    entries = await fs16.promises.readdir(dir, { withFileTypes: true });
+    entries = await fs17.promises.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -8677,7 +8768,7 @@ async function collectEntry(dir, entry, depth) {
 }
 
 // src/commands/sessions/shared/codex/parseCodexSessionFile.ts
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import * as path26 from "path";
 
 // src/commands/sessions/shared/backlogRunMarkers.ts
@@ -8769,12 +8860,12 @@ function firstUserMessage(entry) {
 }
 
 // src/commands/sessions/shared/codex/readCodexHeadLines.ts
-import * as fs17 from "fs";
-import * as readline2 from "readline";
+import * as fs18 from "fs";
+import * as readline3 from "readline";
 var DEFAULT_MAX_LINES = 80;
 async function readCodexHeadLines(filePath, maxLines = DEFAULT_MAX_LINES) {
-  const stream = fs17.createReadStream(filePath, { encoding: "utf8" });
-  const reader = readline2.createInterface({ input: stream });
+  const stream = fs18.createReadStream(filePath, { encoding: "utf8" });
+  const reader = readline3.createInterface({ input: stream });
   const lines2 = [];
   try {
     for await (const line of reader) {
@@ -8812,7 +8903,7 @@ async function parseCodexSessionFile(filePath) {
   }
 }
 async function mtime(filePath) {
-  return (await fs18.promises.stat(filePath)).mtime.toISOString();
+  return (await fs19.promises.stat(filePath)).mtime.toISOString();
 }
 
 // src/commands/sessions/shared/codex/discoverCodexSessions.ts
@@ -8823,7 +8914,7 @@ async function discoverCodexSessions() {
 }
 
 // src/commands/sessions/shared/parseSessionFile.ts
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 
 // src/commands/sessions/shared/extractSessionMeta.ts
 function extractSessionMeta(lines2) {
@@ -8894,10 +8985,10 @@ function dirNameToProject(filePath) {
 async function parseSessionFile(filePath, origin = "wsl") {
   let handle;
   try {
-    handle = await fs19.promises.open(filePath, "r");
+    handle = await fs20.promises.open(filePath, "r");
     const meta = extractSessionMeta(await readHeadLines(handle));
     if (!meta.sessionId) return null;
-    const timestamp6 = meta.timestamp || (await fs19.promises.stat(filePath)).mtime.toISOString();
+    const timestamp6 = meta.timestamp || (await fs20.promises.stat(filePath)).mtime.toISOString();
     return {
       sessionId: meta.sessionId,
       name: meta.name || `Session ${meta.sessionId.slice(0, 8)}`,
@@ -8934,7 +9025,7 @@ async function discoverSessionJsonlPaths() {
     sessionRoots().map(async ({ dir, origin }) => {
       let projectDirs;
       try {
-        projectDirs = await fs20.promises.readdir(dir);
+        projectDirs = await fs21.promises.readdir(dir);
       } catch {
         return;
       }
@@ -8943,7 +9034,7 @@ async function discoverSessionJsonlPaths() {
           const dirPath = path28.join(dir, dirName);
           let entries;
           try {
-            entries = await fs20.promises.readdir(dirPath);
+            entries = await fs21.promises.readdir(dirPath);
           } catch {
             return;
           }
@@ -9824,7 +9915,7 @@ import { spawn as spawn4 } from "child_process";
 import {
   closeSync,
   mkdirSync as mkdirSync10,
-  openSync,
+  openSync as openSync2,
   statSync as statSync2,
   unlinkSync as unlinkSync5,
   writeSync
@@ -9864,7 +9955,7 @@ function acquireSpawnLock() {
 }
 function tryCreateLock() {
   try {
-    const fd = openSync(daemonPaths.spawnLock, "wx");
+    const fd = openSync2(daemonPaths.spawnLock, "wx");
     writeSync(fd, String(process.pid));
     closeSync(fd);
     return true;
@@ -9886,7 +9977,7 @@ function releaseSpawnLock() {
   }
 }
 function spawnDaemon(reason4) {
-  const log2 = openSync(daemonPaths.log, "a");
+  const log2 = openSync2(daemonPaths.log, "a");
   const child = spawn4(process.execPath, [process.argv[1], "daemon", "run"], {
     detached: true,
     windowsHide: true,
@@ -13544,7 +13635,7 @@ var handleRequest = createFallbackHandler(
 );
 
 // src/commands/sessions/web/handleSocket.ts
-import { createInterface as createInterface3 } from "readline";
+import { createInterface as createInterface4 } from "readline";
 var CWD_DEFAULTED_TYPES = /* @__PURE__ */ new Set(["create", "create-run", "create-assist"]);
 function handleSocket(ws, ctx) {
   const connection = openDaemonConnection(ws, ctx);
@@ -13572,7 +13663,7 @@ async function openDaemonConnection(ws, ctx) {
   }
 }
 function relayDaemonLines(conn, ws, repoCwd) {
-  const lines2 = createInterface3({ input: conn });
+  const lines2 = createInterface4({ input: conn });
   lines2.on("error", () => {
   });
   lines2.on("line", (line) => {
@@ -13836,7 +13927,7 @@ function installRestartMenu(options2 = {}) {
 }
 
 // src/commands/sessions/web/streamDaemonLogs.ts
-import { createInterface as createInterface4 } from "readline";
+import { createInterface as createInterface5 } from "readline";
 var RECONNECT_MS = 3e3;
 function streamDaemonLogs() {
   void connect2();
@@ -13855,7 +13946,7 @@ async function connect2() {
   }
 }
 function wire(socket) {
-  const lines2 = createInterface4({ input: socket });
+  const lines2 = createInterface5({ input: socket });
   lines2.on("error", () => {
   });
   lines2.on("line", emit);
@@ -13927,20 +14018,20 @@ async function web2(options2) {
 import chalk64 from "chalk";
 
 // src/commands/sessions/shared/resolveSessionTranscript.ts
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 import * as path35 from "path";
 
 // src/commands/sessions/summarise/readTranscriptHead.ts
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 function readTranscriptHead(filePath, maxBytes = 65536) {
   try {
-    const fd = fs21.openSync(filePath, "r");
+    const fd = fs22.openSync(filePath, "r");
     try {
       const buf = Buffer.alloc(maxBytes);
-      const bytesRead = fs21.readSync(fd, buf, 0, buf.length, 0);
+      const bytesRead = fs22.readSync(fd, buf, 0, buf.length, 0);
       return buf.toString("utf8", 0, bytesRead);
     } finally {
-      fs21.closeSync(fd);
+      fs22.closeSync(fd);
     }
   } catch {
     return void 0;
@@ -13969,13 +14060,13 @@ function resolveSessionTranscript(sessionId, projectsRoot = claudeProjectsRoot()
 function findTranscriptFile(sessionId, projectsRoot) {
   let projectDirs;
   try {
-    projectDirs = fs22.readdirSync(projectsRoot);
+    projectDirs = fs23.readdirSync(projectsRoot);
   } catch {
     return void 0;
   }
   for (const dir of projectDirs) {
     const candidate = path35.join(projectsRoot, dir, `${sessionId}.jsonl`);
-    if (fs22.existsSync(candidate)) return candidate;
+    if (fs23.existsSync(candidate)) return candidate;
   }
   return void 0;
 }
@@ -14025,7 +14116,7 @@ async function addActivity(id, kind, ref, options2) {
 import chalk65 from "chalk";
 
 // src/commands/sessions/shared/resolveCurrentSessionId.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as path36 from "path";
 var SESSION_ID_ENV = "CLAUDE_CODE_SESSION_ID";
 function resolveCurrentSessionId(options2 = {}) {
@@ -14040,7 +14131,7 @@ function resolveCurrentSessionId(options2 = {}) {
 function newestTranscriptId(dir) {
   let entries;
   try {
-    entries = fs23.readdirSync(dir);
+    entries = fs24.readdirSync(dir);
   } catch {
     return void 0;
   }
@@ -14056,7 +14147,7 @@ function newestTranscriptId(dir) {
 }
 function modifiedAtOf(filePath) {
   try {
-    return fs23.statSync(filePath).mtimeMs;
+    return fs24.statSync(filePath).mtimeMs;
   } catch {
     return void 0;
   }
@@ -19022,13 +19113,13 @@ import chalk133 from "chalk";
 import chalk126 from "chalk";
 
 // src/commands/complexity/shared/index.ts
-import fs25 from "fs";
+import fs26 from "fs";
 import path38 from "path";
 import chalk125 from "chalk";
 import ts5 from "typescript";
 
 // src/commands/complexity/findSourceFiles.ts
-import fs24 from "fs";
+import fs25 from "fs";
 import path37 from "path";
 import { minimatch as minimatch5 } from "minimatch";
 function applyIgnoreGlobs(files, extraIgnore = []) {
@@ -19037,11 +19128,11 @@ function applyIgnoreGlobs(files, extraIgnore = []) {
   return files.filter((f) => !ignore3.some((glob) => minimatch5(f, glob)));
 }
 function walk2(dir, results) {
-  if (!fs24.existsSync(dir)) {
+  if (!fs25.existsSync(dir)) {
     return;
   }
   const extensions = [".ts", ".tsx"];
-  const entries = fs24.readdirSync(dir, { withFileTypes: true });
+  const entries = fs25.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = path37.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -19062,10 +19153,10 @@ function findSourceFiles2(pattern2, baseDir = ".", extraIgnore = []) {
       extraIgnore
     );
   }
-  if (fs24.existsSync(pattern2) && fs24.statSync(pattern2).isFile()) {
+  if (fs25.existsSync(pattern2) && fs25.statSync(pattern2).isFile()) {
     return [pattern2];
   }
-  if (fs24.existsSync(pattern2) && fs24.statSync(pattern2).isDirectory()) {
+  if (fs25.existsSync(pattern2) && fs25.statSync(pattern2).isDirectory()) {
     walk2(pattern2, results);
     return applyIgnoreGlobs(results, extraIgnore);
   }
@@ -19263,7 +19354,7 @@ function countSloc(content) {
 
 // src/commands/complexity/shared/index.ts
 function createSourceFromFile(filePath) {
-  const content = fs25.readFileSync(filePath, "utf8");
+  const content = fs26.readFileSync(filePath, "utf8");
   return ts5.createSourceFile(
     path38.basename(filePath),
     content,
@@ -19375,7 +19466,7 @@ function aggregateResults(fileMetrics) {
 }
 
 // src/commands/complexity/maintainability/collectFileMetrics.ts
-import fs26 from "fs";
+import fs27 from "fs";
 
 // src/commands/complexity/maintainability/calculateMaintainabilityIndex.ts
 function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, sloc2) {
@@ -19390,7 +19481,7 @@ function calculateMaintainabilityIndex(halsteadVolume, cyclomaticComplexity, slo
 function collectFileMetrics(files) {
   const fileMetrics = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const content = fs26.readFileSync(file, "utf8");
+    const content = fs27.readFileSync(file, "utf8");
     fileMetrics.set(file, {
       sloc: countSloc(content),
       functions: [],
@@ -19551,14 +19642,14 @@ async function maintainability(pattern2 = "**/*.ts", options2 = {}) {
 }
 
 // src/commands/complexity/sloc.ts
-import fs27 from "fs";
+import fs28 from "fs";
 import chalk132 from "chalk";
 async function sloc(pattern2 = "**/*.ts", options2 = {}) {
   withSourceFiles(pattern2, (files) => {
     const results = [];
     let hasViolation = false;
     for (const file of files) {
-      const content = fs27.readFileSync(file, "utf8");
+      const content = fs28.readFileSync(file, "utf8");
       const lines2 = countSloc(content);
       results.push({ file, lines: lines2 });
       if (options2.threshold !== void 0 && lines2 > options2.threshold) {
@@ -20807,7 +20898,7 @@ function registerDevlog(program2) {
 }
 
 // src/commands/dotnet/checkBuildLocks.ts
-import { closeSync as closeSync3, openSync as openSync3, readdirSync as readdirSync8 } from "fs";
+import { closeSync as closeSync3, openSync as openSync4, readdirSync as readdirSync8 } from "fs";
 import { join as join56 } from "path";
 import chalk154 from "chalk";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "packages"]);
@@ -20822,7 +20913,7 @@ function isLockedDll(debugDir) {
     if (!file.toLowerCase().endsWith(".dll")) continue;
     const dllPath = join56(debugDir, file);
     try {
-      const fd = openSync3(dllPath, "r+");
+      const fd = openSync4(dllPath, "r+");
       closeSync3(fd);
     } catch {
       return dllPath;
@@ -21417,7 +21508,7 @@ function registerDotnet(program2) {
 }
 
 // src/commands/editHook/index.ts
-import fs28 from "fs";
+import fs29 from "fs";
 
 // src/commands/editHook/introducedComments.ts
 function introducedComments(added, removed) {
@@ -21664,7 +21755,7 @@ function tryParseInput2(raw) {
 function readExisting(filePath) {
   if (!filePath) return void 0;
   try {
-    return fs28.readFileSync(filePath, "utf8");
+    return fs29.readFileSync(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -28267,17 +28358,17 @@ Refactor check failed:
 
 // src/commands/refactor/check/getViolations/index.ts
 import { execSync as execSync55 } from "child_process";
-import fs30 from "fs";
+import fs31 from "fs";
 import { minimatch as minimatch6 } from "minimatch";
 
 // src/commands/refactor/check/getViolations/getIgnoredFiles.ts
-import fs29 from "fs";
+import fs30 from "fs";
 var REFACTOR_YML_PATH = "refactor.yml";
 function parseRefactorYml() {
-  if (!fs29.existsSync(REFACTOR_YML_PATH)) {
+  if (!fs30.existsSync(REFACTOR_YML_PATH)) {
     return [];
   }
-  const content = fs29.readFileSync(REFACTOR_YML_PATH, "utf8");
+  const content = fs30.readFileSync(REFACTOR_YML_PATH, "utf8");
   const entries = [];
   const lines2 = content.split("\n");
   let currentEntry = {};
@@ -28307,7 +28398,7 @@ function getIgnoredFiles() {
 
 // src/commands/refactor/check/getViolations/index.ts
 function countLines(filePath) {
-  const content = fs30.readFileSync(filePath, "utf8");
+  const content = fs31.readFileSync(filePath, "utf8");
   return content.split("\n").length;
 }
 function getGitFiles(options2) {
@@ -29065,11 +29156,11 @@ import chalk200 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
-import fs32 from "fs";
+import fs33 from "fs";
 import path52 from "path";
 
 // src/commands/refactor/extract/findEnclosingTsConfig.ts
-import fs31 from "fs";
+import fs32 from "fs";
 import path51 from "path";
 
 // src/commands/refactor/extract/projectIncludesFile.ts
@@ -29090,7 +29181,7 @@ function findEnclosingTsConfig(sourcePath, rootDir, tried) {
     const nested = path51.join(dir, "tsconfig.json");
     if (!tried.has(nested)) {
       tried.add(nested);
-      if (fs31.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
+      if (fs32.existsSync(nested) && projectIncludesFile(nested, sourcePath)) {
         return nested;
       }
     }
@@ -29104,7 +29195,7 @@ function findEnclosingTsConfig(sourcePath, rootDir, tried) {
 // src/commands/refactor/extract/findTsConfig.ts
 function findTsConfig(sourcePath) {
   const rootConfig = path52.resolve("tsconfig.json");
-  if (!fs32.existsSync(rootConfig)) return rootConfig;
+  if (!fs33.existsSync(rootConfig)) return rootConfig;
   const tried = /* @__PURE__ */ new Set();
   const candidates = [rootConfig, ...readReferences(rootConfig)];
   for (const candidate of candidates) {
@@ -29112,7 +29203,7 @@ function findTsConfig(sourcePath) {
     tried.add(candidate);
     if (projectIncludesFile(candidate, sourcePath)) return candidate;
   }
-  const siblings = fs32.readdirSync(path52.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path52.resolve(path52.dirname(rootConfig), f));
+  const siblings = fs33.readdirSync(path52.dirname(rootConfig)).filter((f) => /^tsconfig.*\.json$/.test(f)).map((f) => path52.resolve(path52.dirname(rootConfig), f));
   for (const sibling of siblings) {
     if (tried.has(sibling)) continue;
     tried.add(sibling);
@@ -29127,8 +29218,8 @@ function findTsConfig(sourcePath) {
   return rootConfig;
 }
 function readReferences(configPath) {
-  if (!fs32.existsSync(configPath)) return [];
-  const raw = fs32.readFileSync(configPath, "utf8");
+  if (!fs33.existsSync(configPath)) return [];
+  const raw = fs33.readFileSync(configPath, "utf8");
   const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   let parsed;
   try {
@@ -29140,8 +29231,8 @@ function readReferences(configPath) {
   const cwd = path52.dirname(configPath);
   return parsed.references.map((ref) => {
     const refPath = path52.resolve(cwd, ref.path);
-    return fs32.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path52.join(refPath, "tsconfig.json") : refPath;
-  }).filter((p) => fs32.existsSync(p));
+    return fs33.statSync(refPath, { throwIfNoEntry: false })?.isDirectory() ? path52.join(refPath, "tsconfig.json") : refPath;
+  }).filter((p) => fs33.existsSync(p));
 }
 
 // src/commands/refactor/extract/loadProjectFile.ts
@@ -29183,25 +29274,25 @@ async function extract(file, functionName, destination, options2 = {}) {
 }
 
 // src/commands/refactor/ignore.ts
-import fs33 from "fs";
+import fs34 from "fs";
 import chalk202 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
-  if (!fs33.existsSync(file)) {
+  if (!fs34.existsSync(file)) {
     console.error(chalk202.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
-  const content = fs33.readFileSync(file, "utf8");
+  const content = fs34.readFileSync(file, "utf8");
   const lineCount = content.split("\n").length;
   const maxLines = lineCount + 10;
   const entry = `- file: ${file}
   maxLines: ${maxLines}
 `;
-  if (fs33.existsSync(REFACTOR_YML_PATH2)) {
-    const existing = fs33.readFileSync(REFACTOR_YML_PATH2, "utf8");
-    fs33.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
+  if (fs34.existsSync(REFACTOR_YML_PATH2)) {
+    const existing = fs34.readFileSync(REFACTOR_YML_PATH2, "utf8");
+    fs34.writeFileSync(REFACTOR_YML_PATH2, existing + entry);
   } else {
-    fs33.writeFileSync(REFACTOR_YML_PATH2, entry);
+    fs34.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
     chalk202.green(
@@ -29211,12 +29302,12 @@ function ignore2(file) {
 }
 
 // src/commands/refactor/rename/index.ts
-import fs36 from "fs";
+import fs37 from "fs";
 import path59 from "path";
 import chalk205 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
-import fs35 from "fs";
+import fs36 from "fs";
 import path56 from "path";
 import chalk203 from "chalk";
 
@@ -29224,7 +29315,7 @@ import chalk203 from "chalk";
 import path55 from "path";
 
 // src/commands/refactor/restructure/computeRewrites/applyRewrites.ts
-import fs34 from "fs";
+import fs35 from "fs";
 function getOrCreateList(map, key) {
   const list5 = map.get(key) ?? [];
   if (!map.has(key)) map.set(key, list5);
@@ -29243,7 +29334,7 @@ function rewriteSpecifier(content, oldSpecifier, newSpecifier) {
   return content.replace(pattern2, `$1${newSpecifier}$2`);
 }
 function applyFileRewrites(file, fileRewrites) {
-  let content = fs34.readFileSync(file, "utf8");
+  let content = fs35.readFileSync(file, "utf8");
   for (const { oldSpecifier, newSpecifier } of fileRewrites) {
     content = rewriteSpecifier(content, oldSpecifier, newSpecifier);
   }
@@ -29322,12 +29413,12 @@ function computeRewrites(moves, edges, allProjectFiles) {
 function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
-    fs35.writeFileSync(file, content, "utf8");
+    fs36.writeFileSync(file, content, "utf8");
     console.log(chalk203.cyan(`  Updated imports in ${path56.relative(cwd, file)}`));
   }
   const destDir = path56.dirname(destPath);
-  if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
-  fs35.renameSync(sourcePath, destPath);
+  if (!fs36.existsSync(destDir)) fs36.mkdirSync(destDir, { recursive: true });
+  fs36.renameSync(sourcePath, destPath);
   console.log(
     chalk203.white(
       `  Moved ${path56.relative(cwd, sourcePath)} \u2192 ${path56.relative(cwd, destPath)}`
@@ -29435,11 +29526,11 @@ async function rename(source, destination, options2 = {}) {
   const cwd = process.cwd();
   const relSource = path59.relative(cwd, sourcePath);
   const relDest = path59.relative(cwd, destPath);
-  if (!fs36.existsSync(sourcePath)) {
+  if (!fs37.existsSync(sourcePath)) {
     console.log(chalk205.red(`File not found: ${source}`));
     process.exit(1);
   }
-  if (destPath !== sourcePath && fs36.existsSync(destPath)) {
+  if (destPath !== sourcePath && fs37.existsSync(destPath)) {
     console.log(chalk205.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
@@ -29664,27 +29755,27 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 }
 
 // src/commands/refactor/restructure/executePlan.ts
-import fs37 from "fs";
+import fs38 from "fs";
 import path64 from "path";
 import chalk208 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
-    fs37.writeFileSync(file, content, "utf8");
+    fs38.writeFileSync(file, content, "utf8");
     console.log(
       chalk208.cyan(`  Rewrote imports in ${path64.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
-    fs37.mkdirSync(dir, { recursive: true });
+    fs38.mkdirSync(dir, { recursive: true });
     console.log(chalk208.green(`  Created ${path64.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path64.dirname(move2.to);
-    if (!fs37.existsSync(targetDir)) {
-      fs37.mkdirSync(targetDir, { recursive: true });
+    if (!fs38.existsSync(targetDir)) {
+      fs38.mkdirSync(targetDir, { recursive: true });
     }
-    fs37.renameSync(move2.from, move2.to);
+    fs38.renameSync(move2.from, move2.to);
     console.log(
       chalk208.white(
         `  Moved ${path64.relative(process.cwd(), move2.from)} \u2192 ${path64.relative(process.cwd(), move2.to)}`
@@ -29696,10 +29787,10 @@ function executePlan(plan2) {
 function removeEmptyDirectories(dirs) {
   const unique = [...new Set(dirs)];
   for (const dir of unique) {
-    if (!fs37.existsSync(dir)) continue;
-    const entries = fs37.readdirSync(dir);
+    if (!fs38.existsSync(dir)) continue;
+    const entries = fs38.readdirSync(dir);
     if (entries.length === 0) {
-      fs37.rmdirSync(dir);
+      fs38.rmdirSync(dir);
       console.log(
         chalk208.dim(
           `  Removed empty directory ${path64.relative(process.cwd(), dir)}`
@@ -29713,18 +29804,18 @@ function removeEmptyDirectories(dirs) {
 import path66 from "path";
 
 // src/commands/refactor/restructure/planFileMoves/shared.ts
-import fs38 from "fs";
+import fs39 from "fs";
 function emptyResult() {
   return { moves: [], directories: [], warnings: [] };
 }
 function checkDirConflict(result, label2, dir) {
-  if (!fs38.existsSync(dir)) return false;
+  if (!fs39.existsSync(dir)) return false;
   result.warnings.push(`Skipping ${label2}: directory ${dir} already exists`);
   return true;
 }
 
 // src/commands/refactor/restructure/planFileMoves/planDirectoryMoves.ts
-import fs39 from "fs";
+import fs40 from "fs";
 import path65 from "path";
 function collectEntry2(results, dir, entry) {
   const full = path65.join(dir, entry.name);
@@ -29732,9 +29823,9 @@ function collectEntry2(results, dir, entry) {
   results.push(...items2);
 }
 function listFilesRecursive(dir) {
-  if (!fs39.existsSync(dir)) return [];
+  if (!fs40.existsSync(dir)) return [];
   const results = [];
-  for (const entry of fs39.readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of fs40.readdirSync(dir, { withFileTypes: true })) {
     collectEntry2(results, dir, entry);
   }
   return results;
@@ -32893,7 +32984,7 @@ function registerSql(program2) {
 }
 
 // src/commands/sync.ts
-import * as fs48 from "fs";
+import * as fs49 from "fs";
 import * as os5 from "os";
 import * as path85 from "path";
 import { fileURLToPath as fileURLToPath9 } from "url";
@@ -32902,7 +32993,7 @@ import { fileURLToPath as fileURLToPath9 } from "url";
 import * as path76 from "path";
 
 // src/commands/sync/pruneTarget.ts
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 import * as path75 from "path";
 function pruneTarget(targetDir, keepNames, shape, options2) {
   const result = {
@@ -32911,9 +33002,9 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
     skipped: [],
     unmanaged: []
   };
-  if (!fs40.existsSync(targetDir)) return result;
+  if (!fs41.existsSync(targetDir)) return result;
   const keep = new Set(keepNames);
-  for (const entry of fs40.readdirSync(targetDir, { withFileTypes: true })) {
+  for (const entry of fs41.readdirSync(targetDir, { withFileTypes: true })) {
     const name = shape.nameOf(entry);
     if (name === void 0) {
       result.unmanaged.push(entry.name);
@@ -32928,7 +33019,7 @@ function pruneTarget(targetDir, keepNames, shape, options2) {
       continue;
     }
     if (options2.force) {
-      fs40.rmSync(entryPath, { recursive: true });
+      fs41.rmSync(entryPath, { recursive: true });
       result.removed.push(entry.name);
     }
   }
@@ -32975,7 +33066,7 @@ function reportPrune(label2, result, force) {
 }
 
 // src/commands/sync/reportRetiredAgentsFiles.ts
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 import * as path77 from "path";
 var retired = [
   path77.join(harnesses.claude.homeDir, "CLAUDE.md"),
@@ -32983,7 +33074,7 @@ var retired = [
   path77.join(harnesses.pi.homeDir, "AGENTS.md")
 ];
 function reportRetiredAgentsFiles() {
-  const leftovers = retired.filter((file) => fs41.existsSync(file));
+  const leftovers = retired.filter((file) => fs42.existsSync(file));
   if (leftovers.length === 0) return;
   console.log(
     "No longer written by sync \u2014 each harness now composes its own advice at session start:"
@@ -32998,28 +33089,28 @@ function reportRetiredAgentsFiles() {
 import * as path80 from "path";
 
 // src/commands/sync/installHarnessCommands.ts
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 import * as path78 from "path";
 function installHarnessCommands(claudeDir, harness, transform) {
   const commandsSource = path78.join(claudeDir, "commands");
-  const files = fs42.readdirSync(commandsSource);
+  const files = fs43.readdirSync(commandsSource);
   const names = [];
   let synced = 0;
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
     const name = file.replace(/\.md$/, "");
     names.push(name);
-    const content = fs42.readFileSync(path78.join(commandsSource, file), "utf8");
+    const content = fs43.readFileSync(path78.join(commandsSource, file), "utf8");
     const target = path78.join(harness.homeDir, harness.sync.commandDest(name));
-    fs42.mkdirSync(path78.dirname(target), { recursive: true });
-    fs42.writeFileSync(target, transform(name, content));
+    fs43.mkdirSync(path78.dirname(target), { recursive: true });
+    fs43.writeFileSync(target, transform(name, content));
     synced++;
   }
   return { total: files.length, synced, names };
 }
 
 // src/commands/sync/pruneSkills.ts
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 function pruneSkills(targetDir, skillNames, options2) {
   return pruneTarget(
     targetDir,
@@ -33032,14 +33123,14 @@ function pruneSkills(targetDir, skillNames, options2) {
   );
 }
 function unexpectedContent(skillDir) {
-  const entries = fs43.readdirSync(skillDir);
+  const entries = fs44.readdirSync(skillDir);
   const others = entries.filter((entry) => entry !== "SKILL.md");
   if (others.length > 0) return `contains ${others.sort().join(", ")}`;
   return entries.length === 0 ? "no SKILL.md" : void 0;
 }
 
 // src/commands/sync/syncCodexHooks.ts
-import * as fs44 from "fs";
+import * as fs45 from "fs";
 import * as path79 from "path";
 var BEGIN = "# >>> assist codex hooks (managed) \u2014 do not edit >>>";
 var END = "# <<< assist codex hooks (managed) <<<";
@@ -33070,11 +33161,11 @@ ${rest}
 `;
 }
 function syncCodexHooks(sourcePath) {
-  const body = fs44.readFileSync(sourcePath, "utf8");
+  const body = fs45.readFileSync(sourcePath, "utf8");
   const configPath = path79.join(harnesses.codex.homeDir, "config.toml");
-  const existing = fs44.existsSync(configPath) ? fs44.readFileSync(configPath, "utf8") : "";
-  fs44.mkdirSync(path79.dirname(configPath), { recursive: true });
-  fs44.writeFileSync(configPath, upsertManagedBlock(existing, body));
+  const existing = fs45.existsSync(configPath) ? fs45.readFileSync(configPath, "utf8") : "";
+  fs45.mkdirSync(path79.dirname(configPath), { recursive: true });
+  fs45.writeFileSync(configPath, upsertManagedBlock(existing, body));
   console.log(
     "Registered assist codex-hook in ~/.codex/config.toml (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PermissionRequest, Stop)"
   );
@@ -33117,21 +33208,21 @@ function syncCodex(claudeDir, options2) {
 }
 
 // src/commands/sync/syncDesign.ts
-import * as fs45 from "fs";
+import * as fs46 from "fs";
 import * as path81 from "path";
 function syncDesign(claudeDir, targetBase) {
   const systemPromptSource = path81.join(claudeDir, "design-system-prompt.md");
   const systemPromptTarget = path81.join(targetBase, "design-system-prompt.md");
-  fs45.copyFileSync(systemPromptSource, systemPromptTarget);
+  fs46.copyFileSync(systemPromptSource, systemPromptTarget);
   console.log(
     "Copied design-system-prompt.md to ~/.claude/design-system-prompt.md"
   );
   const skillsSource = path81.join(claudeDir, "skills");
   const skillsTarget = path81.join(targetBase, "skills");
-  fs45.mkdirSync(skillsTarget, { recursive: true });
-  const files = fs45.readdirSync(skillsSource);
+  fs46.mkdirSync(skillsTarget, { recursive: true });
+  const files = fs46.readdirSync(skillsSource);
   for (const file of files) {
-    fs45.copyFileSync(
+    fs46.copyFileSync(
       path81.join(skillsSource, file),
       path81.join(skillsTarget, file)
     );
@@ -33143,17 +33234,17 @@ function syncDesign(claudeDir, targetBase) {
 import * as path83 from "path";
 
 // src/commands/sync/syncPiHooks.ts
-import * as fs46 from "fs";
+import * as fs47 from "fs";
 import * as path82 from "path";
 function piExtensionsDir() {
   return path82.join(harnesses.pi.homeDir, "extensions");
 }
 function syncPiHooks(sourceDir) {
   const target = piExtensionsDir();
-  fs46.mkdirSync(target, { recursive: true });
-  const files = fs46.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
+  fs47.mkdirSync(target, { recursive: true });
+  const files = fs47.readdirSync(sourceDir).filter((f) => f.endsWith(".ts"));
   for (const file of files) {
-    fs46.copyFileSync(
+    fs47.copyFileSync(
       path82.join(sourceDir, file),
       path82.join(target, `assist-${file}`)
     );
@@ -33204,16 +33295,16 @@ function syncPi(claudeDir, options2) {
 }
 
 // src/commands/sync/syncSettings.ts
-import * as fs47 from "fs";
+import * as fs48 from "fs";
 import * as path84 from "path";
 import chalk227 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path84.join(claudeDir, "settings.json");
   const target = path84.join(targetBase, "settings.json");
-  const sourceContent = fs47.readFileSync(source, "utf8");
+  const sourceContent = fs48.readFileSync(source, "utf8");
   const sourceSettings = JSON.parse(sourceContent);
-  const targetExists = fs47.existsSync(target);
-  const targetContent = targetExists ? fs47.readFileSync(target, "utf8") : "";
+  const targetExists = fs48.existsSync(target);
+  const targetContent = targetExists ? fs48.readFileSync(target, "utf8") : "";
   const preservedUserSettings = targetExists ? JSON.parse(targetContent) : {};
   const mergedContent = JSON.stringify(
     { ...preservedUserSettings, ...sourceSettings },
@@ -33243,7 +33334,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
       }
     }
   }
-  fs47.writeFileSync(target, mergedContent);
+  fs48.writeFileSync(target, mergedContent);
   console.log("Copied settings.json to ~/.claude/settings.json");
 }
 
@@ -33274,10 +33365,10 @@ async function sync(options2) {
 function syncCommands(claudeDir, targetBase) {
   const sourceDir = path85.join(claudeDir, "commands");
   const targetDir = path85.join(targetBase, "commands");
-  fs48.mkdirSync(targetDir, { recursive: true });
-  const files = fs48.readdirSync(sourceDir);
+  fs49.mkdirSync(targetDir, { recursive: true });
+  const files = fs49.readdirSync(sourceDir);
   for (const file of files) {
-    fs48.copyFileSync(path85.join(sourceDir, file), path85.join(targetDir, file));
+    fs49.copyFileSync(path85.join(sourceDir, file), path85.join(targetDir, file));
     console.log(`Copied ${file} to ${targetDir}`);
   }
   console.log(`Synced ${files.length} command(s) to ~/.claude/commands`);
@@ -33596,9 +33687,9 @@ function clean(file, options2 = {}) {
 }
 
 // src/commands/transcript/shared.ts
-import * as readline3 from "readline";
+import * as readline4 from "readline";
 function createReadlineInterface() {
-  return readline3.createInterface({
+  return readline4.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -35659,7 +35750,7 @@ function listDaemonPids() {
 }
 
 // src/commands/sessions/daemon/queryDaemon.ts
-import { createInterface as createInterface6 } from "readline";
+import { createInterface as createInterface7 } from "readline";
 var STATUS_TIMEOUT_MS = 5e3;
 function queryDaemon(socket) {
   socket.write(`${JSON.stringify({ type: "ping" })}
@@ -35668,7 +35759,7 @@ function queryDaemon(socket) {
     const result = { sessions: [] };
     const pending = /* @__PURE__ */ new Set(["sessions", "pong"]);
     const timer = setTimeout(() => resolve25(result), STATUS_TIMEOUT_MS);
-    const lines2 = createInterface6({ input: socket });
+    const lines2 = createInterface7({ input: socket });
     lines2.on("error", () => {
     });
     lines2.on("line", (line) => {
@@ -35758,7 +35849,7 @@ function reportStrays(pids) {
 }
 
 // src/commands/sessions/daemon/drainDaemon.ts
-import { createInterface as createInterface7 } from "readline";
+import { createInterface as createInterface8 } from "readline";
 
 // src/commands/sessions/daemon/clearPersistedSessionsOnDrain.ts
 function clearPersistedSessionsOnDrain() {
@@ -35800,7 +35891,7 @@ async function drainDaemon(options2 = {}) {
     clearPersistedSessionsOnDrain();
     return;
   }
-  const lines2 = createInterface7({ input: socket });
+  const lines2 = createInterface8({ input: socket });
   lines2.on("error", () => {
   });
   const live = await liveSessions(lines2);
@@ -36264,7 +36355,7 @@ function serverRunMeta(runName, cwd) {
 }
 
 // src/commands/sessions/daemon/readDesignSystemPrompt.ts
-import * as fs49 from "fs";
+import * as fs50 from "fs";
 import * as path87 from "path";
 import { fileURLToPath as fileURLToPath11 } from "url";
 var __filename5 = fileURLToPath11(import.meta.url);
@@ -36276,7 +36367,7 @@ function readDesignSystemPrompt() {
     "claude",
     "design-system-prompt.md"
   );
-  return fs49.readFileSync(promptPath, "utf8");
+  return fs50.readFileSync(promptPath, "utf8");
 }
 
 // src/commands/sessions/daemon/spawnClaude.ts
@@ -37365,7 +37456,7 @@ function reportSilentFailure(session, clients) {
 }
 
 // src/commands/sessions/shared/codex/resolveCodexSessionId.ts
-import * as fs50 from "fs";
+import * as fs51 from "fs";
 var META_LINES = 5;
 async function resolveCodexSessionId(cwd, sinceMs) {
   if (!cwd) return null;
@@ -37394,7 +37485,7 @@ async function startedIn(file, cwd, sinceMs) {
 }
 async function touchedSince(file, sinceMs) {
   try {
-    return (await fs50.promises.stat(file)).mtimeMs >= sinceMs;
+    return (await fs51.promises.stat(file)).mtimeMs >= sinceMs;
   } catch {
     return false;
   }
@@ -37428,7 +37519,7 @@ function bindCodexSession(session, notify2) {
 import { watch as watch3 } from "fs";
 
 // src/commands/sessions/shared/findTranscriptPathSync.ts
-import * as fs51 from "fs";
+import * as fs52 from "fs";
 import * as path88 from "path";
 function projectDirForCwd(cwd) {
   return path88.join(claudeProjectsRoot(), projectSlug(cwd));
@@ -37438,11 +37529,11 @@ function transcriptPathFor(cwd, claudeSessionId) {
 }
 function findTranscriptPathSync(cwd, claudeSessionId) {
   const direct = transcriptPathFor(cwd, claudeSessionId);
-  if (fs51.existsSync(direct)) return direct;
+  if (fs52.existsSync(direct)) return direct;
   const dir = projectDirForCwd(cwd);
   let files;
   try {
-    files = fs51.readdirSync(dir);
+    files = fs52.readdirSync(dir);
   } catch {
     return null;
   }
@@ -37456,14 +37547,14 @@ function findTranscriptPathSync(cwd, claudeSessionId) {
 function headContainsSessionId(filePath, claudeSessionId) {
   let fd;
   try {
-    fd = fs51.openSync(filePath, "r");
+    fd = fs52.openSync(filePath, "r");
     const buf = Buffer.alloc(16384);
-    const bytesRead = fs51.readSync(fd, buf, 0, buf.length, 0);
+    const bytesRead = fs52.readSync(fd, buf, 0, buf.length, 0);
     return buf.toString("utf8", 0, bytesRead).includes(claudeSessionId);
   } catch {
     return false;
   } finally {
-    if (fd !== void 0) fs51.closeSync(fd);
+    if (fd !== void 0) fs52.closeSync(fd);
   }
 }
 
@@ -37633,7 +37724,7 @@ function asRecord3(value) {
 }
 
 // src/commands/sessions/shared/readTranscriptTail.ts
-import * as fs52 from "fs";
+import * as fs53 from "fs";
 var DEFAULT_MAX_BYTES = 256 * 1024;
 function parseTailEntries(raw) {
   const entries = [];
@@ -37657,7 +37748,7 @@ function dropPartialFirstLine(raw, sliced) {
 async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let handle;
   try {
-    handle = await fs52.promises.open(filePath, "r");
+    handle = await fs53.promises.open(filePath, "r");
     const { size } = await handle.stat();
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
@@ -37676,20 +37767,20 @@ async function readTranscriptTail(filePath, maxBytes = DEFAULT_MAX_BYTES) {
 function readTranscriptTailSync(filePath, maxBytes = DEFAULT_MAX_BYTES) {
   let fd;
   try {
-    fd = fs52.openSync(filePath, "r");
-    const { size } = fs52.fstatSync(fd);
+    fd = fs53.openSync(filePath, "r");
+    const { size } = fs53.fstatSync(fd);
     const start3 = Math.max(0, size - maxBytes);
     const length = size - start3;
     if (length === 0) return [];
     const buf = Buffer.alloc(length);
-    fs52.readSync(fd, buf, 0, length, start3);
+    fs53.readSync(fd, buf, 0, length, start3);
     return parseTailEntries(
       dropPartialFirstLine(buf.toString("utf8"), start3 > 0)
     );
   } catch {
     return [];
   } finally {
-    if (fd !== void 0) fs52.closeSync(fd);
+    if (fd !== void 0) fs53.closeSync(fd);
   }
 }
 
@@ -38068,7 +38159,7 @@ async function recordWindowTokens(db, window, resetsAt, tokensUp, tokensDown) {
 }
 
 // src/commands/sessions/shared/transcriptUsage.ts
-import * as fs53 from "fs";
+import * as fs54 from "fs";
 function transcriptUsage(lines2) {
   const byId = /* @__PURE__ */ new Map();
   for (const line of lines2) {
@@ -38092,7 +38183,7 @@ function transcriptUsage(lines2) {
   return [...byId.values()];
 }
 async function readTranscriptUsage(transcriptPath2) {
-  const content = await fs53.promises.readFile(transcriptPath2, "utf8");
+  const content = await fs54.promises.readFile(transcriptPath2, "utf8");
   return transcriptUsage(content.split("\n"));
 }
 
@@ -38569,7 +38660,7 @@ function restoreBase(id, persisted) {
     cwd: persisted.cwd,
     assistArgs: persisted.assistArgs,
     initialPrompt: persisted.initialPrompt,
-    starred: persisted.starred,
+    starred: persisted.watcher ? false : persisted.starred,
     watcher: persisted.watcher,
     design: persisted.design,
     auto: persisted.auto,
@@ -39785,10 +39876,10 @@ async function isWindowsDaemonRunning() {
 import { spawn as spawn11 } from "child_process";
 
 // src/commands/sessions/daemon/logChildStream.ts
-import { createInterface as createInterface8 } from "readline";
+import { createInterface as createInterface9 } from "readline";
 function logChildStream(stream, label2, onLine) {
   if (!stream) return;
-  const lines2 = createInterface8({ input: stream });
+  const lines2 = createInterface9({ input: stream });
   lines2.on("line", (line) => {
     daemonLog(`[${label2}] ${line}`);
     onLine?.(line);
@@ -40218,7 +40309,7 @@ function isWindowsIo(data) {
 }
 
 // src/commands/sessions/daemon/WindowsConnection.ts
-import { createInterface as createInterface9 } from "readline";
+import { createInterface as createInterface10 } from "readline";
 
 // src/commands/sessions/daemon/LaunchCircuitBreaker.ts
 var MAX_FAILURES = 3;
@@ -40305,7 +40396,7 @@ var WindowsConnection = class {
     return socket;
   }
   wire(socket) {
-    const lines2 = createInterface9({ input: socket });
+    const lines2 = createInterface10({ input: socket });
     lines2.on("error", () => {
     });
     lines2.on("line", (line) => this.deps.onLine(line));
@@ -40914,7 +41005,7 @@ function exitAfterFlush(code) {
 }
 
 // src/commands/sessions/daemon/handleConnection.ts
-import { createInterface as createInterface10 } from "readline";
+import { createInterface as createInterface11 } from "readline";
 
 // src/commands/sessions/daemon/creator.ts
 function creator(isNew, spawn13) {
@@ -40989,7 +41080,7 @@ function handleSetStatus(client, m, d) {
 }
 
 // src/commands/sessions/shared/parseTranscript.ts
-import * as fs54 from "fs";
+import * as fs55 from "fs";
 
 // src/commands/sessions/shared/codex/findCodexRolloutPath.ts
 import * as path89 from "path";
@@ -41072,7 +41163,7 @@ async function parseTranscript(sessionId) {
 }
 async function readMessages(filePath, parse4) {
   try {
-    const raw = await fs54.promises.readFile(filePath, "utf8");
+    const raw = await fs55.promises.readFile(filePath, "utf8");
     return parse4(raw.split("\n"));
   } catch {
     return [];
@@ -41278,7 +41369,7 @@ function handleConnection(socket, manager) {
   };
   manager.addClient(client);
   manager.clients.greet(client);
-  const lines2 = createInterface10({ input: socket });
+  const lines2 = createInterface11({ input: socket });
   lines2.on("error", () => {
   });
   lines2.on("line", (line) => {
@@ -41600,17 +41691,17 @@ async function renameSession(title) {
 }
 
 // src/commands/sessions/summarise/index.ts
-import * as fs56 from "fs";
+import * as fs57 from "fs";
 import chalk230 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
-import * as fs55 from "fs";
+import * as fs56 from "fs";
 function writeSummary(jsonlPath2, summary) {
-  fs55.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
+  fs56.writeFileSync(summaryPathFor(jsonlPath2), `${summary.trim()}
 `, "utf8");
 }
 function hasSummary(jsonlPath2) {
-  return fs55.existsSync(summaryPathFor(jsonlPath2));
+  return fs56.existsSync(summaryPathFor(jsonlPath2));
 }
 function summaryPathFor(jsonlPath2) {
   return jsonlPath2.replace(/\.jsonl$/, ".summary");
@@ -41682,7 +41773,7 @@ function selectCandidates(files, options2) {
   const candidates = options2.force ? files : files.filter((f) => !hasSummary(f));
   candidates.sort((a, b) => {
     try {
-      return fs56.statSync(b).mtimeMs - fs56.statSync(a).mtimeMs;
+      return fs57.statSync(b).mtimeMs - fs57.statSync(a).mtimeMs;
     } catch {
       return 0;
     }
@@ -42005,6 +42096,7 @@ configHelp(screenshotCommand, rootConfigHelp.screenshot);
 registerActivity(program);
 registerAdvise(program);
 registerBackup(program);
+registerChart(program);
 registerDb(program);
 registerDbMigration(program);
 registerCliHook(program);