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

package/dist/{chunk-LFFLHSQO.js → chunk-CU7RW7XU.js}

@@ -1,18 +1,32 @@
+import {
+  getOrCreateWorkspaceId
+} from "./chunk-EZXEWFDG.js";
 import {
   analyzeShellTargets,
   extractFileTargets
-} from "./chunk-ZB4F75SZ.js";
+} from "./chunk-MXVCP33E.js";
+import {
+  scrubEnvironmentPaths
+} from "./chunk-URLLSALP.js";
 import {
-  canonicalRepositoryPath
-} from "./chunk-H4UNYFUC.js";
+  cachedCollectScopeAdmits
+} from "./chunk-Z6NPNLOT.js";
+import {
+  canonicalRepositoryPath,
+  currentBranch,
+  isRepoActiveForCapture,
+  relatedWorktreeTarget,
+  repoSyncId
+} from "./chunk-DHOQGHKQ.js";
 
 // src/hooks/file-refs.ts
 var MAX_PREFLIGHT_FILE_TARGETS = 25;
 function primitiveMetadataForResolution(resolution) {
-  const shouldAttach = resolution.fileRefs.length > 0 || resolution.rejected.length > 0 || resolution.targetsIncomplete || resolution.targetsTruncated || resolution.shellMutation !== void 0;
+  const shouldAttach = resolution.fileRefs.length > 0 || (resolution.targetCheckouts?.length ?? 0) > 0 || resolution.rejected.length > 0 || resolution.targetsIncomplete || resolution.targetsTruncated || resolution.shellMutation !== void 0;
   if (!shouldAttach) return;
   return {
     fileRefs: [...resolution.fileRefs],
+    ...resolution.targetCheckouts ? { targetCheckouts: resolution.targetCheckouts } : {},
     ...resolution.rejected.length > 0 || resolution.targetsIncomplete ? { fileRefsIncomplete: true } : {},
     ...resolution.targetsTruncated ? { fileRefsTruncated: true } : {},
     ...resolution.shellMutation !== void 0 ? { shellMutation: resolution.shellMutation } : {}
@@ -37,13 +51,55 @@ function resolveHookFileRefs(args) {
   const targetsTruncated = uniqueRawPaths.length > MAX_PREFLIGHT_FILE_TARGETS;
   const fileRefs = /* @__PURE__ */ new Set();
   const rejected = [];
+  const targets = /* @__PURE__ */ new Map();
   for (const path of uniqueRawPaths.slice(0, MAX_PREFLIGHT_FILE_TARGETS)) {
     const canonical = canonicalRepositoryPath(path, args.repository, args.cwd);
     if (canonical.ok) fileRefs.add(canonical.file);
-    else rejected.push({ path, reason: canonical.reason });
+    else {
+      const target = args.captureTargets && canonical.reason === "outside_repository" ? relatedWorktreeTarget(path, args.cwd, args.repository) : null;
+      const resolved = target ? canonicalRepositoryPath(path, target, args.cwd) : null;
+      if (target && resolved?.ok && isRepoActiveForCapture(target.repoRoot) && repoSyncId(target.repoRoot) === args.repository.repoSyncId && args.repository.repoSyncId && cachedCollectScopeAdmits(target.repoRoot, {
+        repository: target.repoFullName,
+        branch: currentBranch(target.repoRoot),
+        agent: args.agent,
+        paths: [resolved.file],
+        pathsComplete: true
+      })) {
+        const group = targets.get(target.repoRoot) ?? { repository: target, fileRefs: [] };
+        group.fileRefs.push(resolved.file);
+        targets.set(target.repoRoot, group);
+      } else rejected.push({ path, reason: canonical.reason });
+    }
+  }
+  const targetCheckouts = [];
+  if (targets.size > 0) {
+    if (fileRefs.size > 0)
+      targets.set(args.repository.repoRoot, {
+        repository: args.repository,
+        fileRefs: [...fileRefs]
+      });
+    for (const { repository, fileRefs: paths } of targets.values()) {
+      const identity = getOrCreateWorkspaceId(repository.repoRoot);
+      const binding = repoSyncId(repository.repoRoot);
+      if (identity.status !== "ready" || !binding) {
+        rejected.push({ path: repository.repoRoot, reason: "invalid_path" });
+        continue;
+      }
+      const root = scrubEnvironmentPaths({
+        cwd: repository.repoRoot,
+        gitRoot: repository.repoRoot
+      }).gitRoot;
+      targetCheckouts.push({
+        gitRoot: root,
+        workspaceId: identity.workspaceId,
+        repoSyncId: binding,
+        fileRefs: paths
+      });
+    }
   }
   return {
     fileRefs: [...fileRefs],
+    ...targetCheckouts.length > 0 ? { targetCheckouts } : {},
     rejected,
     targetsIncomplete: nativeTargets?.complete === false,
     targetsTruncated,
@@ -57,7 +113,8 @@ function enrichHookPayloadWithFileRefs(args) {
     toolInput: args.parsed.tool_input,
     agent: args.agent,
     cwd: args.cwd,
-    repository: args.repository
+    repository: args.repository,
+    captureTargets: true
   });
   const primitive = primitiveMetadataForResolution(resolution);
   if (!primitive) return { parsed: args.parsed, resolution };

package/dist/{chunk-H4UNYFUC.js → chunk-DHOQGHKQ.js}

@@ -18,6 +18,24 @@ function gitToplevel(cwd) {
     return null;
   }
 }
+function mainWorktreeRoot(cwd) {
+  try {
+    const [gitDir, commonDir] = execFileSync(
+      "git",
+      ["rev-parse", "--git-dir", "--git-common-dir"],
+      {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: GIT_TIMEOUT_MS
+      }
+    ).trim().split("\n").map((value) => resolve(cwd ?? process.cwd(), value));
+    if (gitDir === void 0 || commonDir === void 0 || gitDir === commonDir) return null;
+    return basename(commonDir) === ".git" ? dirname(commonDir) : null;
+  } catch {
+    return null;
+  }
+}
 function gitValue(cwd, args) {
   try {
     const value = execFileSync("git", args, {
@@ -56,6 +74,31 @@ function canonicalGitRoot(cwd) {
     return null;
   }
 }
+function relatedWorktreeTarget(path, cwd, origin) {
+  let parent = dirname(resolve(cwd, path));
+  while (true) {
+    try {
+      realpathSync.native(parent);
+      break;
+    } catch {
+      const next = dirname(parent);
+      if (next === parent) return null;
+      parent = next;
+    }
+  }
+  const target = resolveRepositoryContext(parent);
+  if (!target || !target.repoKey || target.repoKey !== origin.repoKey) return null;
+  const common = (root) => {
+    const value = gitValue(root, ["rev-parse", "--git-common-dir"]);
+    try {
+      return value ? realpathSync.native(resolve(root, value)) : void 0;
+    } catch {
+      return void 0;
+    }
+  };
+  const originCommon = common(origin.repoRoot);
+  return originCommon && originCommon === common(target.repoRoot) ? target : null;
+}
 function normalizeOriginRemote(remote) {
   const value = remote.trim();
   if (!value) return void 0;
@@ -186,11 +229,151 @@ function canonicalRepositoryPath(filePath, contextOrCwd, baseDirOrRoot) {
   );
 }
 
+// src/lib/activation.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var PRIM_ACTIVE_KEY = "prim.active";
+var PRIM_REPO_SYNC_ID_KEY = "prim.repoSyncId";
+var PRIM_REPO_SYNC_REPOSITORY_KEY = "prim.repoSyncRepository";
+var PRIM_REPO_BINDING_STATE_KEY = "prim.repoBindingState";
+var GIT_TIMEOUT_MS2 = 1e3;
+var REPO_SYNC_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+var PROJECT_INSTALL_FILES = [".claude/settings.json", ".codex/hooks.json", ".cursor/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"],
+      timeout: GIT_TIMEOUT_MS2
+    }).trim();
+    if (value === "true") return "true";
+    if (value === "false") return "false";
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRepoActive(cwd) {
+  return repoActiveFlag(cwd) === "true";
+}
+function setRepoActive(cwd, active) {
+  execFileSync2("git", ["config", "--local", PRIM_ACTIVE_KEY, active ? "true" : "false"], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: GIT_TIMEOUT_MS2
+  });
+}
+function isValidRepoSyncId(value) {
+  return typeof value === "string" && REPO_SYNC_ID_RE.test(value);
+}
+function localGitConfigValue(cwd, key) {
+  try {
+    const value = execFileSync2("git", ["config", "--local", "--get", key], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: GIT_TIMEOUT_MS2
+    }).trim();
+    return value || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function setLocalGitConfigValue(cwd, key, value) {
+  execFileSync2("git", ["config", "--local", key, value], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: GIT_TIMEOUT_MS2
+  });
+}
+function repoSyncId(cwd) {
+  const value = localGitConfigValue(cwd, PRIM_REPO_SYNC_ID_KEY);
+  if (!isValidRepoSyncId(value)) return void 0;
+  const repositoryFullName = localGitConfigValue(cwd, PRIM_REPO_SYNC_REPOSITORY_KEY);
+  return repositoryFullName === githubRepositoryFullName(cwd) ? value : void 0;
+}
+function setRepoSyncId(cwd, value, repositoryFullName) {
+  if (!isValidRepoSyncId(value)) {
+    throw new Error("invalid repository binding returned by server");
+  }
+  execFileSync2("git", ["config", "--local", PRIM_REPO_SYNC_ID_KEY, value], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: GIT_TIMEOUT_MS2
+  });
+  execFileSync2("git", ["config", "--local", PRIM_REPO_SYNC_REPOSITORY_KEY, repositoryFullName], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: GIT_TIMEOUT_MS2
+  });
+}
+function setRepositoryBindingState(cwd, state) {
+  if (state !== "connected" && state !== "unbound" && state !== "invalid") {
+    throw new Error("invalid repository binding state");
+  }
+  execFileSync2("git", ["config", "--local", PRIM_REPO_BINDING_STATE_KEY, state], {
+    cwd,
+    stdio: ["ignore", "ignore", "pipe"],
+    timeout: GIT_TIMEOUT_MS2
+  });
+}
+function repositoryBindingState(cwd) {
+  const rawId = localGitConfigValue(cwd, PRIM_REPO_SYNC_ID_KEY);
+  const marker = localGitConfigValue(cwd, PRIM_REPO_BINDING_STATE_KEY);
+  if (rawId !== void 0 && !isValidRepoSyncId(rawId)) return "invalid";
+  if (marker === "unbound" || marker === "invalid") return marker;
+  if (marker === "connected") return repoSyncId(cwd) ? "connected" : "invalid";
+  if (marker !== void 0) return "invalid";
+  return rawId === void 0 ? "unbound" : repoSyncId(cwd) ? void 0 : "unbound";
+}
+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,
+  mainWorktreeRoot,
   currentBranch,
   githubRepositoryFullName,
   canonicalGitRoot,
