@groundctl/cli 0.3.2 → 0.4.0

package/dist/index.js

@@ -5,9 +5,9 @@ import { Command } from "commander";
 import { createRequire } from "module";
 
 // src/commands/init.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, chmodSync, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, chmodSync, readFileSync as readFileSync3, appendFileSync } from "fs";
 import { join as join3 } from "path";
-import chalk from "chalk";
+import chalk2 from "chalk";
 
 // src/storage/db.ts
 import initSqlJs from "sql.js";
@@ -352,8 +352,6 @@ function generateAgentsMd(db, projectName) {
 
 // src/ingest/git-import.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
 function run(cmd, cwd) {
   try {
     return execSync(cmd, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
@@ -409,67 +407,10 @@ function parseGitLog(cwd) {
   }
   return commits.reverse();
 }
-function parseProjectStateMd(content) {
-  const features = [];
-  const lines = content.split("\n");
-  let section = "";
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("## ")) {
-      section = trimmed.toLowerCase();
-      continue;
-    }
-    if (section.includes("decision") || section.includes("session") || section.includes("debt") || section.includes("note")) continue;
-    if (!trimmed.startsWith("- ") && !trimmed.startsWith("* ")) continue;
-    const item = trimmed.slice(2).trim();
-    if (!item || item.length < 3) continue;
-    const name = item.split("(")[0].split("\u2192")[0].split("\u2014")[0].trim();
-    if (!name || name.length < 3 || name.length > 80) continue;
-    if (/^\d{4}-\d{2}-\d{2}/.test(name)) continue;
-    if (name.split(" ").length > 8) continue;
-    let status = "pending";
-    let priority = "medium";
-    if (section.includes("built") || section.includes("done") || section.includes("complete")) {
-      status = "done";
-    } else if (section.includes("claimed") || section.includes("in progress") || section.includes("current")) {
-      status = "in_progress";
-    } else if (section.includes("available") || section.includes("next")) {
-      status = "pending";
-    } else if (section.includes("blocked")) {
-      status = "blocked";
-    }
-    if (/priority:\s*critical|critical\)/i.test(item)) priority = "critical";
-    else if (/priority:\s*high|high\)/i.test(item)) priority = "high";
-    else if (/priority:\s*low|low\)/i.test(item)) priority = "low";
-    features.push({ name, status, priority });
-  }
-  return features;
-}
-function featureIdFromName(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 60);
-}
 function importFromGit(db, projectPath) {
   let sessionsCreated = 0;
-  let featuresImported = 0;
-  const psMdPath = join2(projectPath, "PROJECT_STATE.md");
-  if (existsSync2(psMdPath)) {
-    const content = readFileSync2(psMdPath, "utf-8");
-    const features = parseProjectStateMd(content);
-    for (const feat of features) {
-      const id = featureIdFromName(feat.name);
-      if (!id) continue;
-      const exists = queryOne(db, "SELECT id FROM features WHERE id = ?", [id]);
-      if (!exists) {
-        db.run(
-          "INSERT INTO features (id, name, status, priority) VALUES (?, ?, ?, ?)",
-          [id, feat.name, feat.status, feat.priority]
-        );
-        featuresImported++;
-      }
-    }
-  }
   const commits = parseGitLog(projectPath);
-  if (commits.length === 0) return { sessionsCreated, featuresImported };
+  if (commits.length === 0) return { sessionsCreated };
   const SESSION_GAP_MS = 4 * 60 * 60 * 1e3;
   const sessions = [];
   let currentSession = [];
@@ -523,7 +464,286 @@ function importFromGit(db, projectPath) {
     }
   }
   saveDb();
