@primitive.ai/prim 0.1.0-alpha.47 → 0.1.0-alpha.49

package/README.md

@@ -11,8 +11,8 @@ presence — from the command line and via session + git hooks.
 > **Conflict Gates** check each edit against the decision graph and surface any
 > load-bearing decision it conflicts with; their **Enforcement** tier blocks or pauses
 > a conflicting edit until you reconcile and retry. Conflict Gates are **not currently
-> enabled** — automatic decision capture runs regardless. To enable them for your team,
-> contact **support@getprimitive.ai**.
+> enabled** — automatic decision capture in active repos runs regardless. To enable them
+> for your team, contact **support@getprimitive.ai**.
 
 ## Installation
 
@@ -28,6 +28,12 @@ Or run directly without installing:
 npx @primitive.ai/prim
 ```
 
+In commands such as `npx --yes @primitive.ai/prim@latest ...`, the first `--yes`
+belongs to **npm**: it skips npm's package-install confirmation. It does not approve a
+Primitive action. Prim's own global `--yes` comes after the package name, for example
+`npx --yes @primitive.ai/prim@latest --yes decisions create ...`, and applies only to
+that Prim invocation.
+
 ## Quick Start
 
 One command does the whole install — auth, session hooks, daemon, git hooks,
@@ -118,6 +124,24 @@ prim codex install                 # Install OpenAI Codex hooks (project scope)
 prim hermes install                # Install Hermes Agent hooks (global ~/.hermes/config.yaml)
 ```
 
+Passive capture is repo-scoped even when these integrations are installed at user
+scope. `prim enable` marks the current Git repo active; `prim disable` makes it
+inactive. A project-scoped install activates its repo automatically. In an inactive
+repo, session content is not passively captured. Here “inactive” means Prim's normal
+effective capture check is false, including an explicit local `prim.active=false`.
+
+An agent may still deliberately record one Decision from an inactive repo with
+`prim decisions create`, but each invocation needs its own user approval. An explicit
+request such as “record this Decision” supplies that approval for that one create; for
+a proactive suggestion, the agent must show the proposed Decision and ask first. The
+agent then passes Prim's global `--yes` for that invocation. This one-time approval does
+not activate passive capture, and neither npm's `npx --yes`, setup approval, nor an
+earlier create counts as approval for another Decision.
+
+When a person runs `prim decisions create` interactively in an inactive repo, Prim
+asks for that one-time approval itself. In non-interactive use it creates nothing
+unless Prim's global `--yes` is present.
+
 #### Claude decision feedback
 
 Claude Code receives eventual, human-visible feedback when automatic capture
@@ -199,6 +223,15 @@ prim decisions unlink <child> --on <parent>  # Remove that dependency
 `<id>` accepts a full decision ID or its short ID. STDOUT is machine-readable
 JSON; human-readable status goes to STDERR.
 
+When passive capture is inactive in the current repo, an approved one-time create is:
+
+```bash
+npx --yes @primitive.ai/prim@latest --yes decisions create --intent "…"
+```
+
+Here npm's first `--yes` only permits package resolution; Prim's second `--yes`
+confirms this create. It does not enable the repo or authorize a later create.
+
 `link` / `unlink` curate the dependency edges the automatic linker would otherwise
 own — `<child>` depends on `<parent>`. Both are idempotent and refuse any link that
 would create a cycle (exit 2); an unresolved id exits 4.
@@ -245,8 +278,8 @@ prim welcome           # Brief orientation to the decision graph (shown after se
 ### Session & journal
 
 Lower-level plumbing for the capture pipeline — org binding and the local move
