@primitive.ai/prim 0.1.0-alpha.15 → 0.1.0-alpha.17

package/dist/index.js

@@ -1,20 +1,42 @@
 #!/usr/bin/env node
 import {
+  color,
+  colorForArea,
+  stripAnsi
+} from "./chunk-BEEGFDGU.js";
+import {
+  checkAffectedDecisions,
+  daemonOrDirectGet,
+  formatDecisionsWarning,
+  getGitContext
+} from "./chunk-TPQ3X244.js";
+import {
+  HttpError,
   REFRESH_TOKEN_PATH,
   TOKEN_EXPIRES_PATH,
   TOKEN_FILE_PATH,
   getAuthToken,
   getClient,
-  getGitContext,
   getSiteUrl,
   getTokenExpiresAt,
   saveTokenExpiry
-} from "./chunk-SHLF6OL2.js";
+} from "./chunk-6SIEWWUL.js";
+import {
+  JOURNAL_DIR,
+  SESSIONS_DIR,
+  bucketStats,
+  listBuckets,
+  readMovesFromPath
+} from "./chunk-JZGWQDM5.js";
+import {
+  daemonIsLive,
+  daemonRequest
+} from "./chunk-UTKQTZHL.js";
 
 // src/index.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname3, resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 import updateNotifier from "update-notifier";
 
@@ -112,10 +134,10 @@ function registerAuthCommands(program2) {
         process.exit(1);
       });
     });