+  relatedWorktreeTarget,
   resolveRepositoryContext,
-  canonicalRepositoryPath
+  canonicalRepositoryPath,
+  repoActiveFlag,
+  isRepoActive,
+  setRepoActive,
+  isValidRepoSyncId,
+  localGitConfigValue,
+  setLocalGitConfigValue,
+  repoSyncId,
+  setRepoSyncId,
+  setRepositoryBindingState,
+  repositoryBindingState,
+  isRepoActiveForCapture,
+  decisionIngestionStatus
 };

package/dist/{chunk-2GP5UFV7.js → chunk-DWRSEC34.js}

@@ -24,6 +24,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/lib/credentials.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+
 // src/lib/paths.ts
 import { homedir } from "os";
 import { isAbsolute, join, normalize } from "path";
@@ -353,9 +358,6 @@ async function pollWorkosDeviceAuthorization(configuration, authorization, optio
 }
 
 // src/lib/credentials.ts
-import { createHash } from "crypto";
-import { readFileSync } from "fs";
-import { join as join2 } from "path";
 var CONFIG_DIRECTORY = primConfigDirectory();
 var TOKEN_FILE_PATH = join2(CONFIG_DIRECTORY, "token");
 var REFRESH_TOKEN_PATH = join2(CONFIG_DIRECTORY, "refresh_token");