-journal. Capture works automatically once the session hooks are installed; these
-are for inspecting and steering it (e.g. multi-org machines).
+journal. Capture works automatically once the session hooks are installed **and the
+repo is active**; these are for inspecting and steering it (e.g. multi-org machines).
 
 ```bash
 prim session start <id>   # Pin a Claude Code session to an org   (list / drop <id>)

package/SKILL.md

@@ -9,9 +9,9 @@ description: Use the prim CLI for Primitive's decision graph — passive capture
 
 ## Mental model
 
-As your team codes, prim passively captures the **decisions** you make -- which library, which pattern, which config value -- into a queryable graph, and links them: a decision can depend on earlier decisions (auto-linked from shared files, or related by hand — see *Relate decisions*) and reference the files it touched. **Conflict Gates** can check a later change against that graph and surface any load-bearing decision it conflicts with; with **Enforcement**, prim blocks the edit until you reconcile the decision and retry. Conflict Gates are **not currently enabled** — capture runs regardless. To enable them for your team, contact support@getprimitive.ai.
+In an active repo, prim passively captures the **decisions** your team makes -- which library, which pattern, which config value -- into a queryable graph, and links them: a decision can depend on earlier decisions (auto-linked from shared files, or related by hand — see *Relate decisions*) and reference the files it touched. **Conflict Gates** can check a later change against that graph and surface any load-bearing decision it conflicts with; with **Enforcement**, prim blocks the edit until you reconcile the decision and retry. Conflict Gates are **not currently enabled** — capture in active repos runs regardless. To enable them for your team, contact support@getprimitive.ai.
 
-Low-level capture runs automatically through the session hooks installed by `npx --yes @primitive.ai/prim claude install` (Claude Code), `npx --yes @primitive.ai/prim codex install` (Codex), or `npx --yes @primitive.ai/prim hermes install` (Hermes). Deliberately record higher-order forks in the road through `prim decisions create` as described below. Your job is also to **read** the graph before load-bearing edits and **answer** the occasional rationale confirmation. (Responding to Conflict Gates applies only once Enforcement is enabled — see below.)
+Low-level capture runs automatically in active repos through the session hooks installed by `npx --yes @primitive.ai/prim claude install` (Claude Code), `npx --yes @primitive.ai/prim codex install` (Codex), or `npx --yes @primitive.ai/prim hermes install` (Hermes). An inactive repo is not passively captured. Deliberately record higher-order forks in the road through `prim decisions create` as described below. Your job is also to **read** the graph before load-bearing edits and **answer** the occasional rationale confirmation. (Responding to Conflict Gates applies only once Enforcement is enabled — see below.)
 
 ## Auth
 
@@ -30,10 +30,11 @@ The CLI auto-refreshes a still-valid session from the stored refresh token (proa
 1. Every command accepts `--help`. When unsure of flags, run `npx --yes @primitive.ai/prim <cmd> --help` rather than guessing.
 2. The CLI prints API errors as one-liners to stderr and exits non-zero. Treat any non-zero exit as actionable. If auth-related, re-check `auth status`.
 3. `<idOrShortId>` arguments accept either a full decision ID or the short ID shown in feeds (and gate reasons, when Conflict Gates are enabled).
+4. In `npx --yes @primitive.ai/prim ...`, `npx --yes` is npm's flag and only skips npm's package-install confirmation. It is not user consent for a Primitive action. Prim's global flag appears after the package name: `npx --yes @primitive.ai/prim --yes ...`.
 
 ## Conflict Gates & Enforcement (not currently enabled)
 
-**Conflict Gates** check each edit against the decision graph before it lands and surface any load-bearing decision it conflicts with. Their **Enforcement** tier goes further -- a conflicting edit is blocked (or paused for confirmation) until you reconcile the decision and retry. **Conflict Gates are not currently enabled** — automatic decision capture (above) runs regardless. To enable Conflict Gates and Enforcement for your team, contact support@getprimitive.ai.
+**Conflict Gates** check each edit against the decision graph before it lands and surface any load-bearing decision it conflicts with. Their **Enforcement** tier goes further -- a conflicting edit is blocked (or paused for confirmation) until you reconcile the decision and retry. **Conflict Gates are not currently enabled** — automatic decision capture in active repos (above) runs regardless. To enable Conflict Gates and Enforcement for your team, contact support@getprimitive.ai.
 
 When Enforcement is enabled, before an edit (Claude Code: Edit/Write/MultiEdit; Codex: apply_patch; Hermes: write_file/patch) a PreToolUse hook scores the target file against the graph:
 
@@ -49,7 +50,9 @@ When enabled, the gate fail-opens on its *own* infrastructure errors (no daemon,
 - `npx --yes @primitive.ai/prim decisions recent` -- the team's recent decisions, each row badged by author and agent (`Your Claude Code` / `Your Codex` / `Your Hermes`); `--limit <n>` and `--since <dur>` narrow it. `--author "<name>"` filters to one teammate (feed name, `"First Last"`, last name, username, email, or email local-part) -- the way to answer "what has X decided?"; an unknown or ambiguous name comes back as `unavailable` with the reason, and `authorHasDecisions` in the JSON distinguishes "no feed-visible decisions" (false) from "has decisions, none in this window" (true). The page defaults to the 10 most recent, so it can hide older ones: on an author query the JSON's `windowTotal` is how many that teammate has in the window. When `windowTotal` exceeds the rows returned, don't present the page as complete -- tell the user you're showing the most recent N of `windowTotal` and offer to pull the rest, which is a re-run with `--limit <windowTotal>` (capped at 100; `windowTotalCapped` means the count is a floor rendered `N+`, and a window past 100 can't be fetched whole).
 - `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.
 
-Before presenting decision reads, use the current conversation, task, and available memory to understand what matters to the requester. Do not dump the API's chronological rows unchanged. Group related decisions around goals or workstreams, lead with decisions that affect the requester's current work, and surface conflicts, supersessions, or consequential tradeoffs before background activity. Explain why an item is relevant when the connection is supported; do not invent relevance or rationale. Preserve the response's `unavailable`, truncation, and count semantics when reshaping it.
+Before presenting decision reads, use the current conversation, task, and available memory to understand what matters to the requester and how they want it delivered. Do not dump the API's chronological rows unchanged. Group related decisions around goals or workstreams, lead with decisions that affect the requester's current work, and surface conflicts, supersessions, or consequential tradeoffs before background activity. Explain why an item is relevant when the connection is supported; do not invent relevance or rationale. Preserve the response's `unavailable`, truncation, and count semantics when reshaping it.
+
+Then tailor the delivery to this requester, not a generic reader. Take your cues from the signals actually present — durable preferences in memory, the format and depth they've used or asked for earlier in the conversation, and the shape of their current goal — and match the form (a one-line answer, a table, grouped headers, or prose), the depth (a bare intent versus full rationale, alternatives, and tradeoffs), the altitude (strategic direction versus specific ids and files), the fields they actually track, and the register of the exchange. Where a preference isn't evidenced, default to a concise, skimmable summary — read taste from signal the way you read rationale, never conjuring a persona from thin air. Tailoring changes how the facts land, never which facts: keep every conflict, supersession, and consequential tradeoff in view even when the requester wants it terse, and never let style override the `unavailable`, truncation, and count semantics above.
 
 ## Reconcile and the verdict footer
 
@@ -75,17 +78,17 @@ Confirmations are author-targeted and rare by design; answering keeps the graph'
 
 ## Preserve durable user decisions
 
