@primitive.ai/prim 0.1.0-alpha.93 → 0.1.0-alpha.96

package/README.md

@@ -75,7 +75,7 @@ Install the Primitive CLI and activate passive decision capture for this reposit
 ```
 
 That single command runs the whole install and current-repository activation in one
-process (auth → session hooks → daemon → git hooks → skill → welcome). The detailed
+process (auth → session hooks → daemon → skill → activate this repository and wire its git hooks → welcome). The detailed
 step-by-step the agent follows — and the manual fallback — live in
 [`setup.md`](./setup.md).
 
@@ -89,12 +89,17 @@ prim setup --agent cursor    # Same, for Cursor IDE and Cursor CLI
 prim setup --agent codex     # Same, for OpenAI Codex
 prim setup --agent hermes    # Same, for Hermes Agent (global-only config)
 prim setup --no-daemon       # Stop it and persistently opt out of supervised delivery
+prim setup --global-hooks-path  # Also route every repository's git hooks through prim
 ```
 
-Orchestrates auth → session hooks → supervised daemon → capture-health gate → git hooks → skill → welcome,
+Orchestrates auth → session hooks → supervised daemon → git hooks (`--scope project`, or `--global-hooks-path`) → skill → activate this repo (which wires its git hooks) → capture-health gate → welcome,
 re-running each underlying command so every step behaves exactly as if run by
 hand (including the browser login). Idempotent — safe to re-run.
 
+Setup wires the current repository's git hooks and never changes git's global
+config on its own: a global `core.hooksPath` reroutes every repository on the
+machine. Pass `--global-hooks-path` to opt in; `prim --yes setup` does not.
+
 ### Uninstall
 
 ```bash
@@ -143,9 +148,12 @@ graph, and presence is reported. Each hook
 self-resolves the CLI at run time (PATH, then a local install, then
 `npx --yes @latest`), so it keeps working with no global install.
 
-Installs into the current project by default — the repo's `.claude/settings.json`,
-`.cursor/hooks.json`, or `.codex/hooks.json`, resolved from the git root (so any subdirectory works);
-pass `--scope user` to install machine-wide. Hermes is the exception: it reads
+Installs into the current project by default — the repo's `.claude/settings.json`
+or `.cursor/hooks.json`, resolved from the git root (so any subdirectory works);
+pass `--scope user` to install machine-wide. Codex defaults to user scope
+(`~/.codex/hooks.json`): Codex reads a project `.codex/hooks.json` only from the
+checkout it lives in and trusts it by absolute path, so a project install covers
+that checkout only, not the repo's other worktrees. Hermes is the exception: it reads
 shell hooks only from the global `~/.hermes/config.yaml`, so `prim hermes install`
 is always user-scoped — and prim merges in place, leaving the rest of that file
 (providers, models, your own hooks) untouched.
@@ -155,7 +163,7 @@ prim claude install                # Install Claude Code hooks (project scope; u
 prim claude install --scope user   # Install machine-wide instead
 prim cursor install                # Install native Cursor hooks (project scope)
 prim cursor install --scope user   # Install hooks, skill, and CLI footer machine-wide
-prim codex install                 # Install OpenAI Codex hooks (project scope)
+prim codex install                 # Install OpenAI Codex hooks (user scope; --scope project for this checkout only)
 prim hermes install                # Install Hermes Agent hooks (global ~/.hermes/config.yaml)
 ```
 
@@ -321,15 +329,52 @@ authorizes one retry for the named decision.
 ### Hooks
 
 ```bash
-prim hooks install     # Install git hooks (pre-commit decision check + post-commit capture)
-prim hooks uninstall   # Remove the prim git hooks
+prim hooks install                # Wire the pre-commit, post-commit, and post-rewrite hooks
+prim hooks install --scope user --global-hooks-path  # Route every repository through prim (exits 3, with the reason on STDERR, if it installs nothing; 1 if prim's hook runtime is not staged)
+prim hooks snippet post-commit    # Print the block that wires one hook, to place by hand
+prim hooks uninstall              # Remove prim's blocks (and any hook file prim created)
 ```
 
 The pre-commit hook checks staged files against the live decision graph
