@primitive.ai/prim 0.1.0-alpha.16 → 0.1.0-alpha.18

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-PTLXSXIY.js → chunk-6LAQVM26.js}

@@ -1,30 +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) {
-  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
-  };
-}
-function shouldFlushAfter(eventType) {
-  return eventType === "SessionEnd";
-}
-
 // src/hooks/redact.ts
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
@@ -105,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/chunk-7YRBACIE.js

@@ -0,0 +1,9 @@
+// src/hooks/agent.ts
+function parseAgent(argv) {
+  const i = argv.indexOf("--agent");
+  return i !== -1 && argv[i + 1] === "codex" ? "codex" : "claude_code";
+}
+
+export {
+  parseAgent
+};

package/dist/{chunk-S47B4VGC.js → chunk-TPQ3X244.js}

@@ -1,6 +1,31 @@
 import {
   getClient
 } from "./chunk-6SIEWWUL.js";
+import {
+  daemonRequest
+} from "./chunk-UTKQTZHL.js";
+
+// src/daemon/proxy.ts
+var DAEMON_HTTP_TIMEOUT_MS = 1e4;
+var DAEMON_PROBE_TIMEOUT_MS = 250;
+async function daemonOrDirect(method, params, direct) {
+  const fromDaemon = await daemonRequest(method, params, {
+    timeoutMs: DAEMON_PROBE_TIMEOUT_MS
+  });
+  if (fromDaemon !== null) {
+    return fromDaemon;
+  }
+  return await direct();
+}
+async function daemonOrDirectGet(method, path, client, timeoutMs = DAEMON_HTTP_TIMEOUT_MS) {
+  return await daemonOrDirect(
+    method,
+    { path },
+    async () => await client.get(path, {
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+  );
+}
 
 // src/hooks/decisions-check.ts
 var DECISIONS_CHECK_TIMEOUT_MS = 1e4;
@@ -19,9 +44,12 @@ async function fetchAffecting(client, batch) {
     params.append("files", file);
   }
   try {
-    return await client.get(`/api/cli/decisions/affecting?${params.toString()}`, {
-      signal: AbortSignal.timeout(DECISIONS_CHECK_TIMEOUT_MS)
-    });
+    return await daemonOrDirectGet(
+      "decisions_affecting",
+      `/api/cli/decisions/affecting?${params.toString()}`,
+      client,
+      DECISIONS_CHECK_TIMEOUT_MS
+    );
   } catch (err) {
     const detail = err instanceof Error ? err.message : String(err);
     return { decisions: [], truncated: false, unavailable: `decision check failed: ${detail}` };
@@ -116,6 +144,7 @@ function getGitContext() {
 }
 
 export {
+  daemonOrDirectGet,
   checkAffectedDecisions,
   formatDecisionsWarning,
   getGitContext

package/dist/daemon/server.js

@@ -16,6 +16,7 @@ var PID_PATH = join(CONFIG_DIR, "daemon.pid");
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var TOKEN_CHECK_INTERVAL_MS = 6e4;
 var TOKEN_REFRESH_THRESHOLD_MS = 9e4;
+var HTTP_PROXY_TIMEOUT_MS = 1e4;
 var PRESENCE_FRESH_WINDOW_MS = 9e4;
 var SOCKET_DIR_MODE = 448;
 var PID_FILE_MODE = 384;
@@ -98,6 +99,22 @@ async function handleConflictCheck(params) {
   }
   return await client.post("/api/cli/decisions/conflict-check", { file: params.file });
 }
+function pathParam(params) {
+  if (typeof params.path !== "string" || !params.path.startsWith("/api/cli/")) {
+    throw new Error("proxy request requires `path: string` under /api/cli/");
+  }
+  return params.path;
+}
+function assertEndpointPath(path, endpoint) {
+  if (path !== endpoint && !path.startsWith(`${endpoint}?`)) {
+    throw new Error(`proxy path must be ${endpoint} or ${endpoint}?...`);
+  }
+}
+async function proxyGet(params, allowedPrefix) {
+  const path = pathParam(params);
+  assertEndpointPath(path, allowedPrefix);
+  return await client.get(path, { signal: AbortSignal.timeout(HTTP_PROXY_TIMEOUT_MS) });
+}
 function handleStatusSnapshot() {
   const presenceFresh = lastOkAtLocal !== void 0 && Date.now() - lastOkAtLocal < PRESENCE_FRESH_WINDOW_MS;
   const presenceStale = lastOkAtLocal !== void 0 && !presenceFresh;
@@ -120,6 +137,22 @@ async function dispatchRequest(req) {
         const result = await handleConflictCheck(req.params ?? {});
         return { id, ok: true, result };
       }
+      case "decisions_recent": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/recent");
+        return { id, ok: true, result };
+      }
+      case "decisions_show": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/show");
+        return { id, ok: true, result };
+      }
+      case "decisions_cascade": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/cascade");
+        return { id, ok: true, result };
+      }
+      case "decisions_affecting": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/affecting");
+        return { id, ok: true, result };
+      }
       case "session_start": {
         const sid = req.params?.sessionId;
         if (typeof sid === "string" && sid.length > 0) {

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,14 @@ import {
   getClient
 } from "../chunk-6SIEWWUL.js";
 import {
-  scrubFromCwd,
+  scrubFromCwd
+} from "../chunk-6LAQVM26.js";
+import {
   toMove
-} from "../chunk-PTLXSXIY.js";
+} from "../chunk-7GHOFNJ2.js";
+import {
+  parseAgent
+} from "../chunk-7YRBACIE.js";
 
 // src/hooks/post-tool-use.ts
 import { readFileSync } from "fs";
@@ -36,6 +41,7 @@ function isVerdictFooterContext(value) {
 var STDIN_TIMEOUT_MS = 1e3;
 var INGEST_TIMEOUT_MS = 4e3;
 var EDITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
+var CODEX_EDITING_TOOLS = /* @__PURE__ */ new Set(["apply_patch"]);
 var here = dirname(fileURLToPath(import.meta.url));
 function resolveCliVersion() {
   try {
@@ -100,7 +106,9 @@ async function main() {
     return;
   }
   const toolName = typeof envelope.tool_name === "string" ? envelope.tool_name : "";
-  if (!EDITING_TOOLS.has(toolName)) {
+  const agent = parseAgent(process.argv);
+  const editingTools = agent === "codex" ? CODEX_EDITING_TOOLS : EDITING_TOOLS;
+  if (!editingTools.has(toolName)) {
     emit();
     return;
   }
@@ -109,7 +117,7 @@ async function main() {
     return;
   }
   const cwd = parsed.cwd ?? process.cwd();
-  const base = toMove(parsed, resolveCliVersion());
+  const base = toMove(parsed, resolveCliVersion(), agent);
   const move = { ...base, payload: scrubFromCwd(parsed, cwd) };
   try {
     const result = await ingestMove(move);

package/dist/hooks/pre-commit.js

@@ -3,10 +3,11 @@ import {
   checkAffectedDecisions,
   formatDecisionsWarning,
   getGitContext
-} from "../chunk-S47B4VGC.js";
+} from "../chunk-TPQ3X244.js";
 import {
   getClient
 } from "../chunk-6SIEWWUL.js";
+import "../chunk-UTKQTZHL.js";
 
 // src/hooks/pre-commit.ts
 import { execSync } from "child_process";

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

@@ -2,6 +2,9 @@
 import {
   getClient
 } from "../chunk-6SIEWWUL.js";
+import {
+  parseAgent
+} from "../chunk-7YRBACIE.js";
 import {
   daemonRequest
 } from "../chunk-UTKQTZHL.js";
@@ -43,7 +46,7 @@ function unverifiedNote(results) {
   }
   return causes.map((c) => `[primitive] ${c}`).join("\n");
 }
-function buildHookOutput(aggregate, results) {
+function buildHookOutput(aggregate, results, agent = "claude_code") {
   if (aggregate === "deny") {
     const reason = results.filter((r) => r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n") || "[primitive] conflict detected (no detail available)";
     return {
@@ -54,6 +57,18 @@ function buildHookOutput(aggregate, results) {
       }
     };
   }
+  if (agent === "codex" && aggregate === "ask") {
+    const reason = results.filter((r) => r.verdict === "ask" || r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n");
+    const context = results.map((r) => r.additionalContext).filter((s) => s.length > 0).join("\n");
+    const merged = [reason, context].filter((s) => s.length > 0).join("\n\n");
+    const out = {
+      hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" }
+    };
+    if (merged.length > 0) {
+      out.hookSpecificOutput.additionalContext = merged;
+    }
+    return out;
+  }
   if (aggregate === "ask") {
     const reason = results.filter((r) => r.verdict === "ask" || r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n") || "[primitive] please confirm this edit";
     const additionalContext = results.map((r) => r.additionalContext).filter((s) => s.length > 0).join("\n");
@@ -98,7 +113,32 @@ function failOpenOutput() {
   };
 }
 var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
-function extractFilePaths(toolName, toolInput) {
+var APPLY_PATCH_FILE_RE = /^\*\*\* (?:Update|Add|Delete) File: (?<path>.+)$/;
+var LINE_SPLIT_RE = /\r?\n/;
+function parseApplyPatchPaths(command) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of command.split(LINE_SPLIT_RE)) {
+    const path = APPLY_PATCH_FILE_RE.exec(line)?.groups?.path?.trim();
+    if (path) {
+      paths.add(path);
+    }
+  }
+  return Array.from(paths);
+}
+function extractCodexFilePaths(toolName, toolInput) {
+  if (toolName !== "apply_patch") {
+    return [];
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return [];
+  }
+  const command = toolInput.command;
+  return typeof command === "string" ? parseApplyPatchPaths(command) : [];
+}
+function extractFilePaths(toolName, toolInput, agent = "claude_code") {
+  if (agent === "codex") {
+    return extractCodexFilePaths(toolName, toolInput);
+  }
   if (!SUPPORTED_TOOLS.has(toolName)) {
     return [];
   }
@@ -199,7 +239,10 @@ async function main() {
   }
   const toolName = typeof envelope.tool_name === "string" ? envelope.tool_name : "";
   const cwd = typeof envelope.cwd === "string" && envelope.cwd.length > 0 ? envelope.cwd : process.cwd();
-  const files = extractFilePaths(toolName, envelope.tool_input).map((f) => toRepoRelative(f, cwd));
+  const agent = parseAgent(process.argv);
+  const files = extractFilePaths(toolName, envelope.tool_input, agent).map(
+    (f) => toRepoRelative(f, cwd)
+  );
   if (files.length === 0) {
     emit(failOpenOutput());
     return;
@@ -213,7 +256,7 @@ async function main() {
   }
   const rawAggregate = aggregateCheckResults(results);
   const aggregate = demoteForMode(rawAggregate, mode);
-  emit(buildHookOutput(aggregate, results));
+  emit(buildHookOutput(aggregate, results, agent));
 }
 main().catch(() => {
   emit(failOpenOutput());

package/dist/hooks/prim-hook.js

@@ -4,10 +4,15 @@ import {
   resolveOrg
 } from "../chunk-JZGWQDM5.js";
 import {
-  scrubFromCwd,
+  scrubFromCwd
+} from "../chunk-6LAQVM26.js";
+import {
   shouldFlushAfter,
   toMove
-} from "../chunk-PTLXSXIY.js";
+} from "../chunk-7GHOFNJ2.js";
+import {
+  parseAgent
+} from "../chunk-7YRBACIE.js";
 
 // src/hooks/prim-hook.ts
 import { spawn } from "child_process";
@@ -34,7 +39,7 @@ try {
   const raw = readFileSync(0, "utf-8");
   const parsed = JSON.parse(raw);
   const cwd = parsed.cwd ?? process.cwd();
-  const base = toMove(parsed, resolveCliVersion());
+  const base = toMove(parsed, resolveCliVersion(), parseAgent(process.argv));
   const move = { ...base, payload: scrubFromCwd(parsed, cwd) };
   const { orgId } = resolveOrg({ sessionId: move.sessionId, cwd: move.env.cwd });
   appendMove(move, orgId);

package/dist/hooks/session-start.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  parseAgent
+} from "../chunk-7YRBACIE.js";
 import {
   daemonRequest
 } from "../chunk-UTKQTZHL.js";
@@ -23,8 +26,19 @@ function readStdin() {
     });
   });
 }
-function emit() {
-  process.stdout.write("{}\n");
+function emit(additionalContext) {
+  if (!additionalContext) {
+    process.stdout.write("{}\n");
+    return;
+  }
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext
+    }
+  };
+  process.stdout.write(`${JSON.stringify(out)}
+`);
 }
 async function main() {
   let raw;
@@ -54,6 +68,17 @@ async function main() {
     { sessionId: envelope.session_id },
     { timeoutMs: DAEMON_TIMEOUT_MS }
   );
+  if (parseAgent(process.argv) === "codex") {
+    const snapshot = await daemonRequest(
+      "status_snapshot",
+      {},
+      { timeoutMs: DAEMON_TIMEOUT_MS }
+    );
+    if (snapshot && !snapshot.presenceStale && typeof snapshot.onlineCount === "number") {
+      emit(`[prim] team: ${snapshot.onlineCount} online`);
+      return;
+    }
+  }
   emit();
 }
 main().catch(() => {

package/dist/index.js

@@ -6,9 +6,10 @@ import {
 } from "./chunk-BEEGFDGU.js";
 import {
   checkAffectedDecisions,
+  daemonOrDirectGet,
   formatDecisionsWarning,
   getGitContext
-} from "./chunk-S47B4VGC.js";
+} from "./chunk-TPQ3X244.js";
 import {
   HttpError,
   REFRESH_TOKEN_PATH,
@@ -532,6 +533,154 @@ ${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";
+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 readFileSync3 } from "fs";
 function registerContextCommands(program2) {
@@ -652,11 +801,11 @@ ${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 homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 var DAEMON_BIN = "prim-daemon-server";
-var PID_PATH = join2(homedir2(), ".config", "prim", "daemon.pid");
-var SOCK_PATH = join2(homedir2(), ".config", "prim", "sock");
+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;
@@ -1036,9 +1185,12 @@ async function fetchCascade(idOrShortId, deps = defaultDeps) {
   const params = new URLSearchParams({ id: idOrShortId });
   const client = deps.getClient();
   try {
-    return await client.get(`/api/cli/decisions/cascade?${params.toString()}`, {
-      signal: AbortSignal.timeout(CASCADE_TIMEOUT_MS)
-    });
+    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);
@@ -1063,9 +1215,12 @@ async function fetchRecent(args, deps = defaultDeps2) {
   }
   const client = deps.getClient();
   try {
-    const res = await client.get(`/api/cli/decisions/recent?${params.toString()}`, {
-      signal: AbortSignal.timeout(RECENT_TIMEOUT_MS)
-    });
+    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;
@@ -1092,6 +1247,8 @@ function authorLabel(row) {
   switch (row.producerKind) {
     case "claude_code":
       return "Your Claude Code";
+    case "codex":
+      return "Your Codex";
     case "chat":
       return "Your chat";
     case "spec_edit":
@@ -1232,9 +1389,12 @@ async function fetchShow(idOrShortId, deps = defaultDeps4) {
   const params = new URLSearchParams({ id: idOrShortId });
   const client = deps.getClient();
   try {
-    return await client.get(`/api/cli/decisions/show?${params.toString()}`, {
-      signal: AbortSignal.timeout(SHOW_TIMEOUT_MS)
-    });
+    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);
@@ -1417,30 +1577,39 @@ import { execSync } from "child_process";
 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
-# 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"
@@ -1464,8 +1633,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;
@@ -1479,52 +1648,63 @@ async function askConfirmation(question) {
     rl.close();
   }
 }
-function installToHusky(gitRoot) {
-  const hookPath = resolve(gitRoot, ".husky", "pre-commit");
+function installToHusky(gitRoot, spec = PRE_COMMIT) {
+  const hookPath = resolve(gitRoot, ".husky", spec.hookName);
   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.");
+    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");
+  const hookPath = resolve(hooksDir, spec.hookName);
   if (!existsSync4(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 (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"
@@ -1535,10 +1715,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."
@@ -1549,30 +1729,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 (!existsSync4(hookPath)) {
+        console.log(`No ${spec.hookName} hook found.`);
+        continue;
+      }
+      if (containsPrimHook(readFileSync5(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 join3 } from "path";
+import { join as join4 } from "path";
 
 // src/flusher.ts
 import { renameSync as renameSync2, unlinkSync as unlinkSync3 } from "fs";
@@ -1681,18 +1867,18 @@ 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 = join3(process.cwd(), ".prim");
+    const dir = join4(process.cwd(), ".prim");
     if (!existsSync5(dir)) {
       mkdirSync4(dir, { recursive: true, mode: DIR_MODE });
     }
-    const file = join3(process.cwd(), WORKSPACE_FILE);
+    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 = join3(process.cwd(), WORKSPACE_FILE);
+    const file = join4(process.cwd(), WORKSPACE_FILE);
     if (!existsSync5(file)) {
       console.log("[prim] no workspace binding in cwd");
       return;
@@ -1815,7 +2001,7 @@ import {
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync5
 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var DIR_MODE2 = 448;
 var FILE_MODE3 = 384;
 function ensureDir() {
@@ -1824,7 +2010,7 @@ function ensureDir() {
   }
 }
 function markerPath(sessionId) {
-  return join4(SESSIONS_DIR, `${sessionId}.json`);
+  return join5(SESSIONS_DIR, `${sessionId}.json`);
 }
 function registerSessionCommands(program2) {
   const session = program2.command("session").description("Decision Event Pipeline \u2014 session binding markers");
@@ -1852,7 +2038,7 @@ function registerSessionCommands(program2) {
     for (const f of files) {
       const sessionId = f.replace(/\.json$/, "");
       try {
-        const m = JSON.parse(readFileSync6(join4(SESSIONS_DIR, f), "utf-8"));
+        const m = JSON.parse(readFileSync6(join5(SESSIONS_DIR, f), "utf-8"));
         console.log(`${sessionId}  org=${m.orgId}`);
       } catch {
       }
@@ -1887,6 +2073,7 @@ 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"
@@ -2366,6 +2553,7 @@ registerMovesCommands(program);
 registerSessionCommands(program);
 registerDecisionsCommands(program);
 registerClaudeCommands(program);
+registerCodexCommands(program);
 registerDaemonCommands(program);
 registerReconcileCommands(program);
 registerStatuslineCommands(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primitive.ai/prim",
-  "version": "0.1.0-alpha.16",
+  "version": "0.1.0-alpha.18",
   "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/",