-    const port = await new Promise((resolve4) => {
+    const port = await new Promise((resolve5) => {
       server.listen(CALLBACK_PORT, LOCALHOST, () => {
         const addr = server.address();
-        resolve4(typeof addr === "object" && addr ? addr.port : 0);
+        resolve5(typeof addr === "object" && addr ? addr.port : 0);
       });
     });
     const redirectUri = `http://${LOCALHOST}:${port}/callback`;
@@ -256,8 +278,411 @@ async function exchangeCode(siteUrl, code, codeVerifier, redirectUri) {
   return data.access_token;
 }
 
+// src/commands/claude-install.ts
+import {
+  closeSync,
+  existsSync as existsSync2,
+  fsyncSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join } from "path";
+var CAPTURE_COMMAND = "prim-hook";
+var GATE_COMMAND = "prim-pre-tool-use";
+var POST_TOOL_USE_COMMAND = "prim-post-tool-use";
+var SESSION_START_COMMAND = "prim-session-start";
+var SESSION_END_COMMAND = "prim-session-end";
+var STATUSLINE_COMMAND = "prim statusline";
+var STATUSLINE_REFRESH_SECONDS = 5;
+var PRIM_COMMANDS = /* @__PURE__ */ new Set([
+  CAPTURE_COMMAND,
+  GATE_COMMAND,
+  POST_TOOL_USE_COMMAND,
+  SESSION_START_COMMAND,
+  SESSION_END_COMMAND
+]);
+var JSON_INDENT = 2;
+var USER_SCOPE_PATH = join(homedir(), ".claude", "settings.json");
+var PROJECT_SCOPE_PATH = join(process.cwd(), ".claude", "settings.json");
+var CAPTURE_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "SessionEnd",
+  "SubagentStop"
+];
+var REGISTRATIONS = [
+  ...CAPTURE_EVENTS.map((event) => ({ event, matcher: "*", command: CAPTURE_COMMAND })),
+  { event: "PreToolUse", matcher: "Edit|Write|MultiEdit", command: GATE_COMMAND },
+  { event: "PostToolUse", matcher: "Edit|Write|MultiEdit", command: POST_TOOL_USE_COMMAND },
+  { event: "SessionStart", matcher: "*", command: SESSION_START_COMMAND },
+  { event: "SessionEnd", matcher: "*", command: SESSION_END_COMMAND }
+];
+function settingsPathFor(scope) {
+  return scope === "user" ? USER_SCOPE_PATH : PROJECT_SCOPE_PATH;
+}
+function readSettings(path) {
+  if (!existsSync2(path)) {
+    return {};
+  }
+  const raw = readFileSync2(path, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`${path} is not valid JSON: ${detail}`);
+  }
+}
+function entryHasCommand(entry, command) {
+  return entry.hooks?.some((h) => h.command === command) ?? false;
+}
+function canonicalEntry(reg) {
+  return { matcher: reg.matcher, hooks: [{ type: "command", command: reg.command }] };
+}
+function stripCommand(list, command) {
+  const out = [];
+  for (const e of list) {
+    const hooks = (e.hooks ?? []).filter((h) => h.command !== command);
+    if (hooks.length > 0) {
+      out.push({ ...e, hooks });
+    }
+  }
+  return out;
+}
+function ensureRegistration(list, reg, force) {
+  const hasCanonical = list.some(
+    (e) => e.matcher === reg.matcher && e.hooks?.length === 1 && e.hooks[0].command === reg.command
+  );
+  if (hasCanonical && !force) {
+    return list;
+  }
+  return [...stripCommand(list, reg.command), canonicalEntry(reg)];
+}
+function isPrimStatusLine(settings) {
+  const s = settings.statusLine;
+  return s?.type === "command" && s?.command === STATUSLINE_COMMAND;
+}
+function applyStatusLine(settings) {
+  if (settings.statusLine && !isPrimStatusLine(settings)) {
+    return settings;
+  }
+  return {
+    ...settings,
+    statusLine: {
+      type: "command",
+      command: STATUSLINE_COMMAND,
+      refreshInterval: STATUSLINE_REFRESH_SECONDS
+    }
+  };
+}
+function applyInstall(settings, options = {}) {
+  const hooks = { ...settings.hooks ?? {} };
+  for (const reg of REGISTRATIONS) {
+    hooks[reg.event] = ensureRegistration(hooks[reg.event] ?? [], reg, options.force ?? false);
+  }
+  return applyStatusLine({ ...settings, hooks });
+}
+function applyUninstall(settings) {
+  const source = settings.hooks ?? {};
+  const hooks = {};
+  for (const event of Object.keys(source)) {
+    let list = source[event] ?? [];
+    for (const command of PRIM_COMMANDS) {
+      list = stripCommand(list, command);
+    }
+    if (list.length > 0) {
+      hooks[event] = list;
+    }
+  }
+  const next = { ...settings, hooks };
+  if (isPrimStatusLine(next)) {
+    next.statusLine = void 0;
+  }
+  return next;
+}
+function captureInstalled(settings) {
+  return CAPTURE_EVENTS.some(
+    (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_COMMAND))
+  );
+}
+function statuslineInstalled(settings) {
+  return isPrimStatusLine(settings);
+}
+function isGateInstalled(settings) {
+  return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_COMMAND));
+}
+function atomicWrite(path, content) {
+  const dir = dirname2(path);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const tmp = `${path}.tmp.${String(Date.now())}`;
+  writeFileSync2(tmp, `${JSON.stringify(content, null, JSON_INDENT)}
+`, "utf-8");
+  const fd = openSync(tmp, "r+");
+  try {
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(tmp, path);
+}
+function performInstall(scope, force) {
+  const path = settingsPathFor(scope);
+  const before = readSettings(path);
+  const after = applyInstall(before, { force });
+  const changed = JSON.stringify(before) !== JSON.stringify(after);
+  if (changed) {
+    atomicWrite(path, after);
+  }
+  return {
+    scope,
+    path,
+    gate: isGateInstalled(after),
+    capture: captureInstalled(after),
+    statusline: statuslineInstalled(after),
+    changed
+  };
+}
+function performUninstall(scope) {
+  const path = settingsPathFor(scope);
+  const before = readSettings(path);
+  const after = applyUninstall(before);
+  const changed = JSON.stringify(before) !== JSON.stringify(after);
+  if (changed) {
+    atomicWrite(path, after);
+  }
+  return {
+    scope,
+    path,
+    gate: isGateInstalled(after),
+    capture: captureInstalled(after),
+    statusline: statuslineInstalled(after),
+    changed
+  };
+}
+function performStatus() {
+  const statusFor = (path) => {
+    const settings = readSettings(path);
+    return {
+      path,
+      gate: isGateInstalled(settings),
+      capture: captureInstalled(settings),
+      statusline: statuslineInstalled(settings)
+    };
+  };
+  return { user: statusFor(USER_SCOPE_PATH), project: statusFor(PROJECT_SCOPE_PATH) };
+}
+function resolveScope(input) {
+  if (input === void 0 || input === "user") {
+    return "user";
+  }
+  if (input === "project") {
+    return "project";
+  }
+  console.error(`[prim] unknown --scope "${input}" (expected: user or project)`);
+  process.exit(1);
+}
+function registerClaudeCommands(program2) {
+  const claude = program2.command("claude").description("Manage the prim Claude Code integration (capture, gate, ingest, presence)");
+  claude.command("install").description("Register the prim hooks + statusline in Claude Code's settings.json").option(
+    "--scope <scope>",
+    "user (default, ~/.claude/settings.json) or project (./.claude/settings.json)"
+  ).option("--force", "Replace any drifted prim hook entries").action((opts) => {
+    const scope = resolveScope(opts.scope);
+    const result = performInstall(scope, opts.force ?? false);
+    if (result.changed) {
+      console.error(
+        `[prim] Claude Code integration installed (${scope} scope) at ${result.path}`
+      );
+    } else {
+      console.error(
+        `[prim] Claude Code integration already present at ${result.path} (no changes)`
+      );
+    }
+    console.log(JSON.stringify(result, null, JSON_INDENT));
+  });
+  claude.command("uninstall").description("Remove all prim hooks + the prim statusline from settings.json").option(
+    "--scope <scope>",
+    "user (default, ~/.claude/settings.json) or project (./.claude/settings.json)"
+  ).action((opts) => {
+    const scope = resolveScope(opts.scope);
+    const result = performUninstall(scope);
+    if (result.changed) {
+      console.error(`[prim] prim hooks removed from ${result.path}`);
+    } else {
+      console.error(`[prim] no prim hooks to remove at ${result.path} (nothing changed)`);
+    }
+    console.log(JSON.stringify(result, null, JSON_INDENT));
+  });
+  claude.command("status").description(
+    "Report whether each prim surface (gate, capture, statusline) is installed per scope"
+  ).action(() => {
+    const result = performStatus();
+    const mark = (b) => b ? "\u2713" : "\u2717";
+    const line = (label, s) => `[prim] ${label}: gate ${mark(s.gate)} \xB7 capture ${mark(s.capture)} \xB7 statusline ${mark(s.statusline)} (${s.path})`;
+    console.error(`${line("user", result.user)}
+${line("project", result.project)}`);
+    console.log(JSON.stringify(result, null, JSON_INDENT));
+  });
+}
+
+// src/commands/codex-install.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var CAPTURE_COMMAND2 = "prim-hook --agent codex";
+var GATE_COMMAND2 = "prim-pre-tool-use --agent codex";
+var POST_TOOL_USE_COMMAND2 = "prim-post-tool-use --agent codex";
+var SESSION_START_COMMAND2 = "prim-session-start --agent codex";
+var JSON_INDENT2 = 2;
+var CODEX_CAPTURE_EVENTS = [
+  "SessionStart",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+  "SubagentStop"
+];
+var PRIM_COMMANDS2 = /* @__PURE__ */ new Set([
+  CAPTURE_COMMAND2,
+  GATE_COMMAND2,
+  POST_TOOL_USE_COMMAND2,
+  SESSION_START_COMMAND2
+]);
+var CODEX_REGISTRATIONS = [
+  ...CODEX_CAPTURE_EVENTS.map((event) => ({ event, matcher: "*", command: CAPTURE_COMMAND2 })),
+  { event: "PreToolUse", matcher: "apply_patch", command: GATE_COMMAND2 },
+  { event: "PostToolUse", matcher: "apply_patch", command: POST_TOOL_USE_COMMAND2 },
+  { event: "SessionStart", matcher: "*", command: SESSION_START_COMMAND2 }
+];
+var USER_SCOPE_PATH2 = join2(homedir2(), ".codex", "hooks.json");
+var PROJECT_SCOPE_PATH2 = join2(process.cwd(), ".codex", "hooks.json");
+function settingsPathFor2(scope) {
+  return scope === "user" ? USER_SCOPE_PATH2 : PROJECT_SCOPE_PATH2;
+}
+function applyInstall2(settings, options = {}) {
+  const hooks = { ...settings.hooks ?? {} };
+  for (const reg of CODEX_REGISTRATIONS) {
+    hooks[reg.event] = ensureRegistration(hooks[reg.event] ?? [], reg, options.force ?? false);
+  }
+  return { ...settings, hooks };
+}
+function applyUninstall2(settings) {
+  const source = settings.hooks ?? {};
+  const hooks = {};
+  for (const event of Object.keys(source)) {
+    let list = source[event] ?? [];
+    for (const command of PRIM_COMMANDS2) {
+      list = stripCommand(list, command);
+    }
+    if (list.length > 0) {
+      hooks[event] = list;
+    }
+  }
+  return { ...settings, hooks };
+}
+function captureInstalled2(settings) {
+  return CODEX_CAPTURE_EVENTS.some(
+    (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_COMMAND2))
+  );
+}
+function isGateInstalled2(settings) {
+  return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_COMMAND2));
+}
+function resultFor(scope, path, after, changed) {
+  return {
+    scope,
+    path,
+    gate: isGateInstalled2(after),
+    capture: captureInstalled2(after),
+    changed
+  };
+}
+function performInstall2(scope, force) {
+  const path = settingsPathFor2(scope);
+  const before = readSettings(path);
+  const after = applyInstall2(before, { force });
+  const changed = JSON.stringify(before) !== JSON.stringify(after);
+  if (changed) {
+    atomicWrite(path, after);
+  }
+  return resultFor(scope, path, after, changed);
+}
+function performUninstall2(scope) {
+  const path = settingsPathFor2(scope);
+  const before = readSettings(path);
+  const after = applyUninstall2(before);
+  const changed = JSON.stringify(before) !== JSON.stringify(after);
+  if (changed) {
+    atomicWrite(path, after);
+  }
+  return resultFor(scope, path, after, changed);
+}
+function performStatus2() {
+  const statusFor = (path) => {
+    const settings = readSettings(path);
+    return { path, gate: isGateInstalled2(settings), capture: captureInstalled2(settings) };
+  };
+  return { user: statusFor(USER_SCOPE_PATH2), project: statusFor(PROJECT_SCOPE_PATH2) };
+}
+function resolveScope2(input) {
+  if (input === void 0 || input === "user") {
+    return "user";
+  }
+  if (input === "project") {
+    return "project";
+  }
+  console.error(`[prim] unknown --scope "${input}" (expected: user or project)`);
+  process.exit(1);
+}
+var TRUST_NOTICE = "[prim] Codex requires hook trust: run `/hooks` in Codex to review and trust these hooks (or start Codex with --dangerously-bypass-hook-trust). Until trusted, the hooks will not fire.";
+function registerCodexCommands(program2) {
+  const codex = program2.command("codex").description("Manage the prim Codex integration (capture, gate, ingest, presence)");
+  codex.command("install").description("Register the prim hooks in Codex's ~/.codex/hooks.json").option(
+    "--scope <scope>",
+    "user (default, ~/.codex/hooks.json) or project (./.codex/hooks.json)"
+  ).option("--force", "Replace any drifted prim hook entries").action((opts) => {
+    const scope = resolveScope2(opts.scope);
+    const result = performInstall2(scope, opts.force ?? false);
+    if (result.changed) {
+      console.error(`[prim] Codex integration installed (${scope} scope) at ${result.path}`);
+    } else {
+      console.error(`[prim] Codex integration already present at ${result.path} (no changes)`);
+    }
+    console.error(TRUST_NOTICE);
+    console.log(JSON.stringify(result, null, JSON_INDENT2));
+  });
+  codex.command("uninstall").description("Remove all prim hooks from ~/.codex/hooks.json").option(
+    "--scope <scope>",
+    "user (default, ~/.codex/hooks.json) or project (./.codex/hooks.json)"
+  ).action((opts) => {
+    const scope = resolveScope2(opts.scope);
+    const result = performUninstall2(scope);
+    if (result.changed) {
+      console.error(`[prim] prim hooks removed from ${result.path}`);
+    } else {
+      console.error(`[prim] no prim hooks to remove at ${result.path} (nothing changed)`);
+    }
+    console.log(JSON.stringify(result, null, JSON_INDENT2));
+  });
+  codex.command("status").description("Report whether each prim surface (gate, capture) is installed per scope").action(() => {
+    const result = performStatus2();
+    const mark = (b) => b ? "\u2713" : "\u2717";
+    const line = (label, s) => `[prim] ${label}: gate ${mark(s.gate)} \xB7 capture ${mark(s.capture)} (${s.path})`;
+    console.error(`${line("user", result.user)}
+${line("project", result.project)}`);
+    console.log(JSON.stringify(result, null, JSON_INDENT2));
+  });
+}
+
 // src/commands/context.ts
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function registerContextCommands(program2) {
   const context = program2.command("context").description("Manage contexts");
   context.command("list").description("List contexts").option("-s, --scope <scope>", "Filter by scope: project, global, external").option("-t, --project-id <projectId>", "List contexts linked to a specific project").option("--json", "Output as JSON").action(async (opts) => {
@@ -286,7 +711,7 @@ function registerContextCommands(program2) {
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync2(opts.file, "utf-8");
+        text = readFileSync3(opts.file, "utf-8");
       }
       const taskIds = opts.projectId ? opts.projectId.split(",").map((id) => id.trim()) : void 0;
       const result = await client.post("/api/cli/contexts", {
@@ -309,7 +734,7 @@ function registerContextCommands(program2) {
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync2(opts.file, "utf-8");
+        text = readFileSync3(opts.file, "utf-8");
       }
       await client.patch(`/api/cli/contexts/${contextId}`, {
         name: opts.name,
@@ -373,9 +798,783 @@ function printContextList(contexts) {
 ${contexts.length} context(s)`);
 }
 
+// src/commands/daemon.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+var DAEMON_BIN = "prim-daemon-server";
+var PID_PATH = join3(homedir3(), ".config", "prim", "daemon.pid");
+var SOCK_PATH = join3(homedir3(), ".config", "prim", "sock");
+var STOP_TIMEOUT_MS = 5e3;
+var STOP_POLL_MS = 100;
+var STATUS_PROBE_TIMEOUT_MS = 500;
+var POST_START_WAIT_MS = 400;
+var EXIT_NOT_RUNNING = 2;
+function readPidfile() {
+  if (!existsSync3(PID_PATH)) {
+    return null;
+  }
+  const raw = readFileSync4(PID_PATH, "utf-8").trim();
+  const pid = Number(raw);
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
+  }
+  return { pid, alive: processIsAlive(pid) };
+}
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearStaleArtifacts() {
+  try {
+    unlinkSync(PID_PATH);
+  } catch {
+  }
+  try {
+    unlinkSync(SOCK_PATH);
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve5) => {
+    const timer = setTimeout(resolve5, ms);
+    timer.unref();
+  });
+}
+async function daemonStart(opts) {
+  const existing = readPidfile();
+  if (existing?.alive) {
+    process.stderr.write(`[prim] daemon already running (pid=${existing.pid})
+`);
+    console.log(JSON.stringify({ started: false, pid: existing.pid }, null, 2));
+    return;
+  }
+  if (existing && !existing.alive) {
+    clearStaleArtifacts();
+  }
+  if (opts.foreground) {
+    const child2 = spawn(DAEMON_BIN, [], { stdio: "inherit" });
+    child2.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+    return;
+  }
+  const child = spawn(DAEMON_BIN, [], {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+  child.unref();
+  await sleep(POST_START_WAIT_MS);
+  const after = readPidfile();
+  if (after?.alive) {
+    process.stderr.write(`[prim] daemon started (pid=${after.pid}, socket=${SOCK_PATH})
+`);
+    console.log(JSON.stringify({ started: true, pid: after.pid }, null, 2));
+    return;
+  }
+  process.stderr.write(
+    "[prim] daemon start: bin spawned but no pidfile observed (check that `prim-daemon-server` is on PATH)\n"
+  );
+  console.log(JSON.stringify({ started: false }, null, 2));
+}
+async function daemonStop() {
+  const existing = readPidfile();
+  if (!existing) {
+    process.stderr.write("[prim] daemon not running (no pidfile)\n");
+    console.log(JSON.stringify({ stopped: false, wasRunning: false }, null, 2));
+    return;
+  }
+  if (!existing.alive) {
+    clearStaleArtifacts();
+    process.stderr.write("[prim] daemon not running (cleared stale pidfile)\n");
+    console.log(JSON.stringify({ stopped: false, wasRunning: false }, null, 2));
+    return;
+  }
+  try {
+    process.kill(existing.pid, "SIGTERM");
+  } catch (err) {
+    process.stderr.write(
+      `[prim] could not signal pid=${existing.pid}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    console.log(JSON.stringify({ stopped: false, pid: existing.pid }, null, 2));
+    return;
+  }
+  const deadline = Date.now() + STOP_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (!processIsAlive(existing.pid)) {
+      clearStaleArtifacts();
+      process.stderr.write(`[prim] daemon stopped (pid=${existing.pid})
+`);
+      console.log(JSON.stringify({ stopped: true, pid: existing.pid }, null, 2));
+      return;
+    }
+    await sleep(STOP_POLL_MS);
+  }
+  process.stderr.write(
+    `[prim] daemon did not exit within ${STOP_TIMEOUT_MS}ms (pid=${existing.pid} still alive)
+`
+  );
+  console.log(JSON.stringify({ stopped: false, pid: existing.pid }, null, 2));
+}
+async function daemonStatus() {
+  const pid = readPidfile();
+  if (!pid?.alive) {
+    process.stderr.write("[prim] \u2717 daemon down\n");
+    console.log(JSON.stringify({ running: false }, null, 2));
+    if (!process.exitCode) {
+      process.exitCode = EXIT_NOT_RUNNING;
+    }
+    return;
+  }
+  const live = await daemonIsLive(STATUS_PROBE_TIMEOUT_MS);
+  if (!live) {
+    process.stderr.write(`[prim] \u2717 daemon pid=${pid.pid} alive but socket not responding
+`);
+    console.log(JSON.stringify({ running: true, responding: false, pid: pid.pid }, null, 2));
+    if (!process.exitCode) {
+      process.exitCode = EXIT_NOT_RUNNING;
+    }
+    return;
+  }
+  const snapshot = await daemonRequest(
+    "status_snapshot",
+    {},
+    { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
+  );
+  if (!snapshot) {
+    process.stderr.write("[prim] \u2713 daemon live (no snapshot)\n");
+    console.log(JSON.stringify({ running: true, responding: true }, null, 2));
+    return;
+  }
+  process.stderr.write(
+    `[prim] \u2713 daemon live \xB7 pid=${snapshot.pid} \xB7 uptime=${Math.round(snapshot.uptimeMs / 1e3)}s \xB7 session=${snapshot.sessionId}
+`
+  );
+  console.log(JSON.stringify({ running: true, responding: true, ...snapshot }, null, 2));
+}
+async function daemonRestart(opts) {
+  await daemonStop();
+  await daemonStart(opts);
+}
+function registerDaemonCommands(program2) {
+  const daemon = program2.command("daemon").description("Manage the prim companion daemon (latency unlock + presence + broadcast)");
+  daemon.command("start").description("Spawn the prim-daemon-server in the background").option("--foreground", "Run in the foreground (inherit stdio); use under launchd / systemd").action(async (opts) => {
+    await daemonStart(opts);
+  });
+  daemon.command("stop").description("Send SIGTERM to the running daemon and clean up the socket").action(async () => {
+    await daemonStop();
+  });
+  daemon.command("status").description("Report daemon liveness + a snapshot if responding").action(async () => {
+    await daemonStatus();
+  });
+  daemon.command("restart").description("Stop, then start (preserves no state today)").option("--foreground", "Restart in the foreground").action(async (opts) => {
+    await daemonRestart(opts);
+  });
+}
+
+// src/decisions/cascade-renderer.ts
+var DEPENDENTS_INLINE_LIMIT = 5;
+var KNOWLEDGE_INLINE_LIMIT = 4;
+var ISO_DATE_LENGTH = 10;
+var INTENT_TRUNC = 60;
+var DEFAULT_WIDTH = 80;
+var SOFT_WRAP_INDENT = "         ";
+function terminalWidth() {
+  return process.stdout.columns ?? DEFAULT_WIDTH;
+}
+function softWrap(line, opts) {
+  const width = opts?.width ?? terminalWidth();
+  const indent = opts?.indent ?? "";
+  if (stripAnsi(line).length <= width) {
+    return [line];
+  }
+  const words = line.split(" ");
+  const out = [];
+  let current = "";
+  for (const w of words) {
+    if (current === "") {
+      current = w;
+      continue;
+    }
+    const tentative = `${current} ${w}`;
+    if (stripAnsi(tentative).length > width) {
+      out.push(current);
+      current = `${indent}${w}`;
+      continue;
+    }
+    current = tentative;
+  }
+  if (current.length > 0) {
+    out.push(current);
+  }
+  return out;
+}
+function formatDate(ms) {
+  return new Date(ms).toISOString().slice(0, ISO_DATE_LENGTH);
+}
+function truncate(s, max) {
+  if (s.length <= max) {
+    return s;
+  }
+  return `${s.slice(0, max - 1)}\u2026`;
+}
+function bracketed(label) {
+  return `[${label}]`;
+}
+function knowledgeRow(files, contexts, triggerFile, triggerContextName) {
+  const tokens = [];
+  for (const ctx of contexts.slice(0, KNOWLEDGE_INLINE_LIMIT)) {
+    const star = ctx.name === triggerContextName ? " *" : "";
+    tokens.push(bracketed(`${ctx.name}${star}`));
+  }
+  for (const f of files.slice(0, Math.max(0, KNOWLEDGE_INLINE_LIMIT - contexts.length))) {
+    const star = f === triggerFile ? " *" : "";
+    tokens.push(bracketed(`${f}${star}`));
+  }
+  const overflow = files.length + contexts.length - tokens.length > 0 ? ` (+${String(files.length + contexts.length - tokens.length)} more)` : "";
+  if (tokens.length === 0) {
+    return ["  (no upstream knowledge refs)"];
+  }
+  return [`  ${tokens.join("  ")}${overflow}`];
+}
+function areaChip(area) {
+  if (!area) {
+    return color("[--]", "gray");
+  }
+  return color(`[${area}]`, colorForArea(area));
+}
+function countCrossAreaDependents(parentArea, dependents) {
+  if (!parentArea) {
+    const areaCounts = /* @__PURE__ */ new Map();
+    for (const d of dependents) {
+      if (d.area) {
+        areaCounts.set(d.area, (areaCounts.get(d.area) ?? 0) + 1);
+      }
+    }
+    if (areaCounts.size <= 1) {
+      return 0;
+    }
+    let dominantCount = 0;
+    for (const c of areaCounts.values()) {
+      if (c > dominantCount) {
+        dominantCount = c;
+      }
+    }
+    return dependents.filter((d) => d.area).length - dominantCount;
+  }
+  let count = 0;
+  for (const d of dependents) {
+    if (d.area && d.area !== parentArea) {
+      count++;
+    }
+  }
+  return count;
+}
+function dependentsBox(dependents) {
+  if (dependents.length === 0) {
+    return ["  (no downstream dependents)"];
+  }
+  const inlineCount = Math.min(dependents.length, DEPENDENTS_INLINE_LIMIT);
+  const header = `${String(dependents.length)} affected:`;
+  const lines = [`  ${header}`];
+  for (const d of dependents.slice(0, inlineCount)) {
+    lines.push(`    \u2022 ${areaChip(d.area)}  ${truncate(d.intent, INTENT_TRUNC)}`);
+  }
+  if (dependents.length > inlineCount) {
+    lines.push(`    + ${String(dependents.length - inlineCount)} more`);
+  }
+  return lines;
+}
+function triggerHeadline(t) {
+  const at = formatDate(t.flaggedAt);
+  if (t.type === "file_edit" && t.file) {
+    return `trigger: file '${t.file}' was edited; cascade fired at ${at}.`;
+  }
+  if (t.type === "context_edit" && t.contextName) {
+    return `trigger: context '${t.contextName}' was edited; cascade fired at ${at}.`;
+  }
+  if (t.type === "supersession") {
+    return `trigger: an upstream decision was superseded; cascade fired at ${at}.`;
+  }
+  if (t.type === "invalidation") {
+    return `trigger: an upstream decision was invalidated; cascade fired at ${at}.`;
+  }
+  if (t.type === "confirmation_request") {
+    return `trigger: asking-policy confirmation request opened at ${at}.`;
+  }
+  return `trigger: ${t.type} at ${at}.`;
+}
+function triggerLine(result) {
+  const t = result.trigger;
+  if (!t) {
+    return [];
+  }
+  const lines = [triggerHeadline(t)];
+  if (t.authorName) {
+    lines.push(`  by ${t.authorName}`);
+  }
+  if (t.reason) {
+    lines.push(`  reason: ${t.reason}`);
+  }
+  return lines;
+}
+function renderCascade(result) {
+  const d = result.decision;
+  const id = d.shortId ? `dec_${d.shortId}` : d.id;
+  const idColored = color(id, "orange");
+  const header = `what this would break \xB7 ${String(result.fanOut)} decision(s) \xB7 enforcing`;
+  const lines = [header, "", "knowledge"];
+  lines.push(
+    ...knowledgeRow(
+      result.upstream.files,
+      result.upstream.contexts,
+      result.trigger?.file,
+      result.trigger?.contextName
+    )
+  );
+  if (result.trigger && (result.trigger.file || result.trigger.contextName)) {
+    lines.push("        |");
+    lines.push("        | refs (just edited)");
+    lines.push("        \u25BC");
+  }
+  const decisionLine = `\u2022 ${idColored}  ${truncate(d.intent, INTENT_TRUNC)}`;
+  const fanOutFragment = result.fanOut > 0 ? `  \xB7  ${String(result.fanOut)} decision(s) depend on this` : "";
+  const meta = `  ${d.authorName} \xB7 ${formatDate(d.classifiedAt)}${fanOutFragment}  \xB7  ${result.reversibility ?? "(unset)"} reversibility`;
+  lines.push("", decisionLine, meta);
+  lines.push("");
+  lines.push("dependents");
+  lines.push(...dependentsBox(result.downstream));
+  const triggered = triggerLine(result);
+  if (triggered.length > 0) {
+    lines.push("");
+    for (const t of triggered) {
+      lines.push(...softWrap(t, { indent: SOFT_WRAP_INDENT }));
+    }
+  }
+  const crossArea = countCrossAreaDependents(d.area, result.downstream);
+  const crossAreaFragment = crossArea > 0 ? ` \xB7 ${String(crossArea)} cross-area dependency` : "";
+  const noEdgesFragment = result.downstream.length === 0 ? " (no edges yet)" : "";
+  lines.push(
+    `impact: ${String(result.fanOut)} decision(s) need review${noEdgesFragment}${crossAreaFragment}.`
+  );
+  if (result.truncated) {
+    lines.push(
+      "  \u26A0 blast radius truncated \u2014 more refs/dependents than the server returns per request; not all shown."
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/decisions/cascade.ts
+var NOT_FOUND_RE = /not found/i;
+var CASCADE_TIMEOUT_MS = 1e4;
+var defaultDeps = { getClient };
+var CascadeNotFoundError = class extends Error {
+  constructor(idOrShortId) {
+    super(`Decision not found: ${idOrShortId}`);
+    this.name = "CascadeNotFoundError";
+  }
+};
+async function fetchCascade(idOrShortId, deps = defaultDeps) {
+  const params = new URLSearchParams({ id: idOrShortId });
+  const client = deps.getClient();
+  try {
+    return await daemonOrDirectGet(
+      "decisions_cascade",
+      `/api/cli/decisions/cascade?${params.toString()}`,
+      client,
+      CASCADE_TIMEOUT_MS
+    );
+  } catch (err) {
+    if (err instanceof Error && NOT_FOUND_RE.test(err.message)) {
+      throw new CascadeNotFoundError(idOrShortId);
+    }
+    throw err;
+  }
+}
+function formatCascadeJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// src/decisions/recent.ts
+var RECENT_TIMEOUT_MS = 1e4;
+var defaultDeps2 = { getClient };
+async function fetchRecent(args, deps = defaultDeps2) {
+  const params = new URLSearchParams();
+  if (args.limit !== void 0) {
+    params.set("limit", String(args.limit));
+  }
+  if (args.since !== void 0) {
+    params.set("since", args.since);
+  }
+  const client = deps.getClient();
+  try {
+    const res = await daemonOrDirectGet(
+      "decisions_recent",
+      `/api/cli/decisions/recent?${params.toString()}`,
+      client,
+      RECENT_TIMEOUT_MS
+    );
+    const result = { decisions: res.decisions };
+    if (res.unavailable !== void 0) {
+      result.unavailable = res.unavailable;
+    }
+    return result;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { decisions: [], unavailable: `recent feed failed: ${detail}` };
+  }
+}
+var SHORT_ID_PREFIX = "dec_";
+var ZERO_PAD_TWO = 2;
+function pad2(n) {
+  return n.toString().padStart(ZERO_PAD_TWO, "0");
+}
+function formatClock(ms) {
+  const d = new Date(ms);
+  return `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+}
+function authorLabel(row) {
+  if (!row.authorIsSelf) {
+    return row.authorName;
+  }
+  switch (row.producerKind) {
+    case "claude_code":
+      return "Your Claude Code";
+    case "codex":
+      return "Your Codex";
+    case "chat":
+      return "Your chat";
+    case "spec_edit":
+      return "Your spec edit";
+    case "cli":
+      return "Your CLI";
+    default:
+      return `Your ${row.authorName}`;
+  }
+}
+var AUTHOR_WIDTH = 18;
+function padRight(s, width) {
+  return s.length >= width ? `${s.slice(0, width - 1)} ` : s.padEnd(width, " ");
+}
+function formatRecentHuman(result) {
+  if (result.unavailable !== void 0) {
+    return `[prim] recent \xB7 feed not verified \u2014 ${result.unavailable}`;
+  }
+  if (result.decisions.length === 0) {
+    return "[prim] recent \xB7 0 decisions";
+  }
+  const lines = [`[prim] recent \xB7 ${String(result.decisions.length)} decision(s)`];
+  for (const row of result.decisions) {
+    const clock = formatClock(row.classifiedAt);
+    const author = padRight(authorLabel(row), AUTHOR_WIDTH);
+    const areaText = row.area ? `\u2022 ${row.area}` : "\u2022";
+    const areaPlain = padRight(areaText, 12);
+    const areaCol = row.area ? areaPlain.replace("\u2022", color("\u2022", colorForArea(row.area))) : areaPlain;
+    lines.push(`  ${clock}  ${author}${areaCol}${row.intent}`);
+  }
+  return lines.join("\n");
+}
+function formatRecentJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+function renderIdentifier(row) {
+  if (row.shortId) {
+    return `${SHORT_ID_PREFIX}${row.shortId}`;
+  }
+  return row.id;
+}
+
+// src/decisions/confirm.ts
+var CONFIRM_TIMEOUT_MS = 1e4;
+var defaultDeps3 = { getClient };
+var NOT_FOUND_RE2 = /not found/i;
+var AMBIGUOUS_RE = /ambiguous/i;
+var NOT_AUTHOR_RE = /author/i;
+var ConfirmNotFoundError = class extends Error {
+  constructor(idOrShortId) {
+    super(`Decision not found: ${idOrShortId}`);
+    this.name = "ConfirmNotFoundError";
+  }
+};
+async function fetchConfirm(idOrShortId, confirmed, deps = defaultDeps3) {
+  const request = { idOrShortId, confirmed };
+  const client = deps.getClient();
+  try {
+    const outcome = await client.post(
+      "/api/cli/decisions/confirm",
+      { id: idOrShortId, confirmed },
+      { signal: AbortSignal.timeout(CONFIRM_TIMEOUT_MS) }
+    );
+    return { request, outcome };
+  } catch (err) {
+    if (err instanceof Error) {
+      if (NOT_FOUND_RE2.test(err.message)) {
+        throw new ConfirmNotFoundError(idOrShortId);
+      }
+      if (AMBIGUOUS_RE.test(err.message)) {
+        return { request, outcome: { outcome: "ambiguous" } };
+      }
+      if (NOT_AUTHOR_RE.test(err.message)) {
+        return { request, outcome: { outcome: "not_author" } };
+      }
+    }
+    throw err;
+  }
+}
+function intentWord(confirmed) {
+  return confirmed ? "confirmed" : "rejected";
+}
+function formatConfirmHuman(result) {
+  const { request, outcome } = result;
+  switch (outcome.outcome) {
+    case "confirmed":
+    case "corrected":
+    case "stale": {
+      const id = renderIdentifier({ shortId: outcome.shortId, id: outcome.decisionId });
+      if (outcome.outcome === "stale") {
+        return `[prim] ${id} ${intentWord(request.confirmed)} \u2014 the prompt had gone stale; recorded against the current decision.`;
+      }
+      if (outcome.outcome === "corrected") {
+        return `[prim] ${id} ${intentWord(request.confirmed)} with a correction.`;
+      }
+      return `[prim] ${id} ${intentWord(request.confirmed)}.`;
+    }
+    case "already_responded": {
+      const id = renderIdentifier({ shortId: outcome.shortId, id: outcome.decisionId });
+      const priorWord = outcome.confirmed === void 0 ? "already answered" : `already ${intentWord(outcome.confirmed)}`;
+      const when = new Date(outcome.respondedAt).toISOString();
+      return `[prim] ${id} was ${priorWord} (responded ${when}); nothing to change.`;
+    }
+    case "no_pending_prompt": {
+      const id = renderIdentifier({ shortId: outcome.shortId, id: outcome.decisionId });
+      return `[prim] ${id} has no pending confirmation request \u2014 nothing to acknowledge.`;
+    }
+    case "ambiguous":
+      return `[prim] shortId "${request.idOrShortId}" is ambiguous in this organization \u2014 retry with the full decision id.`;
+    default:
+      return "[prim] only the decision's author can respond to its confirmation prompt.";
+  }
+}
+function formatConfirmJson(result) {
+  return JSON.stringify(result.outcome, null, 2);
+}
+
+// src/decisions/show.ts
+var NOT_FOUND_RE3 = /not found/i;
+function colorStatus(status) {
+  if (status === "under_review") {
+    return color(status, "orange");
+  }
+  if (status === "active") {
+    return color(status, "green");
+  }
+  return color(status, "gray");
+}
+var SHOW_TIMEOUT_MS = 1e4;
+var defaultDeps4 = { getClient };
+var DecisionNotFoundError = class extends Error {
+  constructor(idOrShortId) {
+    super(`Decision not found: ${idOrShortId}`);
+    this.name = "DecisionNotFoundError";
+  }
+};
+async function fetchShow(idOrShortId, deps = defaultDeps4) {
+  const params = new URLSearchParams({ id: idOrShortId });
+  const client = deps.getClient();
+  try {
+    return await daemonOrDirectGet(
+      "decisions_show",
+      `/api/cli/decisions/show?${params.toString()}`,
+      client,
+      SHOW_TIMEOUT_MS
+    );
+  } catch (err) {
+    if (err instanceof Error && NOT_FOUND_RE3.test(err.message)) {
+      throw new DecisionNotFoundError(idOrShortId);
+    }
+    throw err;
+  }
+}
+var GATED_FLAG_KINDS = /* @__PURE__ */ new Set(["file_edit", "supersession", "context_edit"]);
+function describeFlag(flag) {
+  const detail = flag.reason ? ` \u2014 ${flag.reason}` : "";
+  if (flag.acknowledgedAt !== void 0) {
+    return `acknowledged ${flag.type}${detail}`;
+  }
+  if (flag.type === "confirmation_request") {
+    return `pending confirmation request${detail}`;
+  }
+  if (GATED_FLAG_KINDS.has(flag.type)) {
+    const verdict = flag.gateVerdict ?? "unknown";
+    return `pending ${flag.type} (verdict: ${verdict})${detail}`;
+  }
+  return `pending ${flag.type}${detail}`;
+}
+function describeNode(node) {
+  const id = renderIdentifier({ shortId: node.shortId, id: node.id });
+  const area = node.area ? ` \u2022 ${node.area}` : "";
+  return `${id}${area}  ${node.intent}  (${node.authorName})`;
+}
+function pushFiles(lines, files) {
+  if (files.length === 0) {
+    return;
+  }
+  lines.push(`  files (${String(files.length)}):`);
+  for (const file of files) {
+    lines.push(`    - ${file}`);
+  }
+}
+function pushContexts(lines, contexts) {
+  if (contexts.length === 0) {
+    return;
+  }
+  lines.push(`  contexts (${String(contexts.length)}):`);
+  for (const ctx of contexts) {
+    lines.push(`    - ${ctx.name}`);
+  }
+}
+function pushEdges(lines, label, arrow, nodes) {
+  if (nodes.length === 0) {
+    return;
+  }
+  lines.push(`  ${label} (${String(nodes.length)}):`);
+  for (const node of nodes) {
+    lines.push(`    ${arrow} ${describeNode(node)}`);
+  }
+}
+function formatShowHuman(result) {
+  const d = result.decision;
+  const id = color(renderIdentifier({ shortId: d.shortId, id: d.id }), "orange");
+  const confidence = d.confidence ?? "(unset)";
+  const lines = [
+    `[prim] ${id} \u2014 ${d.intent}`,
+    `  status: ${colorStatus(d.status)}${d.confirmed ? " (confirmed)" : ""}  \xB7  confidence: ${confidence}  \xB7  reversibility: ${d.reversibility ?? "(unset)"}`
+  ];
+  if (d.supersededBy) {
+    lines.push(`  superseded by: ${d.supersededBy}`);
+  }
+  if (d.area) {
+    lines.push(`  area: ${color(d.area, colorForArea(d.area))}`);
+  }
+  if (typeof d.fanOut === "number") {
+    lines.push(`  fan-out: ${String(d.fanOut)}`);
+  }
+  if (d.respondedAt !== void 0) {
+    lines.push(`  responded at: ${new Date(d.respondedAt).toISOString()}`);
+  }
+  if (d.rationale) {
+    lines.push(`  rationale: ${d.rationale}`);
+  }
+  if (d.decided && d.decided.length > 0) {
+    lines.push(`  decided (${String(d.decided.length)}):`);
+    for (const point of d.decided) {
+      lines.push(`    - ${point}`);
+    }
+  }
+  if (d.alternatives.length > 0) {
+    lines.push(`  alternatives: ${d.alternatives.join(" | ")}`);
+  }
+  pushFiles(lines, result.files);
+  pushContexts(lines, result.contexts);
+  pushEdges(lines, "dependents", "\u2192", result.dependents);
+  pushEdges(lines, "depends on", "\u2190", result.dependsOn);
+  if (result.flags.length > 0) {
+    lines.push(`  flags (${String(result.flags.length)}):`);
+    for (const flag of result.flags) {
+      lines.push(`    \xB7 ${describeFlag(flag)}`);
+    }
+  }
+  if (result.truncated) {
+    lines.push("  (partial \u2014 some related rows were truncated by a join cap)");
+  }
+  return lines.join("\n");
+}
+function formatShowJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// src/commands/decisions.ts
+var EXIT_NOT_FOUND = 4;
+function registerDecisionsCommands(program2) {
+  const decisions = program2.command("decisions").description("Inspect the project Decision Graph");
+  decisions.command("check").description("Look up active decisions that reference one or more file paths").requiredOption(
+    "--files <files>",
+    "Comma-separated file paths to check against the Decision Graph"
+  ).action(async (opts) => {
+    const filePaths = opts.files.split(",").map((s) => s.trim()).filter(Boolean);
+    const result = await checkAffectedDecisions(filePaths);
+    const warning = formatDecisionsWarning(result);
+    if (warning) {
+      console.error(warning);
+    }
+    printJson(result);
+  });
+  decisions.command("recent").description("Show the team-wide chronological decision feed").option("--limit <n>", "Maximum number of rows to return (default 10)").option(
+    "--since <duration>",
+    "Lookback window \u2014 accepts `Nm`, `Nh`, `Nd` (minutes / hours / days) or absolute epoch ms"
+  ).action(async (opts) => {
+    const result = await fetchRecent({
+      limit: opts.limit ? Number.parseInt(opts.limit, 10) : void 0,
+      since: opts.since
+    });
+    console.error(formatRecentHuman(result));
+    console.log(formatRecentJson(result));
+  });
+  decisions.command("show <idOrShortId>").description("Show full detail for one decision (intent, rationale, flags, refs, edges)").action(async (idOrShortId) => {
+    try {
+      const result = await fetchShow(idOrShortId);
+      console.error(formatShowHuman(result));
+      console.log(formatShowJson(result));
+    } catch (err) {
+      if (err instanceof DecisionNotFoundError) {
+        console.error(`[prim] ${err.message}`);
+        process.exitCode = EXIT_NOT_FOUND;
+        return;
+      }
+      throw err;
+    }
+  });
+  decisions.command("cascade <idOrShortId>").description("Render the local cascade subgraph (upstream knowledge + downstream dependents)").action(async (idOrShortId) => {
+    try {
+      const result = await fetchCascade(idOrShortId);
+      console.error(renderCascade(result));
+      console.log(formatCascadeJson(result));
+    } catch (err) {
+      if (err instanceof CascadeNotFoundError) {
+        console.error(`[prim] ${err.message}`);
+        process.exitCode = EXIT_NOT_FOUND;
+        return;
+      }
+      throw err;
+    }
+  });
+  decisions.command("confirm <idOrShortId>").description("Acknowledge a confirmation prompt for the named decision").option("--reject", "Record a rejection (sets the decision's confirmed flag to false)").action(async (idOrShortId, opts) => {
+    const confirmed = !opts.reject;
+    try {
+      const result = await fetchConfirm(idOrShortId, confirmed);
+      console.error(formatConfirmHuman(result));
+      console.log(formatConfirmJson(result));
+    } catch (err) {
+      if (err instanceof ConfirmNotFoundError) {
+        console.error(`[prim] ${err.message}`);
+        process.exitCode = EXIT_NOT_FOUND;
+        return;
+      }
+      throw err;
+    }
+  });
+}
+
 // src/commands/hooks.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { resolve } from "path";
 import { Option } from "commander";
 var HOOK_SCRIPT = `#!/bin/sh
@@ -409,13 +1608,13 @@ function getGitRoot() {
 }
 function detectHusky(gitRoot) {
   const huskyDir = resolve(gitRoot, ".husky");
-  if (!existsSync2(huskyDir)) return false;
-  if (existsSync2(resolve(huskyDir, "_"))) return true;
-  if (existsSync2(resolve(huskyDir, "pre-commit"))) return true;
+  if (!existsSync4(huskyDir)) return false;
+  if (existsSync4(resolve(huskyDir, "_"))) return true;
+  if (existsSync4(resolve(huskyDir, "pre-commit"))) return true;
   const pkgPath = resolve(gitRoot, "package.json");
-  if (existsSync2(pkgPath)) {
+  if (existsSync4(pkgPath)) {
     try {
-      const pkg2 = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+      const pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
       const scripts = pkg2.scripts ?? {};
       if (/husky/i.test(scripts.prepare ?? "") || /husky/i.test(scripts.postinstall ?? "")) {
         return true;
@@ -442,20 +1641,20 @@ async function askConfirmation(question) {
 }
 function installToHusky(gitRoot) {
   const hookPath = resolve(gitRoot, ".husky", "pre-commit");
-  if (existsSync2(hookPath)) {
-    const existing = readFileSync3(hookPath, "utf-8");
+  if (existsSync4(hookPath)) {
+    const existing = readFileSync5(hookPath, "utf-8");
     if (containsPrimHook(existing)) {
       console.log("Prim pre-commit hook is already installed in .husky/pre-commit.");
       return;
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    writeFileSync2(hookPath, `${existing}${separator}${PRIM_HUSKY_BLOCK}
+    writeFileSync3(hookPath, `${existing}${separator}${PRIM_HUSKY_BLOCK}
 `, {
       mode: 493
     });
     console.log("Appended prim hook block to .husky/pre-commit.");
   } else {
-    writeFileSync2(hookPath, `#!/bin/sh
+    writeFileSync3(hookPath, `#!/bin/sh
 
 ${PRIM_HUSKY_BLOCK}
 `, {
@@ -467,11 +1666,11 @@ ${PRIM_HUSKY_BLOCK}
 function installToDotGit(gitRoot) {
   const hooksDir = resolve(gitRoot, ".git", "hooks");
   const hookPath = resolve(hooksDir, "pre-commit");
-  if (!existsSync2(hooksDir)) {
-    mkdirSync2(hooksDir, { recursive: true });
+  if (!existsSync4(hooksDir)) {
+    mkdirSync3(hooksDir, { recursive: true });
   }
-  if (existsSync2(hookPath)) {
-    const existing = readFileSync3(hookPath, "utf-8");
+  if (existsSync4(hookPath)) {
+    const existing = readFileSync5(hookPath, "utf-8");
     if (containsPrimHook(existing)) {
       console.log("Prim pre-commit hook is already installed at .git/hooks/pre-commit.");
       return;
@@ -480,7 +1679,7 @@ function installToDotGit(gitRoot) {
     console.log("To replace it, run: prim hooks uninstall && prim hooks install");
     return;
   }
-  writeFileSync2(hookPath, HOOK_SCRIPT, { mode: 493 });
+  writeFileSync3(hookPath, HOOK_SCRIPT, { mode: 493 });
   console.log(`Installed pre-commit hook at ${hookPath}`);
 }
 function registerHooksCommands(program2) {
@@ -522,15 +1721,147 @@ function registerHooksCommands(program2) {
   hooks.command("uninstall").description("Remove the prim pre-commit hook").action(() => {
     const gitRoot = getGitRoot();
     const hookPath = resolve(gitRoot, ".git", "hooks", "pre-commit");
-    if (!existsSync2(hookPath)) {
+    if (!existsSync4(hookPath)) {
       console.log("No pre-commit hook found.");
       return;
     }
-    unlinkSync(hookPath);
+    unlinkSync2(hookPath);
     console.log(`Removed pre-commit hook at ${hookPath}`);
   });
 }
 
+// src/commands/moves.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+
+// src/flusher.ts
+import { renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
+var BATCH_SIZE = 500;
+var HTTP_TIMEOUT_MS = 1e4;
+var OPPORTUNISTIC_FLUSH_AFTER_MS = 6e4;
+async function drainPath(path) {
+  const tmpPath = `${path}.flushing.${String(Date.now())}.${String(process.pid)}`;
+  try {
+    renameSync2(path, tmpPath);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return 0;
+    }
+    throw err;
+  }
+  const moves = readMovesFromPath(tmpPath);
+  if (moves.length === 0) {
+    unlinkSync3(tmpPath);
+    return 0;
+  }
+  const client = getClient();
+  for (let i = 0; i < moves.length; i += BATCH_SIZE) {
+    const batch = moves.slice(i, i + BATCH_SIZE);
+    await client.post(
+      "/api/cli/moves/ingest",
+      { batch },
+      { signal: AbortSignal.timeout(HTTP_TIMEOUT_MS) }
+    );
+  }
+  unlinkSync3(tmpPath);
+  return moves.length;
+}
+async function flush() {
+  let total = 0;
+  for (const { path } of listBuckets()) {
+    total += await drainPath(path);
+  }
+  return { flushed: total };
+}
+async function flushIfNeeded() {
+  try {
+    const stats = bucketStats();
+    if (stats.length === 0) {
+      return;
+    }
+    const oldest = stats.reduce((min, s) => s.mtimeMs < min ? s.mtimeMs : min, stats[0].mtimeMs);
+    if (Date.now() - oldest > OPPORTUNISTIC_FLUSH_AFTER_MS) {
+      await flush();
+    }
+  } catch {
+  }
+}
+
+// src/commands/moves.ts
+var MS_PER_SECOND = 1e3;
+var DEFAULT_TAIL_LINES = "20";
+var RADIX_DECIMAL = 10;
+var ID_PREFIX_LEN = 8;
+var EVENT_COL_WIDTH = 20;
+var BUCKET_COL_WIDTH = 20;
+var TAIL_BUCKET_COL_WIDTH = 12;
+var DIR_MODE = 448;
+var FILE_MODE2 = 384;
+var WORKSPACE_FILE = ".prim/workspace.json";
+function registerMovesCommands(program2) {
+  const moves = program2.command("moves").description("Decision Event Pipeline \u2014 local journal");
+  moves.command("flush").description("Drain all local move journals to the server").action(async () => {
+    const { flushed } = await flush();
+    console.log(`[prim] flushed ${String(flushed)} move${flushed === 1 ? "" : "s"}`);
+  });
+  moves.command("status").description("Show per-bucket pending stats").action(() => {
+    const stats = bucketStats();
+    if (stats.length === 0) {
+      console.log("[prim] journal: empty");
+      return;
+    }
+    console.log(`[prim] root: ${JOURNAL_DIR}`);
+    for (const s of stats) {
+      const ageS = Math.round((Date.now() - s.mtimeMs) / MS_PER_SECOND);
+      console.log(
+        `  ${s.bucket.padEnd(BUCKET_COL_WIDTH)} ${String(s.lineCount).padStart(5)} pending, ${String(s.sizeBytes).padStart(8)} bytes, last write ${String(ageS)}s ago`
+      );
+    }
+  });
+  moves.command("tail").description("Pretty-print recent journal entries across all buckets").option("-n, --lines <n>", "number of lines to tail", DEFAULT_TAIL_LINES).action((opts) => {
+    const lines = Number.parseInt(opts.lines, RADIX_DECIMAL);
+    if (!Number.isInteger(lines) || lines < 1) {
+      console.error("[prim] --lines must be a positive integer");
+      process.exitCode = 1;
+      return;
+    }
+    const all = bucketStats().flatMap((s) => readMovesFromPath(s.path).map((m) => ({ bucket: s.bucket, move: m }))).sort((a, b) => a.move.capturedAt - b.move.capturedAt);
+    if (all.length === 0) {
+      console.log("[prim] journal: empty");
+      return;
+    }
+    const tail = all.slice(-lines);
+    for (const { bucket, move: m } of tail) {
+      const t = new Date(m.capturedAt).toISOString();
+      const session = m.sessionId.slice(0, ID_PREFIX_LEN) || "anon";
+      const move = m.moveId.slice(0, ID_PREFIX_LEN);
+      console.log(
+        `${t}  ${m.eventType.padEnd(EVENT_COL_WIDTH)} bucket=${bucket.padEnd(TAIL_BUCKET_COL_WIDTH)} session=${session}  move=${move}`
+      );
+    }
+  });
+  moves.command("bind").description("Pin the current directory to an org via .prim/workspace.json").requiredOption("--orgId <orgId>", "Convex organization id").action((opts) => {
+    const dir = join4(process.cwd(), ".prim");
+    if (!existsSync5(dir)) {
+      mkdirSync4(dir, { recursive: true, mode: DIR_MODE });
+    }
+    const file = join4(process.cwd(), WORKSPACE_FILE);
+    writeFileSync4(file, JSON.stringify({ orgId: opts.orgId, boundAt: Date.now() }, null, 2), {
+      mode: FILE_MODE2
+    });
+    console.log(`[prim] bound ${process.cwd()} to org ${opts.orgId}`);
+  });
+  moves.command("drop").description("Remove the .prim/workspace.json binding from the cwd").action(() => {
+    const file = join4(process.cwd(), WORKSPACE_FILE);
+    if (!existsSync5(file)) {
+      console.log("[prim] no workspace binding in cwd");
+      return;
+    }
+    unlinkSync4(file);
+    console.log(`[prim] dropped workspace binding from ${process.cwd()}`);
+  });
+}
+
 // src/commands/project.ts
 function registerProjectCommands(program2) {
   const project = program2.command("project").description("Manage projects");
@@ -553,24 +1884,170 @@ function registerProjectCommands(program2) {
   });
 }
 
+// src/commands/reconcile.ts
+var EXIT_OK = 0;
+var EXIT_USAGE = 2;
+var EXIT_SERVER = 3;
+var HTTP_CLIENT_ERROR_MIN = 400;
+var HTTP_SERVER_ERROR_MIN = 500;
+function isOk(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const v = value;
+  return v.ok === true && typeof v.bypassId === "string" && typeof v.expiresAt === "number";
+}
+function formatExpiresIn(expiresAt) {
+  const remainingMs = expiresAt - Date.now();
+  if (remainingMs <= 0) {
+    return "expired";
+  }
+  const SECONDS_PER_MINUTE = 60;
+  const minutes = Math.floor(remainingMs / (SECONDS_PER_MINUTE * 1e3));
+  const seconds = Math.floor(remainingMs / 1e3 % SECONDS_PER_MINUTE);
+  if (minutes === 0) {
+    return `${seconds}s`;
+  }
+  return `${minutes}m${seconds.toString().padStart(2, "0")}s`;
+}
+function renderDecisionIdentifier(short, id) {
+  return short ? `dec_${short}` : id;
+}
+function isDomainRejection(err) {
+  return err instanceof HttpError && err.status >= HTTP_CLIENT_ERROR_MIN && err.status < HTTP_SERVER_ERROR_MIN;
+}
+async function performReconcile(idOrShortId, opts = {}) {
+  const client = getClient();
+  const body = { idOrShortId };
+  if (opts.flag) {
+    body.conflictFlagId = opts.flag;
+  }
+  let response;
+  try {
+    response = await client.post("/api/cli/reconcile/issue", body);
+  } catch (err) {
+    if (isDomainRejection(err)) {
+      process.stderr.write(`[prim] reconcile rejected: ${err.message}
+`);
+      console.log(JSON.stringify({ ok: false, status: err.status, error: err.message }, null, 2));
+      process.exitCode = EXIT_USAGE;
+      return;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[prim] reconcile failed: ${message}
+`);
+    console.log(JSON.stringify({ ok: false, error: message }, null, 2));
+    process.exitCode = EXIT_SERVER;
+    return;
+  }
+  if (isOk(response)) {
+    const ident = renderDecisionIdentifier(response.decisionShortId, response.decisionId);
+    const verb = response.reissued ? "reissued" : "issued";
+    process.stderr.write(
+      `[prim] reconcile bypass ${verb} for ${ident} (expires in ${formatExpiresIn(response.expiresAt)})
+`
+    );
+    console.log(JSON.stringify(response, null, 2));
+    process.exitCode = EXIT_OK;
+    return;
+  }
+  process.stderr.write("[prim] reconcile: malformed server response\n");
+  console.log(JSON.stringify({ ok: false, response }, null, 2));
+  process.exitCode = EXIT_SERVER;
+}
+function registerReconcileCommands(program2) {
+  program2.command("reconcile <idOrShortId>").description(
+    "Issue a single-use bypass for a flagged decision (used by the cooperative reconcile loop)"
+  ).option(
+    "--flag <conflictFlagId>",
+    "Specific flag id to bind the bypass to (default: the decision's latest unack'd flag)"
+  ).option("--json", "(reserved; STDOUT is always JSON)").action(async (idOrShortId, opts) => {
+    await performReconcile(idOrShortId, opts);
+  });
+}
+
+// src/commands/session.ts
+import {
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync6,
+  readdirSync,
+  unlinkSync as unlinkSync5,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { join as join5 } from "path";
+var DIR_MODE2 = 448;
+var FILE_MODE3 = 384;
+function ensureDir() {
+  if (!existsSync6(SESSIONS_DIR)) {
+    mkdirSync5(SESSIONS_DIR, { recursive: true, mode: DIR_MODE2 });
+  }
+}
+function markerPath(sessionId) {
+  return join5(SESSIONS_DIR, `${sessionId}.json`);
+}
+function registerSessionCommands(program2) {
+  const session = program2.command("session").description("Decision Event Pipeline \u2014 session binding markers");
+  session.command("start <sessionId>").description("Pin a Claude Code session to an org").requiredOption("--orgId <orgId>", "Convex organization id").action((sessionId, opts) => {
+    ensureDir();
+    const marker = {
+      orgId: opts.orgId,
+      startedAt: Date.now()
+    };
+    writeFileSync5(markerPath(sessionId), JSON.stringify(marker, null, 2), {
+      mode: FILE_MODE3
+    });
+    console.log(`[prim] session ${sessionId} bound to org ${opts.orgId}`);
+  });
+  session.command("list").description("List active session markers").action(() => {
+    if (!existsSync6(SESSIONS_DIR)) {
+      console.log("[prim] no session markers");
+      return;
+    }
+    const files = readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) {
+      console.log("[prim] no session markers");
+      return;
+    }
+    for (const f of files) {
+      const sessionId = f.replace(/\.json$/, "");
+      try {
+        const m = JSON.parse(readFileSync6(join5(SESSIONS_DIR, f), "utf-8"));
+        console.log(`${sessionId}  org=${m.orgId}`);
+      } catch {
+      }
+    }
+  });
+  session.command("drop <sessionId>").description("Remove a session marker").action((sessionId) => {
+    const p = markerPath(sessionId);
+    if (!existsSync6(p)) {
+      console.log(`[prim] no marker for session ${sessionId}`);
+      return;
+    }
+    unlinkSync5(p);
+    console.log(`[prim] dropped session marker ${sessionId}`);
+  });
+}
+
 // src/commands/skill.ts
 import {
-  closeSync,
-  existsSync as existsSync3,
-  fsyncSync,
-  openSync,
-  readFileSync as readFileSync4,
-  renameSync,
-  writeFileSync as writeFileSync3
+  closeSync as closeSync2,
+  existsSync as existsSync7,
+  fsyncSync as fsyncSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync7,
+  renameSync as renameSync3,
+  writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { dirname as dirname3, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 import { createPatch } from "diff";
-var __dirname = dirname2(fileURLToPath(import.meta.url));
+var __dirname = dirname3(fileURLToPath(import.meta.url));
 var SKILL_BEGIN = "<!-- BEGIN PRIM SKILL v1 -->";
 var SKILL_END = "<!-- END PRIM SKILL v1 -->";
 var TARGET_CANDIDATES = [
   "CLAUDE.md",
+  "AGENTS.md",
   ".cursor/rules",
   ".windsurfrules",
   ".github/instructions/primitive.md"
@@ -578,15 +2055,15 @@ var TARGET_CANDIDATES = [
 var DEFAULT_TARGET = "CLAUDE.md";
 function loadSkill() {
   let dir = __dirname;
-  while (dir !== dirname2(dir)) {
+  while (dir !== dirname3(dir)) {
     const p = resolve2(dir, "SKILL.md");
-    if (existsSync3(p)) return readFileSync4(p, "utf-8");
-    dir = dirname2(dir);
+    if (existsSync7(p)) return readFileSync7(p, "utf-8");
+    dir = dirname3(dir);
   }
   throw new Error("SKILL.md not found in package");
 }
 function detectTargets(cwd) {
-  return TARGET_CANDIDATES.filter((p) => existsSync3(resolve2(cwd, p)));
+  return TARGET_CANDIDATES.filter((p) => existsSync7(resolve2(cwd, p)));
 }
 function detectNewline(content) {
   return content.includes("\r\n") ? "\r\n" : "\n";
@@ -612,16 +2089,16 @@ function removeBlock(existing) {
   const out = existing.slice(0, b) + existing.slice(e + SKILL_END.length);
   return out.replace(/(\r?\n){2,}$/, "$1");
 }
-function atomicWrite(target, content) {
+function atomicWrite2(target, content) {
   const tmp = `${target}.tmp`;
-  writeFileSync3(tmp, content);
-  const fd = openSync(tmp, "r+");
+  writeFileSync6(tmp, content);
+  const fd = openSync2(tmp, "r+");
   try {
-    fsyncSync(fd);
+    fsyncSync2(fd);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
-  renameSync(tmp, target);
+  renameSync3(tmp, target);
 }
 function resolveTarget(cwd, override) {
   if (override) return resolve2(cwd, override);
@@ -635,7 +2112,7 @@ function resolveTarget(cwd, override) {
 function runInstall(cwd, opts) {
   const target = resolveTarget(cwd, opts.target);
   if (target === null) return 1;
-  const existing = existsSync3(target) ? readFileSync4(target, "utf-8") : "";
+  const existing = existsSync7(target) ? readFileSync7(target, "utf-8") : "";
   const eol = existing ? detectNewline(existing) : "\n";
   const block = composeBlock(loadSkill(), eol);
   const next = applyBlock(existing, block, eol);
@@ -647,34 +2124,34 @@ function runInstall(cwd, opts) {
     process.stdout.write(createPatch(target, existing, next, "current", "proposed"));
     return 0;
   }
-  atomicWrite(target, next);
+  atomicWrite2(target, next);
   console.log(`Wrote ${Buffer.byteLength(next)} bytes to ${target}`);
   return 0;
 }
 function runUninstall(cwd, opts) {
   const target = resolveTarget(cwd, opts.target);
   if (target === null) return 1;
-  if (!existsSync3(target)) {
+  if (!existsSync7(target)) {
     console.log(`Skill block not present at ${target}`);
     return 0;
   }
-  const existing = readFileSync4(target, "utf-8");
+  const existing = readFileSync7(target, "utf-8");
   const next = removeBlock(existing);
   if (next === null) {
     console.log(`Skill block not present at ${target}`);
     return 0;
   }
-  atomicWrite(target, next);
+  atomicWrite2(target, next);
   console.log(`Removed skill block from ${target}`);
   return 0;
 }
 function runStatus(cwd, opts) {
   const target = resolveTarget(cwd, opts.target);
   if (target === null) return 1;
-  const fileExists = existsSync3(target);
+  const fileExists = existsSync7(target);
   let installed = false;
   if (fileExists) {
-    const content = readFileSync4(target, "utf-8");
+    const content = readFileSync7(target, "utf-8");
     installed = content.includes(SKILL_BEGIN) && content.includes(SKILL_END);
   }
   if (opts.json) {
@@ -711,7 +2188,7 @@ function registerSkillCommands(program2) {
 }
 
 // src/commands/spec.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 function registerSpecCommands(program2) {
   const spec = program2.command("spec").description("Manage spec documents");
   spec.command("list").description("List spec documents").option("-t, --project-id <projectId>", "List spec for a specific root project").option("--json", "Output as JSON").action(async (opts) => {
@@ -765,7 +2242,7 @@ ${contexts.length} spec(s)`);
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync5(opts.file, "utf-8");
+        text = readFileSync8(opts.file, "utf-8");
       }
       const taskIds = opts.projectId ? opts.projectId.split(",").map((id) => id.trim()) : void 0;
       let linkedBranch;
@@ -806,7 +2283,7 @@ ${contexts.length} spec(s)`);
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync5(opts.file, "utf-8");
+        text = readFileSync8(opts.file, "utf-8");
       }
       if (!(text || opts.name)) {
         console.error("Provide --text, --file, or --name to update.");
@@ -976,9 +2453,64 @@ ${preview}`);
   }
 }
 
+// src/commands/statusline.ts
+import { readFileSync as readFileSync9 } from "fs";
+import { dirname as dirname4, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var STATUSLINE_TIMEOUT_MS = 200;
+function readPackageVersion() {
+  try {
+    const here = dirname4(fileURLToPath2(import.meta.url));
+    const candidates = [resolve3(here, "../../package.json"), resolve3(here, "../package.json")];
+    for (const path of candidates) {
+      try {
+        const pkg2 = JSON.parse(readFileSync9(path, "utf-8"));
+        if (pkg2.version) {
+          return pkg2.version;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "0.0.0";
+}
+function debug(msg) {
+  if (process.env.PRIM_STATUSLINE_DEBUG === "1") {
+    process.stderr.write(`[prim-statusline] ${msg}
+`);
+  }
+}
+async function renderStatusline() {
+  const version = readPackageVersion();
+  const snapshot = await daemonRequest(
+    "status_snapshot",
+    {},
+    { timeoutMs: STATUSLINE_TIMEOUT_MS }
+  );
+  if (!snapshot) {
+    debug("daemon snapshot missing");
+    return `primitive ${version} (daemon: down)`;
+  }
+  if (snapshot.presenceStale) {
+    return `primitive ${version} (daemon: live \xB7 presence: stale)`;
+  }
+  const team = typeof snapshot.onlineCount === "number" ? `team: ${String(snapshot.onlineCount)} online` : "team: \u2014";
+  return `primitive ${version} (daemon: live \xB7 ${team})`;
+}
+function registerStatuslineCommands(program2) {
+  program2.command("statusline").description("Render the Claude Code statusLine for the prim companion daemon").action(async () => {
+    try {
+      const line = await renderStatusline();
+      process.stdout.write(line);
+    } catch {
+    }
+  });
+}
+
 // src/index.ts
-var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync6(resolve3(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync10(resolve4(__dirname2, "../package.json"), "utf-8"));
 updateNotifier({ pkg }).notify();
 var program = new Command();
 program.name("prim").description("CLI for managing Primitive specs and contexts").version(pkg.version).option("-y, --yes", "auto-confirm prompts").option(
@@ -991,9 +2523,23 @@ registerSpecCommands(program);
 registerProjectCommands(program);
 registerHooksCommands(program);
 registerSkillCommands(program);
+registerMovesCommands(program);
+registerSessionCommands(program);
+registerDecisionsCommands(program);
+registerClaudeCommands(program);
+registerCodexCommands(program);
+registerDaemonCommands(program);
+registerReconcileCommands(program);
+registerStatuslineCommands(program);
 process.on("unhandledRejection", (err) => {
   const msg = err instanceof Error ? err.message : String(err);
   console.error(msg);
   process.exit(1);
 });
+var argv = process.argv.slice(2);
+var isExplicitFlush = argv[0] === "moves" && argv[1] === "flush";
+if (!isExplicitFlush) {
+  flushIfNeeded().catch(() => {
+  });
+}
 program.parse();