-Capture is automatic for low-level choices made while coding. Use the deliberate CLI path for higher-order decisions that emerge in conversation: goals, priorities, principles, invariants, constraints, defaults, commitments, durable tradeoffs, and exceptions.
+Capture is automatic for low-level choices made while coding in an active repo. Use the deliberate CLI path for higher-order decisions that emerge in conversation: goals, priorities, principles, invariants, constraints, defaults, commitments, durable tradeoffs, and exceptions.
 
 A decision worth deliberately recording is a genuine **fork in the road**: the user or agent encountered multiple plausible paths, selected one, and that selection should inform future work. Record the chosen behavior, direction, constraint, or tradeoff—not routine implementation needed to finish the task or follow an existing convention. A teammate working elsewhere should benefit from knowing it.
 
-### Ground the rationale in available context
+### Ground the rationale in real sources
 
-Before deliberately recording a decision, use the full context already available to you to identify **why this path was chosen**. Start with the current conversation. When the decision or task points to relevant connected sources, inspect them too—especially Slack, Granola or other meeting notes, Linear, Zoom transcripts, email, and repository docs or skills. Prefer the specific thread, meeting, ticket, or document the user referenced over a broad search.
+Before deliberately recording a decision, actively gather the real context behind **why this path was chosen** — aim to populate the decision with as much genuine, source-grounded rationale as you can find, never a plausible-sounding guess. Start with the current conversation, then reach for every tool, connector, and MCP server available to you to pull from the actual sources the decision or task points to: Slack threads, Granola or other meeting notes, Linear issues, Zoom transcripts, email, and repository docs or skills. Don't limit yourself to that list — use whatever integrations you have. Read the source directly instead of inferring from memory, and target the specific thread, meeting, ticket, or document the user referenced rather than a broad, scattershot search.
 
 Record only rationale supported by those sources. Do not mistake the implementation method, the task request, or a restatement of the decision for its rationale. If the rationale remains unclear or the relevant source is unavailable, omit `--rationale` rather than inventing one.
 
-For proactively identified decisions, let confidence in the rationale determine the interaction:
+For proactively identified decisions in an active repo, let confidence in the rationale determine the interaction:
 
 - **Clear and well-supported** — record the decision and rationale silently at the natural task boundary.
 - **Plausible but uncertain** — at the task boundary, state the proposed rationale and ask for lightweight confirmation: “I understand the reason for choosing X to be Y. Is that right?” Record after confirmation or correction.
@@ -93,13 +96,35 @@ For proactively identified decisions, let confidence in the rationale determine
 
 These questions share the interruption budget below; never ask separate questions for the decision and its rationale. If both are uncertain, combine them into one concise prompt. An explicit request to “add this decision to Primitive” still records immediately with the information supplied—do not delay it to demand rationale.
 
+### Inactive repos: approve each deliberate create
+
+When passive capture is inactive for the current repo, do not silently turn a durable
+decision into a write. “Inactive” means Prim's effective repo-capture check is false;
+an explicit local `prim.active=false` is always inactive. Every
+`prim decisions create` invocation needs fresh user approval:
+
+- An explicit request to record or create that Decision is approval for that one
+  invocation; do not ask redundantly.
+- For a proactively identified Decision, present the proposed intent and supported
+  rationale, then wait for approval before creating it. A previous approval never
+  carries forward to another Decision.
+- After approval, pass Prim's global `--yes` for that invocation:
+  `npx --yes @primitive.ai/prim --yes decisions create ...`. The first `--yes` is
+  npm's package-install flag; the second is Prim's one-time confirmation.
+- Do not run `prim enable` merely to bypass this boundary or infer permission to
+  activate the repo. Activation requires a separate user request (a requested
+  `prim setup` counts because setup explicitly activates its current repo). A
+  one-time create leaves passive capture inactive; auth approval, npm's
+  `npx --yes`, setup's shell-permission grant, and earlier creates do not
+  independently change that state.
+
 ### Direct requests: record immediately
 
-When the user asks to record a decision—for example, “add this decision to Primitive”—author it directly. Do not ask for another confirmation.
+When the user asks to record a decision—for example, “add this decision to Primitive”—author it directly. Do not ask for another confirmation. In an inactive repo, the request is the one-time approval: use Prim's `--yes` for that create as described above.
 
 ### Clear decisions: record without interrupting
 
-When the user clearly makes a durable fork-in-the-road decision without explicitly asking to record it, record it at the next natural task boundary without asking a redundant confirmation question. Preserve the user's meaning and stated rationale; do not strengthen, broaden, or embellish it. Prefer the governing position over the implementation activity that revealed it.
+When the user clearly makes a durable fork-in-the-road decision without explicitly asking to record it, record it at the next natural task boundary without asking a redundant confirmation question **when passive capture is active**. In an inactive repo, present it and obtain the per-create approval above. Preserve the user's meaning and stated rationale; do not strengthen, broaden, or embellish it. Prefer the governing position over the implementation activity that revealed it.
 
 Examples that qualify:
 