-(warn-only — it never blocks the commit). The post-commit hook records each
-commit as a capture boundary for classification. Supports
-[Husky](https://typicode.github.io/husky/) — `prim hooks install` detects Husky
-and offers to install into `.husky/`.
+(warn-only — it never blocks the commit). The post-commit and post-rewrite hooks
+record each commit and each amend/rebase as capture boundaries for
+classification. All three act only in repos where prim is active (`prim enable`).
+Supports [Husky](https://typicode.github.io/husky/) — `prim hooks install`
+detects Husky and offers to install into `.husky/`.
+
+Each hook file gets one short block, inserted right after the shebang so it runs
+before any `exit` or `exec`. The block names no version and no machine path: it
+runs prim's staged entrypoint (`~/.config/prim/prim-git-hook-v1`) and does
+nothing on a machine without prim, so a tracked `.husky/*` file never changes
+across prim releases. `prim enable` and `prim hooks install` write it once and
+never move or rewrite a current block, reformatted or not. Agent session hooks
+only repair Git-private hook files under `.git` and prim's own hooks dir, and
+never add the pre-commit check. prim never edits a hooks dir outside the
+repository, such as a global `core.hooksPath` every repository shares, unless
+you run `prim hooks install --scope user --global-hooks-path` or answer yes at
+its terminal prompt. In a Husky v8 hook the block goes
+after the `husky.sh` line, so it runs once and honors `HUSKY=0`. `prim doctor`
+only reports; it never rewrites a hook.
+
+`prim doctor` also checks evidence rather than file contents: each post-commit
+run that reaches prim leaves a stamp in the checkout's git dir, and doctor's
+`hook-fired` check fails when a local commit made since the hooks were wired
+never reached prim. That catches an `exit` before prim's block, hand wiring
+that broke, or a git client whose environment cannot find prim. The check
+applies in manual mode too: once a repository is enabled, doctor expects your
+own wiring to reach prim. `prim disable` ends the expectation, so commits made
+while disabled are never judged. Turning prim off with `git config prim.active
+false` directly ends it too, once an agent session starts while it is off; if
+doctor still flags a commit made while it was off, run `prim disable` then
+`prim enable`.
+
+To wire the hooks yourself (lefthook, a custom Husky layout, …), run
+`git config prim.gitHooks manual` (or `--global`) first: prim then never writes
+a hook file. That setting is the only signal prim honors. It does not guess
+from a hook that already mentions prim, so without it, `prim enable` adds its
+block. Paste the block from `prim hooks snippet <hook>`, or have your hook
+manager run `~/.config/prim/prim-git-hook-v1 <hook> "$@"` (post-rewrite also
+needs Git's stdin).
 
 ### Presence statusline
 

package/SKILL.md

@@ -223,7 +223,7 @@ With the daemon running (`npx --yes @primitive.ai/prim daemon start`), `npx --ye
 
 ## The git hooks
 
-`npx --yes @primitive.ai/prim hooks install` installs two git hooks:
+`npx --yes @primitive.ai/prim hooks install` installs three git hooks:
 
 ```
 npx --yes @primitive.ai/prim hooks install                       # auto-detects Husky and prompts
@@ -234,8 +234,11 @@ npx --yes @primitive.ai/prim hooks uninstall
 
 - **pre-commit** -- checks staged files against the live decision graph and prints any active decisions that reference them to stderr. It is **warn-only**: failures (auth, network, backend) or matches never block the commit; a successful `git commit` doesn't prove the check ran clean. When the check can't complete it says so ("not verified" / "truncated") rather than implying all-clear.
 - **post-commit** -- records each commit as a capture boundary so the server can classify the surrounding work into decisions. It never blocks and runs in the background.
+- **post-rewrite** -- records amend/rebase rewrites the same way, in the background.
 
-Under `CI=1` (or with `--non-interactive`), `hooks install` fails fast in a Husky repo unless `--yes` or `--target` is set; the error names both escapes. `hooks uninstall` only removes the `.git/hooks` copies — if a hook was installed into `.husky/`, remove the prim block from that file manually. To suppress the hooks for one commit, use `git commit --no-verify`.
+All three act only where the repo is active (`prim enable`). Each hook file gets one version-stable block right after its shebang; `prim enable` and `hooks install` write it once and never rewrite a current block, while session hooks only repair Git-private files under `.git` (and never add the pre-commit check). prim never edits a hooks dir outside the repository, such as a shared global `core.hooksPath`: `hooks install --scope user` changes git's global hooks only with `--global-hooks-path` or a yes typed at a terminal. That changes every repository, so never pass the flag for the user without asking, and know that `--yes` does not count. `prim doctor`'s `hook-fired` check fails if a local commit since the hooks were wired never reached prim (in manual mode too, once the repo is enabled): surface it, since capture is silently missing. If the user wires the hooks themselves, they must set `git config prim.gitHooks manual` (prim does not infer hand wiring from what a hook mentions); prim then never edits their hook files; `npx --yes @primitive.ai/prim hooks snippet <hook>` prints the block to place.
+
+Under `CI=1` (or with `--non-interactive`), `hooks install` fails fast in a Husky repo that Husky has not yet configured, unless `--yes` or `--target` is set; the error names both escapes. `hooks uninstall` removes prim's blocks from `.git/hooks` and `.husky/` alike and leaves the rest of each hook untouched. To suppress the hooks for one commit, use `git commit --no-verify`.
 
 These git hooks are separate from the **session hooks** (`claude install` / `cursor install` / `codex install` / `hermes install`) that drive in-session capture (and Conflict Gates, when enabled).
 

package/dist/{chunk-UKUAAAXE.js → chunk-27ADT6FQ.js}

@@ -2,10 +2,10 @@ import {
   getClient,
   getSiteUrl,
   terminalSafeLine
-} from "./chunk-G2VMA2QO.js";
+} from "./chunk-LY6NJ7KL.js";
 import {
   daemonRequest
-} from "./chunk-OTHKG76J.js";
+} from "./chunk-35FMRWJH.js";
 
 // src/daemon/proxy.ts
 var DAEMON_HTTP_TIMEOUT_MS = 1e4;

package/dist/{chunk-OTHKG76J.js → chunk-35FMRWJH.js}

@@ -2,7 +2,7 @@ import {
   decodeJwtPayload,
   primConfigDirectory,
   resolveAuthCredential
-} from "./chunk-2GP5UFV7.js";
+} from "./chunk-DWRSEC34.js";
 
 // src/daemon/client.ts
 import { createConnection } from "net";

package/dist/{chunk-DXJQR4QI.js → chunk-4GHANPWQ.js}

@@ -1,13 +1,13 @@
 import {
   getSiteUrl
-} from "./chunk-G2VMA2QO.js";
+} from "./chunk-LY6NJ7KL.js";
 import {
   atomicWriteFile,
   ensureDurableDirectory,
   jwtOrganizationId,
   primConfigDirectory,
   resolveAuthCredential
-} from "./chunk-2GP5UFV7.js";
+} from "./chunk-DWRSEC34.js";
 
 // src/journal.ts
 import {