@primitive.ai/prim 0.1.0-alpha.48 → 0.1.0-alpha.50

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:
 
@@ -77,7 +78,7 @@ 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.
 
@@ -87,7 +88,7 @@ Before deliberately recording a decision, actively gather the real context behin
 
 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.
@@ -95,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:
 
@@ -140,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
@@ -227,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-5K725K35.js → chunk-BOTKPLTI.js}

@@ -1,6 +1,6 @@
 import {
   getSiteUrl
-} from "./chunk-TPROV45L.js";
+} from "./chunk-DWDEQRWN.js";
 
 // src/journal.ts
 import {

package/dist/{chunk-TPROV45L.js → chunk-DWDEQRWN.js}

@@ -154,6 +154,7 @@ var CONFIG_DIR_MODE = 448;
 var CREDENTIAL_FILE_MODE = 384;
 var REFRESH_THRESHOLD_MS = 6e4;
 var DEFAULT_API_URL = "https://api.getprimitive.ai";
+var AUTH_EXPIRED_MESSAGE = "Authentication expired. Run `prim auth login` to re-authenticate.";
 function loadEnvFile() {
   const envVars = {};
   for (const file of [".env.local", ".env"]) {
@@ -349,6 +350,7 @@ async function performTokenRefresh(options = {}) {
   if (selected?.source !== "token_file") return void 0;
   const startingGeneration = readTrimmed(REFRESH_TOKEN_PATH);
   if (!startingGeneration || isSessionEnded()) return void 0;
+  const startingAccessToken = selected.token;
   return withCredentialLock(
     async () => {
       const currentCredential = resolveAuthCredential();
@@ -358,6 +360,9 @@ async function performTokenRefresh(options = {}) {
       if (currentGeneration !== startingGeneration) {
         return currentCredential.token;
       }
+      if (currentCredential.token !== startingAccessToken) {
+        return currentCredential.token;
+      }
       if (isSessionEnded()) return void 0;
       const response = await fetch(`${getSiteUrl()}/mcp/broker/refresh`, {
         method: "POST",
@@ -442,6 +447,12 @@ async function request(method, path, body, options) {
     });
     if (token) credential = { token, source: "token_file" };
   }
+  if (!credential) {
+    throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
+  }
+  if (isTokenExpiringSoon(credential) && isSessionEnded()) {
+    throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
+  }
   const doFetch = (token) => {
     const headers = { "Content-Type": "application/json" };
     if (token) headers.Authorization = `Bearer ${token}`;
@@ -471,7 +482,7 @@ async function request(method, path, body, options) {
   }
   if (!response.ok) {
     if (response.status === 401) {
-      throw new HttpError(401, "Authentication expired. Run `prim auth login` to re-authenticate.");
+      throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
     }
     const errorBody = await response.json().catch(() => null);
     throw new HttpError(response.status, errorBody?.error ?? `HTTP ${response.status}`);

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/{chunk-WRPKAPVE.js → chunk-VDLAAUWV.js}

@@ -1,7 +1,7 @@
 import {
   getClient,
   getSiteUrl
-} from "./chunk-TPROV45L.js";
+} from "./chunk-DWDEQRWN.js";
 import {
   daemonRequest
 } from "./chunk-UTKQTZHL.js";

package/dist/{chunk-CK75QBCB.js → chunk-WELBNODJ.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-TPROV45L.js";
+} from "./chunk-DWDEQRWN.js";
 
 // src/decisions/feedback.ts
 var FEEDBACK_PROTOCOL_VERSION = 1;