@primitive.ai/prim 0.1.0-alpha.41 → 0.1.0-alpha.43

package/README.md

@@ -34,7 +34,7 @@ One command does the whole install — auth, session hooks, daemon, git hooks,
 skill, and the welcome:
 
 ```bash
-prim setup                 # add --agent codex or --agent hermes, --no-daemon to skip the daemon
+prim setup                 # add --agent codex or --agent hermes; --no-daemon explicitly opts out
 ```
 
 Or run the steps individually:
@@ -81,10 +81,10 @@ and the manual fallback — live in [`setup.md`](./setup.md).
 prim setup                   # Run the whole install in one shot
 prim setup --agent codex     # Same, for OpenAI Codex
 prim setup --agent hermes    # Same, for Hermes Agent (global-only config)
-prim setup --no-daemon       # Skip the companion daemon
+prim setup --no-daemon       # Stop it and persistently opt out of supervised delivery
 ```
 
-Orchestrates auth → session hooks → daemon → git hooks → skill → welcome,
+Orchestrates auth → session hooks → supervised daemon → capture-health gate → git hooks → skill → 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.
 
@@ -118,11 +118,64 @@ prim codex install                 # Install OpenAI Codex hooks (project scope)
 prim hermes install                # Install Hermes Agent hooks (global ~/.hermes/config.yaml)
 ```
 
+#### Claude decision feedback
+
+Claude Code receives eventual, human-visible feedback when automatic capture
+creates an accepted `change` Decision. A later Claude `Stop` or fresh
+`SessionStart` in the same Git worktree can display:
+
+```text
+[prim] response → created Decision (dec_a1b2c3d4): Use the stable API (https://app.getprimitive.ai/decisions/r571n1dqjdrtyxxpf0fnzee4gn8aed6q)
+```
+
+This is a hook `systemMessage` for the person using Claude Code; it is not
+injected into the model's context. Delivery is at-least-once at the stdout
+handoff boundary: prim acknowledges only after writing the hook response, so a
+failed acknowledgment can show the same notification again. Notifications are
+eligible for 24 hours. The originating session gets limited preference, but any
+concurrent Claude session in the same worktree may consume the backlog. A hook
+claims at most 40 notifications and renders at most 8,000 Unicode code points;
+`hasMore` work is left for a later Stop or SessionStart rather than extending
+the current hook.
+
+Worktree scope comes from an opaque UUID stored under the worktree's Git
+metadata (equivalent to `git rev-parse --git-path prim/workspace-id`), never an
+absolute repository path. Linked worktrees receive distinct IDs, moving a
+worktree preserves its ID, and a clone creates a new one. A corrupt or
+unwritable identity is never silently replaced: capture falls back to the
+legacy envelope and `prim doctor` reports the limitation. Disable/uninstall
+does not delete the identity.
+
+Feedback uses the invoking CLI's credentials for direct HTTPS calls rather
+than the daemon, avoiding cross-organization token ambiguity. One absolute
+three-second in-process budget covers token refresh, lease, parsing, rendering,
+and acknowledgment. This is not a hard three-second wall clock: it cannot
+preempt shell/PATH or `npx` resolution, Node startup, Claude's own hook
+scheduling, or synchronous filesystem work. The Git fallback has a separate
+short timeout.
+
+Alternatives considered:
+
+| Option | Benefit | Limitation |
+| --- | --- | --- |
+| Existing hooks + direct HTTPS (current) | No new install surface; uses the invoking credentials | In-process budget is not a host-enforced wall clock |
+| Claude's native hook timeout | Host-enforced termination | Settings migration; may kill a cold `npx` startup |
+| Daemon routing | Lower steady-state latency | Daemon token/org may not match a concurrent session |
+| Dedicated feedback binary | Lower startup overhead | New distribution and install migration |
+| Synchronous pre-Stop classification | Stronger same-turn immediacy | Adds model latency and cost to the hook path |
+| Detached delivery | Does not block Stop | Cannot return the current hook's `systemMessage` |
+
+Run `prim claude status` to verify both existing feedback handlers are installed
+and `prim doctor` to inspect the worktree identity and server capability. No new
+hook registration or binary is required when upgrading an existing correct
+installation.
+
 ### Daemon
 