@@ -138,12 +163,18 @@ Outside onboarding, before creating a proactively identified decision, read rece
 npx --yes @primitive.ai/prim decisions recent --limit 20
 ```
 
-If an equivalent decision is already present, do not create or suggest it again. After this duplicate check—or after the user confirms an onboarding proposal—author the decision directly:
+If an equivalent decision is already present, do not create or suggest it again. After this duplicate check—or after the user confirms an onboarding proposal—author the decision directly. If the repo is inactive, that confirmation authorizes Prim's `--yes` only for the approved create:
 
 ```
 npx --yes @primitive.ai/prim decisions create --intent "Adopt prosemirror-collab over Yjs" --area data --rationale "Server-authoritative ordering" --alternatives "Yjs,Automerge"
 ```
 
+Inactive-repo form after approval:
+
+```
+npx --yes @primitive.ai/prim --yes decisions create --intent "Adopt prosemirror-collab over Yjs" --area data --rationale "Server-authoritative ordering" --alternatives "Yjs,Automerge"
+```
+
 Only `--intent` is required. Optional: `--kind` (change|exploration|task_execution|unclear, default change), `--rationale`, `--area`, `--decided`, `--alternatives` (comma-separated), `--confidence` (high|medium|low, default high), `--reversibility` (high|low, default high), and `--files` (comma-separated repo-relative paths the decision governs — these are the files Conflict Gates would check on later edits, same path form as `decisions check`; Conflict Gates are not currently enabled). Omit `--files` for broad directions that should not immediately participate in file-based Conflict Gates. STDOUT is the created identity `{ decisionId, shortId, createdAt }`; STDERR prints `[prim] created dec_<short>.` — pass that `dec_<short>` straight into `decisions show` / `cascade` / `confirm`.
 
 ### Inferred decisions: finish first, then optionally ask once
@@ -225,11 +256,11 @@ Examples:
 - **An "unavailable" / "not verified" decision check is not an all-clear.** Treat constraints as UNKNOWN and proceed deliberately; never read the silence as approval — the same holds for Conflict Gates once enabled.
 - **When Enforcement is enabled, a `deny` means a real prior decision conflicts.** Reconcile only when you genuinely intend to override it; otherwise pick an approach that respects it.
 - **Reconcile bypasses are single-use and short-lived.** One bypass clears your *next* edit to the governed file; it is not a standing override.
-- **Capture of coding activity is automatic; never inject moves by hand.** If decisions aren't showing up, check that the session hooks are installed (`claude status` / `codex status` / `hermes status`) and the daemon is running. Deliberately authoring a higher-order fork—either at the user's request or under the conservative proactive policy above—is a separate, supported path through `decisions create`.
+- **Capture of coding activity is automatic only in active repos; never inject moves by hand.** If an active repo's decisions aren't showing up, check that the session hooks are installed (`claude status` / `codex status` / `hermes status`) and the daemon is running. Deliberately authoring a higher-order fork—either at the user's request or under the conservative proactive policy above—is a separate, supported path through `decisions create`; in an inactive repo, honor the per-invocation approval boundary above.
 - **Don't fabricate rationale on a confirmation.** If you don't know why a decision was made, say so rather than guessing.
 
 ## After each task
 
-If the user clearly made a durable fork-in-the-road decision, check recent decisions and record it now if it is not already present. If a strong higher-order decision was only inferred, decide whether it clears the interruption budget; if so, ask the single concise confirmation question after reporting the completed work. Otherwise say nothing about Primitive.
+If the user clearly made a durable fork-in-the-road decision, check recent decisions and record it now if it is not already present when capture is active. When capture is inactive, record it only if the user explicitly requested that create; otherwise present it for the per-invocation approval above. If a strong higher-order decision was only inferred, decide whether it clears the interruption budget; if so, ask the single concise confirmation question after reporting the completed work. Otherwise say nothing about Primitive.
 
 If Conflict Gates are enabled and one denied or warned you, report which decision(s) it named and whether you reconciled. If you read the graph before a load-bearing change, note what you found so the user can verify in the dashboard.

package/dist/{chunk-F7O7V6ZM.js → chunk-HSZPTVKU.js}

@@ -1,83 +1,11 @@
-// src/lib/activation.ts
-import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-
-// src/lib/git.ts
-import { execFileSync } from "child_process";
-function gitToplevel(cwd) {
-  try {
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/lib/activation.ts
-var PRIM_ACTIVE_KEY = "prim.active";
-var PROJECT_INSTALL_FILES = [".claude/settings.json", ".codex/hooks.json"];
-var PRIM_HOOK_BINS = ["prim-hook", "prim-pre-tool-use", "prim-post-tool-use"];
-function repoActiveFlag(cwd) {
-  try {
-    const value = execFileSync2("git", ["config", "--get", PRIM_ACTIVE_KEY], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-    if (value === "true") return "true";
-    if (value === "false") return "false";
-    return void 0;
-  } catch {
-    return void 0;
-  }
-}
-function setRepoActive(cwd, active) {
-  execFileSync2("git", ["config", "--local", PRIM_ACTIVE_KEY, active ? "true" : "false"], {
-    cwd,
-    stdio: ["ignore", "ignore", "pipe"]
-  });
-}
-function activateRepoBestEffort(cwd) {
-  try {
-    setRepoActive(cwd, true);
-  } catch {
-  }
-}
-function hasProjectPrimInstall(cwd) {
-  const root = gitToplevel(cwd);
-  if (root === null || root === homedir()) return false;
-  for (const rel of PROJECT_INSTALL_FILES) {
-    const path = join(root, rel);
-    if (existsSync(path)) {
-      try {
-        const content = readFileSync(path, "utf-8");
-        if (PRIM_HOOK_BINS.some((bin) => content.includes(bin))) return true;
-      } catch {
-      }
-    }
-  }
-  return false;
-}
-function isRepoActiveForCapture(cwd) {
-  const flag = repoActiveFlag(cwd);
-  if (flag === "true") return true;
-  if (flag === "false") return false;
-  return hasProjectPrimInstall(cwd);
-}
-
 // src/lib/bin-cache.ts
 import { chmodSync, mkdirSync, renameSync, writeFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { homedir } from "os";
+import { join as join2 } from "path";
 
 // src/lib/bin-path.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname, isAbsolute, join as join2 } from "path";
+import { existsSync, readFileSync } from "fs";
+import { dirname, isAbsolute, join } from "path";
 import { fileURLToPath } from "url";
 var PKG_NAME = "@primitive.ai/prim";
 var ROOT_WALK_LIMIT = 6;
@@ -91,10 +19,10 @@ function locateRoot() {
   }
   let dir = dirname(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < ROOT_WALK_LIMIT; depth++) {
-    const manifestPath = join2(dir, "package.json");
-    if (existsSync2(manifestPath)) {
+    const manifestPath = join(dir, "package.json");
+    if (existsSync(manifestPath)) {
       try {
-        const manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
         if (manifest.name === PKG_NAME && manifest.bin) {
           resolvedRoot = { dir, bin: manifest.bin };
           return resolvedRoot;
@@ -117,7 +45,7 @@ function binFile(bin) {
   if (!root || !rel) {
     return null;
   }
-  return isAbsolute(rel) ? rel : join2(root.dir, rel);
+  return isAbsolute(rel) ? rel : join(root.dir, rel);
 }
 function hookShimCommand(bin, args = "", opts = {}) {
   const invoke = (cmd) => args ? `${cmd} ${args}` : cmd;
@@ -146,8 +74,8 @@ function commandMatchesBin(command, bin) {
 // src/lib/bin-cache.ts
 var CACHED_BINS = ["prim", "prim-hook", "prim-pre-tool-use", "prim-post-tool-use"];
 function binCacheDir() {
-  const base = process.env.XDG_CACHE_HOME || join3(homedir2(), ".cache");
-  return join3(base, "prim", "bin");
+  const base = process.env.XDG_CACHE_HOME || join2(homedir(), ".cache");
+  return join2(base, "prim", "bin");
 }
 function writeAtomic(path, content) {
   const tmp = `${path}.${process.pid}.tmp`;
@@ -165,11 +93,11 @@ function warmBinCache() {
     const dir = binCacheDir();
     mkdirSync(dir, { recursive: true, mode: 448 });
     chmodSync(dir, 448);
-    writeAtomic(join3(dir, "node"), process.execPath);
+    writeAtomic(join2(dir, "node"), process.execPath);
     for (const bin of CACHED_BINS) {
       const file = binFile(bin);
       if (file) {
-        writeAtomic(join3(dir, bin), file);
+        writeAtomic(join2(dir, bin), file);
       }
     }
   } catch {
@@ -177,10 +105,6 @@ function warmBinCache() {
 }
 
 export {
-  gitToplevel,
-  setRepoActive,
-  activateRepoBestEffort,
-  isRepoActiveForCapture,
   binFile,
   hookShimCommand,
   detachedHookShimCommand,

package/dist/chunk-R5ZJRSLV.js

@@ -0,0 +1,82 @@
+// src/lib/activation.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/lib/git.ts
+import { execFileSync } from "child_process";
+function gitToplevel(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/activation.ts
+var PRIM_ACTIVE_KEY = "prim.active";
+var PROJECT_INSTALL_FILES = [".claude/settings.json", ".codex/hooks.json"];
+var PRIM_HOOK_BINS = ["prim-hook", "prim-pre-tool-use", "prim-post-tool-use"];
+function repoActiveFlag(cwd) {
+  try {
+    const value = execFileSync2("git", ["config", "--get", PRIM_ACTIVE_KEY], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (value === "true") return "true";
+    if (value === "false") return "false";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setRepoActive(cwd, active) {
+  execFileSync2("git", ["config", "--local", PRIM_ACTIVE_KEY, active ? "true" : "false"], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+}
+function activateRepoBestEffort(cwd) {
+  try {
+    setRepoActive(cwd, true);
+  } catch {
+  }
+}
+function hasProjectPrimInstall(cwd) {
+  const root = gitToplevel(cwd);
+  if (root === null || root === homedir()) return false;
+  for (const rel of PROJECT_INSTALL_FILES) {
+    const path = join(root, rel);
+    if (existsSync(path)) {
+      try {
+        const content = readFileSync(path, "utf-8");
+        if (PRIM_HOOK_BINS.some((bin) => content.includes(bin))) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function isRepoActiveForCapture(cwd) {
+  const flag = repoActiveFlag(cwd);
+  if (flag === "true") return true;
+  if (flag === "false") return false;
+  return hasProjectPrimInstall(cwd);
+}
+function decisionIngestionStatus(cwd) {
+  return isRepoActiveForCapture(cwd) ? "enabled" : "disabled";
+}
+
+export {
+  gitToplevel,
+  setRepoActive,
+  activateRepoBestEffort,
+  isRepoActiveForCapture,
+  decisionIngestionStatus
+};

package/dist/hooks/post-commit.js

@@ -6,6 +6,9 @@ import {
   appendMove,
   resolveOrg
 } from "../chunk-5K725K35.js";
+import {
+  isRepoActiveForCapture
+} from "../chunk-R5ZJRSLV.js";
 import "../chunk-TPROV45L.js";
 
 // src/hooks/post-commit.ts
@@ -53,20 +56,31 @@ function spawnBackgroundFlush() {
     stdio: "ignore"
   }).unref();
 }
-try {
+function runPostCommit() {
+  const cwd = git("rev-parse --show-toplevel") ?? process.cwd();
+  if (!isRepoActiveForCapture(cwd)) {
+    return;
+  }
   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}
+}
+if (!process.env.VITEST) {
+  try {
+    runPostCommit();
+  } 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);
 }
-process.exit(0);
+export {
+  runPostCommit
+};

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

@@ -18,9 +18,11 @@ import {
   getOrCreateWorkspaceId
 } from "../chunk-IMAIBPUC.js";
 import {
-  isRepoActiveForCapture,
   warmBinCache
-} from "../chunk-F7O7V6ZM.js";
+} from "../chunk-HSZPTVKU.js";
+import {
+  isRepoActiveForCapture
+} from "../chunk-R5ZJRSLV.js";
 import {
   getClient
 } from "../chunk-TPROV45L.js";

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

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
-  isRepoActiveForCapture,
   warmBinCache
-} from "../chunk-F7O7V6ZM.js";
+} from "../chunk-HSZPTVKU.js";
+import {
+  isRepoActiveForCapture
+} from "../chunk-R5ZJRSLV.js";
 import {
   getClient,
   getSiteUrl

package/dist/hooks/prim-hook.js

@@ -24,9 +24,11 @@ import {
   getOrCreateWorkspaceId
 } from "../chunk-IMAIBPUC.js";
 import {
-  isRepoActiveForCapture,
   warmBinCache
-} from "../chunk-F7O7V6ZM.js";
+} from "../chunk-HSZPTVKU.js";
+import {
+  isRepoActiveForCapture
+} from "../chunk-R5ZJRSLV.js";
 import "../chunk-TPROV45L.js";
 import {
   normalizeEnvelope,

package/dist/hooks/session-start.js

@@ -14,9 +14,11 @@ import {
 } from "../chunk-IMAIBPUC.js";
 import {
   binFile,
-  isRepoActiveForCapture,
   warmBinCache
-} from "../chunk-F7O7V6ZM.js";
+} from "../chunk-HSZPTVKU.js";
+import {
+  isRepoActiveForCapture
+} from "../chunk-R5ZJRSLV.js";
 import {
   getSiteUrl
 } from "../chunk-TPROV45L.js";

package/dist/index.js

@@ -29,15 +29,19 @@ import {
   inspectWorkspaceId
 } from "./chunk-IMAIBPUC.js";
 import {
-  activateRepoBestEffort,
   binFile,
   commandMatchesBin,
   detachedHookShimCommand,
-  gitToplevel,
   hookShimCommand,
-  setRepoActive,
   warmBinCache
-} from "./chunk-F7O7V6ZM.js";
+} from "./chunk-HSZPTVKU.js";
+import {
+  activateRepoBestEffort,
+  decisionIngestionStatus,
+  gitToplevel,
+  isRepoActiveForCapture,
+  setRepoActive
+} from "./chunk-R5ZJRSLV.js";
 import {
   HttpError,
   REFRESH_TOKEN_PATH,
@@ -1703,6 +1707,12 @@ var HEALTHY_POLL_MS = 250;
 var EXIT_OK2 = 0;
 var EXIT_NOT_RUNNING = 2;
 var EXIT_BOOTING = 3;
+function formatDaemonLifecycleMessage(message, decisionIngestion) {
+  return `${message} \xB7 Decision ingestion ${decisionIngestion}`;
+}
+function formatCurrentDaemonLifecycleMessage(message) {
+  return formatDaemonLifecycleMessage(message, decisionIngestionStatus(process.cwd()));
+}
 var MAX_HEALTH_ERROR_LENGTH = 240;
 function boundedHealthError(value) {
   if (!value) return void 0;
@@ -1819,8 +1829,10 @@ async function detachedDaemonStart(opts) {
   if (existing?.alive) {
     const snapshot = await verifiedPid(existing);
     if (snapshot) {
-      process.stderr.write(`[prim] daemon already running (pid=${existing.pid})
-`);
+      process.stderr.write(
+        `${formatCurrentDaemonLifecycleMessage(`[prim] daemon already running (pid=${existing.pid})`)}
+`
+      );
       console.log(JSON.stringify({ started: false, pid: existing.pid }, null, 2));
       return;
     }
@@ -1876,7 +1888,7 @@ async function detachedDaemonStart(opts) {
   if (live) {
     const after = readPidfile();
     process.stderr.write(
-      `[prim] \u2713 daemon started (pid=${after?.pid ?? "?"}, socket=${SOCK_PATH})
+      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon started (pid=${after?.pid ?? "?"}, socket=${SOCK_PATH})`)}
 `
     );
     console.log(JSON.stringify({ started: true, pid: after?.pid }, null, 2));