-  return { sessionsCreated, featuresImported };
+  return { sessionsCreated };
+}
+
+// src/ingest/feature-detector.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
+import { execSync as execSync2 } from "child_process";
+import { request as httpsRequest } from "https";
+import { createInterface } from "readline";
+import chalk from "chalk";
+function run2(cmd, cwd) {
+  try {
+    return execSync2(cmd, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] });
+  } catch {
+    return "";
+  }
+}
+function collectContext(projectPath) {
+  const parts = [];
+  const gitLog = run2("git log --oneline --no-merges", projectPath);
+  if (gitLog.trim()) {
+    const lines = gitLog.trim().split("\n").slice(0, 150).join("\n");
+    parts.push(`## Git history (${lines.split("\n").length} commits)
+${lines}`);
+  }
+  const diffStat = run2("git log --stat --no-merges --oneline -30", projectPath);
+  if (diffStat.trim()) {
+    parts.push(`## Recent commit file changes
+${diffStat.trim().slice(0, 3e3)}`);
+  }
+  const find = run2(
+    [
+      "find . -type f",
+      "-not -path '*/node_modules/*'",
+      "-not -path '*/.git/*'",
+      "-not -path '*/dist/*'",
+      "-not -path '*/.groundctl/*'",
+      "-not -path '*/build/*'",
+      "-not -path '*/coverage/*'",
+      "-not -path '*/.venv/*'",
+      "-not -path '*/__pycache__/*'",
+      "-not -path '*/.pytest_cache/*'",
+      "-not -path '*/vendor/*'",
+      "-not -path '*/.next/*'",
+      "-not -name '*.lock'",
+      "-not -name '*.log'",
+      "-not -name '*.pyc'",
+      "| sort | head -120"
+    ].join(" "),
+    projectPath
+  );
+  if (find.trim()) {
+    parts.push(`## Project file structure
+${find.trim()}`);
+  }
+  const readmePath = join2(projectPath, "README.md");
+  if (existsSync2(readmePath)) {
+    const readme = readFileSync2(readmePath, "utf-8").slice(0, 3e3);
+    parts.push(`## README.md
+${readme}`);
+  }
+  const psPath = join2(projectPath, "PROJECT_STATE.md");
+  if (existsSync2(psPath)) {
+    const ps = readFileSync2(psPath, "utf-8").slice(0, 2e3);
+    parts.push(`## Existing PROJECT_STATE.md
+${ps}`);
+  }
+  return parts.join("\n\n");
+}
+var SYSTEM_PROMPT = "You are a product analyst. Analyze this project and identify the main product features.";
+var USER_TEMPLATE = (context) => `Based on this git history and project structure, identify the product features with their status and priority.
+
+Rules:
+- Features are functional capabilities, not technical tasks
+- Maximum 12 features
+- status: "done" if all related commits are old and nothing is open, otherwise "open"
+- priority: critical/high/medium/low
+- name: short, kebab-case, human-readable (e.g. "user-auth", "data-pipeline")
+- description: one sentence, what the feature does for the user
+
+Respond ONLY with valid JSON, no markdown, no explanation:
+{"features":[{"name":"...","status":"done","priority":"high","description":"..."}]}
+
+Project context:
+${context}`;
+function httpsPost(opts) {
+  return new Promise((resolve3, reject) => {
+    const body = JSON.stringify({
+      model: opts.model,
+      max_tokens: opts.maxTokens ?? 1024,
+      system: opts.system,
+      messages: [{ role: "user", content: opts.userMessage }]
+    });
+    const req = httpsRequest(
+      {
+        hostname: "api.anthropic.com",
+        path: "/v1/messages",
+        method: "POST",
+        headers: {
+          "x-api-key": opts.apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(body)
+        }
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk.toString();
+        });
+        res.on("end", () => {
+          resolve3(data);
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+function extractText(raw) {
+  const json = JSON.parse(raw);
+  if (json.error) throw new Error(`API error: ${json.error.message}`);
+  const block = (json.content ?? []).find((b) => b.type === "text");
+  if (!block) throw new Error("No text block in API response");
+  return block.text;
+}
+function parseFeatureJson(text) {
+  const stripped = text.replace(/^```[^\n]*\n?/, "").replace(/\n?```$/, "").trim();
+  let obj;
+  try {
+    obj = JSON.parse(stripped);
+  } catch {
+    const match = stripped.match(/\{[\s\S]*\}/);
+    if (!match) throw new Error("Could not parse JSON from model response");
+    obj = JSON.parse(match[0]);
+  }
+  if (!Array.isArray(obj.features)) throw new Error("Response missing 'features' array");
+  return obj.features.map((f) => ({
+    name: String(f.name ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, ""),
+    status: f.status === "done" ? "done" : "open",
+    priority: ["critical", "high", "medium", "low"].includes(f.priority) ? f.priority : "medium",
+    description: String(f.description ?? "").slice(0, 120)
+  })).filter((f) => f.name.length >= 2);
+}
+async function callClaude(apiKey, context) {
+  const raw = await httpsPost({
+    apiKey,
+    model: "claude-haiku-4-5-20251001",
+    system: SYSTEM_PROMPT,
+    userMessage: USER_TEMPLATE(context),
+    maxTokens: 1024
+  });
+  const text = extractText(raw);
+  return parseFeatureJson(text);
+}
+function renderFeatureList(features) {
+  console.log(chalk.bold(`
+  Detected ${features.length} features:
+`));
+  for (const f of features) {
+    const statusIcon = f.status === "done" ? chalk.green("\u2713") : chalk.gray("\u25CB");
+    const prioColor = f.priority === "critical" || f.priority === "high" ? chalk.red : chalk.gray;
+    console.log(
+      `  ${statusIcon} ${chalk.white(f.name.padEnd(28))}` + prioColor(`(${f.priority}, ${f.status})`.padEnd(18)) + chalk.gray(f.description)
+    );
+  }
+  console.log("");
+}
+function readLine(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve3) => {
+    rl.question(prompt, (answer) => {
+      rl.close();
+      resolve3(answer.trim().toLowerCase());
+    });
+  });
+}
+async function editInEditor(features) {
+  const tmpPath = join2(tmpdir(), `groundctl-features-${Date.now()}.json`);
+  writeFileSync2(tmpPath, JSON.stringify({ features }, null, 2), "utf-8");
+  const editor = process.env.EDITOR ?? process.env.VISUAL ?? "vi";
+  try {
+    execSync2(`${editor} "${tmpPath}"`, { stdio: "inherit" });
+  } catch {
+    console.log(chalk.red("  Editor exited with error \u2014 using original features."));
+    return features;
+  }
+  try {
+    const edited = readFileSync2(tmpPath, "utf-8");
+    return parseFeatureJson(edited);
+  } catch (err) {
+    console.log(chalk.red(`  Could not parse edited JSON: ${err.message}`));
+    return null;
+  }
+}
+function importFeatures(db, features) {
+  db.run(
+    `DELETE FROM features
+     WHERE id NOT IN (SELECT DISTINCT feature_id FROM claims)
+       AND status = 'pending'`
+  );
+  for (const f of features) {
+    const id = f.name;
+    const status = f.status === "done" ? "done" : "pending";
+    const exists = queryOne(db, "SELECT id FROM features WHERE id = ?", [id]);
+    if (!exists) {
+      db.run(
+        "INSERT INTO features (id, name, status, priority, description) VALUES (?, ?, ?, ?, ?)",
+        [id, f.name, status, f.priority, f.description]
+      );
+    } else {
+      db.run(
+        `UPDATE features
+         SET description = ?, priority = ?, updated_at = datetime('now')
+         WHERE id = ?`,
+        [f.description, f.priority, id]
+      );
+    }
+  }
+  saveDb();
+}
+async function detectAndImportFeatures(db, projectPath) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    console.log(chalk.yellow(
+      "\n  Smart feature detection disabled \u2014 ANTHROPIC_API_KEY not set."
+    ));
+    console.log(chalk.gray("  To enable:"));
+    console.log(chalk.gray("    export ANTHROPIC_API_KEY=sk-ant-..."));
+    console.log(chalk.gray(
+      "\n  Or add features manually:\n    groundctl add feature -n 'my-feature'\n"
+    ));
+    return false;
+  }
+  console.log(chalk.gray("  Collecting project context..."));
+  const context = collectContext(projectPath);
+  console.log(chalk.gray("  Asking Claude to detect features..."));
+  let features;
+  try {
+    features = await callClaude(apiKey, context);
+  } catch (err) {
+    console.log(chalk.red(`  \u2717 Feature detection failed: ${err.message}`));
+    console.log(chalk.gray("  Add features manually with: groundctl add feature -n 'my-feature'\n"));
+    return false;
+  }
+  if (features.length === 0) {
+    console.log(chalk.yellow("  No features detected \u2014 add them manually.\n"));
+    return false;
+  }
+  renderFeatureList(features);
+  let pending = features;
+  while (true) {
+    const answer = await readLine(
+      chalk.bold("  Import these features? ") + chalk.gray("[y/n/edit] ") + ""
+    );
+    if (answer === "y" || answer === "yes") {
+      importFeatures(db, pending);
+      console.log(chalk.green(`
+  \u2713 ${pending.length} features imported
+`));
+      return true;
+    }
+    if (answer === "n" || answer === "no") {
+      console.log(chalk.gray("  Skipped \u2014 no features imported.\n"));
+      return false;
+    }
+    if (answer === "e" || answer === "edit") {
+      const edited = await editInEditor(pending);
+      if (edited && edited.length > 0) {
+        pending = edited;
+        renderFeatureList(pending);
+      } else {
+        console.log(chalk.yellow("  No valid features after edit \u2014 try again.\n"));
+      }
+      continue;
+    }
+    console.log(chalk.gray("  Please answer y, n, or edit."));
+  }
 }
 
 // src/commands/init.ts
@@ -563,53 +783,52 @@ echo "--- groundctl: Product state updated ---"
 async function initCommand(options) {
   const cwd = process.cwd();
   const projectName = cwd.split("/").pop() ?? "unknown";
-  console.log(chalk.bold(`
+  console.log(chalk2.bold(`
 groundctl init \u2014 ${projectName}
 `));
-  console.log(chalk.gray("  Creating SQLite database..."));
+  console.log(chalk2.gray("  Creating SQLite database..."));
   const db = await openDb();
   if (options.importFromGit) {
     const isGitRepo = existsSync3(join3(cwd, ".git"));
     if (!isGitRepo) {
-      console.log(chalk.yellow("  \u26A0 Not a git repo \u2014 skipping --import-from-git"));
+      console.log(chalk2.yellow("  \u26A0 Not a git repo \u2014 skipping --import-from-git"));
     } else {
-      console.log(chalk.gray("  Importing from git history..."));
+      console.log(chalk2.gray("  Importing sessions from git history..."));
       const result = importFromGit(db, cwd);
       console.log(
-        chalk.green(
-          `  \u2713 Git import: ${result.sessionsCreated} sessions, ${result.featuresImported} features`
-        )
+        chalk2.green(`  \u2713 Git import: ${result.sessionsCreated} sessions`)
       );
+      await detectAndImportFeatures(db, cwd);
     }
   }
   const projectState = generateProjectState(db, projectName);
   const agentsMd = generateAgentsMd(db, projectName);
   closeDb();
-  console.log(chalk.green("  \u2713 Database ready"));
+  console.log(chalk2.green("  \u2713 Database ready"));
   const claudeHooksDir = join3(cwd, ".claude", "hooks");
   if (!existsSync3(claudeHooksDir)) {
     mkdirSync2(claudeHooksDir, { recursive: true });
   }
-  writeFileSync2(join3(claudeHooksDir, "pre-session.sh"), PRE_SESSION_HOOK);
+  writeFileSync3(join3(claudeHooksDir, "pre-session.sh"), PRE_SESSION_HOOK);
   chmodSync(join3(claudeHooksDir, "pre-session.sh"), 493);
-  writeFileSync2(join3(claudeHooksDir, "post-session.sh"), POST_SESSION_HOOK);
+  writeFileSync3(join3(claudeHooksDir, "post-session.sh"), POST_SESSION_HOOK);
   chmodSync(join3(claudeHooksDir, "post-session.sh"), 493);
-  console.log(chalk.green("  \u2713 Claude Code hooks installed"));
+  console.log(chalk2.green("  \u2713 Claude Code hooks installed"));
   const codexHooksDir = join3(cwd, ".codex", "hooks");
   if (!existsSync3(codexHooksDir)) {
     mkdirSync2(codexHooksDir, { recursive: true });
   }
   const codexPre = PRE_SESSION_HOOK.replace("Claude Code", "Codex");
   const codexPost = POST_SESSION_HOOK.replace("Claude Code", "Codex").replace("claude-code", "codex");
-  writeFileSync2(join3(codexHooksDir, "pre-session.sh"), codexPre);
+  writeFileSync3(join3(codexHooksDir, "pre-session.sh"), codexPre);
   chmodSync(join3(codexHooksDir, "pre-session.sh"), 493);
-  writeFileSync2(join3(codexHooksDir, "post-session.sh"), codexPost);
+  writeFileSync3(join3(codexHooksDir, "post-session.sh"), codexPost);
   chmodSync(join3(codexHooksDir, "post-session.sh"), 493);
-  console.log(chalk.green("  \u2713 Codex hooks installed"));
-  writeFileSync2(join3(cwd, "PROJECT_STATE.md"), projectState);
-  writeFileSync2(join3(cwd, "AGENTS.md"), agentsMd);
-  console.log(chalk.green("  \u2713 PROJECT_STATE.md generated"));
-  console.log(chalk.green("  \u2713 AGENTS.md generated"));
+  console.log(chalk2.green("  \u2713 Codex hooks installed"));
+  writeFileSync3(join3(cwd, "PROJECT_STATE.md"), projectState);
+  writeFileSync3(join3(cwd, "AGENTS.md"), agentsMd);
+  console.log(chalk2.green("  \u2713 PROJECT_STATE.md generated"));
+  console.log(chalk2.green("  \u2713 AGENTS.md generated"));
   const gitignorePath = join3(cwd, ".gitignore");
   const gitignoreEntry = "\n# groundctl local state\n.groundctl/\n";
   if (existsSync3(gitignorePath)) {
@@ -618,32 +837,32 @@ groundctl init \u2014 ${projectName}
       appendFileSync(gitignorePath, gitignoreEntry);
     }
   }
-  console.log(chalk.bold.green(`
+  console.log(chalk2.bold.green(`
   \u2713 groundctl initialized for ${projectName}
 `));
   if (!options.importFromGit) {
-    console.log(chalk.gray("  Next steps:"));
-    console.log(chalk.gray("    groundctl add feature -n 'my-feature' -p high"));
-    console.log(chalk.gray("    groundctl status"));
-    console.log(chalk.gray("    groundctl claim my-feature"));
-    console.log(chalk.gray("\n  Or bootstrap from git history:"));
-    console.log(chalk.gray("    groundctl init --import-from-git\n"));
+    console.log(chalk2.gray("  Next steps:"));
+    console.log(chalk2.gray("    groundctl add feature -n 'my-feature' -p high"));
+    console.log(chalk2.gray("    groundctl status"));
+    console.log(chalk2.gray("    groundctl claim my-feature"));
+    console.log(chalk2.gray("\n  Or bootstrap from git history:"));
+    console.log(chalk2.gray("    groundctl init --import-from-git\n"));
   } else {
-    console.log(chalk.gray("  Next steps:"));
-    console.log(chalk.gray("    groundctl status"));
-    console.log(chalk.gray("    groundctl next\n"));
+    console.log(chalk2.gray("  Next steps:"));
+    console.log(chalk2.gray("    groundctl status"));
+    console.log(chalk2.gray("    groundctl next\n"));
   }
 }
 
 // src/commands/status.ts
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 var BAR_W = 14;
 var NAME_W = 22;
 var PROG_W = 6;
 function progressBar(done, total, width) {
-  if (total <= 0) return chalk2.gray("\u2591".repeat(width));
+  if (total <= 0) return chalk3.gray("\u2591".repeat(width));
   const filled = Math.min(width, Math.round(done / total * width));
-  return chalk2.green("\u2588".repeat(filled)) + chalk2.gray("\u2591".repeat(width - filled));
+  return chalk3.green("\u2588".repeat(filled)) + chalk3.gray("\u2591".repeat(width - filled));
 }
 function featureBar(status, progressDone, progressTotal) {
   if (progressTotal != null && progressTotal > 0) {
@@ -655,9 +874,9 @@ function featureBar(status, progressDone, progressTotal) {
     case "in_progress":
       return progressBar(1, 2, BAR_W);
     case "blocked":
-      return chalk2.red("\u2591".repeat(BAR_W));
+      return chalk3.red("\u2591".repeat(BAR_W));
     default:
-      return chalk2.gray("\u2591".repeat(BAR_W));
+      return chalk3.gray("\u2591".repeat(BAR_W));
   }
 }
 function featureProgress(progressDone, progressTotal) {
@@ -726,10 +945,10 @@ async function statusCommand() {
   closeDb();
   console.log("");
   if (features.length === 0) {
-    console.log(chalk2.bold(`  ${projectName} \u2014 no features tracked yet
+    console.log(chalk3.bold(`  ${projectName} \u2014 no features tracked yet
 `));
-    console.log(chalk2.gray("  Add features with: groundctl add feature -n 'my-feature'"));
-    console.log(chalk2.gray("  Then run: groundctl status\n"));
+    console.log(chalk3.gray("  Add features with: groundctl add feature -n 'my-feature'"));
+    console.log(chalk3.gray("  Then run: groundctl status\n"));
     return;
   }
   const total = features.length;
@@ -738,13 +957,13 @@ async function statusCommand() {
   const blocked = features.filter((f) => f.status === "blocked").length;
   const pct = Math.round(done / total * 100);
   console.log(
-    chalk2.bold(`  ${projectName} \u2014 ${pct}% implemented`) + chalk2.gray(` (${sessionCount} session${sessionCount !== 1 ? "s" : ""})`)
+    chalk3.bold(`  ${projectName} \u2014 ${pct}% implemented`) + chalk3.gray(` (${sessionCount} session${sessionCount !== 1 ? "s" : ""})`)
   );
   console.log("");
   const aggBar = progressBar(done, total, 20);
-  let aggSuffix = chalk2.white(`  ${done}/${total} done`);
-  if (inProg > 0) aggSuffix += chalk2.yellow(`  ${inProg} in progress`);
-  if (blocked > 0) aggSuffix += chalk2.red(`  ${blocked} blocked`);
+  let aggSuffix = chalk3.white(`  ${done}/${total} done`);
+  if (inProg > 0) aggSuffix += chalk3.yellow(`  ${inProg} in progress`);
+  if (blocked > 0) aggSuffix += chalk3.red(`  ${blocked} blocked`);
   console.log(`  Features  ${aggBar}${aggSuffix}`);
   console.log("");
   const maxNameLen = Math.min(NAME_W, Math.max(...features.map((f) => f.name.length)));
@@ -756,20 +975,20 @@ async function statusCommand() {
     const isActive = f.status === "in_progress";
     const isBlocked = f.status === "blocked";
     const icon = isDone ? "\u2713" : isActive ? "\u25CF" : isBlocked ? "\u2717" : "\u25CB";
-    const iconChalk = isDone ? chalk2.green : isActive ? chalk2.yellow : isBlocked ? chalk2.red : chalk2.gray;
+    const iconChalk = isDone ? chalk3.green : isActive ? chalk3.yellow : isBlocked ? chalk3.red : chalk3.gray;
     const nameRaw = f.name.slice(0, nameW).padEnd(nameW);
-    const nameChalk = isDone ? chalk2.dim : isActive ? chalk2.white : isBlocked ? chalk2.red : chalk2.gray;
+    const nameChalk = isDone ? chalk3.dim : isActive ? chalk3.white : isBlocked ? chalk3.red : chalk3.gray;
     const pd = f.progress_done ?? null;
     const pt = f.progress_total ?? null;
     const bar2 = featureBar(f.status, pd, pt);
     const prog = featureProgress(pd, pt).padEnd(PROG_W);
     const descRaw = f.description ?? "";
     const descTrunc = descRaw.length > 38 ? descRaw.slice(0, 36) + "\u2026" : descRaw;
-    const descStr = descTrunc ? chalk2.gray(`  ${descTrunc}`) : "";
+    const descStr = descTrunc ? chalk3.gray(`  ${descTrunc}`) : "";
     let claimedStr = "";
     if (isActive && f.claimed_session) {
       const elapsed = f.claimed_at ? timeSince(f.claimed_at) : "";
-      claimedStr = chalk2.yellow(` \u2192 ${f.claimed_session}${elapsed ? ` (${elapsed})` : ""}`);
+      claimedStr = chalk3.yellow(` \u2192 ${f.claimed_session}${elapsed ? ` (${elapsed})` : ""}`);
     }
     console.log(
       `  ${iconChalk(icon)} ${nameChalk(nameRaw)} ${bar2}  ${prog}${descStr}${claimedStr}`
@@ -777,7 +996,7 @@ async function statusCommand() {
     if (f.items) {
       const lines = wrapItems(f.items, itemsMaxW);
       for (const line of lines) {
-        console.log(chalk2.dim(`${contIndent}${line}`));
+        console.log(chalk3.dim(`${contIndent}${line}`));
       }
     }
   }
@@ -785,7 +1004,7 @@ async function statusCommand() {
 }
 
 // src/commands/claim.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { randomUUID } from "crypto";
 function findFeature(db, term) {
   return queryOne(
@@ -822,15 +1041,15 @@ async function claimCommand(featureIdOrName, options) {
   const db = await openDb();
   const feature = findFeature(db, featureIdOrName);
   if (!feature) {
-    console.log(chalk3.red(`
+    console.log(chalk4.red(`
   Feature "${featureIdOrName}" not found.
 `));
-    console.log(chalk3.gray("  Add it with: groundctl add feature -n '" + featureIdOrName + "'"));
+    console.log(chalk4.gray("  Add it with: groundctl add feature -n '" + featureIdOrName + "'"));
     closeDb();
     process.exit(1);
   }
   if (feature.status === "done") {
-    console.log(chalk3.yellow(`
+    console.log(chalk4.yellow(`
   Feature "${feature.name}" is already done.
 `));
     closeDb();
@@ -844,7 +1063,7 @@ async function claimCommand(featureIdOrName, options) {
   );
   if (existingClaim) {
     console.log(
-      chalk3.red(`
+      chalk4.red(`
   Feature "${feature.name}" is already claimed by session ${existingClaim.session_id}`)
     );
     const alternatives = query(
@@ -859,9 +1078,9 @@ async function claimCommand(featureIdOrName, options) {
        LIMIT 3`
     );
     if (alternatives.length > 0) {
-      console.log(chalk3.gray("\n  Available instead:"));
+      console.log(chalk4.gray("\n  Available instead:"));
       for (const alt of alternatives) {
-        console.log(chalk3.gray(`    \u25CB ${alt.name}`));
+        console.log(chalk4.gray(`    \u25CB ${alt.name}`));
       }
     }
     console.log("");
@@ -891,7 +1110,7 @@ async function claimCommand(featureIdOrName, options) {
   saveDb();
   closeDb();
   console.log(
-    chalk3.green(`
+    chalk4.green(`
   \u2713 Claimed "${feature.name}" \u2192 session ${sessionId}
 `)
   );
@@ -900,7 +1119,7 @@ async function completeCommand(featureIdOrName) {
   const db = await openDb();
   const feature = findFeature(db, featureIdOrName);
   if (!feature) {
-    console.log(chalk3.red(`
+    console.log(chalk4.red(`
   Feature "${featureIdOrName}" not found.
 `));
     closeDb();
@@ -916,15 +1135,15 @@ async function completeCommand(featureIdOrName) {
   );
   saveDb();
   closeDb();
-  console.log(chalk3.green(`
+  console.log(chalk4.green(`
   \u2713 Completed "${feature.name}"
 `));
 }
 
 // src/commands/sync.ts
-import { writeFileSync as writeFileSync3 } from "fs";
+import { writeFileSync as writeFileSync4 } from "fs";
 import { join as join4 } from "path";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 async function syncCommand(opts) {
   const db = await openDb();
   const projectName = process.cwd().split("/").pop() ?? "unknown";
@@ -932,16 +1151,16 @@ async function syncCommand(opts) {
   const agentsMd = generateAgentsMd(db, projectName);
   closeDb();
   const cwd = process.cwd();
-  writeFileSync3(join4(cwd, "PROJECT_STATE.md"), projectState);
-  writeFileSync3(join4(cwd, "AGENTS.md"), agentsMd);
+  writeFileSync4(join4(cwd, "PROJECT_STATE.md"), projectState);
+  writeFileSync4(join4(cwd, "AGENTS.md"), agentsMd);
   if (!opts?.silent) {
-    console.log(chalk4.green("\n  \u2713 PROJECT_STATE.md regenerated"));
-    console.log(chalk4.green("  \u2713 AGENTS.md regenerated\n"));
+    console.log(chalk5.green("\n  \u2713 PROJECT_STATE.md regenerated"));
+    console.log(chalk5.green("  \u2713 AGENTS.md regenerated\n"));
   }
 }
 
 // src/commands/next.ts
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 async function nextCommand() {
   const db = await openDb();
   const available = query(
@@ -961,26 +1180,26 @@ async function nextCommand() {
   );
   closeDb();
   if (available.length === 0) {
-    console.log(chalk5.yellow("\n  No available features to claim.\n"));
+    console.log(chalk6.yellow("\n  No available features to claim.\n"));
     return;
   }
-  console.log(chalk5.bold("\n  Next available features:\n"));
+  console.log(chalk6.bold("\n  Next available features:\n"));
   for (let i = 0; i < available.length; i++) {
     const feat = available[i];
-    const pColor = feat.priority === "critical" || feat.priority === "high" ? chalk5.red : chalk5.gray;
-    const marker = i === 0 ? chalk5.green("\u2192") : " ";
+    const pColor = feat.priority === "critical" || feat.priority === "high" ? chalk6.red : chalk6.gray;
+    const marker = i === 0 ? chalk6.green("\u2192") : " ";
     console.log(`  ${marker} ${feat.name} ${pColor(`(${feat.priority})`)}`);
     if (feat.description) {
-      console.log(chalk5.gray(`      ${feat.description}`));
+      console.log(chalk6.gray(`      ${feat.description}`));
     }
   }
-  console.log(chalk5.gray(`
+  console.log(chalk6.gray(`
   Claim with: groundctl claim "${available[0].name}"
 `));
 }
 
 // src/commands/log.ts
-import chalk6 from "chalk";
+import chalk7 from "chalk";
 async function logCommand(options) {
   const db = await openDb();
   if (options.session) {
@@ -989,18 +1208,18 @@ async function logCommand(options) {
       `%${options.session}%`
     ]);
     if (!session) {
-      console.log(chalk6.red(`
+      console.log(chalk7.red(`
   Session "${options.session}" not found.
 `));
       closeDb();
       return;
     }
-    console.log(chalk6.bold(`
+    console.log(chalk7.bold(`
   Session ${session.id}`));
-    console.log(chalk6.gray(`  Agent: ${session.agent}`));
-    console.log(chalk6.gray(`  Started: ${session.started_at}`));
+    console.log(chalk7.gray(`  Agent: ${session.agent}`));
+    console.log(chalk7.gray(`  Started: ${session.started_at}`));
     if (session.ended_at) {
-      console.log(chalk6.gray(`  Ended: ${session.ended_at}`));
+      console.log(chalk7.gray(`  Ended: ${session.ended_at}`));
     }
     if (session.summary) {
       console.log(`
@@ -1012,11 +1231,11 @@ async function logCommand(options) {
       [session.id]
     );
     if (decisions.length > 0) {
-      console.log(chalk6.bold("\n  Decisions:"));
+      console.log(chalk7.bold("\n  Decisions:"));
       for (const d of decisions) {
         console.log(`    \u2022 ${d.description}`);
         if (d.rationale) {
-          console.log(chalk6.gray(`      ${d.rationale}`));
+          console.log(chalk7.gray(`      ${d.rationale}`));
         }
       }
     }
@@ -1026,10 +1245,10 @@ async function logCommand(options) {
       [session.id]
     );
     if (files.length > 0) {
-      console.log(chalk6.bold(`
+      console.log(chalk7.bold(`
   Files modified (${files.length}):`));
       for (const f of files) {
-        const op = f.operation === "created" ? chalk6.green("+") : f.operation === "deleted" ? chalk6.red("-") : chalk6.yellow("~");
+        const op = f.operation === "created" ? chalk7.green("+") : f.operation === "deleted" ? chalk7.red("-") : chalk7.yellow("~");
         console.log(`    ${op} ${f.path} (${f.lines_changed} lines)`);
       }
     }
@@ -1037,18 +1256,18 @@ async function logCommand(options) {
   } else {
     const sessions = query(db, "SELECT * FROM sessions ORDER BY started_at DESC LIMIT 20");
     if (sessions.length === 0) {
-      console.log(chalk6.yellow("\n  No sessions recorded yet.\n"));
+      console.log(chalk7.yellow("\n  No sessions recorded yet.\n"));
       closeDb();
       return;
     }
-    console.log(chalk6.bold("\n  Session timeline:\n"));
+    console.log(chalk7.bold("\n  Session timeline:\n"));
     for (const s of sessions) {
-      const status = s.ended_at ? chalk6.green("done") : chalk6.yellow("active");
+      const status = s.ended_at ? chalk7.green("done") : chalk7.yellow("active");
       console.log(
-        `  ${chalk6.bold(s.id)}  ${chalk6.gray(s.started_at)}  ${status}  ${chalk6.gray(s.agent)}`
+        `  ${chalk7.bold(s.id)}  ${chalk7.gray(s.started_at)}  ${status}  ${chalk7.gray(s.agent)}`
       );
       if (s.summary) {
-        console.log(chalk6.gray(`    ${s.summary}`));
+        console.log(chalk7.gray(`    ${s.summary}`));
       }
     }
     console.log("");
@@ -1057,7 +1276,7 @@ async function logCommand(options) {
 }
 
 // src/commands/add.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 import { randomUUID as randomUUID2 } from "crypto";
 function parseProgress(s) {
   const m = s.match(/^(\d+)\/(\d+)$/);
@@ -1068,7 +1287,7 @@ async function addCommand(type, options) {
   const db = await openDb();
   if (type === "feature") {
     if (!options.name) {
-      console.log(chalk7.red("\n  --name is required for features.\n"));
+      console.log(chalk8.red("\n  --name is required for features.\n"));
       closeDb();
       process.exit(1);
     }
@@ -1082,7 +1301,7 @@ async function addCommand(type, options) {
         progressDone = p.done;
         progressTotal = p.total;
       } else {
-        console.log(chalk7.yellow(`  \u26A0  --progress "${options.progress}" ignored (expected N/N format)`));
+        console.log(chalk8.yellow(`  \u26A0  --progress "${options.progress}" ignored (expected N/N format)`));
       }
     }
     const items = options.items ? options.items.split(",").map((s) => s.trim()).filter(Boolean).join(",") : null;
@@ -1105,8 +1324,8 @@ async function addCommand(type, options) {
     const extras = [];
     if (progressDone !== null) extras.push(`${progressDone}/${progressTotal}`);
     if (items) extras.push(`${items.split(",").length} items`);
-    const suffix = extras.length ? chalk7.gray(` \u2014 ${extras.join(", ")}`) : "";
-    console.log(chalk7.green(`
+    const suffix = extras.length ? chalk8.gray(` \u2014 ${extras.join(", ")}`) : "";
+    console.log(chalk8.green(`
   \u2713 Feature added: ${options.name} (${priority})${suffix}
 `));
   } else if (type === "session") {
@@ -1115,11 +1334,11 @@ async function addCommand(type, options) {
     db.run("INSERT INTO sessions (id, agent) VALUES (?, ?)", [id, agent]);
     saveDb();
     closeDb();
-    console.log(chalk7.green(`
+    console.log(chalk8.green(`
   \u2713 Session created: ${id} (${agent})
 `));
   } else {
-    console.log(chalk7.red(`
+    console.log(chalk8.red(`
   Unknown type "${type}". Use "feature" or "session".
 `));
     closeDb();
@@ -1131,7 +1350,7 @@ async function addCommand(type, options) {
 import { existsSync as existsSync4, readdirSync } from "fs";
 import { join as join5, resolve } from "path";
 import { homedir as homedir2 } from "os";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/ingest/claude-parser.ts
 import { readFileSync as readFileSync4 } from "fs";
@@ -1401,11 +1620,11 @@ async function ingestCommand(options) {
     transcriptPath = findLatestTranscript(projectPath) ?? void 0;
   }
   if (!transcriptPath || !existsSync4(transcriptPath)) {
-    console.log(chalk8.yellow("\n  No transcript found. Skipping ingest.\n"));
+    console.log(chalk9.yellow("\n  No transcript found. Skipping ingest.\n"));
     if (!options.noSync) await syncCommand();
     return;
   }
-  console.log(chalk8.gray(`
+  console.log(chalk9.gray(`
   Parsing transcript: ${transcriptPath.split("/").slice(-2).join("/")}`));
   const parsed = parseTranscript(transcriptPath, options.sessionId ?? "auto", projectPath);
   const db = await openDb();
@@ -1455,16 +1674,16 @@ async function ingestCommand(options) {
   saveDb();
   closeDb();
   console.log(
-    chalk8.green(
+    chalk9.green(
       `  \u2713 Ingested session ${sessionId}: ${newFiles} files, ${parsed.commits.length} commits, ${newDecisions} decisions`
     )
   );
   if (parsed.decisions.length > 0 && newDecisions > 0) {
-    console.log(chalk8.gray(`
+    console.log(chalk9.gray(`
   Decisions captured:`));
     for (const d of parsed.decisions.slice(0, 5)) {
-      const conf = d.confidence === "low" ? chalk8.gray(" (low confidence)") : "";
-      console.log(chalk8.gray(`    \u2022 ${d.description.slice(0, 80)}${conf}`));
+      const conf = d.confidence === "low" ? chalk9.gray(" (low confidence)") : "";
+      console.log(chalk9.gray(`    \u2022 ${d.description.slice(0, 80)}${conf}`));
     }
   }
   if (!options.noSync) {
@@ -1474,9 +1693,9 @@ async function ingestCommand(options) {
 }
 
 // src/commands/report.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 import { join as join6 } from "path";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function formatDuration(start, end) {
   if (!end) return "ongoing";
   const startMs = new Date(start).getTime();
@@ -1571,7 +1790,7 @@ async function reportCommand(options) {
       [options.session, `%${options.session}%`]
     );
     if (!s) {
-      console.log(chalk9.red(`
+      console.log(chalk10.red(`
   Session "${options.session}" not found.
 `));
       closeDb();
@@ -1584,7 +1803,7 @@ async function reportCommand(options) {
       "SELECT * FROM sessions ORDER BY started_at DESC LIMIT 1"
     );
     if (!s) {
-      console.log(chalk9.yellow("\n  No sessions found. Run groundctl init first.\n"));
+      console.log(chalk10.yellow("\n  No sessions found. Run groundctl init first.\n"));
       closeDb();
       return;
     }
@@ -1626,8 +1845,8 @@ async function reportCommand(options) {
     }
     closeDb();
     const outPath2 = join6(cwd, "SESSION_HISTORY.md");
-    writeFileSync4(outPath2, fullReport);
-    console.log(chalk9.green(`
+    writeFileSync5(outPath2, fullReport);
+    console.log(chalk10.green(`
   \u2713 SESSION_HISTORY.md written (${sessions.length} sessions)
 `));
     return;
@@ -1653,16 +1872,16 @@ async function reportCommand(options) {
     activeClaims
   );
   const outPath = join6(cwd, "SESSION_REPORT.md");
-  writeFileSync4(outPath, report);
-  console.log(chalk9.green(`
+  writeFileSync5(outPath, report);
+  console.log(chalk10.green(`
   \u2713 SESSION_REPORT.md written (session ${session.id})
 `));
-  console.log(chalk9.gray(`  ${files.length} files \xB7 ${decisions.length} arch log entries \xB7 ${completedFeatures.length} features completed`));
+  console.log(chalk10.gray(`  ${files.length} files \xB7 ${decisions.length} arch log entries \xB7 ${completedFeatures.length} features completed`));
   console.log("");
 }
 
 // src/commands/health.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 async function healthCommand() {
   const db = await openDb();
   const projectName = process.cwd().split("/").pop() ?? "unknown";
@@ -1713,32 +1932,32 @@ async function healthCommand() {
   closeDb();
   const totalScore = featureScore + testScore + decisionScore + claimScore + deployScore;
   console.log("");
-  console.log(chalk10.bold(`  ${projectName} \u2014 Health Score: ${totalScore}/100
+  console.log(chalk11.bold(`  ${projectName} \u2014 Health Score: ${totalScore}/100
 `));
-  const featureColor = featurePct >= 0.7 ? chalk10.green : featurePct >= 0.4 ? chalk10.yellow : chalk10.red;
+  const featureColor = featurePct >= 0.7 ? chalk11.green : featurePct >= 0.4 ? chalk11.yellow : chalk11.red;
   const featureMark = featurePct >= 0.4 ? "\u2705" : "\u26A0\uFE0F ";
   console.log(
-    `  ${featureMark} Features    ${String(counts.done).padStart(2)}/${total} complete` + featureColor(`  (${Math.round(featurePct * 100)}%)`) + chalk10.gray(`  +${featureScore}pts`)
+    `  ${featureMark} Features    ${String(counts.done).padStart(2)}/${total} complete` + featureColor(`  (${Math.round(featurePct * 100)}%)`) + chalk11.gray(`  +${featureScore}pts`)
   );
   const testMark = testFiles > 0 ? "\u2705" : "\u26A0\uFE0F ";
-  const testColor = testFiles > 0 ? chalk10.green : chalk10.red;
+  const testColor = testFiles > 0 ? chalk11.green : chalk11.red;
   console.log(
-    `  ${testMark} Tests       ${testColor(String(testFiles) + " test files")}` + (testFiles === 0 ? chalk10.red("  (-20pts)") : chalk10.gray(`  +${testScore}pts`))
+    `  ${testMark} Tests       ${testColor(String(testFiles) + " test files")}` + (testFiles === 0 ? chalk11.red("  (-20pts)") : chalk11.gray(`  +${testScore}pts`))
   );
   const decMark = decisionCount > 0 ? "\u2705" : "\u26A0\uFE0F ";
-  const decColor = decisionCount > 0 ? chalk10.green : chalk10.yellow;
+  const decColor = decisionCount > 0 ? chalk11.green : chalk11.yellow;
   console.log(
-    `  ${decMark} Arch log    ${decColor(decisionCount + " entries")}` + chalk10.gray(`  +${decisionScore}pts`)
+    `  ${decMark} Arch log    ${decColor(decisionCount + " entries")}` + chalk11.gray(`  +${decisionScore}pts`)
   );
   const claimMark = staleClaims === 0 ? "\u2705" : "\u26A0\uFE0F ";
-  const claimColor = staleClaims === 0 ? chalk10.green : chalk10.red;
+  const claimColor = staleClaims === 0 ? chalk11.green : chalk11.red;
   console.log(
-    `  ${claimMark} Claims      ${claimColor(staleClaims > 0 ? staleClaims + " stale (>24h)" : "0 stale")}` + chalk10.gray(`  +${claimScore}pts`)
+    `  ${claimMark} Claims      ${claimColor(staleClaims > 0 ? staleClaims + " stale (>24h)" : "0 stale")}` + chalk11.gray(`  +${claimScore}pts`)
   );
   const deployMark = deployScore > 0 ? "\u2705" : "\u26A0\uFE0F ";
-  const deployLabel = deployScore > 0 ? chalk10.green("detected") : chalk10.gray("not detected");
+  const deployLabel = deployScore > 0 ? chalk11.green("detected") : chalk11.gray("not detected");
   console.log(
-    `  ${deployMark} Deploy      ${deployLabel}` + (deployScore > 0 ? chalk10.gray(`  +${deployScore}pts`) : chalk10.gray("  +0pts"))
+    `  ${deployMark} Deploy      ${deployLabel}` + (deployScore > 0 ? chalk11.gray(`  +${deployScore}pts`) : chalk11.gray("  +0pts"))
   );
   console.log("");
   const recommendations = [];
@@ -1747,9 +1966,9 @@ async function healthCommand() {
   if (decisionCount === 0) recommendations.push("Log architecture decisions during sessions so agents understand the why.");
   if (featurePct < 0.5 && total > 0) recommendations.push(`${counts.pending} features pending \u2014 run groundctl next to pick one.`);
   if (recommendations.length > 0) {
-    console.log(chalk10.bold("  Recommendations:"));
+    console.log(chalk11.bold("  Recommendations:"));
     for (const r of recommendations) {
-      console.log(chalk10.yellow(`    \u2192 ${r}`));
+      console.log(chalk11.yellow(`    \u2192 ${r}`));
     }
     console.log("");
   }
@@ -1760,7 +1979,7 @@ import { createServer } from "http";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { join as join7, dirname as dirname2 } from "path";
 import { exec } from "child_process";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import initSqlJs2 from "sql.js";
 function findDbPath(startDir = process.cwd()) {
   let dir = startDir;
@@ -1923,9 +2142,9 @@ async function dashboardCommand(options) {
     }
   });
   server.listen(port, "127.0.0.1", () => {
-    console.log(chalk11.bold(`
-  groundctl dashboard \u2192 `) + chalk11.blue(`http://localhost:${port}`) + "\n");
-    console.log(chalk11.gray("  Auto-refreshes every 10s. Press Ctrl+C to stop.\n"));
+    console.log(chalk12.bold(`
+  groundctl dashboard \u2192 `) + chalk12.blue(`http://localhost:${port}`) + "\n");
+    console.log(chalk12.gray("  Auto-refreshes every 10s. Press Ctrl+C to stop.\n"));
     exec(`open http://localhost:${port} 2>/dev/null || xdg-open http://localhost:${port} 2>/dev/null || true`);
   });
   await new Promise((_, reject) => {
@@ -1938,7 +2157,7 @@ import {
   existsSync as existsSync6,
   readdirSync as readdirSync2,
   statSync,
-  writeFileSync as writeFileSync5,
+  writeFileSync as writeFileSync6,
   readFileSync as readFileSync6,
   mkdirSync as mkdirSync3,
   watch as fsWatch
@@ -1946,7 +2165,7 @@ import {
 import { join as join8, resolve as resolve2 } from "path";
 import { homedir as homedir3 } from "os";
 import { spawn } from "child_process";
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 var DEBOUNCE_MS = 8e3;
 var DIR_POLL_MS = 5e3;
 function claudeEncode2(p) {
@@ -1978,7 +2197,7 @@ function fileSize(p) {
 function writePidFile(groundctlDir, pid) {
   try {
     mkdirSync3(groundctlDir, { recursive: true });
-    writeFileSync5(join8(groundctlDir, "watch.pid"), String(pid), "utf8");
+    writeFileSync6(join8(groundctlDir, "watch.pid"), String(pid), "utf8");
   } catch {
   }
 }
@@ -2001,8 +2220,8 @@ function processAlive(pid) {
 async function runIngest(transcriptPath, projectPath) {
   const filename = transcriptPath.split("/").slice(-2).join("/");
   console.log(
-    chalk12.gray(`
-  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk12.cyan(`Transcript stable \u2192 ingesting ${filename}`)
+    chalk13.gray(`
+  [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] `) + chalk13.cyan(`Transcript stable \u2192 ingesting ${filename}`)
   );
   try {
     const parsed = parseTranscript(transcriptPath, "auto", projectPath);
@@ -2058,11 +2277,11 @@ async function runIngest(transcriptPath, projectPath) {
     if (parsed.commits.length > 0) parts.push(`${parsed.commits.length} commit${parsed.commits.length !== 1 ? "s" : ""}`);
     if (newDecisions > 0) parts.push(`${newDecisions} decision${newDecisions !== 1 ? "s" : ""} captured`);
     const summary = parts.length > 0 ? parts.join(", ") : "no new data";
-    console.log(chalk12.green(`  \u2713 Session ingested \u2014 ${summary}`));
+    console.log(chalk13.green(`  \u2713 Session ingested \u2014 ${summary}`));
     await syncCommand({ silent: true });
-    console.log(chalk12.gray("  \u21B3 PROJECT_STATE.md + AGENTS.md updated"));
+    console.log(chalk13.gray("  \u21B3 PROJECT_STATE.md + AGENTS.md updated"));
   } catch (err) {
-    console.log(chalk12.red(`  \u2717 Ingest failed: ${err.message}`));
+    console.log(chalk13.red(`  \u2717 Ingest failed: ${err.message}`));
   }
 }
 function startWatcher(transcriptDir, projectPath) {
@@ -2110,12 +2329,12 @@ function startWatcher(transcriptDir, projectPath) {
       schedule(fp);
     }
   });
-  console.log(chalk12.bold("\n  groundctl watch") + chalk12.gray(" \u2014 auto-ingest on session end\n"));
+  console.log(chalk13.bold("\n  groundctl watch") + chalk13.gray(" \u2014 auto-ingest on session end\n"));
   console.log(
-    chalk12.gray("  Watching: ") + chalk12.blue(transcriptDir.replace(homedir3(), "~"))
+    chalk13.gray("  Watching: ") + chalk13.blue(transcriptDir.replace(homedir3(), "~"))
   );
-  console.log(chalk12.gray("  Stability threshold: ") + chalk12.white(`${DEBOUNCE_MS / 1e3}s`));
-  console.log(chalk12.gray("  Press Ctrl+C to stop.\n"));
+  console.log(chalk13.gray("  Stability threshold: ") + chalk13.white(`${DEBOUNCE_MS / 1e3}s`));
+  console.log(chalk13.gray("  Press Ctrl+C to stop.\n"));
 }
 async function watchCommand(options) {
   const projectPath = options.projectPath ? resolve2(options.projectPath) : process.cwd();
@@ -2128,29 +2347,29 @@ async function watchCommand(options) {
     child.unref();
     const groundctlDir2 = join8(projectPath, ".groundctl");
     writePidFile(groundctlDir2, child.pid);
-    console.log(chalk12.green(`
+    console.log(chalk13.green(`
   \u2713 groundctl watch running in background (PID ${child.pid})`));
-    console.log(chalk12.gray(`  PID saved to .groundctl/watch.pid`));
-    console.log(chalk12.gray(`  To stop: kill ${child.pid}
+    console.log(chalk13.gray(`  PID saved to .groundctl/watch.pid`));
+    console.log(chalk13.gray(`  To stop: kill ${child.pid}
 `));
     process.exit(0);
   }
   const groundctlDir = join8(projectPath, ".groundctl");
   const existingPid = readPidFile(groundctlDir);
   if (existingPid && processAlive(existingPid)) {
-    console.log(chalk12.yellow(`
+    console.log(chalk13.yellow(`
   \u26A0  A watcher is already running (PID ${existingPid}).`));
-    console.log(chalk12.gray(`  To stop it: kill ${existingPid}
+    console.log(chalk13.gray(`  To stop it: kill ${existingPid}
 `));
     process.exit(1);
   }
   let transcriptDir = findTranscriptDir(projectPath);
   if (!transcriptDir) {
-    console.log(chalk12.bold("\n  groundctl watch\n"));
+    console.log(chalk13.bold("\n  groundctl watch\n"));
     console.log(
-      chalk12.yellow("  No Claude Code transcript directory found for this project yet.")
+      chalk13.yellow("  No Claude Code transcript directory found for this project yet.")
     );
-    console.log(chalk12.gray("  Waiting for first session to start...\n"));
+    console.log(chalk13.gray("  Waiting for first session to start...\n"));
     await new Promise((resolve3) => {
       const interval = setInterval(() => {
         const dir = findTranscriptDir(projectPath);
@@ -2165,7 +2384,7 @@ async function watchCommand(options) {
   startWatcher(transcriptDir, projectPath);
   await new Promise(() => {
     process.on("SIGINT", () => {
-      console.log(chalk12.gray("\n  Watcher stopped.\n"));
+      console.log(chalk13.gray("\n  Watcher stopped.\n"));
       process.exit(0);
     });
     process.on("SIGTERM", () => {
@@ -2175,7 +2394,7 @@ async function watchCommand(options) {
 }
 
 // src/commands/update.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 function parseProgress2(s) {
   const m = s.match(/^(\d+)\/(\d+)$/);
   if (!m) return null;
@@ -2183,7 +2402,7 @@ function parseProgress2(s) {
 }
 async function updateCommand(type, nameOrId, options) {
   if (type !== "feature") {
-    console.log(chalk13.red(`
+    console.log(chalk14.red(`
   Unknown type "${type}". Use "feature".
 `));
     process.exit(1);
@@ -2199,7 +2418,7 @@ async function updateCommand(type, nameOrId, options) {
     [nameOrId, `%${nameOrId}%`]
   );
   if (!feature) {
-    console.log(chalk13.red(`
+    console.log(chalk14.red(`
   Feature "${nameOrId}" not found.
 `));
     closeDb();
@@ -2219,7 +2438,7 @@ async function updateCommand(type, nameOrId, options) {
   if (options.progress !== void 0) {
     const p = parseProgress2(options.progress);
     if (!p) {
-      console.log(chalk13.yellow(`  \u26A0  --progress "${options.progress}" ignored (expected N/N format)
+      console.log(chalk14.yellow(`  \u26A0  --progress "${options.progress}" ignored (expected N/N format)
 `));
     } else {
       sets.push("progress_done = ?", "progress_total = ?");
@@ -2235,7 +2454,7 @@ async function updateCommand(type, nameOrId, options) {
     params.push(options.status);
   }
   if (sets.length === 0) {
-    console.log(chalk13.yellow("\n  Nothing to update \u2014 pass at least one option.\n"));
+    console.log(chalk14.yellow("\n  Nothing to update \u2014 pass at least one option.\n"));
     closeDb();
     return;
   }
@@ -2247,7 +2466,7 @@ async function updateCommand(type, nameOrId, options) {
   );
   saveDb();
   closeDb();
-  console.log(chalk13.green(`  \u2713 Updated: ${feature.name}`));
+  console.log(chalk14.green(`  \u2713 Updated: ${feature.name}`));
 }
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groundctl/cli",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Always know what to build next.",
   "license": "MIT",
   "bin": {