package/dist/{chunk-36TWVNBE.js → chunk-FVDBULGZ.js}

@@ -1,30 +1,28 @@
 import {
   formatStatusline
-} from "./chunk-ZU563PQI.js";
-import {
-  decisionIngestionStatus,
-  repositoryBindingState
-} from "./chunk-DSWT6BCC.js";
+} from "./chunk-ROLYLXJS.js";
 import {
   getSiteUrl,
   isSessionEnded,
   terminalSafeText
-} from "./chunk-G2VMA2QO.js";
+} from "./chunk-LY6NJ7KL.js";
 import {
   packageVersion
-} from "./chunk-X64HTHUF.js";
+} from "./chunk-Y5W4TZM7.js";
 import {
-  gitToplevel
-} from "./chunk-H4UNYFUC.js";
+  decisionIngestionStatus,
+  gitToplevel,
+  repositoryBindingState
+} from "./chunk-DHOQGHKQ.js";
 import {
   daemonPrincipalsMatch,
   daemonRequest,
   resolveDaemonPrincipal
-} from "./chunk-OTHKG76J.js";
+} from "./chunk-35FMRWJH.js";
 import {
   primConfigDirectory,
   withFileLock
-} from "./chunk-2GP5UFV7.js";
+} from "./chunk-DWRSEC34.js";
 
 // src/hooks/codex-context.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";

