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

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: prim
-description: Use the prim CLI for managing Primitive specs, contexts, projects, and pre-commit hooks. TRIGGER when the user mentions Primitive, prim, "specs" (in the Primitive sense), or "contexts" (in the Primitive sense); when the repo's package.json depends on @primitive.ai/prim; when the user asks to sync, map, update, or auto-map a spec; when configuring Primitive pre-commit hooks. SKIP when "spec" means test specs (vitest, jest, rspec), when "context" means React context or LLM context window, or for unrelated CLIs.
+description: Use the prim CLI for Primitive specs, contexts, projects, pre-commit hooks, and the decision graph (passive decision capture, the conflict gate, reconcile, and team presence). TRIGGER when the user mentions Primitive, prim, "specs" or "contexts" (in the Primitive sense), or decisions / the decision graph / a conflict gate / reconcile; when the repo's package.json depends on @primitive.ai/prim; when the user asks to sync, map, update, or auto-map a spec; when an edit is denied or warned by a prior decision; when configuring Primitive hooks. SKIP when "spec" means test specs (vitest, jest, rspec), when "context" means React context or an LLM context window, or for unrelated CLIs.
 ---
 
 # Working with the prim CLI
@@ -35,6 +35,36 @@ The CLI auto-refreshes expired tokens. On unrecoverable expiry it throws `Authen
 2. Every command accepts `--help`. When unsure of flags, run `npx --yes @primitive.ai/prim <cmd> --help` rather than guessing.
 3. The CLI prints API errors as one-liners to stderr and exits non-zero. Treat any non-zero exit as actionable. If a command fails with an unrecognized error, re-run with `--help` to check your flags. If auth-related, re-check `auth status`.
 
+## Working with the decision graph
+
+Separate from specs, prim passively captures the decisions you make during a coding session -- which library, which pattern, which config value -- into a queryable decision graph, and actively **gates** edits that would conflict with a load-bearing prior decision. Capture and the gate run automatically through the session hooks installed by `npx --yes @primitive.ai/prim claude install` (Claude Code) or `npx --yes @primitive.ai/prim codex install` (Codex). You never invoke capture; you *respond* to the gate and *read* the graph.
+
+### Heed the conflict gate
+Before an edit (Claude Code: Edit/Write/MultiEdit; Codex: apply_patch) a PreToolUse hook scores the target file against the graph:
+
+- **deny** -- the edit is blocked: it conflicts with a load-bearing prior decision. Don't fight it. Read the reason line; it names the decision id. If you genuinely intend to override that decision, run `npx --yes @primitive.ai/prim reconcile dec_<shortId>`, then retry the edit once. Otherwise choose an approach that respects the decision.
+- **warn / additional context** -- the edit proceeds, but a relevant prior decision is surfaced. Read it. On Codex a would-be `ask` is delivered as allow-plus-context (Codex can't pause mid-tool), so that context is your only signal -- read it before continuing.
+- **"decision check skipped / not verified" or "... partial / truncated"** -- the check could not fully run. Treat constraints as UNKNOWN, not clear; never read silence as approval.
+
+The gate fail-opens on its *own* infrastructure errors (no daemon, network blip, org-unbound token) -- a setup problem never blocks your edit. That is exactly why an "unavailable" note matters: it is the honest signal that the check, not your edit, is what failed.
+
+### Read the graph before large or load-bearing edits
+- `npx --yes @primitive.ai/prim decisions check --files "src/a.ts,src/b.ts"` -- which active decisions reference the files you're about to touch (comma-separated paths, one `--files` value). Run it before a big change.
+- `npx --yes @primitive.ai/prim decisions recent` -- the team's recent decisions, each row badged by author and agent (`Your Claude Code` / `Your Codex`); `--limit <n>` and `--since <dur>` narrow it.
+- `npx --yes @primitive.ai/prim decisions show <idOrShortId>` and `npx --yes @primitive.ai/prim decisions cascade <idOrShortId>` -- full detail, and the downstream blast radius a change would disturb.
+
+### Reconcile and the verdict footer
+`npx --yes @primitive.ai/prim reconcile <idOrShortId>` mints a single-use bypass for the named decision -- it prints `[prim] reconcile bypass issued for dec_<short> (expires in ...)` to STDERR, with the bypass JSON on STDOUT. Your *next* edit to the governed file then goes through, and on that edit prim prints a verdict footer to STDERR -- confirmation the override was recorded, not silently dropped:
+
+```
+✓ Conflict caught before merge · N decisions saved · <author>'s intent preserved
+```
+
+`N` is the reconciled decision's downstream live-dependent count, shown as `N+` when the server caps it.
+
+### Presence
+With the daemon running (`npx --yes @primitive.ai/prim daemon start`), `npx --yes @primitive.ai/prim daemon status` includes the live online count in its STDOUT JSON (when presence is fresh); Claude Code surfaces it in the statusline as `team: N online`. Your captured decisions are attributed to your agent automatically -- no flag required.
+
 ## Common workflows
 
 ### Read a spec's current text (do this before any partial edit)

package/dist/{chunk-LCC66K45.js → chunk-6LAQVM26.js}

@@ -1,34 +1,3 @@
-// src/hooks/prim-hook-core.ts
-import { randomUUID } from "crypto";
-import { platform } from "os";
-
-// src/protocol/move.ts
-var ENVELOPE_VERSION = 1;
-
-// src/hooks/prim-hook-core.ts
-function toMove(parsed, cliVersion, agent = "claude_code") {
-  return {
-    moveId: randomUUID(),
-    capturedAt: Date.now(),
-    sessionId: parsed.session_id ?? "",
-    eventType: parsed.hook_event_name ?? "unknown",
-    payload: parsed,
-    env: {
-      cwd: parsed.cwd ?? process.cwd(),
-      cliVersion,
-      osPlatform: platform()
-    },
-    envelopeVersion: ENVELOPE_VERSION,
-    // Stamp the producer only for Codex; Claude Code moves omit it (the
-    // backend defaults an absent value to "claude_code"), keeping the
-    // Claude wire shape byte-identical.
-    ...agent === "codex" ? { producer: "codex" } : {}
-  };
-}
-function shouldFlushAfter(eventType) {
-  return eventType === "SessionEnd";
-}
-
 // src/hooks/redact.ts
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
@@ -109,7 +78,5 @@ function scrubFromCwd(value, cwd) {
 }
 
 export {
-  toMove,
-  shouldFlushAfter,
   scrubFromCwd
 };

package/dist/chunk-7GHOFNJ2.js

@@ -0,0 +1,57 @@
+// src/hooks/prim-hook-core.ts
+import { randomUUID } from "crypto";
+import { platform } from "os";
+
+// src/protocol/move.ts
+var ENVELOPE_VERSION = 1;
+
+// src/hooks/prim-hook-core.ts
+function toMove(parsed, cliVersion, agent = "claude_code") {
+  return {
+    moveId: randomUUID(),
+    capturedAt: Date.now(),
+    sessionId: parsed.session_id ?? "",
+    eventType: parsed.hook_event_name ?? "unknown",
+    payload: parsed,
+    env: {
+      cwd: parsed.cwd ?? process.cwd(),
+      cliVersion,
+      osPlatform: platform()
+    },
+    envelopeVersion: ENVELOPE_VERSION,
+    // Stamp the producer only for Codex; Claude Code moves omit it (the
+    // backend defaults an absent value to "claude_code"), keeping the
+    // Claude wire shape byte-identical.
+    ...agent === "codex" ? { producer: "codex" } : {}
+  };
+}
+function toCommitMove(commit, cliVersion, cwd) {
+  return {
+    moveId: `commit:${commit.sha}`,
+    capturedAt: Date.now(),
+    sessionId: "",
+    eventType: "git.commit",
+    payload: {
+      kind: "git.commit",
+      sha: commit.sha,
+      parentSha: commit.parentSha,
+      branch: commit.branch,
+      files: commit.files
+    },
+    env: {
+      cwd,
+      cliVersion,
+      osPlatform: platform()
+    },
+    envelopeVersion: ENVELOPE_VERSION
+  };
+}
+function shouldFlushAfter(eventType) {
+  return eventType === "SessionEnd";
+}
+
+export {
+  toMove,
+  toCommitMove,
+  shouldFlushAfter
+};

package/dist/hooks/post-commit.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import {
+  appendMove,
+  resolveOrg
+} from "../chunk-JZGWQDM5.js";
+import {
+  toCommitMove
+} from "../chunk-7GHOFNJ2.js";
+
+// src/hooks/post-commit.ts
+import { execSync, spawn } from "child_process";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var here = dirname(fileURLToPath(import.meta.url));
+function git(args) {
+  try {
+    return execSync(`git ${args}`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return;
+  }
+}
+function readCommit() {
+  const sha = git("rev-parse HEAD");
+  if (!sha) {
+    return null;
+  }
+  const branch = git("rev-parse --abbrev-ref HEAD");
+  const files = (git("diff-tree --no-commit-id --name-only -r -m --root HEAD") ?? "").split("\n").filter((f) => f.length > 0);
+  return {
+    sha,
+    parentSha: git("rev-parse --verify --quiet HEAD^") || void 0,
+    branch: branch && branch !== "HEAD" ? branch : void 0,
+    files
+  };
+}
+function resolveCliVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(here, "..", "..", "package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function spawnBackgroundFlush() {
+  const entry = join(here, "..", "index.js");
+  spawn(process.execPath, [entry, "moves", "flush"], {
+    detached: true,
+    stdio: "ignore"
+  }).unref();
+}
+try {
+  const commit = readCommit();
+  if (commit) {
+    const cwd = git("rev-parse --show-toplevel") ?? process.cwd();
+    const move = toCommitMove(commit, resolveCliVersion(), cwd);
+    const { orgId } = resolveOrg({ sessionId: "", cwd });
+    appendMove(move, orgId);
+    spawnBackgroundFlush();
+  }
+} catch (err) {
+  if (process.env.PRIM_HOOK_DEBUG) {
+    const detail = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[prim-post-commit] capture failed: ${detail}
+`);
+  }
+}
+process.exit(0);