-A long-lived companion process that accelerates the in-session decision checks
-and powers the "team: N online" presence count. Optional — hooks fall back to
-direct calls if it is down.
+A supervised long-lived companion process that continuously drains captured
+Moves, accelerates in-session decision checks, and powers the "team: N online"
+presence count. `prim setup` requires it to become healthy unless the explicit
+`--no-daemon` opt-out is supplied; hooks still fail soft if it later degrades.
 
 ```bash
 prim daemon start      # start (stop / restart / status)
@@ -178,6 +231,11 @@ and offers to install into `.husky/`.
 prim statusline        # Render the team-presence statusline (reads the daemon)
 ```
 
+Claude Code has one custom status-line slot. Installation uses a staged,
+lightweight Primitive renderer when that slot is empty or already Primitive's;
+an existing custom status line is preserved and reported explicitly. Use
+`prim daemon status` or `prim doctor` for the same health signal in that case.
+
 ### Welcome
 
 ```bash

package/dist/{chunk-UWAJCF7P.js → chunk-BSZGI5RL.js}

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

package/dist/{chunk-S2O4P4A3.js → chunk-F5QCFBJ6.js}

@@ -3,11 +3,21 @@ import { randomUUID } from "crypto";
 import { platform } from "os";
 
 // src/protocol/move.ts
-var ENVELOPE_VERSION = 1;
+var LEGACY_ENVELOPE_VERSION = 1;
+var AGENT_ENVELOPE_VERSION = 2;
+var ENVELOPE_VERSION = LEGACY_ENVELOPE_VERSION;
+function withAgentProvenance(move, producer, workspaceId) {
+  return {
+    ...move,
+    env: { ...move.env, workspaceId },
+    envelopeVersion: AGENT_ENVELOPE_VERSION,
+    producer
+  };
+}
 
 // src/hooks/prim-hook-core.ts
-function toMove(parsed, cliVersion, agent = "claude_code") {
-  return {
+function toMove(parsed, cliVersion, agent = "claude_code", workspaceId) {
+  const move = {
     moveId: randomUUID(),
     capturedAt: Date.now(),
     sessionId: parsed.session_id ?? "",
@@ -24,6 +34,7 @@ function toMove(parsed, cliVersion, agent = "claude_code") {
     // keeping the Claude wire shape byte-identical.
     ...agent === "claude_code" ? {} : { producer: agent }
   };
+  return workspaceId ? withAgentProvenance(move, agent, workspaceId) : move;
 }
 function toCommitMove(commit, cliVersion, cwd) {
   return {

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

@@ -1,11 +1,83 @@
+// 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 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
 
 // src/lib/bin-path.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, isAbsolute, join } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname, isAbsolute, join as join2 } from "path";
 import { fileURLToPath } from "url";
 var PKG_NAME = "@primitive.ai/prim";
 var ROOT_WALK_LIMIT = 6;
@@ -19,10 +91,10 @@ function locateRoot() {
   }
   let dir = dirname(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < ROOT_WALK_LIMIT; depth++) {
-    const manifestPath = join(dir, "package.json");
-    if (existsSync(manifestPath)) {
+    const manifestPath = join2(dir, "package.json");
+    if (existsSync2(manifestPath)) {
       try {
-        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        const manifest = JSON.parse(readFileSync2(manifestPath, "utf-8"));
         if (manifest.name === PKG_NAME && manifest.bin) {
           resolvedRoot = { dir, bin: manifest.bin };
           return resolvedRoot;
@@ -45,7 +117,7 @@ function binFile(bin) {
   if (!root || !rel) {
     return null;
   }
-  return isAbsolute(rel) ? rel : join(root.dir, rel);
+  return isAbsolute(rel) ? rel : join2(root.dir, rel);
 }
 function hookShimCommand(bin, args = "", opts = {}) {
   const invoke = (cmd) => args ? `${cmd} ${args}` : cmd;
@@ -74,8 +146,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 || join2(homedir(), ".cache");
-  return join2(base, "prim", "bin");
+  const base = process.env.XDG_CACHE_HOME || join3(homedir2(), ".cache");
+  return join3(base, "prim", "bin");
 }
 function writeAtomic(path, content) {
   const tmp = `${path}.${process.pid}.tmp`;
@@ -93,11 +165,11 @@ function warmBinCache() {
     const dir = binCacheDir();
     mkdirSync(dir, { recursive: true, mode: 448 });
     chmodSync(dir, 448);
-    writeAtomic(join2(dir, "node"), process.execPath);
+    writeAtomic(join3(dir, "node"), process.execPath);
     for (const bin of CACHED_BINS) {
       const file = binFile(bin);
       if (file) {
-        writeAtomic(join2(dir, bin), file);
+        writeAtomic(join3(dir, bin), file);
       }
     }
   } catch {
@@ -105,6 +177,10 @@ function warmBinCache() {
 }
 
 export {
+  gitToplevel,
+  setRepoActive,
+  activateRepoBestEffort,
+  isRepoActiveForCapture,
   binFile,
   hookShimCommand,
   detachedHookShimCommand,

package/dist/chunk-IMAIBPUC.js

@@ -0,0 +1,210 @@
+// src/lib/workspace-id.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  constants,
+  chmodSync,
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
+var WORKSPACE_ID_RELATIVE_PATH = join("prim", "workspace-id");
+var MAX_ANCESTORS = 64;
+var MAX_GIT_FILE_BYTES = 4096;
+var MAX_ID_FILE_BYTES = 128;
+var GIT_FALLBACK_TIMEOUT_MS = 250;
+var RACE_READ_ATTEMPTS = 5;
+var RACE_READ_DELAY_MS = 5;
+var CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var raceDelay = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function isCanonicalWorkspaceId(value) {
+  return CANONICAL_UUID.test(value);
+}
+function inspectWorkspaceId(cwd = process.cwd()) {
+  const resolved = resolveWorkspaceIdPath(cwd);
+  if (resolved.status !== "resolved") return resolved;
+  return inspectPath(resolved.path);
+}
+function getOrCreateWorkspaceId(cwd = process.cwd()) {
+  const inspection = inspectWorkspaceId(cwd);
+  if (inspection.status !== "missing") return inspection;
+  return createWorkspaceId(inspection.path);
+}
+function resolveWorkspaceIdPath(cwd) {
+  if (!process.env.GIT_DIR && !process.env.GIT_WORK_TREE) {
+    const fromFilesystem = resolveFromFilesystem(cwd);
+    if (fromFilesystem) return { status: "resolved", path: fromFilesystem };
+  }
+  try {
+    const output = execFileSync(
+      "git",
+      ["rev-parse", "--is-inside-work-tree", "--git-path", WORKSPACE_ID_RELATIVE_PATH],
+      {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: 4096,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: GIT_FALLBACK_TIMEOUT_MS,
+        windowsHide: true
+      }
+    );
+    const [insideWorktree, gitPath, ...extra] = output.trim().split(/\r?\n/);
+    if (insideWorktree !== "true" || !gitPath || extra.length > 0 || gitPath.includes("\0")) {
+      return { status: "not_git" };
+    }
+    return {
+      status: "resolved",
+      path: isAbsolute(gitPath) ? resolve(gitPath) : resolve(cwd, gitPath)
+    };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ETIMEDOUT" || code === "EACCES" || code === "EPERM") {
+      return { status: "unavailable", operation: "resolve", errorCode: code };
+    }
+    return { status: "not_git" };
+  }
+}
+function resolveFromFilesystem(cwd) {
+  let current = resolve(cwd);
+  for (let depth = 0; depth < MAX_ANCESTORS; depth += 1) {
+    const dotGit = join(current, ".git");
+    try {
+      const stat = lstatSync(dotGit);
+      if (stat.isDirectory() && isGitDirectory(dotGit)) {
+        return join(dotGit, WORKSPACE_ID_RELATIVE_PATH);
+      }
+      if (stat.isFile() && stat.size <= MAX_GIT_FILE_BYTES) {
+        const contents = readFileSync(dotGit, "utf8");
+        const match = /^gitdir: (.+?)(?:\r?\n)?$/.exec(contents);
+        if (match?.[1]) {
+          const gitDirectory = isAbsolute(match[1]) ? resolve(match[1]) : resolve(current, match[1]);
+          if (isGitDirectory(gitDirectory)) {
+            return join(gitDirectory, WORKSPACE_ID_RELATIVE_PATH);
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      const code = errorCode(error);
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        return null;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function isGitDirectory(path) {
+  try {
+    return statSync(join(path, "HEAD")).isFile();
+  } catch {
+    return false;
+  }
+}
+function inspectPath(path) {
+  let stat;
+  try {
+    stat = lstatSync(path);
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ENOENT" || code === "ENOTDIR") return { status: "missing", path };
+    return { status: "unavailable", path, operation: "read", errorCode: code };
+  }
+  if (!stat.isFile()) return { status: "corrupt", path, reason: "not_file" };
+  if (stat.size > MAX_ID_FILE_BYTES) {
+    return { status: "corrupt", path, reason: "invalid_content" };
+  }
+  try {
+    const contents = readFileSync(path, "utf8");
+    const workspaceId = contents.endsWith("\n") ? contents.slice(0, -1) : contents;
+    if ((contents === workspaceId || contents === `${workspaceId}
+`) && isCanonicalWorkspaceId(workspaceId)) {
+      return { status: "ready", workspaceId, path, created: false };
+    }
+    return { status: "corrupt", path, reason: "invalid_content" };
+  } catch (error) {
+    return {
+      status: "unavailable",
+      path,
+      operation: "read",
+      errorCode: errorCode(error)
+    };
+  }
+}
+function createWorkspaceId(path) {
+  const parent = dirname(path);
+  const workspaceId = randomUUID();
+  const temporaryPath = join(parent, `.workspace-id-${process.pid}-${randomUUID()}.tmp`);
+  let temporaryCreated = false;
+  let publishing = false;
+  try {
+    mkdirSync(parent, { recursive: true, mode: 448 });
+    chmodSync(parent, 448);
+    const fd = openSync(
+      temporaryPath,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+      384
+    );
+    temporaryCreated = true;
+    try {
+      writeFileSync(fd, `${workspaceId}
+`, "utf8");
+      fchmodSync(fd, 384);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    publishing = true;
+    linkSync(temporaryPath, path);
+    return { status: "ready", workspaceId, path, created: true };
+  } catch (error) {
+    if (publishing && errorCode(error) === "EEXIST") return inspectAfterRace(path);
+    return {
+      status: "unavailable",
+      path,
+      operation: "create",
+      errorCode: errorCode(error)
+    };
+  } finally {
+    if (temporaryCreated) {
+      try {
+        unlinkSync(temporaryPath);
+      } catch {
+      }
+    }
+  }
+}
+function inspectAfterRace(path) {
+  let result = { status: "missing", path };
+  for (let attempt = 0; attempt < RACE_READ_ATTEMPTS; attempt += 1) {
+    result = inspectPath(path);
+    if (result.status === "ready") return result;
+    if (attempt + 1 < RACE_READ_ATTEMPTS) {
+      Atomics.wait(raceDelay, 0, 0, RACE_READ_DELAY_MS);
+    }
+  }
+  if (result.status === "missing") {
+    return { status: "unavailable", path, operation: "create", errorCode: "EEXIST" };
+  }
+  return result;
+}
+function errorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  return typeof error.code === "string" ? error.code : void 0;
+}
+
+export {
+  inspectWorkspaceId,
+  getOrCreateWorkspaceId
+};