@primitive.ai/prim 0.1.0-alpha.90 → 0.1.0-alpha.91

package/dist/{chunk-2JRX7ZR4.js → chunk-NAHHFSLH.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-EZXEWFDG.js";
 import {
   scrubEnvironmentPaths
-} from "./chunk-FI3LIRCB.js";
+} from "./chunk-OAAP2MY6.js";
 import {
   isValidRepoSyncId
-} from "./chunk-MAZWKJGL.js";
+} from "./chunk-M6RIJVRE.js";
 
 // src/hooks/prim-hook-core.ts
 import { createHash, randomUUID } from "crypto";
@@ -45,6 +45,17 @@ function toolOutcomeFor(parsed, agent) {
   if (agent === "codex") {
     return event === "PostToolUse" ? "returned" : void 0;
   }
+  if (agent === "cursor") {
+    if (event === "PostToolUse") return "succeeded";
+    if (event === "PostToolUseFailure") {
+      if (parsed.is_interrupt === true) return "interrupted";
+      const failureType = lowerString(parsed.failure_type);
+      if (failureType === "permission_denied") return "prevented";
+      if (failureType === "error" || failureType === "timeout") return "failed";
+      return "unknown";
+    }
+    return void 0;
+  }
   const extra = parsed.extra;
   if (event === "post_approval_response") {
     const choice = lowerString(extra?.choice);
@@ -75,7 +86,7 @@ function toMove(parsed, cliVersion, agent = "claude_code", workspaceId, reposito
   let moveId;
   if (CORRELATED_TOOL_EVENTS.has(eventType) && sessionId && invocationId) {
     moveId = `posttool:v1:${createHash("sha256").update(JSON.stringify([agent, sessionId, eventType, invocationId])).digest("hex")}`;
-  } else if (CORRELATED_TOOL_EVENTS.has(eventType) && sessionId) {
+  } else if (CORRELATED_TOOL_EVENTS.has(eventType) && sessionId && agent !== "cursor") {
     moveId = `posttool:fallback:v1:${createHash("sha256").update(
       JSON.stringify([
         agent,
@@ -231,8 +242,8 @@ function toRewriteMove(rewrite, cliVersion, cwd, context) {
   }
   return moves;
 }
-function shouldFlushAfter(eventType) {
-  return eventType === "SessionEnd";
+function shouldFlushAfter(eventType, agent = "claude_code") {
+  return eventType === "SessionEnd" || agent === "cursor" && eventType === "Stop";
 }
 
 export {

package/dist/{chunk-FI3LIRCB.js → chunk-OAAP2MY6.js}

@@ -1,9 +1,9 @@
 import {
   boundedHealthError
-} from "./chunk-LEMX3IOG.js";
+} from "./chunk-BTNNEH2W.js";
 import {
   terminalSafeLine
-} from "./chunk-Z7YPFWAZ.js";
+} from "./chunk-PCVGBE5B.js";
 
 // src/hooks/redact.ts
 import { existsSync, readFileSync, statSync } from "fs";

package/dist/{chunk-Z7YPFWAZ.js → chunk-PCVGBE5B.js}

@@ -10,268 +10,16 @@ import {
   TOKEN_EXPIRES_PATH,
   TOKEN_FILE_PATH,
   WORKOS_CONNECT_RESPONSE_MAX_BYTES,
+  atomicWriteFile,
   jwtExpiresAt,
   parseWorkosConnectTokens,
   readBoundedJson,
   readCredentialMigrationState,
   readStoredCredentialMetadata,
   resolveAuthCredential,
+  withFileLock,
   workosConnectTokenEndpoint
-} from "./chunk-3EEFL6NJ.js";
-
-// src/lib/atomic-file.ts
-import { randomUUID } from "crypto";
-import {
-  constants,
-  closeSync,
-  fchmodSync,
-  fsyncSync,
-  mkdirSync,
-  openSync,
-  renameSync,
-  rmSync,
-  writeFileSync
-} from "fs";
-import { dirname } from "path";
-var DEFAULT_FILE_MODE = 438;
-function syncDirectory(path) {
-  const fd = openSync(path, constants.O_RDONLY);
-  try {
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-}
-function syncFile(path) {
-  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
-  try {
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-}
-function syncCreatedParentChain(firstCreatedParent, parent) {
-  const createdDirectories = [];
-  let current = parent;
-  while (current !== firstCreatedParent) {
-    createdDirectories.push(current);
-    const next = dirname(current);
-    if (next === current) {
-      throw new Error("recursive mkdir returned a path outside the target parent chain");
-    }
-    current = next;
-  }
-  createdDirectories.push(firstCreatedParent);
-  syncDirectory(dirname(firstCreatedParent));
-  for (const directory of createdDirectories.reverse().slice(0, -1)) {
-    syncDirectory(directory);
-  }
-}
-function ensureDurableDirectory(path, mode) {
-  const firstCreatedParent = mkdirSync(path, { recursive: true, mode });
-  if (firstCreatedParent) {
-    syncCreatedParentChain(firstCreatedParent, path);
-  }
-}
-function atomicWriteFile(target, content, options = {}) {
-  const parent = dirname(target);
-  if (options.ensureParent) {
-    ensureDurableDirectory(parent);
-  }
-  const temporaryPath = `${target}.${randomUUID()}.tmp`;
-  let temporaryCreated = false;
-  try {
-    const flags = constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW;
-    const fd = openSync(temporaryPath, flags, options.mode ?? DEFAULT_FILE_MODE);
-    temporaryCreated = true;
-    try {
-      if (options.mode !== void 0) fchmodSync(fd, options.mode);
-      writeFileSync(fd, content);
-      fsyncSync(fd);
-    } finally {
-      closeSync(fd);
-    }
-    options.validate?.(temporaryPath);
-    renameSync(temporaryPath, target);
-    syncDirectory(parent);
-  } catch (error) {
-    if (temporaryCreated) {
-      try {
-        rmSync(temporaryPath, { force: true });
-      } catch {
-      }
-    }
-    throw error;
-  }
-}
-
-// src/lib/process-liveness.ts
-function processIsAlive(pid, probe = process.kill) {
-  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
-  try {
-    probe(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-
-// src/lib/file-lock.ts
-import { randomBytes } from "crypto";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync, rmSync as rmSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, join } from "path";
-var DEFAULT_TIMEOUT_MS = 3e4;
-var DEFAULT_POLL_MS = 50;
-var DEFAULT_INIT_GRACE_MS = 2e3;
-var DIRECTORY_MODE = 448;
-var FILE_MODE = 384;
-function ownerPath(lockDir) {
-  return join(lockDir, "owner.json");
-}
-function readOwner(lockDir) {
-  try {
-    const owner = JSON.parse(readFileSync(ownerPath(lockDir), "utf8"));
-    if (!Number.isInteger(owner.pid) || owner.pid <= 0 || typeof owner.nonce !== "string" || typeof owner.createdAt !== "number") {
-      return null;
-    }
-    return owner;
-  } catch {
-    return null;
-  }
-}
-function sameOwner(a, b) {
-  return a?.pid === b.pid && a.nonce === b.nonce && a.createdAt === b.createdAt;
-}
-function tryTakeLock(lockDir, now) {
-  try {
-    mkdirSync2(lockDir, { mode: DIRECTORY_MODE });
-  } catch (error) {
-    if (error.code === "EEXIST") return null;
-    throw error;
-  }
-  const owner = {
-    pid: process.pid,
-    nonce: randomBytes(16).toString("hex"),
-    createdAt: now
-  };
-  try {
-    writeFileSync2(ownerPath(lockDir), `${JSON.stringify(owner)}
-`, {
-      encoding: "utf8",
-      mode: FILE_MODE,
-      flag: "wx"
-    });
-    return owner;
-  } catch (error) {
-    rmSync2(lockDir, { recursive: true, force: true });
-    throw error;
-  }
-}
-function recoverStaleLock(lockDir, now, alive, initGraceMs) {
-  const owner = readOwner(lockDir);
-  if (owner) {
-    if (alive(owner.pid)) return false;
-    if (!sameOwner(readOwner(lockDir), owner)) return false;
-    rmSync2(lockDir, { recursive: true, force: true });
-    return true;
-  }
-  try {
-    const before = statSync(lockDir).mtimeMs;
-    if (now - before < initGraceMs) return false;
-    if (readOwner(lockDir)) return false;
-    if (statSync(lockDir).mtimeMs !== before) return false;
-    rmSync2(lockDir, { recursive: true, force: true });
-    return true;
-  } catch {
-    return true;
-  }
-}
-function abortError(signal) {
-  if (signal.reason instanceof Error) return signal.reason;
-  const error = new Error("The operation was aborted");
-  error.name = "AbortError";
-  return error;
-}
-function throwIfAborted(signal) {
-  if (signal?.aborted) throw abortError(signal);
-}
-async function defaultSleep(ms, signal) {
-  if (!signal) {
-    await new Promise((resolve2) => setTimeout(resolve2, ms));
-    return;
-  }
-  throwIfAborted(signal);
-  await new Promise((resolve2, reject) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve2();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(abortError(signal));
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-var syncSleeper = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
-function defaultSleepSync(ms) {
-  Atomics.wait(syncSleeper, 0, 0, ms);
-}
-function withFileLockSync(lockDir, operation, options = {}) {
-  mkdirSync2(dirname2(lockDir), { recursive: true, mode: DIRECTORY_MODE });
-  const nowMs = options.nowMs ?? Date.now;
-  const alive = options.processAlive ?? processIsAlive;
-  const deadline = nowMs() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-  let owner = null;
-  while (!owner) {
-    const now = nowMs();
-    owner = tryTakeLock(lockDir, now);
-    if (owner) break;
-    recoverStaleLock(lockDir, now, alive, options.initGraceMs ?? DEFAULT_INIT_GRACE_MS);
-    if (now >= deadline) {
-      throw new Error(`timed out waiting for file lock ${lockDir}`);
-    }
-    (options.sleep ?? defaultSleepSync)(options.pollMs ?? DEFAULT_POLL_MS);
-  }
-  try {
-    return operation();
-  } finally {
-    if (sameOwner(readOwner(lockDir), owner)) {
-      rmSync2(lockDir, { recursive: true, force: true });
-    }
-  }
-}
-async function withFileLock(lockDir, operation, options = {}) {
-  mkdirSync2(dirname2(lockDir), { recursive: true, mode: DIRECTORY_MODE });
-  const nowMs = options.nowMs ?? Date.now;
-  const alive = options.processAlive ?? processIsAlive;
-  const deadline = nowMs() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-  let owner = null;
-  while (!owner) {
-    throwIfAborted(options.signal);
-    const now = nowMs();
-    owner = tryTakeLock(lockDir, now);
-    if (owner) break;
-    recoverStaleLock(lockDir, now, alive, options.initGraceMs ?? DEFAULT_INIT_GRACE_MS);
-    if (now >= deadline) {
-      throw new Error(`timed out waiting for file lock ${lockDir}`);
-    }
-    if (options.sleep) {
-      await options.sleep(options.pollMs ?? DEFAULT_POLL_MS);
-      throwIfAborted(options.signal);
-    } else {
-      await defaultSleep(options.pollMs ?? DEFAULT_POLL_MS, options.signal);
-    }
-  }
-  try {
-    throwIfAborted(options.signal);
-    return await operation();
-  } finally {
-    if (sameOwner(readOwner(lockDir), owner)) {
-      rmSync2(lockDir, { recursive: true, force: true });
-    }
-  }
-}
+} from "./chunk-67VNLLBN.js";
 
 // src/lib/terminal-safe.ts
 function replaceIsolatedSurrogates(value) {
@@ -320,8 +68,8 @@ var stripControlChars = terminalSafeText;
 
 // src/client.ts
 import { createHash } from "crypto";
-import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, rmSync as rmSync3 } from "fs";
-import { dirname as dirname3 } from "path";
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync } from "fs";
+import { dirname } from "path";
 var CONFIG_DIR_MODE = 448;
 var CREDENTIAL_FILE_MODE = 384;
 var REFRESH_THRESHOLD_MS = 6e4;
@@ -329,7 +77,7 @@ var DEFAULT_API_URL = "https://api.getprimitive.ai";
 var AUTH_EXPIRED_MESSAGE = "Authentication expired. Run `prim auth login` to re-authenticate.";
 function readTrimmed(path) {
   try {
-    const value = readFileSync2(path, "utf8").trim();
+    const value = readFileSync(path, "utf8").trim();
     return value || void 0;
   } catch {
     return void 0;
@@ -345,8 +93,8 @@ function expiresAtFor(token, expiresIn) {
   return expiresIn === void 0 ? jwtExpiresAt(token) : Date.now() + expiresIn * 1e3;
 }
 function ensureConfigDirectory() {
-  const directory = dirname3(TOKEN_FILE_PATH);
-  mkdirSync3(directory, { recursive: true, mode: CONFIG_DIR_MODE });
+  const directory = dirname(TOKEN_FILE_PATH);
+  mkdirSync(directory, { recursive: true, mode: CONFIG_DIR_MODE });
   chmodSync(directory, CONFIG_DIR_MODE);
 }
 function atomicWrite(path, content) {
@@ -354,8 +102,8 @@ function atomicWrite(path, content) {
   atomicWriteFile(path, content, { mode: CREDENTIAL_FILE_MODE });
 }
 function removeCredentialFile(path) {
-  if (!existsSync2(path)) return false;
-  rmSync3(path, { force: true });
+  if (!existsSync(path)) return false;
+  rmSync(path, { force: true });
   return true;
 }
 function getTokenExpiresAt() {
@@ -892,12 +640,6 @@ async function getPinnedManagementClient(options = {}) {
 }
 
 export {
-  syncDirectory,
-  syncFile,
-  atomicWriteFile,
-  processIsAlive,
-  withFileLockSync,
-  withFileLock,
   terminalSafeText,
   terminalSafeLine,
   isTerminalSafeText,

package/dist/{chunk-UZPBB7V4.js → chunk-VW3FDYRT.js}

@@ -1,26 +1,30 @@
 import {
-  formatStatusline,
-  packageVersion
-} from "./chunk-PMRDE2DA.js";
+  formatStatusline
+} from "./chunk-WX52U7Z2.js";
 import {
   decisionIngestionStatus,
-  gitToplevel,
   repositoryBindingState
-} from "./chunk-MAZWKJGL.js";
+} from "./chunk-M6RIJVRE.js";
 import {
   getSiteUrl,
   isSessionEnded,
-  terminalSafeText,
-  withFileLock
-} from "./chunk-Z7YPFWAZ.js";
+  terminalSafeText
+} from "./chunk-PCVGBE5B.js";
+import {
+  packageVersion
+} from "./chunk-EWZMDD44.js";
+import {
+  gitToplevel
+} from "./chunk-H4UNYFUC.js";
 import {
   daemonPrincipalsMatch,
   daemonRequest,
   resolveDaemonPrincipal
-} from "./chunk-CUE2LKLR.js";
+} from "./chunk-KFXF2V5G.js";
 import {
-  primConfigDirectory
-} from "./chunk-3EEFL6NJ.js";
+  primConfigDirectory,
+  withFileLock
+} from "./chunk-67VNLLBN.js";
 
 // src/hooks/codex-context.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";
@@ -61,9 +65,7 @@ var CODEX_DRAFT_DIGEST_MAX_SEEN_IDS = 4096;
 var CODEX_DIGEST_STATE_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 var CODEX_DIGEST_STATE_MAX_FILES = 256;
 var STATE_VERSION = 1;
-var STATE_DIRECTORY = ["codex", "decision-digests"];
 var DRAFT_STATE_VERSION = 2;
-var DRAFT_STATE_DIRECTORY = ["codex", "decision-draft-deliveries"];
 var NO_CURSOR = -1;
 function hasVisibleCodexMessage(output) {
   if (typeof output !== "object" || output === null || Array.isArray(output)) return false;
@@ -95,11 +97,11 @@ function appendCodexContext(output, context) {
   }
   return next;
 }
-function stateRoot() {
-  return join(primConfigDirectory(), ...STATE_DIRECTORY);
+function stateRoot(namespace) {
+  return join(primConfigDirectory(), namespace, "decision-digests");
 }
-function draftStateRoot() {
-  return join(primConfigDirectory(), ...DRAFT_STATE_DIRECTORY);
+function draftStateRoot(namespace) {
+  return join(primConfigDirectory(), namespace, "decision-draft-deliveries");
 }
 function workspaceFor(cwd) {
   try {
@@ -111,12 +113,12 @@ function workspaceFor(cwd) {
 function statePath(args) {
   const identity = `${args.siteUrl}\0${workspaceFor(args.cwd)}\0${args.sessionId}`;
   const key = createHash("sha256").update(identity).digest("hex");
-  return join(stateRoot(), `${key}.json`);
+  return join(stateRoot(args.namespace), `${key}.json`);
 }
 function draftStatePath(args) {
   const identity = `${args.siteUrl}\0${workspaceFor(args.cwd)}\0${args.sessionId}\0${args.principalId}\0${args.organizationId}\0${args.credentialFingerprint}`;
   const key = createHash("sha256").update(identity).digest("hex");
-  return join(draftStateRoot(), `${key}.json`);
+  return join(draftStateRoot(args.namespace), `${key}.json`);
 }
 function parseState(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
@@ -307,14 +309,14 @@ function mergeState(latest, args) {
     updatedAt: args.now
   };
 }
-async function commitState(path, args) {
+async function commitState(path, args, namespace) {
   try {
     await withFileLock(
       `${path}.lock`,
       () => {
         const latest = readState(path);
-        writeStateFile(path, stateRoot(), mergeState(latest, args));
-        cleanupStateFiles(stateRoot(), args.now);
+        writeStateFile(path, stateRoot(namespace), mergeState(latest, args));
+        cleanupStateFiles(stateRoot(namespace), args.now);
       },
       { timeoutMs: 50, pollMs: 10 }
     );
@@ -336,7 +338,7 @@ function mergeDraftState(latest, args) {
     updatedAt: args.now
   };
 }
-async function commitDraftState(path, args) {
+async function commitDraftState(path, args, namespace) {
   try {
     let next;
     await withFileLock(
@@ -344,8 +346,8 @@ async function commitDraftState(path, args) {
       () => {
         const latest = readDraftState(path);
         next = mergeDraftState(latest, args);
-        writeStateFile(path, draftStateRoot(), next);
-        cleanupStateFiles(draftStateRoot(), args.now);
+        writeStateFile(path, draftStateRoot(namespace), next);
+        cleanupStateFiles(draftStateRoot(namespace), args.now);
       },
       { timeoutMs: 50, pollMs: 10 }
     );
@@ -355,9 +357,10 @@ async function commitDraftState(path, args) {
   }
 }
 async function prepareCodexContext(options) {
+  const namespace = options.namespace ?? "codex";
   const siteUrl = getSiteUrl();
   const workspace = workspaceFor(options.cwd);
-  const path = statePath({ cwd: options.cwd, sessionId: options.sessionId, siteUrl });
+  const path = statePath({ cwd: options.cwd, sessionId: options.sessionId, siteUrl, namespace });
   const previous = readState(path);
   const principal = resolveDaemonPrincipal();
   const privatePath = principal ? draftStatePath({
@@ -366,7 +369,8 @@ async function prepareCodexContext(options) {
     siteUrl,
     principalId: principal.principalId,
     organizationId: principal.organizationId,
-    credentialFingerprint: principal.credentialFingerprint
+    credentialFingerprint: principal.credentialFingerprint,
+    namespace
   }) : void 0;
   const previousDraft = privatePath ? readDraftState(privatePath) : void 0;
   const startup = options.startup === true;
@@ -456,32 +460,40 @@ async function prepareCodexContext(options) {
     acknowledge: async (handedOff) => {
       if (!handedOff || acknowledged) return;
       acknowledged = true;
-      await commitState(path, {
-        sessionId: options.sessionId,
-        siteUrl,
-        workspace,
-        startedAt,
-        watermarkMs: pageWatermark,
-        seenIds: freshRows.map((row) => row.id),
-        report,
-        feedAvailable,
-        now: Date.now()
-      });
+      await commitState(
+        path,
+        {
+          sessionId: options.sessionId,
+          siteUrl,
+          workspace,
+          startedAt,
+          watermarkMs: pageWatermark,
+          seenIds: freshRows.map((row) => row.id),
+          report,
+          feedAvailable,
+          now: Date.now()
+        },
+        namespace
+      );
       if (privatePath === void 0 || principal === void 0 || draftPageToken === void 0) {
         return;
       }
       let persistedDraft = previousDraft;
       if (draftDigest?.deliveredIds.length) {
-        persistedDraft = await commitDraftState(privatePath, {
-          sessionId: options.sessionId,
-          siteUrl,
-          workspace,
-          principalId: principal.principalId,
-          organizationId: principal.organizationId,
-          credentialFingerprint: principal.credentialFingerprint,
-          deliveredIds: draftDigest.deliveredIds,
-          now: Date.now()
-        });
+        persistedDraft = await commitDraftState(
+          privatePath,
+          {
+            sessionId: options.sessionId,
+            siteUrl,
+            workspace,
+            principalId: principal.principalId,
+            organizationId: principal.organizationId,
+            credentialFingerprint: principal.credentialFingerprint,
+            deliveredIds: draftDigest.deliveredIds,
+            now: Date.now()
+          },
+          namespace
+        );
       }
       const seenDrafts = new Set(persistedDraft?.seenDraftIds ?? []);
       const deliveredOnThisPage = draftPageActionableIds.filter((id) => seenDrafts.has(id));