@staff0rd/assist 0.657.1 → 0.659.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.657.1",
+  version: "0.659.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -561,6 +561,23 @@ function stripLegacyConfigKeys(config) {
 // src/shared/types.ts
 import { z as z3 } from "zod";
 
+// src/shared/adviceFragmentNames.ts
+var adviceFragmentNames = [
+  "assist-global",
+  "backlog-ids",
+  "backlog-prs",
+  "code-comments",
+  "drafting-messages",
+  "editing-files",
+  "filename-convention",
+  "jira-context",
+  "jira-smart-links",
+  "markdown",
+  "refactor",
+  "settings-json",
+  "verify"
+];
+
 // src/shared/runConfigSchema.ts
 import { z } from "zod";
 var runParamSchema = z.strictObject({
@@ -619,8 +636,8 @@ var DEFAULT_BACKUP_DIR = "~/.assist/backups";
 var DEFAULT_CLONE_DIR = "~/git";
 var assistConfigShape = {
   advice: z3.strictObject({
-    include: z3.array(z3.string()).default([]),
-    exclude: z3.array(z3.string()).default([]),
+    include: z3.array(z3.enum(adviceFragmentNames)).default([]),
+    exclude: z3.array(z3.enum(adviceFragmentNames)).default([]),
     extra: z3.string().optional(),
     verify: z3.string().optional()
   }).optional(),
@@ -2013,7 +2030,96 @@ function lint(options2 = {}) {
 
 // src/commands/new/registerNew/newCli/index.ts
 import { execSync as execSync12 } from "child_process";
-import { basename as basename3, resolve as resolve6 } from "path";
+import { basename as basename4, resolve as resolve6 } from "path";
+
+// src/commands/advise/loadAdviceFragments.ts
+import { readdirSync, readFileSync as readFileSync10 } from "fs";
+import { basename as basename2, join as join10 } from "path";
+
+// src/commands/advise/adviceDir.ts
+import { existsSync as existsSync13 } from "fs";
+import { dirname as dirname10, join as join9 } from "path";
+import { fileURLToPath } from "url";
+function adviceDir() {
+  let current = dirname10(fileURLToPath(import.meta.url));
+  while (current !== dirname10(current)) {
+    const candidate = join9(current, "claude", "advice");
+    if (existsSync13(candidate)) return candidate;
+    current = dirname10(current);
+  }
+  throw new Error("Could not locate the shipped claude/advice directory");
+}
+
+// src/commands/advise/parseAdviceFragment.ts
+import { parse as parseYaml2 } from "yaml";
+var frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseAdviceFragment(name, content) {
+  const match = frontmatter.exec(content);
+  if (!match) throw new Error(`Advice fragment ${name} has no frontmatter`);
+  const meta = parseYaml2(match[1]) ?? {};
+  const title = meta.title;
+  const when = meta.when;
+  if (typeof title !== "string" || typeof when !== "string")
+    throw new Error(
+      `Advice fragment ${name} needs a title and a when condition`
+    );
+  return {
+    name,
+    title,
+    when,
+    body: content.slice(match[0].length).trim()
+  };
+}
+
+// src/commands/advise/loadAdviceFragments.ts
+function loadAdviceFragments(dir = adviceDir()) {
+  return readdirSync(dir).filter((file) => file.endsWith(".md")).sort().map(
+    (file) => parseAdviceFragment(
+      basename2(file, ".md"),
+      readFileSync10(join10(dir, file), "utf8")
+    )
+  );
+}
+
+// src/commands/verify/reportVerifyProblems.ts
+function verifySection(label2, entries) {
+  if (entries.length === 0) return void 0;
+  const list5 = entries.sort().map((entry) => `  ${entry}`).join("\n");
+  return `${label2}:
+${list5}`;
+}
+function reportVerifyProblems(problems, success) {
+  const found = problems.filter(
+    (problem) => problem !== void 0
+  );
+  if (found.length > 0) {
+    console.log(found.join("\n\n"));
+    process.exit(1);
+  }
+  console.log(success);
+  process.exit(0);
+}
+
+// src/commands/verify/adviceFragments.ts
+function adviceFragments() {
+  const shipped = new Set(
+    loadAdviceFragments().map((fragment) => fragment.name)
+  );
+  const declared = new Set(adviceFragmentNames);
+  reportVerifyProblems(
+    [
+      verifySection(
+        "Shipped in claude/advice but missing from adviceFragmentNames (add them, or advice.include/exclude cannot name them)",
+        [...shipped].filter((name) => !declared.has(name))
+      ),
+      verifySection(
+        "Listed in adviceFragmentNames but no longer shipped in claude/advice (remove them)",
+        [...declared].filter((name) => !shipped.has(name))
+      )
+    ],
+    `All ${shipped.size} advice fragments are named in adviceFragmentNames.`
+  );
+}
 
 // src/commands/verify/blockCodeComments/findComments.ts
 import { execSync as execSync4 } from "child_process";
@@ -2960,12 +3066,12 @@ var adviceConfigHelp = [
   {
     key: "advice.include",
     setter: 'assist config set advice.include "refactor"',
-    note: "fragment names included whatever their condition says"
+    note: "fragment names included whatever their condition says; 'assist advise --explain' lists every name"
   },
   {
     key: "advice.exclude",
     setter: 'assist config set advice.exclude "jira-context"',
-    note: "fragment names dropped even when their condition matches"
+    note: "fragment names dropped even when their condition matches; 'assist advise --explain' lists every name"
   },
   {
     key: "advice.extra",
@@ -3573,57 +3679,46 @@ var pendingConfigDocumentation = /* @__PURE__ */ new Set([
 ]);
 
 // src/commands/verify/configKeys.ts
-function section(label2, keys) {
-  if (keys.length === 0) return void 0;
-  const list5 = keys.sort().map((key) => `  ${key}`).join("\n");
-  return `${label2}:
-${list5}`;
-}
 function configKeys() {
   const schemaKeys = new Set(enumerateConfigLeafKeys(assistConfigSchema));
   const documented = getDocumentedConfigKeys();
   const pending = pendingConfigDocumentation;
   const aggregated = new Set(configHelpEntries.map((entry) => entry.key));
-  const problems = [
-    section(
-      "Config keys documented by no command (surface them with configHelp)",
-      [...schemaKeys].filter(
-        (key) => !documented.has(key) && !pending.has(key)
+  reportVerifyProblems(
+    [
+      verifySection(
+        "Config keys documented by no command (surface them with configHelp)",
+        [...schemaKeys].filter(
+          (key) => !documented.has(key) && !pending.has(key)
+        )
+      ),
+      verifySection(
+        "Documented config keys not present in assistConfigSchema",
+        [...documented].filter((key) => !schemaKeys.has(key))
+      ),
+      verifySection(
+        "Keys now documented but still in pendingConfigDocumentation (remove them)",
+        [...pending].filter((key) => documented.has(key))
+      ),
+      verifySection(
+        "pendingConfigDocumentation lists keys not in assistConfigSchema (remove them)",
+        [...pending].filter((key) => !schemaKeys.has(key))
+      ),
+      verifySection(
+        "Keys documented by a command but missing from configHelpEntries (add their module to src/commands/configHelpEntries.ts)",
+        [...documented].filter((key) => !aggregated.has(key))
+      ),
+      verifySection(
+        "configHelpEntries lists keys no command documents (remove them)",
+        [...aggregated].filter((key) => !documented.has(key))
       )
-    ),
-    section(
-      "Documented config keys not present in assistConfigSchema",
-      [...documented].filter((key) => !schemaKeys.has(key))
-    ),
-    section(
-      "Keys now documented but still in pendingConfigDocumentation (remove them)",
-      [...pending].filter((key) => documented.has(key))
-    ),
-    section(
-      "pendingConfigDocumentation lists keys not in assistConfigSchema (remove them)",
-      [...pending].filter((key) => !schemaKeys.has(key))
-    ),
-    section(
-      "Keys documented by a command but missing from configHelpEntries (add their module to src/commands/configHelpEntries.ts)",
-      [...documented].filter((key) => !aggregated.has(key))
-    ),
-    section(
-      "configHelpEntries lists keys no command documents (remove them)",
-      [...aggregated].filter((key) => !documented.has(key))
-    )
-  ].filter((problem) => problem !== void 0);
-  if (problems.length > 0) {
-    console.log(problems.join("\n\n"));
-    process.exit(1);
-  }
-  console.log(
+    ],
     `All ${schemaKeys.size} config keys are surfaced in --help or pending documentation.`
   );
-  process.exit(0);
 }
 
 // src/commands/verify/forbiddenStrings/index.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
 
 // src/commands/verify/forbiddenStrings/findForbiddenStrings.ts
 import { minimatch as minimatch2 } from "minimatch";
@@ -3664,13 +3759,13 @@ function forbiddenStrings() {
   const cache5 = /* @__PURE__ */ new Map();
   const readJson = (file) => {
     if (cache5.has(file)) return cache5.get(file);
-    if (!existsSync13(file)) {
+    if (!existsSync14(file)) {
       console.log(`Forbidden-strings file not found: ${file}`);
       process.exit(1);
     }
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync10(file, "utf8"));
+      parsed = JSON.parse(readFileSync11(file, "utf8"));
     } catch (error) {
       console.log(`Could not parse ${file}: ${error.message}`);
       process.exit(1);
@@ -3743,7 +3838,7 @@ Total: ${lines2.length} hardcoded color(s)`);
 import * as path20 from "path";
 
 // src/shared/resolveRunConfigs.ts
-import { dirname as dirname10, relative, resolve as resolve4 } from "path";
+import { dirname as dirname11, relative, resolve as resolve4 } from "path";
 
 // src/shared/assertNoDuplicateRunNames.ts
 function findDuplicateNames(configs) {
@@ -3765,14 +3860,14 @@ function assertNoDuplicateRunNames(configs) {
 }
 
 // src/shared/findLinkedConfigPath.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join9, resolve as resolve2 } from "path";
+import { existsSync as existsSync15 } from "fs";
+import { join as join11, resolve as resolve2 } from "path";
 function findLinkedConfigPath(linkPath, fromDir) {
   const resolved = resolve2(fromDir, linkPath);
-  const claudePath = join9(resolved, ".claude", "assist.yml");
-  if (existsSync14(claudePath)) return claudePath;
-  const rootPath = join9(resolved, "assist.yml");
-  if (existsSync14(rootPath)) return rootPath;
+  const claudePath = join11(resolved, ".claude", "assist.yml");
+  if (existsSync15(claudePath)) return claudePath;
+  const rootPath = join11(resolved, "assist.yml");
+  if (existsSync15(rootPath)) return rootPath;
   throw new Error(`No assist.yml found in linked project: ${resolved}`);
 }
 
@@ -3814,7 +3909,7 @@ function loadAndResolveLink(linkPath, configDir, ctx) {
   const entries = loadLinkedEntries(configPath, ctx.visited);
   const defaultCwd = relativeToRoot(ctx, resolve4(configDir, linkPath));
   return setDefaultCwd(
-    resolveRecursive(entries, dirname10(configPath), ctx),
+    resolveRecursive(entries, dirname11(configPath), ctx),
     defaultCwd
   );
 }
@@ -3841,12 +3936,12 @@ function resolveLocalCwd(config, configDir, ctx) {
 }
 
 // src/shared/findRepoRoot.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import path19 from "path";
 function findRepoRoot(dir) {
   let current = dir;
   while (current !== path19.dirname(current)) {
-    if (existsSync15(path19.join(current, ".git"))) {
+    if (existsSync16(path19.join(current, ".git"))) {
       return current;
     }
     current = path19.dirname(current);
@@ -3917,9 +4012,9 @@ function list() {
 }
 
 // src/commands/verify/migrations/index.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import path21 from "path";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/shared/db/migrations/migration0001Baseline.ts
 var sql = `
@@ -4267,15 +4362,15 @@ function checkSequential(migrations3, files) {
 }
 
 // src/commands/verify/migrations/listMigrationFiles.ts
-import { readdirSync } from "fs";
+import { readdirSync as readdirSync2 } from "fs";
 var MIGRATION_FILE2 = /^migration\d+[A-Za-z0-9]*\.ts$/;
 function listMigrationFiles(dir) {
-  return readdirSync(dir).filter((file) => MIGRATION_FILE2.test(file));
+  return readdirSync2(dir).filter((file) => MIGRATION_FILE2.test(file));
 }
 
 // src/commands/verify/migrations/readBaselineMigrations.ts
 import { execSync as execSync6 } from "child_process";
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 var MIGRATION_FILE3 = /^migration\d+[A-Za-z0-9]*\.ts$/;
 function readBaselineMigrations(repoRelativeDir, ref) {
   const baseline = /* @__PURE__ */ new Map();
@@ -4288,7 +4383,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
   } catch {
     return baseline;
   }
-  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path91) => MIGRATION_FILE3.test(basename2(path91)));
+  const paths = listing.split("\n").map((line) => line.trim()).filter(Boolean).filter((path91) => MIGRATION_FILE3.test(basename3(path91)));
   for (const path91 of paths) {
     try {
       const content = execSync6(`git show "${ref}:${path91}"`, {
@@ -4296,7 +4391,7 @@ function readBaselineMigrations(repoRelativeDir, ref) {
         maxBuffer: 16 * 1024 * 1024,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      baseline.set(basename2(path91), content);
+      baseline.set(basename3(path91), content);
     } catch {
     }
   }
@@ -4338,7 +4433,7 @@ function resolveBaselineRef() {
 var REPO_RELATIVE_DIR = "src/shared/db/migrations";
 function migrationsDir() {
   return path21.resolve(
-    path21.dirname(fileURLToPath(import.meta.url)),
+    path21.dirname(fileURLToPath2(import.meta.url)),
     "../../../shared/db/migrations"
   );
 }
@@ -4356,7 +4451,7 @@ function migrations2() {
   if (ref) {
     const baseline = readBaselineMigrations(REPO_RELATIVE_DIR, ref);
     const current = new Map(
-      files.map((file) => [file, readFileSync11(path21.join(dir, file), "utf8")])
+      files.map((file) => [file, readFileSync12(path21.join(dir, file), "utf8")])
     );
     for (const finding of checkAppendOnly(baseline, current)) {
       problems.push(
@@ -4415,15 +4510,15 @@ import * as net from "net";
 
 // src/commands/sessions/daemon/daemonPaths.ts
 import { homedir as homedir2 } from "os";
-import { join as join10 } from "path";
-var DAEMON_DIR = join10(homedir2(), ".assist", "daemon");
+import { join as join12 } from "path";
+var DAEMON_DIR = join12(homedir2(), ".assist", "daemon");
 var daemonPaths = {
   dir: DAEMON_DIR,
-  socket: process.platform === "win32" ? String.raw`\\.\pipe\assist-sessions-daemon` : join10(DAEMON_DIR, "daemon.sock"),
-  log: join10(DAEMON_DIR, "daemon.log"),
-  pid: join10(DAEMON_DIR, "daemon.pid"),
-  spawnLock: join10(DAEMON_DIR, "spawn.lock"),
-  hooksSettings: join10(DAEMON_DIR, "hooks-settings.json")
+  socket: process.platform === "win32" ? String.raw`\\.\pipe\assist-sessions-daemon` : join12(DAEMON_DIR, "daemon.sock"),
+  log: join12(DAEMON_DIR, "daemon.log"),
+  pid: join12(DAEMON_DIR, "daemon.pid"),
+  spawnLock: join12(DAEMON_DIR, "spawn.lock"),
+  hooksSettings: join12(DAEMON_DIR, "hooks-settings.json")
 };
 
 // src/commands/sessions/daemon/connectToDaemon.ts
@@ -4731,7 +4826,7 @@ program.parse();
 
 // src/commands/new/registerNew/newCli/index.ts
 async function newCli() {
-  const name = basename3(resolve6("."));
+  const name = basename4(resolve6("."));
   initGit();
   initPackageJson(name);
   console.log("Installing dependencies...");
@@ -4746,7 +4841,7 @@ async function newCli() {
 
 // src/commands/new/registerNew/newProject.ts
 import { execSync as execSync14 } from "child_process";
-import { existsSync as existsSync17, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "fs";
 
 // src/commands/deploy/init/index.ts
 import { execSync as execSync13 } from "child_process";
@@ -4754,33 +4849,33 @@ import chalk27 from "chalk";
 import enquirer3 from "enquirer";
 
 // src/commands/deploy/init/updateWorkflow.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync12 } from "fs";
-import { dirname as dirname12, join as join11 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync17, mkdirSync as mkdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname13, join as join13 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import chalk26 from "chalk";
 var WORKFLOW_PATH = ".github/workflows/build.yml";
-var __dirname2 = dirname12(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname13(fileURLToPath3(import.meta.url));
 function getExistingSiteId() {
-  if (!existsSync16(WORKFLOW_PATH)) {
+  if (!existsSync17(WORKFLOW_PATH)) {
     return null;
   }
-  const content = readFileSync12(WORKFLOW_PATH, "utf8");
+  const content = readFileSync13(WORKFLOW_PATH, "utf8");
   const match = content.match(/-s\s+([a-f0-9-]{36})/);
   return match ? match[1] : null;
 }
 function getTemplateContent(siteId) {
-  const templatePath = join11(__dirname2, "commands/deploy/build.yml");
-  const template = readFileSync12(templatePath, "utf8");
+  const templatePath = join13(__dirname2, "commands/deploy/build.yml");
+  const template = readFileSync13(templatePath, "utf8");
   return template.replace("{{NETLIFY_SITE_ID}}", siteId);
 }
 async function updateWorkflow(siteId) {
   const newContent = getTemplateContent(siteId);
   const workflowDir = ".github/workflows";
-  if (!existsSync16(workflowDir)) {
+  if (!existsSync17(workflowDir)) {
     mkdirSync3(workflowDir, { recursive: true });
   }
-  if (existsSync16(WORKFLOW_PATH)) {
-    const oldContent = readFileSync12(WORKFLOW_PATH, "utf8");
+  if (existsSync17(WORKFLOW_PATH)) {
+    const oldContent = readFileSync13(WORKFLOW_PATH, "utf8");
     if (oldContent === newContent) {
       console.log(chalk26.green("build.yml is already up to date"));
       return;
@@ -4874,11 +4969,11 @@ async function newProject() {
 }
 function addViteBaseConfig() {
   const viteConfigPath = "vite.config.ts";
-  if (!existsSync17(viteConfigPath)) {
+  if (!existsSync18(viteConfigPath)) {
     console.log("No vite.config.ts found, skipping base config");
     return;
   }
-  const content = readFileSync13(viteConfigPath, "utf8");
+  const content = readFileSync14(viteConfigPath, "utf8");
   if (content.includes("base:")) {
     console.log("vite.config.ts already has base config");
     return;
@@ -5019,28 +5114,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 +5160,7 @@ function activityChart(data, range) {
   ]);
   screen.key(["q", "C-c", "escape"], () => {
     screen.destroy();
+    input?.destroy();
   });
   screen.render();
 }
@@ -5107,7 +5220,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
@@ -5126,55 +5246,6 @@ function adviceContextFor(cwd) {
   };
 }
 
-// src/commands/advise/loadAdviceFragments.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync14 } from "fs";
-import { basename as basename4, join as join13 } from "path";
-
-// src/commands/advise/adviceDir.ts
-import { existsSync as existsSync18 } from "fs";
-import { dirname as dirname13, join as join12 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function adviceDir() {
-  let current = dirname13(fileURLToPath3(import.meta.url));
-  while (current !== dirname13(current)) {
-    const candidate = join12(current, "claude", "advice");
-    if (existsSync18(candidate)) return candidate;
-    current = dirname13(current);
-  }
-  throw new Error("Could not locate the shipped claude/advice directory");
-}
-
-// src/commands/advise/parseAdviceFragment.ts
-import { parse as parseYaml2 } from "yaml";
-var frontmatter = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-function parseAdviceFragment(name, content) {
-  const match = frontmatter.exec(content);
-  if (!match) throw new Error(`Advice fragment ${name} has no frontmatter`);
-  const meta = parseYaml2(match[1]) ?? {};
-  const title = meta.title;
-  const when = meta.when;
-  if (typeof title !== "string" || typeof when !== "string")
-    throw new Error(
-      `Advice fragment ${name} needs a title and a when condition`
-    );
-  return {
-    name,
-    title,
-    when,
-    body: content.slice(match[0].length).trim()
-  };
-}
-
-// src/commands/advise/loadAdviceFragments.ts
-function loadAdviceFragments(dir = adviceDir()) {
-  return readdirSync2(dir).filter((file) => file.endsWith(".md")).sort().map(
-    (file) => parseAdviceFragment(
-      basename4(file, ".md"),
-      readFileSync14(join13(dir, file), "utf8")
-    )
-  );
-}
-
 // src/commands/advise/verifyRunCommandNames.ts
 function verifyRunCommandNames({
   config,
@@ -5243,9 +5314,11 @@ var adviceConditions = {
 // src/commands/advise/selectAdvice.ts
 function decide(fragment, context) {
   const advice = context.config.advice;
-  if (advice?.exclude.includes(fragment.name))
+  const exclude = advice?.exclude ?? [];
+  const include = advice?.include ?? [];
+  if (exclude.includes(fragment.name))
     return { fragment, included: false, reason: "excluded by advice.exclude" };
-  if (advice?.include.includes(fragment.name))
+  if (include.includes(fragment.name))
     return { fragment, included: true, reason: "included by advice.include" };
   const condition = adviceConditions[fragment.when];
   if (!condition)
@@ -6337,6 +6410,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 +8770,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 +8800,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 +8816,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 +8908,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 +8951,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 +8962,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 +9033,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 +9073,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 +9082,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 +9963,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 +10003,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 +10025,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 +13683,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 +13711,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 +13975,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 +13994,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 +14066,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 +14108,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 +14164,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 +14179,7 @@ function resolveCurrentSessionId(options2 = {}) {
 function newestTranscriptId(dir) {
   let entries;
   try {
-    entries = fs23.readdirSync(dir);
+    entries = fs24.readdirSync(dir);
   } catch {
     return void 0;
   }
@@ -14056,7 +14195,7 @@ function newestTranscriptId(dir) {
 }
 function modifiedAtOf(filePath) {
   try {
-    return fs23.statSync(filePath).mtimeMs;
+    return fs24.statSync(filePath).mtimeMs;
   } catch {
     return void 0;
   }
@@ -16709,13 +16848,13 @@ function phaseNotes(entry, position) {
 }
 function renderDiffPhase(entry, idx) {
   const notes = phaseNotes(entry, idx + 1);
-  const section3 = renderPhaseSection(
+  const section2 = renderPhaseSection(
     { ...entry.phase, name: `${entry.phase.name} (${notes.join(", ")})` },
     idx
   );
-  if (!entry.previousTasks) return section3;
+  if (!entry.previousTasks) return section2;
   return [
-    section3,
+    section2,
     "**Previously:**",
     entry.previousTasks.map((task) => `- ${task}`).join("\n")
   ].join("\n\n");
@@ -19022,13 +19161,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 +19176,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 +19201,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 +19402,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 +19514,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 +19529,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 +19690,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 +20946,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 +20961,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 +21556,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 +21803,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;
   }
@@ -26228,9 +26367,9 @@ function parsePrBody(body) {
   return sections;
 }
 function serializePrBody(sections) {
-  return sections.map((section3) => `## ${section3.heading}
+  return sections.map((section2) => `## ${section2.heading}
 
-${section3.content}`).join("\n\n");
+${section2.content}`).join("\n\n");
 }
 
 // src/commands/prs/editPrBody.ts
@@ -26279,11 +26418,11 @@ function findWallOfText(body) {
 }
 function splitParagraphs(body) {
   const paragraphs = [];
-  let section3 = "(intro)";
+  let section2 = "(intro)";
   let lines2 = [];
   const flush = () => {
     if (lines2.length > 0) {
-      paragraphs.push({ section: section3, lines: lines2 });
+      paragraphs.push({ section: section2, lines: lines2 });
       lines2 = [];
     }
   };
@@ -26291,7 +26430,7 @@ function splitParagraphs(body) {
     const heading2 = line.match(/^#{1,6}\s+(.*)$/);
     if (heading2) {
       flush();
-      section3 = heading2[1].trim();
+      section2 = heading2[1].trim();
     } else if (line.trim() === "") {
       flush();
     } else {
@@ -28267,17 +28406,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 +28446,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) {
@@ -29012,13 +29151,13 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 // src/commands/refactor/extract/displayPlan.ts
 import path50 from "path";
 import chalk199 from "chalk";
-function section2(title) {
+function section(title) {
   return `
   ${chalk199.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
-  console.log(section2("Update importers:"));
+  console.log(section("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path50.relative(cwd, imp.file.getFilePath());
     console.log(`    ${chalk199.dim(rel)}: \u2192 import from "${imp.relPath}"`);
@@ -29032,18 +29171,18 @@ function displayPlan(functionName, relDest, plan2, cwd) {
     console.log(`    ${name}`);
   }
   if (plan2.imports.length > 0) {
-    console.log(section2("Imports to copy:"));
+    console.log(section("Imports to copy:"));
     for (const imp of plan2.imports) {
       console.log(`    ${formatImportLine(imp)}`);
     }
   }
   if (plan2.exportedDeps.length > 0) {
-    console.log(section2("New imports from source:"));
+    console.log(section("New imports from source:"));
     console.log(
       `    import { ${plan2.exportedDeps.join(", ")} } from "${plan2.sourceRelPath}";`
     );
   }
-  console.log(section2("Source file changes:"));
+  console.log(section("Source file changes:"));
   console.log(`    Remove: ${plan2.extractedNames.join(", ")}`);
   if (plan2.sourceNeedsReimport) {
     console.log(
@@ -29052,7 +29191,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
   }
   displayImporters(plan2, cwd);
   if (plan2.barrel) {
-    console.log(section2("Barrel export:"));
+    console.log(section("Barrel export:"));
     console.log(
       `    Add: export { ${functionName} } from "${plan2.barrelRelPath}";`
     );
@@ -29065,11 +29204,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 +29229,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 +29243,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 +29251,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 +29266,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 +29279,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 +29322,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 +29350,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 +29363,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 +29382,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 +29461,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 +29574,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 +29803,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 +29835,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 +29852,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 +29871,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 +33032,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 +33041,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 +33050,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 +33067,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 +33114,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 +33122,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 +33137,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 +33171,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 +33209,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 +33256,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 +33282,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 +33343,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 +33382,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 +33413,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 +33735,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
   });
@@ -33989,6 +34128,11 @@ var checks = [
     description: "Check every assistConfigSchema key is surfaced in some command's --help via configHelp",
     action: configKeys
   },
+  {
+    name: "advice-fragments",
+    description: "Check ADVICE_FRAGMENT_NAMES matches the fragments shipped in claude/advice, so advice.include/exclude can name every one",
+    action: adviceFragments
+  },
   {
     name: "migrations",
     description: "Check DB migrations are sequentially numbered, append-only, and gate destructive DDL behind an acknowledgement marker",
@@ -35659,7 +35803,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 +35812,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 +35902,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 +35944,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 +36408,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 +36420,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 +37509,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 +37538,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 +37572,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 +37582,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 +37600,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 +37777,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 +37801,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 +37820,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 +38212,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 +38236,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"));
 }
 
@@ -39785,10 +39929,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 +40362,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 +40449,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 +41058,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 +41133,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 +41216,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 +41422,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 +41744,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 +41826,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 +42149,7 @@ configHelp(screenshotCommand, rootConfigHelp.screenshot);
 registerActivity(program);
 registerAdvise(program);
 registerBackup(program);
+registerChart(program);
 registerDb(program);
 registerDbMigration(program);
 registerCliHook(program);