@@ -1966,7 +1978,7 @@ async function macDaemonStart(forceRestart = false) {
   if (healthy) {
     const verb = result.action === "none" ? "already running" : "started";
     process.stderr.write(
-      `[prim] \u2713 daemon ${verb} under launchd (pid=${snapshot?.pid ?? result.service.pid ?? "?"})
+      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon ${verb} under launchd (pid=${snapshot?.pid ?? result.service.pid ?? "?"})`)}
 `
     );
   } else {
@@ -2140,28 +2152,23 @@ function classifyLaunchdStatus(service, responding, snapshot, disabled) {
     exitCode: EXIT_OK2
   };
 }
-function writeLiveSnapshot(snapshot, supervised = false) {
+function formatDaemonSnapshotMessage(snapshot, supervised, decisionIngestion) {
   if (!snapshot) {
-    process.stderr.write(
-      supervised ? "[prim] \u2713 daemon live under launchd (no snapshot)\n" : "[prim] \u2713 daemon live\n"
-    );
-    return;
+    return supervised ? `[prim] \u2713 daemon live, Decision ingestion ${decisionIngestion} under launchd (no snapshot)` : `[prim] \u2713 daemon live, Decision ingestion ${decisionIngestion}`;
   }
   const team = snapshot.onlineNames !== void 0 ? ` \xB7 team: ${formatTeammates(snapshot.onlineNames, Number.POSITIVE_INFINITY)}` : "";
   if (snapshot.healthy === false) {
     const reason = daemonDegradedReason(snapshot);
-    process.stderr.write(
-      `[prim] \u2717 daemon unhealthy${supervised ? " under launchd" : ""} \xB7 pid=${snapshot.pid}${team}${reason ? ` \xB7 ${reason}` : ""}
-`
-    );
-    return;
+    return `[prim] \u2717 daemon unhealthy${supervised ? " under launchd" : ""} \xB7 pid=${snapshot.pid}${team}${reason ? ` \xB7 ${reason}` : ""}`;
   }
-  process.stderr.write(
-    `[prim] \u2713 daemon live${supervised ? " under launchd" : ""} \xB7 pid=${snapshot.pid} \xB7 uptime=${Math.round(
-      snapshot.uptimeMs / 1e3
-    )}s \xB7 session=${snapshot.sessionId}${team}
-`
-  );
+  return `[prim] \u2713 daemon live, Decision ingestion ${decisionIngestion}${supervised ? " under launchd" : ""} \xB7 pid=${snapshot.pid} \xB7 uptime=${Math.round(
+    snapshot.uptimeMs / 1e3
+  )}s \xB7 session=${snapshot.sessionId}${team}`;
+}
+function writeLiveSnapshot(snapshot, supervised = false) {
+  const decisionIngestion = snapshot?.healthy === false ? "disabled" : decisionIngestionStatus(process.cwd());
+  process.stderr.write(`${formatDaemonSnapshotMessage(snapshot, supervised, decisionIngestion)}
+`);
 }
 async function detachedDaemonStatus() {
   const pid = readPidfile();
@@ -2262,8 +2269,10 @@ async function daemonEnsure() {
   if (result.state === "disabled") {
     process.stderr.write("[prim] daemon remains explicitly disabled\n");
   } else if (result.state === "running") {
-    process.stderr.write(`[prim] \u2713 daemon ensured under launchd (${result.action})
-`);
+    process.stderr.write(
+      `${formatCurrentDaemonLifecycleMessage(`[prim] \u2713 daemon ensured under launchd (${result.action})`)}
+`
+    );
   } else {
     process.stderr.write(`[prim] \u2717 daemon ensure failed; see ${LOG_PATH}
 `);
@@ -2999,9 +3008,29 @@ function formatShowJson(result) {
   return JSON.stringify(result, null, 2);
 }
 
+// src/lib/confirmation.ts
+function isNonInteractive(globals) {
+  return Boolean(globals.nonInteractive || process.env.CI || process.env.PRIM_NON_INTERACTIVE);
+}
+async function askConfirmation(question, output = process.stdout) {
+  if (!process.stdin.isTTY) return false;
+  const { createInterface: createInterface2 } = await import("readline/promises");
+  const rl = createInterface2({ input: process.stdin, output });
+  try {
+    const answer = await rl.question(`${question} [y/N] `);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "y" || normalized === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
 // src/commands/decisions.ts
 var EXIT_NOT_FOUND = 4;
 var EXIT_USAGE = 2;
+var CREATE_INACTIVE_PROMPT = "[prim] Decision ingestion is disabled here. Create this one Decision without enabling passive ingestion?";
+var CREATE_INACTIVE_APPROVED = "[prim] one-time Decision creation approved; passive ingestion remains disabled here";
+var CREATE_INACTIVE_REJECTED = "[prim] decision not created: Decision ingestion is disabled here; rerun with prim's --yes to approve this one Decision, or run `prim enable` in a Git project";
 var splitList = (value) => (value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
 function registerDecisionsCommands(program2) {
   const decisions = program2.command("decisions").description("Inspect the project Decision Graph");
@@ -3081,7 +3110,19 @@ function registerDecisionsCommands(program2) {
   ).option("--decided <items>", "Comma-separated option(s) chosen").option("--alternatives <items>", "Comma-separated options considered but rejected").option("--confidence <level>", "high | medium | low (default high)").option("--reversibility <level>", "high | low (default high)").option(
     "--files <paths>",
     "Comma-separated repo-relative paths this decision governs (the files Conflict Gates would check \u2014 not currently enabled)"
-  ).action(async (opts) => {
+  ).action(async (opts, command) => {
+    if (!isRepoActiveForCapture(process.cwd())) {
+      const globals = command.optsWithGlobals();
+      const nonInteractive = isNonInteractive(globals);
+      const approved = Boolean(globals.yes) || !nonInteractive && await askConfirmation(CREATE_INACTIVE_PROMPT, process.stderr);
+      if (!approved) {
+        console.error(CREATE_INACTIVE_REJECTED);
+        console.log(JSON.stringify({ ok: false, error: "prim_inactive" }, null, 2));
+        process.exitCode = EXIT_USAGE;
+        return;
+      }
+      console.error(CREATE_INACTIVE_APPROVED);
+    }
     const request = {
       intent: opts.intent,
       kind: opts.kind,
@@ -3243,10 +3284,11 @@ function classifyDaemonHealth(snapshot, options = {}) {
   if (snapshot.healthy !== true) {
     return { name: "daemon", status: "fail", detail: "health state is not ready" };
   }
+  const ingestionStatus = options.ingestionStatus ?? decisionIngestionStatus(process.cwd());
   return {
     name: "daemon",
     status: "ok",
-    detail: `supervised and healthy${snapshot.version ? ` \xB7 v${snapshot.version}` : ""}`
+    detail: `supervised and healthy${snapshot.version ? ` \xB7 v${snapshot.version}` : ""} \xB7 Decision ingestion ${ingestionStatus}`
   };
 }
 async function checkDaemon() {
@@ -3925,18 +3967,6 @@ function detectHusky(gitRoot) {
 function containsPrimHook(content, binName = PRE_COMMIT.binName) {
   return content.includes(binName);
 }
-async function askConfirmation(question) {
-  if (!process.stdin.isTTY) return false;
-  const { createInterface: createInterface2 } = await import("readline/promises");
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await rl.question(`${question} [y/N] `);
-    const normalized = answer.trim().toLowerCase();
-    return normalized === "y" || normalized === "yes";
-  } finally {
-    rl.close();
-  }
-}
 function installToHusky(gitRoot, spec = PRE_COMMIT) {
   const hookPath = resolve2(gitRoot, ".husky", spec.hookName);
   const existed = existsSync7(hookPath);
@@ -4154,9 +4184,7 @@ function registerHooksCommands(program2) {
         return;
       }
       const globals = command.optsWithGlobals();
-      const nonInteractive = Boolean(
-        globals.nonInteractive || process.env.CI || process.env.PRIM_NON_INTERACTIVE
-      );
+      const nonInteractive = isNonInteractive(globals);
       const gitRoot = getGitRoot();
       if (opts.target === "husky") return installHooks(gitRoot, "husky");
       if (opts.target === "git-hooks") return installHooks(gitRoot, "git-hooks");
@@ -5179,11 +5207,12 @@ async function renderStatusline() {
     }
     return `primitive ${version} (daemon: starting)`;
   }
+  const ingestionStatus = decisionIngestionStatus(process.cwd());
   if (snapshot.envMismatch) {
-    return `primitive ${version} (daemon: live \xB7 presence: other env)`;
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 presence: other env)`;
   }
   if (snapshot.presenceStale) {
-    return `primitive ${version} (daemon: live \xB7 presence: stale)`;
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 presence: stale)`;
   }
   let team;
   if (snapshot.onlineTeammates !== void 0) {
@@ -5195,7 +5224,7 @@ async function renderStatusline() {
   } else {
     team = "team: \u2014";
   }
-  return `primitive ${version} (daemon: live \xB7 ${team})`;
+  return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 ${team})`;
 }
 function registerStatuslineCommands(program2) {
   program2.command("statusline").description("Render the Claude Code statusLine for the prim companion daemon").action(async () => {

package/dist/statusline-main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/commands/statusline.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
@@ -132,14 +132,77 @@ function daemonRequest(method, params = {}, opts = {}) {
   });
 }
 
+// src/lib/activation.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+
+// src/lib/git.ts
+import { execFileSync } from "child_process";
+function gitToplevel(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/activation.ts
+var PRIM_ACTIVE_KEY = "prim.active";
+var PROJECT_INSTALL_FILES = [".claude/settings.json", ".codex/hooks.json"];
+var PRIM_HOOK_BINS = ["prim-hook", "prim-pre-tool-use", "prim-post-tool-use"];
+function repoActiveFlag(cwd) {
+  try {
+    const value = execFileSync2("git", ["config", "--get", PRIM_ACTIVE_KEY], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (value === "true") return "true";
+    if (value === "false") return "false";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function hasProjectPrimInstall(cwd) {
+  const root = gitToplevel(cwd);
+  if (root === null || root === homedir3()) return false;
+  for (const rel of PROJECT_INSTALL_FILES) {
+    const path = join4(root, rel);
+    if (existsSync3(path)) {
+      try {
+        const content = readFileSync3(path, "utf-8");
+        if (PRIM_HOOK_BINS.some((bin) => content.includes(bin))) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function isRepoActiveForCapture(cwd) {
+  const flag = repoActiveFlag(cwd);
+  if (flag === "true") return true;
+  if (flag === "false") return false;
+  return hasProjectPrimInstall(cwd);
+}
+function decisionIngestionStatus(cwd) {
+  return isRepoActiveForCapture(cwd) ? "enabled" : "disabled";
+}
+
 // src/lib/bin-cache.ts
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
 
 // src/lib/bin-path.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, isAbsolute, join as join4 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, isAbsolute, join as join5 } from "path";
 import { fileURLToPath } from "url";
 var PKG_NAME = "@primitive.ai/prim";
 var NPX_FALLBACK = `npx --yes -p ${PKG_NAME}@latest`;
@@ -218,7 +281,7 @@ function readPackageVersion() {
     ];
     for (const path of candidates) {
       try {
-        const pkg = JSON.parse(readFileSync4(path, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(path, "utf-8"));
         if (pkg.version) {
           return pkg.version;
         }
@@ -259,11 +322,12 @@ async function renderStatusline() {
     }
     return `primitive ${version} (daemon: starting)`;
   }
+  const ingestionStatus = decisionIngestionStatus(process.cwd());
   if (snapshot.envMismatch) {
-    return `primitive ${version} (daemon: live \xB7 presence: other env)`;
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 presence: other env)`;
   }
   if (snapshot.presenceStale) {
-    return `primitive ${version} (daemon: live \xB7 presence: stale)`;
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 presence: stale)`;
   }
   let team;
   if (snapshot.onlineTeammates !== void 0) {
@@ -275,7 +339,7 @@ async function renderStatusline() {
   } else {
     team = "team: \u2014";
   }
-  return `primitive ${version} (daemon: live \xB7 ${team})`;
+  return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 ${team})`;
 }
 
 // src/statusline-main.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primitive.ai/prim",
-  "version": "0.1.0-alpha.47",
+  "version": "0.1.0-alpha.49",
   "description": "CLI for Primitive's decision graph — passive decision capture, conflict gate, and team presence",
   "type": "module",
   "license": "MIT",