package/dist/{chunk-G2VMA2QO.js → chunk-LY6NJ7KL.js}

@@ -19,7 +19,12 @@ import {
   resolveAuthCredential,
   withFileLock,
   workosConnectTokenEndpoint
-} from "./chunk-2GP5UFV7.js";
+} from "./chunk-DWRSEC34.js";
+
+// src/client.ts
+import { createHash } from "crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync } from "fs";
+import { dirname } from "path";
 
 // src/lib/terminal-safe.ts
 function replaceIsolatedSurrogates(value) {
@@ -67,9 +72,6 @@ function isTerminalSafeText(value) {
 var stripControlChars = terminalSafeText;
 
 // src/client.ts
-import { createHash } from "crypto";
-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;

package/dist/{chunk-ZB4F75SZ.js → chunk-MXVCP33E.js}

@@ -253,7 +253,7 @@ var COMMAND_OPTIONS = {
     longOptionalValues: set("--color")
   },
   grep: {
-    shortFlags: "EFGHIPRTUVabcdhLlnqrsuvwxyZz",
+    shortFlags: "EFGHIPRTUVabcdhiLlnoqrsuvwxyZz",
     shortValues: "ABCDefm",
     longFlags: set(
       "--basic-regexp --binary-files-without-match --byte-offset --count --extended-regexp --files-with-matches --files-without-match --fixed-regexp --fixed-strings --help --ignore-case --initial-tab --invert-match --line-buffered --line-number --line-regexp --null --null-data --only-matching --perl-regexp --quiet --recursive --silent --unix-byte-offsets --version --with-filename --word-regexp"
@@ -264,12 +264,14 @@ var COMMAND_OPTIONS = {
     longOptionalValues: set("--color")
   },
   head: {
+    numericCount: true,
     shortFlags: "qvz",
     shortValues: "cn",
     longFlags: set("--help --quiet --verbose --version --zero-terminated"),
     longValues: set("--bytes --lines")
   },
   tail: {
+    numericCount: true,
     shortFlags: "Fqsvz",
     shortValues: "cn",
     longFlags: set("--help --quiet --retry --silent --verbose --version --zero-terminated"),
@@ -294,6 +296,7 @@ var COMMAND_OPTIONS = {
   }
 };
 var GIT_INSPECTION_OPTIONS = {
+  numericCount: true,
   shortFlags: "abcdfhiklmnprstuvwz",
   shortValues: "ABCGLMSU",
   longFlags: set(
@@ -436,6 +439,7 @@ function parseOptions(args, spec) {
       optionsEnded = true;
       continue;
     }
+    if (spec.numericCount && /^-\d+$/.test(arg)) continue;
     if (arg.startsWith("--")) {
       const separator = arg.indexOf("=");
       const option = separator === -1 ? arg : arg.slice(0, separator);

package/dist/{chunk-TYAHC25F.js → chunk-QCBB5HFX.js}

@@ -1,6 +1,6 @@
 import {
   scheduleCollectScopeRefresh
-} from "./chunk-DSWT6BCC.js";
+} from "./chunk-Z6NPNLOT.js";
 
 // src/ingest-response.ts
 var IngestAcknowledgementError = class extends Error {

package/dist/{chunk-C3VAA5CG.js → chunk-RK4ZS3HG.js}

@@ -2,10 +2,10 @@ import {
   cursorHooksPath,
   hasExactCursorHandler,
   readCursorHooks
-} from "./chunk-X64HTHUF.js";
+} from "./chunk-Y5W4TZM7.js";
 import {
   resolveRepositoryContext
-} from "./chunk-H4UNYFUC.js";
+} from "./chunk-DHOQGHKQ.js";
 
 // src/hooks/agent.ts
 function parseAgent(argv) {

package/dist/{chunk-ZU563PQI.js → chunk-ROLYLXJS.js}

@@ -1,9 +1,9 @@
 import {
   boundedHealthError
-} from "./chunk-DSWT6BCC.js";
+} from "./chunk-Z6NPNLOT.js";
 import {
   stripControlChars
-} from "./chunk-G2VMA2QO.js";
+} from "./chunk-LY6NJ7KL.js";
 
 // src/lib/delivery-backlog.ts
 var MS_PER_SECOND = 1e3;

package/dist/{chunk-OH3EZXYX.js → chunk-UO2U6IKF.js}

@@ -3,7 +3,7 @@ import {
   isTerminalSafeText,
   terminalSafeLine,
   terminalSafeText
-} from "./chunk-G2VMA2QO.js";
+} from "./chunk-LY6NJ7KL.js";
 
 // src/decisions/feedback.ts
 var FEEDBACK_PROTOCOL_VERSION = 2;

package/dist/{chunk-K7D2EYBS.js → chunk-URLLSALP.js}

@@ -1,9 +1,9 @@
 import {
   boundedHealthError
-} from "./chunk-DSWT6BCC.js";
+} from "./chunk-Z6NPNLOT.js";
 import {
   terminalSafeLine
-} from "./chunk-G2VMA2QO.js";
+} from "./chunk-LY6NJ7KL.js";
 
 // src/hooks/redact.ts
 import { existsSync, readFileSync, statSync } from "fs";

package/dist/chunk-XEDJ5N3M.js

@@ -0,0 +1,177 @@
+import {
+  repoActiveFlag
+} from "./chunk-DHOQGHKQ.js";
+import {
+  atomicWriteFile
+} from "./chunk-DWRSEC34.js";
+
+// src/lib/commit-heartbeat.ts
+import { execFileSync } from "child_process";
+import { mkdirSync, readFileSync, readdirSync, unlinkSync } from "fs";
+import { dirname, join, resolve } from "path";
+var FIRED_DIR = "prim/post-commit-fired";
+var WIRED_PATH = "prim/git-hooks-wired";
+var GIT_TIMEOUT_MS = 1e3;
+var MAX_STAMP_BYTES = 1024;
+var REFLOG_SCAN_LIMIT = 50;
+var MAX_FIRED_STAMPS = 256;
+var PRUNE_SLACK = 64;
+var FULL_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u;
+var REFLOG_LINE_RE = /^([0-9a-f]{40}|[0-9a-f]{64})\tHEAD@\{([0-9]+)\}\t(.*)$/u;
+var COMMIT_SUBJECT_RE = /^commit(?: \([^)]*\))?:/u;
+var REFLOG_RESOLUTION_MS = 1e3;
+var POST_COMMIT_GRACE_MS = 6e4;
+function commonPath(cwd, relative) {
+  const value = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: GIT_TIMEOUT_MS
+  }).replace(/\r?\n$/u, "");
+  if (value === "" || /[\0\r\n]/u.test(value)) throw new Error("Git returned an unsafe path");
+  return join(resolve(cwd, value), relative);
+}
+function gitPath(cwd, relative) {
+  const value = execFileSync("git", ["rev-parse", "--git-path", relative], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: GIT_TIMEOUT_MS
+  }).replace(/\r?\n$/u, "");
+  if (value === "" || /[\0\r\n]/u.test(value)) throw new Error("Git returned an unsafe path");
+  return resolve(cwd, value);
+}
+function ensurePrivateParent(path) {
+  mkdirSync(dirname(dirname(path)), { recursive: true, mode: 448 });
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+}
+function writeStamp(path, at) {
+  ensurePrivateParent(path);
+  atomicWriteFile(path, `${JSON.stringify({ at })}
+`, { mode: 384 });
+}
+function readStampAt(path) {
+  try {
+    const raw = readFileSync(path, "utf8");
+    if (raw.length > MAX_STAMP_BYTES) return void 0;
+    const parsed = JSON.parse(raw);
+    return typeof parsed.at === "number" && Number.isSafeInteger(parsed.at) && parsed.at > 0 ? parsed.at : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function recordConversationCaptured(cwd, agent) {
+  try {
+    writeStamp(gitPath(cwd, `prim/conversation-captured/${agent}`), Date.now());
+  } catch {
+  }
+}
+function lastConversationCaptured(cwd, agent) {
+  try {
+    return readStampAt(gitPath(cwd, `prim/conversation-captured/${agent}`));
+  } catch {
+    return void 0;
+  }
+}
+function readFiredStamps(cwd) {
+  try {
+    const dir = gitPath(cwd, FIRED_DIR);
+    return readdirSync(dir).flatMap((sha) => {
+      if (!FULL_SHA_RE.test(sha)) return [];
+      const at = readStampAt(join(dir, sha));
+      return at === void 0 ? [] : [{ sha, at }];
+    });
+  } catch {
+    return [];
+  }
+}
+function recordPostCommitFired(cwd, sha, now = Date.now()) {
+  if (!sha || !FULL_SHA_RE.test(sha)) return;
+  try {
+    const dir = gitPath(cwd, FIRED_DIR);
+    writeStamp(join(dir, sha), now);
+    const names = readdirSync(dir).filter((name) => FULL_SHA_RE.test(name));
+    if (names.length <= MAX_FIRED_STAMPS + PRUNE_SLACK) return;
+    const stale = names.map((name) => ({ name, at: readStampAt(join(dir, name)) ?? 0 })).sort((left, right) => right.at - left.at || left.name.localeCompare(right.name)).slice(MAX_FIRED_STAMPS);
+    for (const { name } of stale) unlinkSync(join(dir, name));
+  } catch {
+  }
+}
+function recordHooksWired(cwd, options = {}) {
+  try {
+    const path = commonPath(cwd, WIRED_PATH);
+    if (options.onlyIfAbsent && readStampAt(path) !== void 0) return;
+    writeStamp(path, options.now ?? Date.now());
+  } catch {
+  }
+}
+function clearHooksWired(cwd) {
+  try {
+    unlinkSync(commonPath(cwd, WIRED_PATH));
+  } catch {
+  }
+}
+function latestLocalCommit(cwd) {
+  let output;
+  try {
+    output = execFileSync(
+      "git",
+      [
+        "log",
+        "-g",
+        "--no-show-signature",
+        "-n",
+        String(REFLOG_SCAN_LIMIT),
+        "--date=unix",
+        "--format=%H%x09%gd%x09%gs",
+        "HEAD"
+      ],
+      { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: GIT_TIMEOUT_MS }
+    );
+  } catch {
+    return void 0;
+  }
+  for (const line of output.split("\n")) {
+    const match = REFLOG_LINE_RE.exec(line);
+    if (match?.[1] && match[2] && COMMIT_SUBJECT_RE.test(match[3] ?? "")) {
+      return { sha: match[1], at: Number(match[2]) * 1e3 };
+    }
+  }
+  return void 0;
+}
+function inspectPostCommitFiring(cwd, now = Date.now()) {
+  if (repoActiveFlag(cwd) !== "true") return { state: "inactive" };
+  const commit = latestLocalCommit(cwd);
+  if (!commit) return { state: "unverified" };
+  const stamps = readFiredStamps(cwd);
+  const own = stamps.find((stamp) => stamp.sha === commit.sha);
+  if (own) return { state: "fired", commitAt: commit.at, firedAt: own.at };
+  if (now - commit.at < POST_COMMIT_GRACE_MS) return { state: "pending", commitAt: commit.at };
+  const lastFiredAt = stamps.reduce(
+    (latest, stamp) => latest === void 0 || stamp.at > latest ? stamp.at : latest,
+    void 0
+  );
+  let wiredAt;
+  try {
+    wiredAt = readStampAt(commonPath(cwd, WIRED_PATH));
+  } catch {
+    wiredAt = void 0;
+  }
+  if (wiredAt === void 0) return { state: "unverified" };
+  const firedSinceWired = lastFiredAt !== void 0 && lastFiredAt >= wiredAt;
+  const judged = commit.at > wiredAt || firedSinceWired && commit.at + REFLOG_RESOLUTION_MS > lastFiredAt;
+  if (judged) {
+    return lastFiredAt === void 0 ? { state: "not_firing", commitAt: commit.at } : { state: "not_firing", commitAt: commit.at, firedAt: lastFiredAt };
+  }
+  return { state: "unverified" };
+}
+
+export {
+  POST_COMMIT_GRACE_MS,
+  recordConversationCaptured,
+  lastConversationCaptured,
+  recordPostCommitFired,
+  recordHooksWired,
+  clearHooksWired,
+  inspectPostCommitFiring
+};