package/dist/hooks/post-tool-use.js

@@ -7,9 +7,11 @@ import {
   getClient
 } from "../chunk-6SIEWWUL.js";
 import {
-  scrubFromCwd,
+  scrubFromCwd
+} from "../chunk-6LAQVM26.js";
+import {
   toMove
-} from "../chunk-LCC66K45.js";
+} from "../chunk-7GHOFNJ2.js";
 import {
   parseAgent
 } from "../chunk-7YRBACIE.js";

package/dist/hooks/prim-hook.js

@@ -4,10 +4,12 @@ import {
   resolveOrg
 } from "../chunk-JZGWQDM5.js";
 import {
-  scrubFromCwd,
+  scrubFromCwd
+} from "../chunk-6LAQVM26.js";
+import {
   shouldFlushAfter,
   toMove
-} from "../chunk-LCC66K45.js";
+} from "../chunk-7GHOFNJ2.js";
 import {
   parseAgent
 } from "../chunk-7YRBACIE.js";

package/dist/index.js

@@ -34,9 +34,9 @@ import {
 } from "./chunk-UTKQTZHL.js";
 
 // src/index.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { dirname as dirname5, resolve as resolve4 } from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { readFileSync as readFileSync11 } from "fs";
+import { dirname as dirname6, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { Command } from "commander";
 import updateNotifier from "update-notifier";
 
@@ -125,7 +125,8 @@ function registerAuthCommands(program2) {
       res.end("<h1>Authentication successful!</h1><p>You can close this tab.</p>");
       exchangeCode(siteUrl, code, verifier, `http://${LOCALHOST}:${port}/callback`).then((token) => {
         saveToken(token);
-        console.log(`Authenticated! Token saved to ${TOKEN_FILE_PATH}`);
+        console.error(`Authenticated! Token saved to ${TOKEN_FILE_PATH}`);
+        console.log(JSON.stringify({ authenticated: true, tokenFile: TOKEN_FILE_PATH }));
         server.close();
         process.exit(0);
       }).catch((err) => {
@@ -151,12 +152,12 @@ function registerAuthCommands(program2) {
     authUrl.searchParams.set("state", state);
     authUrl.searchParams.set("code_challenge", challenge);
     authUrl.searchParams.set("code_challenge_method", "S256");
-    console.log("Opening browser for authentication...");
+    console.error("Opening browser for authentication...");
     openBrowser(authUrl.toString());
-    console.log(`If the browser doesn't open, visit:
+    console.error(`If the browser doesn't open, visit:
 ${authUrl.toString()}
 `);
-    console.log("Waiting for callback...");
+    console.error("Waiting for callback...");
     setTimeout(() => {
       console.error("Authentication timed out.");
       server.close();
@@ -281,33 +282,94 @@ async function exchangeCode(siteUrl, code, codeVerifier, redirectUri) {
 // src/commands/claude-install.ts
 import {
   closeSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   fsyncSync,
   mkdirSync as mkdirSync2,
   openSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   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";
+import { dirname as dirname3, join as join2 } from "path";
+
+// src/lib/bin-path.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, isAbsolute, join } from "path";
+import { fileURLToPath } from "url";
+var PKG_NAME = "@primitive.ai/prim";
+var ROOT_WALK_LIMIT = 6;
+var NPX_FALLBACK = `npx --yes -p ${PKG_NAME}@latest`;
+var resolvedRoot;
+function locateRoot() {
+  if (resolvedRoot !== void 0) {
+    return resolvedRoot;
+  }
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < ROOT_WALK_LIMIT; depth++) {
+    const manifestPath = join(dir, "package.json");
+    if (existsSync2(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+        if (manifest.name === PKG_NAME && manifest.bin) {
+          resolvedRoot = { dir, bin: manifest.bin };
+          return resolvedRoot;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  resolvedRoot = null;
+  return resolvedRoot;
+}
+function binFile(bin) {
+  const root = locateRoot();
+  const rel = root?.bin[bin];
+  if (!root || !rel) {
+    return null;
+  }
+  return isAbsolute(rel) ? rel : join(root.dir, rel);
+}
+function hookShimCommand(bin, args = "") {
+  const invoke = (cmd) => args ? `${cmd} ${args}` : cmd;
+  return `if command -v ${bin} >/dev/null 2>&1; then ${invoke(bin)}; elif [ -f "./node_modules/.bin/${bin}" ]; then ${invoke(`./node_modules/.bin/${bin}`)}; else ${invoke(`${NPX_FALLBACK} ${bin}`)}; fi`;
+}
+function commandMatchesBin(command, bin) {
+  if (!command) {
+    return false;
+  }
+  const c = command.trim();
+  if (c === bin || c.startsWith(`${bin} `)) {
+    return true;
+  }
+  return c.includes(`command -v ${bin} `);
+}
+
+// src/commands/claude-install.ts
+var CAPTURE_BIN = "prim-hook";
+var GATE_BIN = "prim-pre-tool-use";
+var POST_TOOL_USE_BIN = "prim-post-tool-use";
+var SESSION_START_BIN = "prim-session-start";
+var SESSION_END_BIN = "prim-session-end";
+var STATUSLINE_BIN = "prim";
+var STATUSLINE_ARGS = "statusline";
+var STATUSLINE_COMMAND = hookShimCommand(STATUSLINE_BIN, STATUSLINE_ARGS);
 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 PRIM_BINS = [
+  CAPTURE_BIN,
+  GATE_BIN,
+  POST_TOOL_USE_BIN,
+  SESSION_START_BIN,
+  SESSION_END_BIN
+];
 var JSON_INDENT = 2;
-var USER_SCOPE_PATH = join(homedir(), ".claude", "settings.json");
-var PROJECT_SCOPE_PATH = join(process.cwd(), ".claude", "settings.json");
+var USER_SCOPE_PATH = join2(homedir(), ".claude", "settings.json");
+var PROJECT_SCOPE_PATH = join2(process.cwd(), ".claude", "settings.json");
 var CAPTURE_EVENTS = [
   "SessionStart",
   "UserPromptSubmit",
@@ -317,21 +379,24 @@ var CAPTURE_EVENTS = [
   "SessionEnd",
   "SubagentStop"
 ];
+function makeRegistration(event, matcher, bin, args = "") {
+  return { event, matcher, bin, command: hookShimCommand(bin, args) };
+}
 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 }
+  ...CAPTURE_EVENTS.map((event) => makeRegistration(event, "*", CAPTURE_BIN)),
+  makeRegistration("PreToolUse", "Edit|Write|MultiEdit", GATE_BIN),
+  makeRegistration("PostToolUse", "Edit|Write|MultiEdit", POST_TOOL_USE_BIN),
+  makeRegistration("SessionStart", "*", SESSION_START_BIN),
+  makeRegistration("SessionEnd", "*", SESSION_END_BIN)
 ];
 function settingsPathFor(scope) {
   return scope === "user" ? USER_SCOPE_PATH : PROJECT_SCOPE_PATH;
 }
 function readSettings(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return {};
   }
-  const raw = readFileSync2(path, "utf-8");
+  const raw = readFileSync3(path, "utf-8");
   try {
     return JSON.parse(raw);
   } catch (err) {
@@ -339,16 +404,16 @@ function readSettings(path) {
     throw new Error(`${path} is not valid JSON: ${detail}`);
   }
 }
-function entryHasCommand(entry, command) {
-  return entry.hooks?.some((h) => h.command === command) ?? false;
+function entryHasCommand(entry, bin) {
+  return entry.hooks?.some((h) => commandMatchesBin(h.command, bin)) ?? false;
 }
 function canonicalEntry(reg) {
   return { matcher: reg.matcher, hooks: [{ type: "command", command: reg.command }] };
 }
-function stripCommand(list, command) {
+function stripCommand(list, bin) {
   const out = [];
   for (const e of list) {
-    const hooks = (e.hooks ?? []).filter((h) => h.command !== command);
+    const hooks = (e.hooks ?? []).filter((h) => !commandMatchesBin(h.command, bin));
     if (hooks.length > 0) {
       out.push({ ...e, hooks });
     }
@@ -362,11 +427,16 @@ function ensureRegistration(list, reg, force) {
   if (hasCanonical && !force) {
     return list;
   }
-  return [...stripCommand(list, reg.command), canonicalEntry(reg)];
+  return [...stripCommand(list, reg.bin), canonicalEntry(reg)];
 }
+var LEGACY_STATUSLINE_COMMAND = "prim statusline";
 function isPrimStatusLine(settings) {
   const s = settings.statusLine;
-  return s?.type === "command" && s?.command === STATUSLINE_COMMAND;
+  if (s?.type !== "command") {
+    return false;
+  }
+  const c = (s.command ?? "").trim();
+  return c === LEGACY_STATUSLINE_COMMAND || c.includes("@primitive.ai/prim") && c.includes("statusline");
 }
 function applyStatusLine(settings) {
   if (settings.statusLine && !isPrimStatusLine(settings)) {
@@ -393,8 +463,8 @@ function applyUninstall(settings) {
   const hooks = {};
   for (const event of Object.keys(source)) {
     let list = source[event] ?? [];
-    for (const command of PRIM_COMMANDS) {
-      list = stripCommand(list, command);
+    for (const bin of PRIM_BINS) {
+      list = stripCommand(list, bin);
     }
     if (list.length > 0) {
       hooks[event] = list;
@@ -408,18 +478,18 @@ function applyUninstall(settings) {
 }
 function captureInstalled(settings) {
   return CAPTURE_EVENTS.some(
-    (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_COMMAND))
+    (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_BIN))
   );
 }
 function statuslineInstalled(settings) {
   return isPrimStatusLine(settings);
 }
 function isGateInstalled(settings) {
-  return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_COMMAND));
+  return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_BIN));
 }
 function atomicWrite(path, content) {
-  const dir = dirname2(path);
-  if (!existsSync2(dir)) {
+  const dir = dirname3(path);
+  if (!existsSync3(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   const tmp = `${path}.tmp.${String(Date.now())}`;
@@ -535,11 +605,12 @@ ${line("project", result.project)}`);
 
 // 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";
+import { join as join3 } from "path";
+var CAPTURE_BIN2 = "prim-hook";
+var GATE_BIN2 = "prim-pre-tool-use";
+var POST_TOOL_USE_BIN2 = "prim-post-tool-use";
+var SESSION_START_BIN2 = "prim-session-start";
+var CODEX_ARGS = "--agent codex";
 var JSON_INDENT2 = 2;
 var CODEX_CAPTURE_EVENTS = [
   "SessionStart",
@@ -549,20 +620,15 @@ var CODEX_CAPTURE_EVENTS = [
   "Stop",
   "SubagentStop"
 ];
-var PRIM_COMMANDS2 = /* @__PURE__ */ new Set([
-  CAPTURE_COMMAND2,
-  GATE_COMMAND2,
-  POST_TOOL_USE_COMMAND2,
-  SESSION_START_COMMAND2
-]);
+var PRIM_BINS2 = [CAPTURE_BIN2, GATE_BIN2, POST_TOOL_USE_BIN2, SESSION_START_BIN2];
 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 }
+  ...CODEX_CAPTURE_EVENTS.map((event) => makeRegistration(event, "*", CAPTURE_BIN2, CODEX_ARGS)),
+  makeRegistration("PreToolUse", "apply_patch", GATE_BIN2, CODEX_ARGS),
+  makeRegistration("PostToolUse", "apply_patch", POST_TOOL_USE_BIN2, CODEX_ARGS),
+  makeRegistration("SessionStart", "*", SESSION_START_BIN2, CODEX_ARGS)
 ];
-var USER_SCOPE_PATH2 = join2(homedir2(), ".codex", "hooks.json");
-var PROJECT_SCOPE_PATH2 = join2(process.cwd(), ".codex", "hooks.json");
+var USER_SCOPE_PATH2 = join3(homedir2(), ".codex", "hooks.json");
+var PROJECT_SCOPE_PATH2 = join3(process.cwd(), ".codex", "hooks.json");
 function settingsPathFor2(scope) {
   return scope === "user" ? USER_SCOPE_PATH2 : PROJECT_SCOPE_PATH2;
 }
@@ -578,8 +644,8 @@ function applyUninstall2(settings) {
   const hooks = {};
   for (const event of Object.keys(source)) {
     let list = source[event] ?? [];
-    for (const command of PRIM_COMMANDS2) {
-      list = stripCommand(list, command);
+    for (const bin of PRIM_BINS2) {
+      list = stripCommand(list, bin);
     }
     if (list.length > 0) {
       hooks[event] = list;
@@ -589,11 +655,11 @@ function applyUninstall2(settings) {
 }
 function captureInstalled2(settings) {
   return CODEX_CAPTURE_EVENTS.some(
-    (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_COMMAND2))
+    (event) => (settings.hooks?.[event] ?? []).some((e) => entryHasCommand(e, CAPTURE_BIN2))
   );
 }
 function isGateInstalled2(settings) {
-  return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_COMMAND2));
+  return (settings.hooks?.PreToolUse ?? []).some((e) => entryHasCommand(e, GATE_BIN2));
 }
 function resultFor(scope, path, after, changed) {
   return {
@@ -682,7 +748,7 @@ ${line("project", result.project)}`);
 }
 
 // src/commands/context.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } 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) => {
@@ -711,7 +777,7 @@ function registerContextCommands(program2) {
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync3(opts.file, "utf-8");
+        text = readFileSync4(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", {
@@ -734,7 +800,7 @@ function registerContextCommands(program2) {
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync3(opts.file, "utf-8");
+        text = readFileSync4(opts.file, "utf-8");
       }
       await client.patch(`/api/cli/contexts/${contextId}`, {
         name: opts.name,
@@ -800,22 +866,26 @@ ${contexts.length} context(s)`);
 
 // src/commands/daemon.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5, unlinkSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } 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 PID_PATH = join4(homedir3(), ".config", "prim", "daemon.pid");
+var SOCK_PATH = join4(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 READY_TIMEOUT_MS = 5e3;
+var READY_POLL_MS = 100;
+var READY_PROBE_TIMEOUT_MS = 250;
+var EXIT_OK = 0;
 var EXIT_NOT_RUNNING = 2;
+var EXIT_BOOTING = 3;
 function readPidfile() {
-  if (!existsSync3(PID_PATH)) {
+  if (!existsSync4(PID_PATH)) {
     return null;
   }
-  const raw = readFileSync4(PID_PATH, "utf-8").trim();
+  const raw = readFileSync5(PID_PATH, "utf-8").trim();
   const pid = Number(raw);
   if (!Number.isInteger(pid) || pid <= 0) {
     return null;
@@ -846,6 +916,20 @@ function sleep(ms) {
     timer.unref();
   });
 }
+function spawnDaemon(options) {
+  const file = binFile(DAEMON_BIN);
+  return file ? spawn(process.execPath, [file], options) : spawn(DAEMON_BIN, [], options);
+}
+async function waitForReady() {
+  const deadline = Date.now() + READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    if (await daemonIsLive(READY_PROBE_TIMEOUT_MS)) {
+      return true;
+    }
+    await sleep(READY_POLL_MS);
+  }
+  return daemonIsLive(READY_PROBE_TIMEOUT_MS);
+}
 async function daemonStart(opts) {
   const existing = readPidfile();
   if (existing?.alive) {
@@ -858,29 +942,32 @@ async function daemonStart(opts) {
     clearStaleArtifacts();
   }
   if (opts.foreground) {
-    const child2 = spawn(DAEMON_BIN, [], { stdio: "inherit" });
+    const child2 = spawnDaemon({ stdio: "inherit" });
     child2.on("exit", (code) => {
       process.exit(code ?? 0);
     });
     return;
   }
-  const child = spawn(DAEMON_BIN, [], {
-    detached: true,
-    stdio: ["ignore", "ignore", "ignore"]
-  });
+  const child = spawnDaemon({ 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));
+  const live = await waitForReady();
+  if (live) {
+    const after = readPidfile();
+    process.stderr.write(
+      `[prim] \u2713 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"
+    `[prim] \u2717 daemon start: spawned but the socket did not respond within ${READY_TIMEOUT_MS}ms (check that \`${DAEMON_BIN}\` resolves, and see its log)
+`
   );
   console.log(JSON.stringify({ started: false }, null, 2));
+  if (!process.exitCode) {
+    process.exitCode = EXIT_NOT_RUNNING;
+  }
 }
 async function daemonStop() {
   const existing = readPidfile();
@@ -922,41 +1009,48 @@ async function daemonStop() {
   );
   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;
+function classifyStatus(pidAlive, responding, snapshot, pid) {
+  if (!pidAlive) {
+    return { json: { running: false }, exitCode: EXIT_NOT_RUNNING };
   }
-  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;
+  if (!responding) {
+    return {
+      json: { running: true, responding: false, state: "starting", pid },
+      exitCode: EXIT_BOOTING
+    };
   }
-  const snapshot = await daemonRequest(
+  if (!snapshot) {
+    return { json: { running: true, responding: true }, exitCode: EXIT_OK };
+  }
+  return { json: { running: true, responding: true, ...snapshot }, exitCode: EXIT_OK };
+}
+async function daemonStatus() {
+  const pid = readPidfile();
+  const pidAlive = pid?.alive ?? false;
+  const responding = pidAlive ? await daemonIsLive(STATUS_PROBE_TIMEOUT_MS) : false;
+  const snapshot = responding ? await daemonRequest(
     "status_snapshot",
     {},
     { timeoutMs: STATUS_PROBE_TIMEOUT_MS }
-  );
-  if (!snapshot) {
+  ) : null;
+  const { json, exitCode } = classifyStatus(pidAlive, responding, snapshot, pid?.pid);
+  if (!pidAlive) {
+    process.stderr.write("[prim] \u2717 daemon down\n");
+  } else if (!responding) {
+    process.stderr.write(`[prim] \u25CC daemon pid=${pid?.pid} starting (socket not responding yet)
+`);
+  } else 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}
+  } else {
+    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));
+    );
+  }
+  console.log(JSON.stringify(json, null, 2));
+  if (exitCode !== EXIT_OK && !process.exitCode) {
+    process.exitCode = exitCode;
+  }
 }
 async function daemonRestart(opts) {
   await daemonStop();
@@ -1574,33 +1668,42 @@ function registerDecisionsCommands(program2) {
 
 // src/commands/hooks.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { resolve } from "path";
 import { Option } from "commander";
-var HOOK_SCRIPT = `#!/bin/sh
-# prim pre-commit hook \u2014 auto-syncs affected specs on commit
-# Installed by: prim hooks install
-
-# Find the nearest node_modules/.bin with prim, or use npx
-if command -v prim-pre-commit >/dev/null 2>&1; then
-  prim-pre-commit
-elif [ -f "./node_modules/.bin/prim-pre-commit" ]; then
-  ./node_modules/.bin/prim-pre-commit
+var PRE_COMMIT = { hookName: "pre-commit", binName: "prim-pre-commit" };
+var POST_COMMIT = { hookName: "post-commit", binName: "prim-post-commit" };
+var HOOKS = [PRE_COMMIT, POST_COMMIT];
+function blockMarkers(spec) {
+  return {
+    start: `# >>> prim ${spec.hookName} hook >>>`,
+    end: `# <<< prim ${spec.hookName} hook <<<`
+  };
+}
+var PRIM_BLOCK_START = blockMarkers(PRE_COMMIT).start;
+var PRIM_BLOCK_END = blockMarkers(PRE_COMMIT).end;
+function hookShim(binName) {
+  return `if command -v ${binName} >/dev/null 2>&1; then
+  ${binName}
+elif [ -f "./node_modules/.bin/${binName}" ]; then
+  ./node_modules/.bin/${binName}
 else
-  npx --yes -p @primitive.ai/prim prim-pre-commit 2>/dev/null || true
-fi
+  npx --yes -p @primitive.ai/prim ${binName} 2>/dev/null || true
+fi`;
+}
+function dotGitScript(spec) {
+  return `#!/bin/sh
+# prim ${spec.hookName} hook \u2014 installed by: prim hooks install
+
+${hookShim(spec.binName)}
 `;
-var PRIM_BLOCK_START = "# >>> prim pre-commit hook >>>";
-var PRIM_BLOCK_END = "# <<< prim pre-commit hook <<<";
-var PRIM_HUSKY_BLOCK = `${PRIM_BLOCK_START}
-if command -v prim-pre-commit >/dev/null 2>&1; then
-  prim-pre-commit
-elif [ -f "./node_modules/.bin/prim-pre-commit" ]; then
-  ./node_modules/.bin/prim-pre-commit
-else
-  npx --yes -p @primitive.ai/prim prim-pre-commit 2>/dev/null || true
-fi
-${PRIM_BLOCK_END}`;
+}
+function huskyBlock(spec) {
+  const { start, end } = blockMarkers(spec);
+  return `${start}
+${hookShim(spec.binName)}
+${end}`;
+}
 function getGitRoot() {
   return execSync("git rev-parse --show-toplevel", {
     encoding: "utf-8"
@@ -1608,13 +1711,13 @@ function getGitRoot() {
 }
 function detectHusky(gitRoot) {
   const huskyDir = resolve(gitRoot, ".husky");
-  if (!existsSync4(huskyDir)) return false;
-  if (existsSync4(resolve(huskyDir, "_"))) return true;
-  if (existsSync4(resolve(huskyDir, "pre-commit"))) return true;
+  if (!existsSync5(huskyDir)) return false;
+  if (existsSync5(resolve(huskyDir, "_"))) return true;
+  if (existsSync5(resolve(huskyDir, "pre-commit"))) return true;
   const pkgPath = resolve(gitRoot, "package.json");
-  if (existsSync4(pkgPath)) {
+  if (existsSync5(pkgPath)) {
     try {
-      const pkg2 = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+      const pkg2 = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       const scripts = pkg2.scripts ?? {};
       if (/husky/i.test(scripts.prepare ?? "") || /husky/i.test(scripts.postinstall ?? "")) {
         return true;
@@ -1624,8 +1727,8 @@ function detectHusky(gitRoot) {
   }
   return false;
 }
-function containsPrimHook(content) {
-  return content.includes("prim-pre-commit");
+function containsPrimHook(content, binName = PRE_COMMIT.binName) {
+  return content.includes(binName);
 }
 async function askConfirmation(question) {
   if (!process.stdin.isTTY) return false;
@@ -1639,52 +1742,63 @@ async function askConfirmation(question) {
     rl.close();
   }
 }
-function installToHusky(gitRoot) {
-  const hookPath = resolve(gitRoot, ".husky", "pre-commit");
-  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.");
+function installToHusky(gitRoot, spec = PRE_COMMIT) {
+  const hookPath = resolve(gitRoot, ".husky", spec.hookName);
+  if (existsSync5(hookPath)) {
+    const existing = readFileSync6(hookPath, "utf-8");
+    if (containsPrimHook(existing, spec.binName)) {
+      console.log(`Prim ${spec.hookName} hook is already installed in .husky/${spec.hookName}.`);
       return;
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    writeFileSync3(hookPath, `${existing}${separator}${PRIM_HUSKY_BLOCK}
+    writeFileSync3(hookPath, `${existing}${separator}${huskyBlock(spec)}
 `, {
       mode: 493
     });
-    console.log("Appended prim hook block to .husky/pre-commit.");
+    console.log(`Appended prim hook block to .husky/${spec.hookName}.`);
   } else {
     writeFileSync3(hookPath, `#!/bin/sh
 
-${PRIM_HUSKY_BLOCK}
+${huskyBlock(spec)}
 `, {
       mode: 493
     });
-    console.log("Created .husky/pre-commit with prim hook block.");
+    console.log(`Created .husky/${spec.hookName} with prim hook block.`);
   }
 }
-function installToDotGit(gitRoot) {
+function installToDotGit(gitRoot, spec = PRE_COMMIT) {
   const hooksDir = resolve(gitRoot, ".git", "hooks");
-  const hookPath = resolve(hooksDir, "pre-commit");
-  if (!existsSync4(hooksDir)) {
+  const hookPath = resolve(hooksDir, spec.hookName);
+  if (!existsSync5(hooksDir)) {
     mkdirSync3(hooksDir, { recursive: true });
   }
-  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.");
+  if (existsSync5(hookPath)) {
+    const existing = readFileSync6(hookPath, "utf-8");
+    if (containsPrimHook(existing, spec.binName)) {
+      console.log(`Prim ${spec.hookName} hook is already installed at ${hookPath}.`);
       return;
     }
-    console.log(`A pre-commit hook already exists at ${hookPath}.`);
+    console.log(`A ${spec.hookName} hook already exists at ${hookPath}.`);
     console.log("To replace it, run: prim hooks uninstall && prim hooks install");
     return;
   }
-  writeFileSync3(hookPath, HOOK_SCRIPT, { mode: 493 });
-  console.log(`Installed pre-commit hook at ${hookPath}`);
+  writeFileSync3(hookPath, dotGitScript(spec), { mode: 493 });
+  console.log(`Installed ${spec.hookName} hook at ${hookPath}`);
+}
+function installHooks(gitRoot, target) {
+  for (const spec of HOOKS) {
+    if (target === "husky") {
+      installToHusky(gitRoot, spec);
+    } else {
+      installToDotGit(gitRoot, spec);
+    }
+  }
 }
 function registerHooksCommands(program2) {
   const hooks = program2.command("hooks").description("Manage git hooks");
-  hooks.command("install").description("Install the prim pre-commit hook (auto-detects Husky; use --target to override)").addOption(
+  hooks.command("install").description(
+    "Install the prim git hooks \u2014 pre-commit + post-commit (auto-detects Husky; use --target to override)"
+  ).addOption(
     new Option("--target <where>", "install destination; bypasses Husky detection").choices([
       "husky",
       "git-hooks"
@@ -1695,10 +1809,10 @@ function registerHooksCommands(program2) {
       globals.nonInteractive || process.env.CI || process.env.PRIM_NON_INTERACTIVE
     );
     const gitRoot = getGitRoot();
-    if (opts.target === "husky") return installToHusky(gitRoot);
-    if (opts.target === "git-hooks") return installToDotGit(gitRoot);
+    if (opts.target === "husky") return installHooks(gitRoot, "husky");
+    if (opts.target === "git-hooks") return installHooks(gitRoot, "git-hooks");
     if (detectHusky(gitRoot)) {
-      if (globals.yes) return installToHusky(gitRoot);
+      if (globals.yes) return installHooks(gitRoot, "husky");
       if (nonInteractive) {
         throw new Error(
           "--non-interactive set, refusing to prompt for Husky-hook installation. Pass --yes to confirm or --target=git-hooks to choose."
@@ -1709,30 +1823,36 @@ function registerHooksCommands(program2) {
           "Note: Husky detected but stdin is not a TTY \u2014 falling back to .git/hooks. Pass --yes for Husky or --non-interactive to fail fast."
         );
       } else if (await askConfirmation(
-        "Husky detected. Install prim hook into .husky/pre-commit instead of .git/hooks/pre-commit?"
+        "Husky detected. Install prim hooks into .husky/ instead of .git/hooks/?"
       )) {
-        return installToHusky(gitRoot);
+        return installHooks(gitRoot, "husky");
       } else {
-        console.log("Falling back to .git/hooks/pre-commit install.");
+        console.log("Falling back to .git/hooks install.");
       }
     }
-    installToDotGit(gitRoot);
+    installHooks(gitRoot, "git-hooks");
   });
-  hooks.command("uninstall").description("Remove the prim pre-commit hook").action(() => {
+  hooks.command("uninstall").description("Remove the prim git hooks (.git/hooks)").action(() => {
     const gitRoot = getGitRoot();
-    const hookPath = resolve(gitRoot, ".git", "hooks", "pre-commit");
-    if (!existsSync4(hookPath)) {
-      console.log("No pre-commit hook found.");
-      return;
+    for (const spec of HOOKS) {
+      const hookPath = resolve(gitRoot, ".git", "hooks", spec.hookName);
+      if (!existsSync5(hookPath)) {
+        console.log(`No ${spec.hookName} hook found.`);
+        continue;
+      }
+      if (containsPrimHook(readFileSync6(hookPath, "utf-8"), spec.binName)) {
+        unlinkSync2(hookPath);
+        console.log(`Removed ${spec.hookName} hook at ${hookPath}`);
+      } else {
+        console.log(`Left ${spec.hookName} hook at ${hookPath} untouched (not a prim hook).`);
+      }
     }
-    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";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join5 } from "path";
 
 // src/flusher.ts
 import { renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
@@ -1841,19 +1961,19 @@ function registerMovesCommands(program2) {
     }
   });
   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)) {
+    const dir = join5(process.cwd(), ".prim");
+    if (!existsSync6(dir)) {
       mkdirSync4(dir, { recursive: true, mode: DIR_MODE });
     }
-    const file = join4(process.cwd(), WORKSPACE_FILE);
+    const file = join5(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)) {
+    const file = join5(process.cwd(), WORKSPACE_FILE);
+    if (!existsSync6(file)) {
       console.log("[prim] no workspace binding in cwd");
       return;
     }
@@ -1885,7 +2005,7 @@ function registerProjectCommands(program2) {
 }
 
 // src/commands/reconcile.ts
-var EXIT_OK = 0;
+var EXIT_OK2 = 0;
 var EXIT_USAGE = 2;
 var EXIT_SERVER = 3;
 var HTTP_CLIENT_ERROR_MIN = 400;
@@ -1948,7 +2068,7 @@ async function performReconcile(idOrShortId, opts = {}) {
 `
     );
     console.log(JSON.stringify(response, null, 2));
-    process.exitCode = EXIT_OK;
+    process.exitCode = EXIT_OK2;
     return;
   }
   process.stderr.write("[prim] reconcile: malformed server response\n");
@@ -1968,23 +2088,23 @@ function registerReconcileCommands(program2) {
 
 // src/commands/session.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readdirSync,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync5
 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var DIR_MODE2 = 448;
 var FILE_MODE3 = 384;
 function ensureDir() {
-  if (!existsSync6(SESSIONS_DIR)) {
+  if (!existsSync7(SESSIONS_DIR)) {
     mkdirSync5(SESSIONS_DIR, { recursive: true, mode: DIR_MODE2 });
   }
 }
 function markerPath(sessionId) {
-  return join5(SESSIONS_DIR, `${sessionId}.json`);
+  return join6(SESSIONS_DIR, `${sessionId}.json`);
 }
 function registerSessionCommands(program2) {
   const session = program2.command("session").description("Decision Event Pipeline \u2014 session binding markers");
@@ -2000,7 +2120,7 @@ function registerSessionCommands(program2) {
     console.log(`[prim] session ${sessionId} bound to org ${opts.orgId}`);
   });
   session.command("list").description("List active session markers").action(() => {
-    if (!existsSync6(SESSIONS_DIR)) {
+    if (!existsSync7(SESSIONS_DIR)) {
       console.log("[prim] no session markers");
       return;
     }
@@ -2012,7 +2132,7 @@ function registerSessionCommands(program2) {
     for (const f of files) {
       const sessionId = f.replace(/\.json$/, "");
       try {
-        const m = JSON.parse(readFileSync6(join5(SESSIONS_DIR, f), "utf-8"));
+        const m = JSON.parse(readFileSync7(join6(SESSIONS_DIR, f), "utf-8"));
         console.log(`${sessionId}  org=${m.orgId}`);
       } catch {
       }
@@ -2020,7 +2140,7 @@ function registerSessionCommands(program2) {
   });
   session.command("drop <sessionId>").description("Remove a session marker").action((sessionId) => {
     const p = markerPath(sessionId);
-    if (!existsSync6(p)) {
+    if (!existsSync7(p)) {
       console.log(`[prim] no marker for session ${sessionId}`);
       return;
     }
@@ -2032,17 +2152,17 @@ function registerSessionCommands(program2) {
 // src/commands/skill.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   fsyncSync as fsyncSync2,
   openSync as openSync2,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   renameSync as renameSync3,
   writeFileSync as writeFileSync6
 } from "fs";
-import { dirname as dirname3, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
+import { dirname as dirname4, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { createPatch } from "diff";
-var __dirname = dirname3(fileURLToPath(import.meta.url));
+var __dirname = dirname4(fileURLToPath2(import.meta.url));
 var SKILL_BEGIN = "<!-- BEGIN PRIM SKILL v1 -->";
 var SKILL_END = "<!-- END PRIM SKILL v1 -->";
 var TARGET_CANDIDATES = [
@@ -2055,15 +2175,15 @@ var TARGET_CANDIDATES = [
 var DEFAULT_TARGET = "CLAUDE.md";
 function loadSkill() {
   let dir = __dirname;
-  while (dir !== dirname3(dir)) {
+  while (dir !== dirname4(dir)) {
     const p = resolve2(dir, "SKILL.md");
-    if (existsSync7(p)) return readFileSync7(p, "utf-8");
-    dir = dirname3(dir);
+    if (existsSync8(p)) return readFileSync8(p, "utf-8");
+    dir = dirname4(dir);
   }
   throw new Error("SKILL.md not found in package");
 }
 function detectTargets(cwd) {
-  return TARGET_CANDIDATES.filter((p) => existsSync7(resolve2(cwd, p)));
+  return TARGET_CANDIDATES.filter((p) => existsSync8(resolve2(cwd, p)));
 }
 function detectNewline(content) {
   return content.includes("\r\n") ? "\r\n" : "\n";
@@ -2112,7 +2232,7 @@ function resolveTarget(cwd, override) {
 function runInstall(cwd, opts) {
   const target = resolveTarget(cwd, opts.target);
   if (target === null) return 1;
-  const existing = existsSync7(target) ? readFileSync7(target, "utf-8") : "";
+  const existing = existsSync8(target) ? readFileSync8(target, "utf-8") : "";
   const eol = existing ? detectNewline(existing) : "\n";
   const block = composeBlock(loadSkill(), eol);
   const next = applyBlock(existing, block, eol);
@@ -2131,11 +2251,11 @@ function runInstall(cwd, opts) {
 function runUninstall(cwd, opts) {
   const target = resolveTarget(cwd, opts.target);
   if (target === null) return 1;
-  if (!existsSync7(target)) {
+  if (!existsSync8(target)) {
     console.log(`Skill block not present at ${target}`);
     return 0;
   }
-  const existing = readFileSync7(target, "utf-8");
+  const existing = readFileSync8(target, "utf-8");
   const next = removeBlock(existing);
   if (next === null) {
     console.log(`Skill block not present at ${target}`);
@@ -2148,10 +2268,10 @@ function runUninstall(cwd, opts) {
 function runStatus(cwd, opts) {
   const target = resolveTarget(cwd, opts.target);
   if (target === null) return 1;
-  const fileExists = existsSync7(target);
+  const fileExists = existsSync8(target);
   let installed = false;
   if (fileExists) {
-    const content = readFileSync7(target, "utf-8");
+    const content = readFileSync8(target, "utf-8");
     installed = content.includes(SKILL_BEGIN) && content.includes(SKILL_END);
   }
   if (opts.json) {
@@ -2188,7 +2308,7 @@ function registerSkillCommands(program2) {
 }
 
 // src/commands/spec.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } 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) => {
@@ -2242,7 +2362,7 @@ ${contexts.length} spec(s)`);
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync8(opts.file, "utf-8");
+        text = readFileSync9(opts.file, "utf-8");
       }
       const taskIds = opts.projectId ? opts.projectId.split(",").map((id) => id.trim()) : void 0;
       let linkedBranch;
@@ -2283,7 +2403,7 @@ ${contexts.length} spec(s)`);
       const client = getClient();
       let text = opts.text;
       if (opts.file) {
-        text = readFileSync8(opts.file, "utf-8");
+        text = readFileSync9(opts.file, "utf-8");
       }
       if (!(text || opts.name)) {
         console.error("Provide --text, --file, or --name to update.");
@@ -2454,17 +2574,17 @@ ${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";
+import { readFileSync as readFileSync10 } from "fs";
+import { dirname as dirname5, resolve as resolve3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var STATUSLINE_TIMEOUT_MS = 200;
 function readPackageVersion() {
   try {
-    const here = dirname4(fileURLToPath2(import.meta.url));
+    const here = dirname5(fileURLToPath3(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"));
+        const pkg2 = JSON.parse(readFileSync10(path, "utf-8"));
         if (pkg2.version) {
           return pkg2.version;
         }
@@ -2509,8 +2629,8 @@ function registerStatuslineCommands(program2) {
 }
 
 // src/index.ts
-var __dirname2 = dirname5(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(readFileSync10(resolve4(__dirname2, "../package.json"), "utf-8"));
+var __dirname2 = dirname6(fileURLToPath4(import.meta.url));
+var pkg = JSON.parse(readFileSync11(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(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primitive.ai/prim",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "description": "CLI for managing Primitive specs, contexts, and git hooks",
   "type": "module",
   "license": "MIT",
@@ -30,6 +30,7 @@
   "bin": {
     "prim": "dist/index.js",
     "prim-pre-commit": "dist/hooks/pre-commit.js",
+    "prim-post-commit": "dist/hooks/post-commit.js",
     "prim-hook": "dist/hooks/prim-hook.js",
     "prim-pre-tool-use": "dist/hooks/pre-tool-use.js",
     "prim-post-tool-use": "dist/hooks/post-tool-use.js",
@@ -45,9 +46,9 @@
     "SKILL.md"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/hooks/pre-commit.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts src/daemon/server.ts --format esm --clean",
-    "postbuild": "chmod +x ./dist/index.js ./dist/hooks/pre-commit.js ./dist/hooks/prim-hook.js ./dist/hooks/pre-tool-use.js ./dist/hooks/post-tool-use.js ./dist/hooks/session-start.js ./dist/hooks/session-end.js ./dist/daemon/server.js",
-    "dev": "tsup src/index.ts src/hooks/pre-commit.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts src/daemon/server.ts --format esm --watch --clean",
+    "build": "tsup src/index.ts src/hooks/pre-commit.ts src/hooks/post-commit.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts src/daemon/server.ts --format esm --clean",
+    "postbuild": "chmod +x ./dist/index.js ./dist/hooks/pre-commit.js ./dist/hooks/post-commit.js ./dist/hooks/prim-hook.js ./dist/hooks/pre-tool-use.js ./dist/hooks/post-tool-use.js ./dist/hooks/session-start.js ./dist/hooks/session-end.js ./dist/daemon/server.js",
+    "dev": "tsup src/index.ts src/hooks/pre-commit.ts src/hooks/post-commit.ts src/hooks/prim-hook.ts src/hooks/pre-tool-use.ts src/hooks/post-tool-use.ts src/hooks/session-start.ts src/hooks/session-end.ts src/daemon/server.ts --format esm --watch --clean",
     "clean": "rm -rf dist coverage",
     "lint": "biome check src/",
     "format": "biome check --fix src/",