@groundctl/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1638 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, chmodSync, readFileSync as readFileSync3, appendFileSync } from "fs";
+import { join as join3 } from "path";
+import chalk from "chalk";
+
+// src/storage/db.ts
+import initSqlJs from "sql.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+
+// src/storage/schema.ts
+var SCHEMA_VERSION = 1;
+function applySchema(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS features (
+      id            TEXT PRIMARY KEY,
+      name          TEXT NOT NULL,
+      status        TEXT NOT NULL DEFAULT 'pending'
+                    CHECK (status IN ('pending', 'in_progress', 'done', 'blocked')),
+      priority      TEXT NOT NULL DEFAULT 'medium'
+                    CHECK (priority IN ('critical', 'high', 'medium', 'low')),
+      description   TEXT,
+      parallel_safe INTEGER NOT NULL DEFAULT 1,
+      session_claimed TEXT,
+      claimed_at    TEXT,
+      completed_at  TEXT,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id          TEXT PRIMARY KEY,
+      agent       TEXT NOT NULL DEFAULT 'claude-code',
+      started_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      ended_at    TEXT,
+      summary     TEXT,
+      prompt      TEXT
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS decisions (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id  TEXT NOT NULL REFERENCES sessions(id),
+      description TEXT NOT NULL,
+      rationale   TEXT,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS files_modified (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id    TEXT NOT NULL REFERENCES sessions(id),
+      path          TEXT NOT NULL,
+      operation     TEXT NOT NULL DEFAULT 'modified'
+                    CHECK (operation IN ('created', 'modified', 'deleted')),
+      lines_changed INTEGER DEFAULT 0,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS claims (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id  TEXT NOT NULL REFERENCES features(id),
+      session_id  TEXT NOT NULL REFERENCES sessions(id),
+      claimed_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      released_at TEXT,
+      UNIQUE(feature_id, session_id, claimed_at)
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS feature_dependencies (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      feature_id    TEXT NOT NULL REFERENCES features(id),
+      depends_on_id TEXT NOT NULL REFERENCES features(id),
+      type          TEXT NOT NULL DEFAULT 'blocks'
+                    CHECK (type IN ('blocks', 'suggests')),
+      UNIQUE(feature_id, depends_on_id)
+    )
+  `);
+  db.run("CREATE INDEX IF NOT EXISTS idx_deps_feature ON feature_dependencies(feature_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_deps_depends ON feature_dependencies(depends_on_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_features_status ON features(status)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_claims_feature ON claims(feature_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_claims_active ON claims(feature_id) WHERE released_at IS NULL");
+  db.run("CREATE INDEX IF NOT EXISTS idx_files_session ON files_modified(session_id)");
+  db.run("CREATE INDEX IF NOT EXISTS idx_decisions_session ON decisions(session_id)");
+  db.run(
+    "INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', ?)",
+    [String(SCHEMA_VERSION)]
+  );
+}
+
+// src/storage/db.ts
+var GROUNDCTL_DIR = join(homedir(), ".groundctl");
+var DB_PATH = join(GROUNDCTL_DIR, "db.sqlite");
+var _db = null;
+var _dbPath = DB_PATH;
+async function openDb(path) {
+  if (_db) return _db;
+  const dbPath = path ?? DB_PATH;
+  _dbPath = dbPath;
+  const dir = dirname(dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const SQL = await initSqlJs();
+  if (existsSync(dbPath)) {
+    const buffer = readFileSync(dbPath);
+    _db = new SQL.Database(buffer);
+  } else {
+    _db = new SQL.Database();
+  }
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA busy_timeout = 5000");
+  applySchema(_db);
+  saveDb();
+  return _db;
+}
+function saveDb() {
+  if (!_db) return;
+  const data = _db.export();
+  const buffer = Buffer.from(data);
+  const dir = dirname(_dbPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(_dbPath, buffer);
+}
+function closeDb() {
+  if (_db) {
+    saveDb();
+    _db.close();
+    _db = null;
+  }
+}
+
+// src/storage/query.ts
+function query(db, sql, params = []) {
+  const stmt = db.prepare(sql);
+  if (params.length > 0) {
+    stmt.bind(params);
+  }
+  const results = [];
+  while (stmt.step()) {
+    const row = stmt.getAsObject();
+    results.push(row);
+  }
+  stmt.free();
+  return results;
+}
+function queryOne(db, sql, params = []) {
+  const rows = query(db, sql, params);
+  return rows[0];
+}
+
+// src/generators/markdown.ts
+function generateProjectState(db, projectName) {
+  const now = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const features = query(db, "SELECT * FROM features ORDER BY created_at");
+  const activeClaims = query(
+    db,
+    `SELECT c.feature_id, f.name as feature_name, c.session_id, c.claimed_at
+     FROM claims c JOIN features f ON c.feature_id = f.id
+     WHERE c.released_at IS NULL`
+  );
+  const available = query(
+    db,
+    `SELECT f.* FROM features f
+     WHERE f.status = 'pending'
+     AND f.id NOT IN (SELECT feature_id FROM claims WHERE released_at IS NULL)
+     ORDER BY CASE f.priority
+       WHEN 'critical' THEN 0 WHEN 'high' THEN 1
+       WHEN 'medium' THEN 2 WHEN 'low' THEN 3
+     END`
+  );
+  const decisions = query(
+    db,
+    "SELECT d.session_id, d.description, d.rationale FROM decisions d ORDER BY d.created_at"
+  );
+  const sessions = query(
+    db,
+    "SELECT * FROM sessions ORDER BY started_at DESC"
+  );
+  const lastSession = sessions[0];
+  const done = features.filter((f) => f.status === "done");
+  const blocked = features.filter((f) => f.status === "blocked");
+  let md = `# ${projectName} \u2014 Product State
+`;
+  md += `Last updated: ${now}`;
+  if (lastSession) {
+    md += ` | Last session: ${lastSession.id}`;
+  }
+  if (features.length > 0) {
+    const pct = Math.round(done.length / features.length * 100);
+    md += ` | Progress: ${pct}%`;
+  }
+  md += "\n\n";
+  if (done.length > 0) {
+    md += "## What's been built\n";
+    for (const f of done) {
+      md += `- ${f.name}`;
+      if (f.completed_at) md += ` (completed ${String(f.completed_at).slice(0, 10)})`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  if (activeClaims.length > 0) {
+    md += "## Currently claimed\n";
+    for (const claim of activeClaims) {
+      md += `- ${claim.feature_name} \u2192 session ${claim.session_id} (started ${claim.claimed_at})
+`;
+    }
+    md += "\n";
+  }
+  if (available.length > 0) {
+    md += "## Available next\n";
+    for (const f of available) {
+      md += `- ${f.name} (priority: ${f.priority})`;
+      if (f.description) md += ` \u2014 ${f.description}`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  if (blocked.length > 0) {
+    md += "## Blocked\n";
+    for (const f of blocked) {
+      md += `- ${f.name}`;
+      if (f.description) md += ` \u2014 ${f.description}`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  if (decisions.length > 0) {
+    md += "## Decisions made\n";
+    for (const d of decisions) {
+      md += `- ${d.session_id}: ${d.description}`;
+      if (d.rationale) md += ` \u2014 ${d.rationale}`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  if (sessions.length > 0) {
+    md += "## Recent sessions\n";
+    for (const s of sessions.slice(0, 10)) {
+      const status = s.ended_at ? "done" : "active";
+      md += `- ${s.id} (${s.agent}, ${status})`;
+      if (s.summary) md += ` \u2014 ${s.summary}`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  return md;
+}
+function generateAgentsMd(db, projectName) {
+  const available = query(
+    db,
+    `SELECT f.name, f.priority, f.description FROM features f
+     WHERE f.status = 'pending'
+     AND f.id NOT IN (SELECT feature_id FROM claims WHERE released_at IS NULL)
+     ORDER BY CASE f.priority
+       WHEN 'critical' THEN 0 WHEN 'high' THEN 1
+       WHEN 'medium' THEN 2 WHEN 'low' THEN 3
+     END`
+  );
+  const activeClaims = query(
+    db,
+    `SELECT f.name as feature_name, c.session_id
+     FROM claims c JOIN features f ON c.feature_id = f.id
+     WHERE c.released_at IS NULL`
+  );
+  let md = `# ${projectName} \u2014 Agent Instructions
+
+`;
+  md += "This file is auto-generated by groundctl. Read it before starting work.\n\n";
+  md += "## Before you start\n";
+  md += "1. Read PROJECT_STATE.md for full product context\n";
+  md += "2. Run `groundctl next` to see available features\n";
+  md += "3. Run `groundctl claim <feature>` to reserve your work\n";
+  md += "4. When done, run `groundctl complete <feature>`\n";
+  md += "5. Run `groundctl sync` to update state files\n\n";
+  if (activeClaims.length > 0) {
+    md += "## Do NOT work on (already claimed)\n";
+    for (const c of activeClaims) {
+      md += `- ${c.feature_name} (session ${c.session_id})
+`;
+    }
+    md += "\n";
+  }
+  if (available.length > 0) {
+    md += "## Available to claim\n";
+    for (const f of available) {
+      md += `- ${f.name} (${f.priority})`;
+      if (f.description) md += ` \u2014 ${f.description}`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  return md;
+}
+
+// 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"] });
+  } catch {
+    return "";
+  }
+}
+function parseGitLog(cwd) {
+  const logOutput = run(
+    'git log --format="%H|||%ai|||%s" --no-merges',
+    cwd
+  );
+  if (!logOutput.trim()) return [];
+  const commits = [];
+  for (const line of logOutput.trim().split("\n")) {
+    const parts = line.split("|||");
+    if (parts.length < 3) continue;
+    const [hash, date, ...messageParts] = parts;
+    const message = messageParts.join("|||").trim();
+    const diffOutput = run(
+      `git diff-tree --no-commit-id -r --name-status "${hash.trim()}"`,
+      cwd
+    );
+    const filesChanged = [];
+    for (const diffLine of diffOutput.trim().split("\n")) {
+      if (!diffLine.trim()) continue;
+      const [status, ...pathParts] = diffLine.trim().split(/\s+/);
+      const filePath = pathParts.join(" ");
+      if (!filePath) continue;
+      let operation = "modified";
+      if (status.startsWith("A")) operation = "created";
+      else if (status.startsWith("D")) operation = "deleted";
+      else if (status.startsWith("M") || status.startsWith("R")) operation = "modified";
+      const numstatLine = run(
+        `git diff-tree --no-commit-id -r --numstat "${hash.trim()}" -- "${filePath}"`,
+        cwd
+      );
+      let insertions = 0;
+      let deletions = 0;
+      if (numstatLine.trim()) {
+        const [ins, del] = numstatLine.trim().split(/\s+/);
+        insertions = parseInt(ins) || 0;
+        deletions = parseInt(del) || 0;
+      }
+      filesChanged.push({ path: filePath, operation, insertions, deletions });
+    }
+    commits.push({
+      hash: hash.trim(),
+      message,
+      date: date.trim(),
+      filesChanged
+    });
+  }
+  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 (!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) 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 };
+  const SESSION_GAP_MS = 4 * 60 * 60 * 1e3;
+  const sessions = [];
+  let currentSession = [];
+  let lastDate = null;
+  for (const commit of commits) {
+    const commitDate = new Date(commit.date);
+    if (lastDate && commitDate.getTime() - lastDate.getTime() > SESSION_GAP_MS) {
+      if (currentSession.length > 0) sessions.push(currentSession);
+      currentSession = [];
+    }
+    currentSession.push(commit);
+    lastDate = commitDate;
+  }
+  if (currentSession.length > 0) sessions.push(currentSession);
+  for (let i = 0; i < sessions.length; i++) {
+    const sessionCommits = sessions[i];
+    const sessionId = `S${i + 1}`;
+    const firstCommit = sessionCommits[0];
+    const lastCommit = sessionCommits[sessionCommits.length - 1];
+    const exists = queryOne(db, "SELECT id FROM sessions WHERE id = ?", [sessionId]);
+    if (exists) continue;
+    const summary = sessionCommits.map((c) => c.message).slice(0, 3).join("; ").slice(0, 200);
+    db.run(
+      "INSERT INTO sessions (id, agent, started_at, ended_at, summary) VALUES (?, 'claude-code', ?, ?, ?)",
+      [sessionId, firstCommit.date, lastCommit.date, summary]
+    );
+    sessionsCreated++;
+    const filesInSession = /* @__PURE__ */ new Map();
+    for (const commit of sessionCommits) {
+      for (const file of commit.filesChanged) {
+        const existing = filesInSession.get(file.path);
+        if (!existing) {
+          filesInSession.set(file.path, { ...file });
+        } else {
+          existing.insertions += file.insertions;
+          existing.deletions += file.deletions;
+          if (file.operation === "deleted") existing.operation = "deleted";
+        }
+      }
+    }
+    for (const [, file] of filesInSession) {
+      db.run(
+        "INSERT INTO files_modified (session_id, path, operation, lines_changed) VALUES (?, ?, ?, ?)",
+        [
+          sessionId,
+          file.path,
+          file.operation,
+          file.insertions + file.deletions
+        ]
+      );
+    }
+  }
+  saveDb();
+  return { sessionsCreated, featuresImported };
+}
+
+// src/commands/init.ts
+var PRE_SESSION_HOOK = `#!/bin/bash
+# groundctl \u2014 pre-session hook for Claude Code
+# Reads product state before the agent starts working
+
+groundctl sync 2>/dev/null
+if [ -f PROJECT_STATE.md ]; then
+  echo "--- groundctl: Product state loaded ---"
+  cat PROJECT_STATE.md
+fi
+if [ -f AGENTS.md ]; then
+  cat AGENTS.md
+fi
+`;
+var POST_SESSION_HOOK = `#!/bin/bash
+# groundctl \u2014 post-session hook for Claude Code
+# Updates product state after the agent finishes
+
+set -euo pipefail
+
+if ! command -v groundctl &>/dev/null; then
+  exit 0
+fi
+
+groundctl ingest \\
+  --source claude-code \\
+  \${CLAUDE_SESSION_ID:+--session-id "$CLAUDE_SESSION_ID"} \\
+  \${CLAUDE_TRANSCRIPT_PATH:+--transcript "$CLAUDE_TRANSCRIPT_PATH"} \\
+  --project-path "$PWD" \\
+  --no-sync 2>/dev/null || true
+
+groundctl sync 2>/dev/null || true
+echo "--- groundctl: Product state updated ---"
+`;
+async function initCommand(options) {
+  const cwd = process.cwd();
+  const projectName = cwd.split("/").pop() ?? "unknown";
+  console.log(chalk.bold(`
+groundctl init \u2014 ${projectName}
+`));
+  console.log(chalk.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"));
+    } else {
+      console.log(chalk.gray("  Importing from git history..."));
+      const result = importFromGit(db, cwd);
+      console.log(
+        chalk.green(
+          `  \u2713 Git import: ${result.sessionsCreated} sessions, ${result.featuresImported} features`
+        )
+      );
+    }
+  }
+  const projectState = generateProjectState(db, projectName);
+  const agentsMd = generateAgentsMd(db, projectName);
+  closeDb();
+  console.log(chalk.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);
+  chmodSync(join3(claudeHooksDir, "pre-session.sh"), 493);
+  writeFileSync2(join3(claudeHooksDir, "post-session.sh"), POST_SESSION_HOOK);
+  chmodSync(join3(claudeHooksDir, "post-session.sh"), 493);
+  console.log(chalk.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);
+  chmodSync(join3(codexHooksDir, "pre-session.sh"), 493);
+  writeFileSync2(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"));
+  const gitignorePath = join3(cwd, ".gitignore");
+  const gitignoreEntry = "\n# groundctl local state\n.groundctl/\n";
+  if (existsSync3(gitignorePath)) {
+    const content = readFileSync3(gitignorePath, "utf-8");
+    if (!content.includes(".groundctl/")) {
+      appendFileSync(gitignorePath, gitignoreEntry);
+    }
+  }
+  console.log(chalk.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"));
+  } else {
+    console.log(chalk.gray("  Next steps:"));
+    console.log(chalk.gray("    groundctl status"));
+    console.log(chalk.gray("    groundctl next\n"));
+  }
+}
+
+// src/commands/status.ts
+import chalk2 from "chalk";
+function progressBar(done, total, width = 20) {
+  if (total === 0) return chalk2.gray("\u2591".repeat(width));
+  const filled = Math.round(done / total * width);
+  const empty = width - filled;
+  return chalk2.green("\u2588".repeat(filled)) + chalk2.gray("\u2591".repeat(empty));
+}
+async function statusCommand() {
+  const db = await openDb();
+  const projectName = process.cwd().split("/").pop() ?? "unknown";
+  const statusCounts = query(
+    db,
+    "SELECT status, COUNT(*) as count FROM features GROUP BY status"
+  );
+  const counts = {
+    pending: 0,
+    in_progress: 0,
+    done: 0,
+    blocked: 0
+  };
+  for (const row of statusCounts) {
+    counts[row.status] = row.count;
+  }
+  const total = counts.pending + counts.in_progress + counts.done + counts.blocked;
+  const activeClaims = query(
+    db,
+    `SELECT c.feature_id, f.name as feature_name, c.session_id, c.claimed_at
+     FROM claims c
+     JOIN features f ON c.feature_id = f.id
+     WHERE c.released_at IS NULL`
+  );
+  const available = query(
+    db,
+    `SELECT f.id, f.name, f.priority
+     FROM features f
+     WHERE f.status = 'pending'
+     AND f.id NOT IN (SELECT feature_id FROM claims WHERE released_at IS NULL)
+     ORDER BY
+       CASE f.priority
+         WHEN 'critical' THEN 0
+         WHEN 'high' THEN 1
+         WHEN 'medium' THEN 2
+         WHEN 'low' THEN 3
+       END`
+  );
+  const sessionCount = queryOne(
+    db,
+    "SELECT COUNT(*) as count FROM sessions"
+  )?.count ?? 0;
+  closeDb();
+  console.log("");
+  if (total === 0) {
+    console.log(chalk2.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"));
+    return;
+  }
+  const pct = total > 0 ? Math.round(counts.done / total * 100) : 0;
+  console.log(
+    chalk2.bold(`  ${projectName} \u2014 ${pct}% implemented`) + chalk2.gray(` (${sessionCount} sessions)`)
+  );
+  console.log("");
+  console.log(
+    `  Features  ${progressBar(counts.done, total)}  ${counts.done}/${total} done`
+  );
+  if (counts.in_progress > 0) {
+    console.log(chalk2.yellow(`            ${counts.in_progress} in progress`));
+  }
+  if (counts.blocked > 0) {
+    console.log(chalk2.red(`            ${counts.blocked} blocked`));
+  }
+  console.log("");
+  if (activeClaims.length > 0) {
+    console.log(chalk2.bold("  Claimed:"));
+    for (const claim of activeClaims) {
+      const elapsed = timeSince(claim.claimed_at);
+      console.log(
+        chalk2.yellow(`    \u25CF ${claim.feature_name} \u2192 session ${claim.session_id} (${elapsed})`)
+      );
+    }
+    console.log("");
+  }
+  if (available.length > 0) {
+    console.log(chalk2.bold("  Available:"));
+    for (const feat of available.slice(0, 5)) {
+      const pColor = feat.priority === "critical" || feat.priority === "high" ? chalk2.red : chalk2.gray;
+      console.log(`    \u25CB ${feat.name} ${pColor(`(${feat.priority})`)}`);
+    }
+    if (available.length > 5) {
+      console.log(chalk2.gray(`    ... and ${available.length - 5} more`));
+    }
+    console.log("");
+  }
+}
+function timeSince(isoDate) {
+  const then = (/* @__PURE__ */ new Date(isoDate + "Z")).getTime();
+  const now = Date.now();
+  const diffMs = now - then;
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  const remainMins = mins % 60;
+  return `${hours}h${remainMins > 0 ? String(remainMins).padStart(2, "0") : ""}`;
+}
+
+// src/commands/claim.ts
+import chalk3 from "chalk";
+import { randomUUID } from "crypto";
+async function claimCommand(featureIdOrName, options) {
+  const db = await openDb();
+  const feature = queryOne(
+    db,
+    `SELECT id, name, status FROM features
+     WHERE id = ? OR name = ? OR name LIKE ?`,
+    [featureIdOrName, featureIdOrName, `%${featureIdOrName}%`]
+  );
+  if (!feature) {
+    console.log(chalk3.red(`
+  Feature "${featureIdOrName}" not found.
+`));
+    console.log(chalk3.gray("  Add it with: groundctl add feature -n '" + featureIdOrName + "'"));
+    closeDb();
+    process.exit(1);
+  }
+  if (feature.status === "done") {
+    console.log(chalk3.yellow(`
+  Feature "${feature.name}" is already done.
+`));
+    closeDb();
+    return;
+  }
+  const existingClaim = queryOne(
+    db,
+    `SELECT session_id, claimed_at FROM claims
+     WHERE feature_id = ? AND released_at IS NULL`,
+    [feature.id]
+  );
+  if (existingClaim) {
+    console.log(
+      chalk3.red(`
+  Feature "${feature.name}" is already claimed by session ${existingClaim.session_id}`)
+    );
+    const alternatives = query(
+      db,
+      `SELECT id, name FROM features
+       WHERE status = 'pending'
+       AND id NOT IN (SELECT feature_id FROM claims WHERE released_at IS NULL)
+       ORDER BY CASE priority
+         WHEN 'critical' THEN 0 WHEN 'high' THEN 1
+         WHEN 'medium' THEN 2 WHEN 'low' THEN 3
+       END
+       LIMIT 3`
+    );
+    if (alternatives.length > 0) {
+      console.log(chalk3.gray("\n  Available instead:"));
+      for (const alt of alternatives) {
+        console.log(chalk3.gray(`    \u25CB ${alt.name}`));
+      }
+    }
+    console.log("");
+    closeDb();
+    process.exit(1);
+  }
+  const sessionId = options.session ?? randomUUID().slice(0, 8);
+  const sessionExists = queryOne(
+    db,
+    "SELECT id FROM sessions WHERE id = ?",
+    [sessionId]
+  );
+  if (!sessionExists) {
+    db.run(
+      "INSERT INTO sessions (id, agent, started_at) VALUES (?, 'claude-code', datetime('now'))",
+      [sessionId]
+    );
+  }
+  db.run(
+    "INSERT INTO claims (feature_id, session_id) VALUES (?, ?)",
+    [feature.id, sessionId]
+  );
+  db.run(
+    "UPDATE features SET status = 'in_progress', session_claimed = ?, claimed_at = datetime('now'), updated_at = datetime('now') WHERE id = ?",
+    [sessionId, feature.id]
+  );
+  saveDb();
+  closeDb();
+  console.log(
+    chalk3.green(`
+  \u2713 Claimed "${feature.name}" \u2192 session ${sessionId}
+`)
+  );
+}
+async function completeCommand(featureIdOrName) {
+  const db = await openDb();
+  const feature = queryOne(
+    db,
+    `SELECT id, name, status FROM features
+     WHERE id = ? OR name = ? OR name LIKE ?`,
+    [featureIdOrName, featureIdOrName, `%${featureIdOrName}%`]
+  );
+  if (!feature) {
+    console.log(chalk3.red(`
+  Feature "${featureIdOrName}" not found.
+`));
+    closeDb();
+    process.exit(1);
+  }
+  db.run(
+    "UPDATE claims SET released_at = datetime('now') WHERE feature_id = ? AND released_at IS NULL",
+    [feature.id]
+  );
+  db.run(
+    "UPDATE features SET status = 'done', completed_at = datetime('now'), updated_at = datetime('now') WHERE id = ?",
+    [feature.id]
+  );
+  saveDb();
+  closeDb();
+  console.log(chalk3.green(`
+  \u2713 Completed "${feature.name}"
+`));
+}
+
+// src/commands/sync.ts
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import chalk4 from "chalk";
+async function syncCommand() {
+  const db = await openDb();
+  const projectName = process.cwd().split("/").pop() ?? "unknown";
+  const projectState = generateProjectState(db, projectName);
+  const agentsMd = generateAgentsMd(db, projectName);
+  closeDb();
+  const cwd = process.cwd();
+  writeFileSync3(join4(cwd, "PROJECT_STATE.md"), projectState);
+  writeFileSync3(join4(cwd, "AGENTS.md"), agentsMd);
+  console.log(chalk4.green("\n  \u2713 PROJECT_STATE.md regenerated"));
+  console.log(chalk4.green("  \u2713 AGENTS.md regenerated\n"));
+}
+
+// src/commands/next.ts
+import chalk5 from "chalk";
+async function nextCommand() {
+  const db = await openDb();
+  const available = query(
+    db,
+    `SELECT f.id, f.name, f.priority, f.description
+     FROM features f
+     WHERE f.status = 'pending'
+     AND f.id NOT IN (SELECT feature_id FROM claims WHERE released_at IS NULL)
+     ORDER BY
+       CASE f.priority
+         WHEN 'critical' THEN 0
+         WHEN 'high' THEN 1
+         WHEN 'medium' THEN 2
+         WHEN 'low' THEN 3
+       END
+     LIMIT 5`
+  );
+  closeDb();
+  if (available.length === 0) {
+    console.log(chalk5.yellow("\n  No available features to claim.\n"));
+    return;
+  }
+  console.log(chalk5.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") : " ";
+    console.log(`  ${marker} ${feat.name} ${pColor(`(${feat.priority})`)}`);
+    if (feat.description) {
+      console.log(chalk5.gray(`      ${feat.description}`));
+    }
+  }
+  console.log(chalk5.gray(`
+  Claim with: groundctl claim "${available[0].name}"
+`));
+}
+
+// src/commands/log.ts
+import chalk6 from "chalk";
+async function logCommand(options) {
+  const db = await openDb();
+  if (options.session) {
+    const session = queryOne(db, "SELECT * FROM sessions WHERE id = ? OR id LIKE ?", [
+      options.session,
+      `%${options.session}%`
+    ]);
+    if (!session) {
+      console.log(chalk6.red(`
+  Session "${options.session}" not found.
+`));
+      closeDb();
+      return;
+    }
+    console.log(chalk6.bold(`
+  Session ${session.id}`));
+    console.log(chalk6.gray(`  Agent: ${session.agent}`));
+    console.log(chalk6.gray(`  Started: ${session.started_at}`));
+    if (session.ended_at) {
+      console.log(chalk6.gray(`  Ended: ${session.ended_at}`));
+    }
+    if (session.summary) {
+      console.log(`
+  ${session.summary}`);
+    }
+    const decisions = query(
+      db,
+      "SELECT description, rationale FROM decisions WHERE session_id = ?",
+      [session.id]
+    );
+    if (decisions.length > 0) {
+      console.log(chalk6.bold("\n  Decisions:"));
+      for (const d of decisions) {
+        console.log(`    \u2022 ${d.description}`);
+        if (d.rationale) {
+          console.log(chalk6.gray(`      ${d.rationale}`));
+        }
+      }
+    }
+    const files = query(
+      db,
+      "SELECT path, operation, lines_changed FROM files_modified WHERE session_id = ? ORDER BY created_at",
+      [session.id]
+    );
+    if (files.length > 0) {
+      console.log(chalk6.bold(`
+  Files modified (${files.length}):`));
+      for (const f of files) {
+        const op = f.operation === "created" ? chalk6.green("+") : f.operation === "deleted" ? chalk6.red("-") : chalk6.yellow("~");
+        console.log(`    ${op} ${f.path} (${f.lines_changed} lines)`);
+      }
+    }
+    console.log("");
+  } 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"));
+      closeDb();
+      return;
+    }
+    console.log(chalk6.bold("\n  Session timeline:\n"));
+    for (const s of sessions) {
+      const status = s.ended_at ? chalk6.green("done") : chalk6.yellow("active");
+      console.log(
+        `  ${chalk6.bold(s.id)}  ${chalk6.gray(s.started_at)}  ${status}  ${chalk6.gray(s.agent)}`
+      );
+      if (s.summary) {
+        console.log(chalk6.gray(`    ${s.summary}`));
+      }
+    }
+    console.log("");
+  }
+  closeDb();
+}
+
+// src/commands/add.ts
+import chalk7 from "chalk";
+import { randomUUID as randomUUID2 } from "crypto";
+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"));
+      closeDb();
+      process.exit(1);
+    }
+    const id = options.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const priority = options.priority ?? "medium";
+    db.run(
+      "INSERT INTO features (id, name, priority, description) VALUES (?, ?, ?, ?)",
+      [id, options.name, priority, options.description ?? null]
+    );
+    saveDb();
+    closeDb();
+    console.log(chalk7.green(`
+  \u2713 Feature added: ${options.name} (${priority})
+`));
+  } else if (type === "session") {
+    const id = options.name ?? randomUUID2().slice(0, 8);
+    const agent = options.agent ?? "claude-code";
+    db.run("INSERT INTO sessions (id, agent) VALUES (?, ?)", [id, agent]);
+    saveDb();
+    closeDb();
+    console.log(chalk7.green(`
+  \u2713 Session created: ${id} (${agent})
+`));
+  } else {
+    console.log(chalk7.red(`
+  Unknown type "${type}". Use "feature" or "session".
+`));
+    closeDb();
+    process.exit(1);
+  }
+}
+
+// src/commands/ingest.ts
+import { existsSync as existsSync4, readdirSync } from "fs";
+import { join as join5, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import chalk8 from "chalk";
+
+// src/ingest/claude-parser.ts
+import { readFileSync as readFileSync4 } from "fs";
+var DECISION_PATTERNS = [
+  /\bI(?:'m going to| decided| chose| picked| went with| opted for)\b(.{10,120})/i,
+  /\bgoing with\b(.{5,100})/i,
+  /\bchose?\s+(\w[\w\s-]+)\s+(?:over|instead of|rather than)\b(.{0,80})/i,
+  /\btradeoff[:\s]+(.{10,120})/i,
+  /\bdecision[:\s]+(.{10,120})/i,
+  /\brationale[:\s]+(.{10,120})/i,
+  /\bbecause\s+(.{10,100})\s+(?:—|\.)/i,
+  /\bswitched?\s+(?:from\s+\S+\s+)?to\s+(.{5,80})\s+(?:—|because|since|for)/i
+];
+var PROJECT_PATH_RE = /^\/[^\s'"]+\.[a-zA-Z0-9]{1,10}$/;
+function isFilePath(s) {
+  return PROJECT_PATH_RE.test(s) && !s.includes("*") && !s.includes("?");
+}
+function countContentLines(content) {
+  return content.split("\n").length;
+}
+function parseTranscript(transcriptPath, sessionId, projectPath) {
+  const raw = readFileSync4(transcriptPath, "utf-8");
+  const lines = raw.split("\n").filter((l) => l.trim());
+  const parsed = [];
+  for (const line of lines) {
+    try {
+      parsed.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  const timestamps = [];
+  for (const entry of parsed) {
+    if (entry.timestamp) timestamps.push(entry.timestamp);
+  }
+  const startedAt = timestamps[0] ?? (/* @__PURE__ */ new Date()).toISOString();
+  const endedAt = timestamps[timestamps.length - 1] ?? (/* @__PURE__ */ new Date()).toISOString();
+  const toolResults = /* @__PURE__ */ new Map();
+  for (const entry of parsed) {
+    if (entry.type !== "user") continue;
+    const content = entry.message?.content ?? [];
+    for (const block of content) {
+      if (block.type === "tool_result") {
+        toolResults.set(block.tool_use_id, block);
+      }
+    }
+  }
+  const filesMap = /* @__PURE__ */ new Map();
+  const commits = [];
+  const decisions = [];
+  let lastAssistantText = "";
+  for (const entry of parsed) {
+    if (entry.type !== "assistant") continue;
+    const content = entry.message?.content ?? [];
+    for (const block of content) {
+      if (block.type === "text") {
+        const text = block.text;
+        if (text.length > 20) {
+          lastAssistantText = text;
+          extractDecisions(text, decisions);
+        }
+      }
+      if (block.type === "tool_use") {
+        const tool = block;
+        const result = toolResults.get(tool.id);
+        const succeeded = result ? !result.is_error : true;
+        if (tool.name === "Write") {
+          const filePath = tool.input.file_path;
+          if (filePath && isFilePath(filePath)) {
+            const content2 = tool.input.content;
+            const lines2 = content2 ? countContentLines(content2) : 0;
+            const rel = relativePath(filePath, projectPath);
+            if (!filesMap.has(rel)) {
+              filesMap.set(rel, {
+                path: rel,
+                operation: "created",
+                linesChanged: lines2
+              });
+            }
+          }
+        }
+        if (tool.name === "Edit" && succeeded) {
+          const filePath = tool.input.file_path;
+          if (filePath && isFilePath(filePath)) {
+            const rel = relativePath(filePath, projectPath);
+            const existing = filesMap.get(rel);
+            const oldStr = tool.input.old_string;
+            const newStr = tool.input.new_string;
+            const lines2 = Math.max(
+              oldStr ? countContentLines(oldStr) : 0,
+              newStr ? countContentLines(newStr) : 0
+            );
+            if (existing) {
+              existing.linesChanged += lines2;
+            } else {
+              filesMap.set(rel, {
+                path: rel,
+                operation: "modified",
+                linesChanged: lines2
+              });
+            }
+          }
+        }
+        if (tool.name === "Bash") {
+          const command = tool.input.command;
+          if (!command) continue;
+          if (succeeded && command.includes("git commit")) {
+            const msg = extractCommitMessage(command);
+            if (msg) {
+              commits.push({ message: msg, command: command.slice(0, 100) });
+            }
+          }
+          if (succeeded) {
+            extractBashFileOps(command, filesMap, projectPath);
+          }
+        }
+      }
+    }
+  }
+  const seenDecisions = /* @__PURE__ */ new Set();
+  const uniqueDecisions = decisions.filter((d) => {
+    const key = d.description.slice(0, 40).toLowerCase();
+    if (seenDecisions.has(key)) return false;
+    seenDecisions.add(key);
+    return true;
+  });
+  const summary = buildSummary(
+    sessionId,
+    filesMap.size,
+    commits.length,
+    uniqueDecisions.length,
+    lastAssistantText
+  );
+  return {
+    sessionId,
+    startedAt,
+    endedAt,
+    filesModified: Array.from(filesMap.values()),
+    commits,
+    decisions: uniqueDecisions,
+    summary,
+    agent: "claude-code"
+  };
+}
+function relativePath(abs, projectPath) {
+  if (!projectPath) return abs;
+  if (abs.startsWith(projectPath)) {
+    return abs.slice(projectPath.length).replace(/^\//, "");
+  }
+  return abs;
+}
+function extractCommitMessage(command) {
+  const heredocMatch = command.match(/git commit -m "\$\(cat <<'EOF'\n([\s\S]+?)\nEOF/);
+  if (heredocMatch) {
+    return heredocMatch[1].split("\n")[0].trim();
+  }
+  const simpleMatch = command.match(/git commit -m ["']([^"']+)["']/);
+  if (simpleMatch) return simpleMatch[1].trim();
+  const mMatch = command.match(/git commit.*?-m\s+"([^"]+)"/);
+  if (mMatch) return mMatch[1].trim();
+  return null;
+}
+function extractBashFileOps(command, filesMap, projectPath) {
+  const rmMatches = command.matchAll(/\brm\s+(?:-[rf]+\s+)?([^\s;&|]+\.[a-zA-Z0-9]+)/g);
+  for (const m of rmMatches) {
+    if (isFilePath(m[1])) {
+      const rel = relativePath(m[1], projectPath);
+      filesMap.set(rel, { path: rel, operation: "deleted", linesChanged: 0 });
+    }
+  }
+}
+var SKIP_DECISION_PHRASES = /* @__PURE__ */ new Set([
+  "i decided to read",
+  "i decided to check",
+  "i decided to look",
+  "i'm going to read",
+  "i'm going to check",
+  "i'm going to look",
+  "i'm going to run",
+  "i'm going to use",
+  "let me",
+  "going with npm"
+]);
+function extractDecisions(text, decisions) {
+  for (const pattern of DECISION_PATTERNS) {
+    const matches = text.matchAll(new RegExp(pattern.source, "gi"));
+    for (const m of matches) {
+      const raw = m[1]?.trim() ?? "";
+      if (raw.length < 10 || raw.length > 200) continue;
+      const lower = raw.toLowerCase();
+      if (SKIP_DECISION_PHRASES.has(lower.slice(0, 30))) continue;
+      if (lower.startsWith("the ") && lower.length < 20) continue;
+      if (/^(it|this|that|to |the file|a |an )/.test(lower) && lower.length < 25) continue;
+      const matchIndex = m.index ?? 0;
+      const surrounding = text.slice(
+        Math.max(0, matchIndex + m[0].length),
+        Math.min(text.length, matchIndex + m[0].length + 200)
+      );
+      const rationale = extractRationale(surrounding);
+      decisions.push({
+        description: clean(raw),
+        rationale,
+        confidence: rationale ? "high" : "low"
+      });
+      if (decisions.length >= 20) return;
+    }
+  }
+}
+function extractRationale(text) {
+  const match = text.match(
+    /^[^.!?]*(?:because|since|—|:)\s*([^.!?\n]{15,120})/i
+  );
+  if (match) return clean(match[1]);
+  const first = text.split(/[.!?\n]/)[0]?.trim();
+  if (first && first.length > 15 && first.length < 120 && !first.match(/^(Let|I |Now|Next|This )/)) {
+    return clean(first);
+  }
+  return null;
+}
+function clean(s) {
+  return s.replace(/\s+/g, " ").replace(/^[.,;:\-—\s]+/, "").replace(/[.,;:\-—\s]+$/, "").trim();
+}
+function buildSummary(sessionId, fileCount, commitCount, decisionCount, lastText) {
+  const firstLine = lastText.split("\n")[0]?.trim() ?? "";
+  if (firstLine.length > 20 && firstLine.length < 200 && !firstLine.includes("```")) {
+    return firstLine;
+  }
+  return `Session ${sessionId}: ${fileCount} files, ${commitCount} commits, ${decisionCount} decisions`;
+}
+
+// src/commands/ingest.ts
+function findLatestTranscript(projectPath) {
+  const projectsDir = join5(homedir2(), ".claude", "projects");
+  if (!existsSync4(projectsDir)) return null;
+  const projectKey = projectPath.replace(/\//g, "-");
+  let transcriptDir = null;
+  const directMatch = join5(projectsDir, projectKey);
+  if (existsSync4(directMatch)) {
+    transcriptDir = directMatch;
+  } else {
+    const projectName = projectPath.split("/").pop() ?? "";
+    const dirs = readdirSync(projectsDir);
+    for (const d of dirs) {
+      if (d.endsWith(`-${projectName}`) || d.includes(projectName.replace(/\//g, "-"))) {
+        transcriptDir = join5(projectsDir, d);
+        break;
+      }
+    }
+  }
+  if (!transcriptDir || !existsSync4(transcriptDir)) return null;
+  const jsonlFiles = readdirSync(transcriptDir).filter((f) => f.endsWith(".jsonl")).map((f) => ({
+    name: f,
+    path: join5(transcriptDir, f)
+  }));
+  if (jsonlFiles.length === 0) return null;
+  jsonlFiles.sort((a, b) => b.name.localeCompare(a.name));
+  return jsonlFiles[0].path;
+}
+async function ingestCommand(options) {
+  const projectPath = options.projectPath ? resolve(options.projectPath) : process.cwd();
+  const source = options.source ?? "claude-code";
+  let transcriptPath = options.transcript;
+  if (!transcriptPath) {
+    transcriptPath = findLatestTranscript(projectPath) ?? void 0;
+  }
+  if (!transcriptPath || !existsSync4(transcriptPath)) {
+    console.log(chalk8.yellow("\n  No transcript found. Skipping ingest.\n"));
+    if (!options.noSync) await syncCommand();
+    return;
+  }
+  console.log(chalk8.gray(`
+  Parsing transcript: ${transcriptPath.split("/").slice(-2).join("/")}`));
+  const parsed = parseTranscript(transcriptPath, options.sessionId ?? "auto", projectPath);
+  const db = await openDb();
+  const sessionId = options.sessionId ?? parsed.sessionId;
+  const sessionExists = queryOne(db, "SELECT id FROM sessions WHERE id = ?", [sessionId]);
+  if (sessionExists) {
+    db.run(
+      "UPDATE sessions SET ended_at = ?, summary = ? WHERE id = ?",
+      [parsed.endedAt, parsed.summary, sessionId]
+    );
+  } else {
+    db.run(
+      "INSERT INTO sessions (id, agent, started_at, ended_at, summary) VALUES (?, ?, ?, ?, ?)",
+      [sessionId, source, parsed.startedAt, parsed.endedAt, parsed.summary]
+    );
+  }
+  let newFiles = 0;
+  for (const file of parsed.filesModified) {
+    const exists = queryOne(
+      db,
+      "SELECT id FROM files_modified WHERE session_id = ? AND path = ?",
+      [sessionId, file.path]
+    );
+    if (!exists) {
+      db.run(
+        "INSERT INTO files_modified (session_id, path, operation, lines_changed) VALUES (?, ?, ?, ?)",
+        [sessionId, file.path, file.operation, file.linesChanged]
+      );
+      newFiles++;
+    }
+  }
+  let newDecisions = 0;
+  for (const d of parsed.decisions) {
+    const exists = queryOne(
+      db,
+      "SELECT id FROM decisions WHERE session_id = ? AND description = ?",
+      [sessionId, d.description]
+    );
+    if (!exists) {
+      db.run(
+        "INSERT INTO decisions (session_id, description, rationale) VALUES (?, ?, ?)",
+        [sessionId, d.description, d.rationale ?? null]
+      );
+      newDecisions++;
+    }
+  }
+  saveDb();
+  closeDb();
+  console.log(
+    chalk8.green(
+      `  \u2713 Ingested session ${sessionId}: ${newFiles} files, ${parsed.commits.length} commits, ${newDecisions} decisions`
+    )
+  );
+  if (parsed.decisions.length > 0 && newDecisions > 0) {
+    console.log(chalk8.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}`));
+    }
+  }
+  if (!options.noSync) {
+    console.log("");
+    await syncCommand();
+  }
+}
+
+// src/commands/report.ts
+import { writeFileSync as writeFileSync4 } from "fs";
+import { join as join6 } from "path";
+import chalk9 from "chalk";
+function formatDuration(start, end) {
+  if (!end) return "ongoing";
+  const startMs = new Date(start).getTime();
+  const endMs = new Date(end).getTime();
+  if (isNaN(startMs) || isNaN(endMs)) return "unknown";
+  const ms = endMs - startMs;
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 60) return `${mins}min`;
+  const h = Math.floor(mins / 60);
+  const m = mins % 60;
+  return m > 0 ? `${h}h${m}min` : `${h}h`;
+}
+function buildSessionReport(sessionRow, files, decisions, completedFeatures, nextAvailable, activeClaims) {
+  const date = sessionRow.started_at.slice(0, 10);
+  const duration = formatDuration(sessionRow.started_at, sessionRow.ended_at);
+  let md = `# Session ${sessionRow.id} \u2014 ${date}
+`;
+  md += `Date: ${date} | Duration: ${duration} | Agent: ${sessionRow.agent}
+
+`;
+  if (sessionRow.summary) {
+    md += `## Summary
+${sessionRow.summary}
+
+`;
+  }
+  if (completedFeatures.length > 0) {
+    md += "## What was built\n";
+    for (const f of completedFeatures) {
+      md += `- ${f.name}
+`;
+    }
+    md += "\n";
+  }
+  if (files.length > 0) {
+    const created = files.filter((f) => f.operation === "created");
+    const modified = files.filter((f) => f.operation === "modified");
+    const deleted = files.filter((f) => f.operation === "deleted");
+    md += `## Files touched (${files.length})
+`;
+    for (const f of created) {
+      md += `- ${f.path} (created, ${f.lines_changed} lines)
+`;
+    }
+    for (const f of modified) {
+      md += `- ${f.path} (modified, ${f.lines_changed} lines)
+`;
+    }
+    for (const f of deleted) {
+      md += `- ${f.path} (deleted)
+`;
+    }
+    md += "\n";
+  }
+  if (decisions.length > 0) {
+    md += "## Decisions\n";
+    for (const d of decisions) {
+      md += `- ${d.description}`;
+      if (d.rationale) md += ` \u2014 ${d.rationale}`;
+      md += "\n";
+    }
+    md += "\n";
+  }
+  if (activeClaims.length > 0) {
+    md += "## In progress\n";
+    for (const c of activeClaims) {
+      md += `- ${c.feature_name} (session ${c.session_id})
+`;
+    }
+    md += "\n";
+  }
+  if (nextAvailable.length > 0) {
+    md += "## Next available\n";
+    for (const f of nextAvailable.slice(0, 5)) {
+      md += `- feature/${f.name.toLowerCase().replace(/\s+/g, "-")}
+`;
+    }
+    md += "\n";
+  }
+  return md;
+}
+async function reportCommand(options) {
+  const db = await openDb();
+  const cwd = process.cwd();
+  let sessions;
+  if (options.all) {
+    sessions = query(db, "SELECT * FROM sessions ORDER BY started_at");
+  } else if (options.session) {
+    const s = queryOne(
+      db,
+      "SELECT * FROM sessions WHERE id = ? OR id LIKE ?",
+      [options.session, `%${options.session}%`]
+    );
+    if (!s) {
+      console.log(chalk9.red(`
+  Session "${options.session}" not found.
+`));
+      closeDb();
+      return;
+    }
+    sessions = [s];
+  } else {
+    const s = queryOne(
+      db,
+      "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"));
+      closeDb();
+      return;
+    }
+    sessions = [s];
+  }
+  const nextAvailable = query(
+    db,
+    `SELECT name, status FROM features
+     WHERE status = 'pending'
+     AND id NOT IN (SELECT feature_id FROM claims WHERE released_at IS NULL)
+     ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1
+       WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END
+     LIMIT 5`
+  );
+  const activeClaims = query(
+    db,
+    `SELECT f.name as feature_name, c.session_id
+     FROM claims c JOIN features f ON c.feature_id = f.id
+     WHERE c.released_at IS NULL`
+  );
+  closeDb();
+  if (options.all) {
+    const allDb = await openDb();
+    let fullReport = `# Session History
+
+`;
+    for (const s of sessions) {
+      const files2 = query(allDb, "SELECT * FROM files_modified WHERE session_id = ?", [s.id]);
+      const decisions2 = query(allDb, "SELECT description, rationale FROM decisions WHERE session_id = ?", [s.id]);
+      const completedFeatures2 = query(
+        allDb,
+        `SELECT f.name, f.status FROM features f
+         JOIN claims c ON c.feature_id = f.id
+         WHERE c.session_id = ? AND f.status = 'done'`,
+        [s.id]
+      );
+      fullReport += buildSessionReport(s, files2, decisions2, completedFeatures2, nextAvailable, []);
+      fullReport += "---\n\n";
+    }
+    closeDb();
+    const outPath2 = join6(cwd, "SESSION_HISTORY.md");
+    writeFileSync4(outPath2, fullReport);
+    console.log(chalk9.green(`
+  \u2713 SESSION_HISTORY.md written (${sessions.length} sessions)
+`));
+    return;
+  }
+  const db2 = await openDb();
+  const session = sessions[0];
+  const files = query(db2, "SELECT * FROM files_modified WHERE session_id = ?", [session.id]);
+  const decisions = query(db2, "SELECT description, rationale FROM decisions WHERE session_id = ?", [session.id]);
+  const completedFeatures = query(
+    db2,
+    `SELECT f.name, f.status FROM features f
+     JOIN claims c ON c.feature_id = f.id
+     WHERE c.session_id = ? AND f.status = 'done'`,
+    [session.id]
+  );
+  closeDb();
+  const report = buildSessionReport(
+    session,
+    files,
+    decisions,
+    completedFeatures,
+    nextAvailable,
+    activeClaims
+  );
+  const outPath = join6(cwd, "SESSION_REPORT.md");
+  writeFileSync4(outPath, report);
+  console.log(chalk9.green(`
+  \u2713 SESSION_REPORT.md written (session ${session.id})
+`));
+  console.log(chalk9.gray(`  ${files.length} files \xB7 ${decisions.length} decisions \xB7 ${completedFeatures.length} features completed`));
+  console.log("");
+}
+
+// src/commands/health.ts
+import chalk10 from "chalk";
+async function healthCommand() {
+  const db = await openDb();
+  const projectName = process.cwd().split("/").pop() ?? "unknown";
+  const featureCounts = query(
+    db,
+    "SELECT status, COUNT(*) as count FROM features GROUP BY status"
+  );
+  const counts = { pending: 0, in_progress: 0, done: 0, blocked: 0 };
+  for (const row of featureCounts) counts[row.status] = row.count;
+  const total = counts.pending + counts.in_progress + counts.done + counts.blocked;
+  const featurePct = total > 0 ? counts.done / total : 0;
+  const featureScore = Math.round(featurePct * 40);
+  const testFiles = queryOne(
+    db,
+    `SELECT COUNT(*) as count FROM files_modified
+     WHERE path LIKE '%.test.%' OR path LIKE '%.spec.%'
+        OR path LIKE '%/test/%' OR path LIKE '%/tests/%'
+        OR path LIKE '%/__tests__/%'`
+  )?.count ?? 0;
+  const testScore = testFiles > 0 ? Math.min(20, Math.round(testFiles / Math.max(1, total) * 40)) : 0;
+  const decisionCount = queryOne(db, "SELECT COUNT(*) as count FROM decisions")?.count ?? 0;
+  const sessionCount = queryOne(db, "SELECT COUNT(*) as count FROM sessions")?.count ?? 0;
+  const decisionRatio = sessionCount > 0 ? Math.min(1, decisionCount / sessionCount) : 0;
+  const decisionScore = Math.round(decisionRatio * 20);
+  const staleClaims = queryOne(
+    db,
+    `SELECT COUNT(*) as count FROM claims
+     WHERE released_at IS NULL
+     AND datetime(claimed_at, '+24 hours') < datetime('now')`
+  )?.count ?? 0;
+  const claimScore = staleClaims === 0 ? 10 : Math.max(0, 10 - staleClaims * 5);
+  const deployMentions = queryOne(
+    db,
+    `SELECT COUNT(*) as count FROM decisions
+     WHERE lower(description) LIKE '%deploy%'
+        OR lower(description) LIKE '%railway%'
+        OR lower(description) LIKE '%fly.io%'
+        OR lower(description) LIKE '%heroku%'`
+  )?.count ?? 0;
+  const deployFiles = queryOne(
+    db,
+    `SELECT COUNT(*) as count FROM files_modified
+     WHERE lower(path) LIKE '%railway%' OR lower(path) LIKE '%fly.toml%'
+        OR lower(path) LIKE '%heroku%' OR lower(path) LIKE 'procfile%'
+        OR lower(path) LIKE '%dockerfile%' OR lower(path) LIKE '%deploy%'`
+  )?.count ?? 0;
+  const deployScore = deployMentions > 0 || deployFiles > 0 ? 10 : 0;
+  closeDb();
+  const totalScore = featureScore + testScore + decisionScore + claimScore + deployScore;
+  console.log("");
+  console.log(chalk10.bold(`  ${projectName} \u2014 Health Score: ${totalScore}/100
+`));
+  const featureColor = featurePct >= 0.7 ? chalk10.green : featurePct >= 0.4 ? chalk10.yellow : chalk10.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`)
+  );
+  const testMark = testFiles > 0 ? "\u2705" : "\u26A0\uFE0F ";
+  const testColor = testFiles > 0 ? chalk10.green : chalk10.red;
+  console.log(
+    `  ${testMark} Tests       ${testColor(String(testFiles) + " test files")}` + (testFiles === 0 ? chalk10.red("  (-20pts)") : chalk10.gray(`  +${testScore}pts`))
+  );
+  const decMark = decisionCount > 0 ? "\u2705" : "\u26A0\uFE0F ";
+  const decColor = decisionCount > 0 ? chalk10.green : chalk10.yellow;
+  console.log(
+    `  ${decMark} Decisions   ${decColor(decisionCount + " documented")}` + chalk10.gray(`  +${decisionScore}pts`)
+  );
+  const claimMark = staleClaims === 0 ? "\u2705" : "\u26A0\uFE0F ";
+  const claimColor = staleClaims === 0 ? chalk10.green : chalk10.red;
+  console.log(
+    `  ${claimMark} Claims      ${claimColor(staleClaims > 0 ? staleClaims + " stale (>24h)" : "0 stale")}` + chalk10.gray(`  +${claimScore}pts`)
+  );
+  const deployMark = deployScore > 0 ? "\u2705" : "\u26A0\uFE0F ";
+  const deployLabel = deployScore > 0 ? chalk10.green("detected") : chalk10.gray("not detected");
+  console.log(
+    `  ${deployMark} Deploy      ${deployLabel}` + (deployScore > 0 ? chalk10.gray(`  +${deployScore}pts`) : chalk10.gray("  +0pts"))
+  );
+  console.log("");
+  const recommendations = [];
+  if (testFiles === 0) recommendations.push("Write tests before your next feature (0 test files found).");
+  if (staleClaims > 0) recommendations.push(`Release ${staleClaims} stale claim(s) with groundctl complete <feature>.`);
+  if (decisionCount === 0) recommendations.push("Document decisions during sessions so agents have context.");
+  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:"));
+    for (const r of recommendations) {
+      console.log(chalk10.yellow(`    \u2192 ${r}`));
+    }
+    console.log("");
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("groundctl").description("The shared memory your agents and you actually need.").version("0.1.0");
+program.command("init").description("Setup hooks + initial state for the current project").option("--import-from-git", "Bootstrap sessions and features from git history").action((opts) => initCommand({ importFromGit: opts.importFromGit }));
+program.command("status").description("Show macro view of the product state").action(statusCommand);
+program.command("claim <feature>").description("Reserve a feature for the current session").option("-s, --session <id>", "Session ID (auto-generated if omitted)").action(claimCommand);
+program.command("complete <feature>").description("Mark a feature as done and release the claim").action(completeCommand);
+program.command("sync").description("Regenerate PROJECT_STATE.md and AGENTS.md from SQLite").action(syncCommand);
+program.command("next").description("Show next available (unclaimed) feature").action(nextCommand);
+program.command("log").description("Show session timeline").option("-s, --session <id>", "Show details for a specific session").action(logCommand);
+program.command("add <type>").description("Add a feature or session (type: feature, session)").option("-n, --name <name>", "Name").option("-p, --priority <priority>", "Priority (critical, high, medium, low)").option("-d, --description <desc>", "Description").option("--agent <agent>", "Agent type for sessions").action(addCommand);
+program.command("ingest").description("Parse a transcript and write session data to SQLite").option("--source <source>", "Source agent (claude-code, codex)", "claude-code").option("--session-id <id>", "Session ID").option("--transcript <path>", "Path to transcript JSONL file (auto-detected if omitted)").option("--project-path <path>", "Project path (defaults to cwd)").option("--no-sync", "Skip regenerating markdown after ingest").action(
+  (opts) => ingestCommand({
+    source: opts.source,
+    sessionId: opts.sessionId,
+    transcript: opts.transcript,
+    projectPath: opts.projectPath,
+    noSync: !opts.sync
+  })
+);
+program.command("report").description("Generate SESSION_REPORT.md from SQLite").option("-s, --session <id>", "Report for a specific session").option("--all", "Generate report for all sessions").action(reportCommand);
+program.command("health").description("Show product health score").action(healthCommand);
+program.parse();