@primitive.ai/prim 0.1.0-alpha.62 → 0.1.0-alpha.64

package/dist/daemon/server.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/daemon/server.ts
-import { existsSync as existsSync6, readFileSync as readFileSync5, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "fs";
 import { createServer } from "net";
-import { homedir as homedir5 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join9 } from "path";
 import { fileURLToPath } from "url";
 
 // src/client.ts
@@ -110,14 +110,14 @@ function throwIfAborted(signal) {
 }
 async function defaultSleep(ms, signal) {
   if (!signal) {
-    await new Promise((resolve2) => setTimeout(resolve2, ms));
+    await new Promise((resolve3) => setTimeout(resolve3, ms));
     return;
   }
   throwIfAborted(signal);
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve2();
+      resolve3();
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
@@ -164,10 +164,10 @@ 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() {
+function loadEnvFile(cwd = process.cwd()) {
   const envVars = {};
   for (const file of [".env.local", ".env"]) {
-    const filePath = resolve(process.cwd(), file);
+    const filePath = resolve(cwd, file);
     if (!existsSync2(filePath)) continue;
     const content = readFileSync2(filePath, "utf-8");
     for (const line of content.split("\n")) {
@@ -205,8 +205,11 @@ function resolveAuthCredential() {
   return envToken ? { token: envToken, source: "env_file" } : void 0;
 }
 function getSiteUrl() {
-  if (process.env.PRIM_API_URL) return process.env.PRIM_API_URL;
-  return loadEnvFile().PRIM_API_URL ?? DEFAULT_API_URL;
+  return getSiteUrlForCwd(process.cwd(), process.env.PRIM_API_URL);
+}
+function getSiteUrlForCwd(cwd, primApiUrl) {
+  if (primApiUrl) return primApiUrl;
+  return loadEnvFile(cwd).PRIM_API_URL ?? DEFAULT_API_URL;
 }
 function getJwtExpiry(token) {
   const parts = token.split(".");
@@ -861,18 +864,217 @@ function flush() {
   return attempt;
 }
 
-// src/daemon/client.ts
-import { createConnection } from "net";
+// src/lib/activation.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join5 } from "path";
-var SOCK_PATH = join5(homedir3(), ".config", "prim", "sock");
+
+// src/lib/git.ts
+import { execFileSync } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { lstatSync, realpathSync } from "fs";
+import { basename, dirname as dirname5, isAbsolute, relative, resolve as resolve2, sep } from "path";
+var GIT_TIMEOUT_MS = 1e3;
+function gitToplevel(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: GIT_TIMEOUT_MS
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/lib/activation.ts
+var PRIM_ACTIVE_KEY = "prim.active";
+var GIT_TIMEOUT_MS2 = 1e3;
+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"],
+      timeout: GIT_TIMEOUT_MS2
+    }).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 = join5(root, rel);
+    if (existsSync4(path)) {
+      try {
+        const content = readFileSync4(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/ansi.ts
+function stripControlChars(text) {
+  let out = "";
+  for (const ch of text) {
+    const code = ch.codePointAt(0) ?? 0;
+    if (code > 31 && !(code >= 127 && code <= 159)) {
+      out += ch;
+    }
+  }
+  return out;
+}
+
+// src/lib/presence.ts
+var DECISION_ORIGIN = "https://app.getprimitive.ai";
+function validDecisionUrl(value) {
+  if (typeof value !== "string" || stripControlChars(value) !== value) {
+    return void 0;
+  }
+  try {
+    const url = new URL(value);
+    if (url.origin !== DECISION_ORIGIN || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !/^\/decisions\/[^/]+$/u.test(url.pathname)) {
+      return void 0;
+    }
+    return url.href;
+  } catch {
+    return void 0;
+  }
+}
+function decisionLink(label, decisionUrl) {
+  const url = validDecisionUrl(decisionUrl);
+  return url ? `\x1B]8;;${url}\x07\x1B[34;4m${label}\x1B[0m\x1B]8;;\x07` : label;
+}
+function formatLabeled(labels, cap) {
+  if (labels === void 0) {
+    return "\u2014";
+  }
+  if (labels.length === 0) {
+    return "just you";
+  }
+  if (labels.length <= cap) {
+    return labels.join(", ");
+  }
+  return `${labels.slice(0, cap).join(", ")} +${String(labels.length - cap)}`;
+}
+function formatTeammates(names, cap) {
+  return formatLabeled(names?.map(stripControlChars), cap);
+}
+function formatTeammatesWithArea(teammates, cap) {
+  return formatLabeled(
+    teammates?.map((t) => {
+      const name = stripControlChars(t.name);
+      const area = stripControlChars(t.area ?? "").trim();
+      const label = area ? `${name} - ${area}` : name;
+      return decisionLink(label, t.decisionUrl);
+    }),
+    cap
+  );
+}
+
+// src/lib/statusline-render.ts
+var STATUSLINE_NAME_CAP = 3;
+function formatStatusline(version, snapshot, resolveIngestionStatus) {
+  if (!snapshot) {
+    return `primitive ${version} (daemon: down)`;
+  }
+  if (snapshot.healthy === false) {
+    if (snapshot.needsReauth) {
+      return `primitive ${version} (daemon: paused \xB7 run \`prim auth login\`)`;
+    }
+    if (snapshot.ingestion?.healthy === false) {
+      const pending = snapshot.ingestion.pendingCount;
+      const qualifier = snapshot.ingestion.pendingSampled ? "at least " : "";
+      return `primitive ${version} (daemon: degraded \xB7 delivery: stalled${typeof pending === "number" ? ` \xB7 ${qualifier}${String(pending)} pending` : ""})`;
+    }
+    if (snapshot.heartbeat?.healthy === false) {
+      return `primitive ${version} (daemon: degraded \xB7 presence: unavailable)`;
+    }
+    return `primitive ${version} (daemon: starting)`;
+  }
+  const ingestionStatus = resolveIngestionStatus();
+  if (snapshot.envMismatch) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 presence: other env)`;
+  }
+  if (snapshot.presenceStale) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 presence: stale)`;
+  }
+  let team;
+  if (snapshot.onlineTeammates !== void 0) {
+    team = `team: ${formatTeammatesWithArea(snapshot.onlineTeammates, STATUSLINE_NAME_CAP)}`;
+  } else if (snapshot.onlineNames !== void 0) {
+    team = `team: ${formatTeammates(snapshot.onlineNames, STATUSLINE_NAME_CAP)}`;
+  } else if (typeof snapshot.onlineCount === "number") {
+    team = `team: ${String(snapshot.onlineCount)} online`;
+  } else {
+    team = "team: \u2014";
+  }
+  return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus} \xB7 ${team})`;
+}
+var STATUSLINE_INGESTION_CACHE_TTL_MS = 3e4;
+var STATUSLINE_INGESTION_CACHE_MAX_ENTRIES = 256;
+var StatuslineIngestionCache = class {
+  constructor(resolve3, now = Date.now, ttlMs = STATUSLINE_INGESTION_CACHE_TTL_MS, maxEntries = STATUSLINE_INGESTION_CACHE_MAX_ENTRIES) {
+    this.resolve = resolve3;
+    this.now = now;
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+  }
+  #entries = /* @__PURE__ */ new Map();
+  get(cwd) {
+    const now = this.now();
+    const cached = this.#entries.get(cwd);
+    if (cached && cached.expiresAt > now) {
+      return cached.value;
+    }
+    const value = this.resolve(cwd);
+    this.#entries.delete(cwd);
+    this.#entries.set(cwd, { expiresAt: now + this.ttlMs, value });
+    while (this.#entries.size > this.maxEntries) {
+      const oldest = this.#entries.keys().next().value;
+      if (oldest === void 0) break;
+      this.#entries.delete(oldest);
+    }
+    return value;
+  }
+  clear() {
+    this.#entries.clear();
+  }
+};
+
+// src/daemon/client.ts
+import { createConnection } from "net";
+import { homedir as homedir4 } from "os";
+import { join as join6 } from "path";
+var SOCK_PATH = join6(homedir4(), ".config", "prim", "sock");
 var DEFAULT_TIMEOUT_MS2 = 250;
 var nextRequestId = 1;
 function daemonRequest(method, params = {}, opts = {}) {
   const id = nextRequestId++;
   const request2 = { id, method, params };
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     let settled = false;
     let socket;
     let buffer = "";
@@ -887,7 +1089,7 @@ function daemonRequest(method, params = {}, opts = {}) {
         } catch {
         }
       }
-      resolve2(value);
+      resolve3(value);
     };
     const timer = setTimeout(() => settle(null), timeoutMs);
     timer.unref();
@@ -958,9 +1160,9 @@ function assertCallerEnvMatches(callerEnv, boundEnv) {
 }
 
 // src/daemon/health.ts
-import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync4, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname as dirname5, join as join6 } from "path";
+import { chmodSync as chmodSync2, existsSync as existsSync5, mkdirSync as mkdirSync4, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname6, join as join7 } from "path";
 var CONFIG_DIR_MODE2 = 448;
 var HEALTH_FILE_MODE = 384;
 var INGESTION_SLA_MS = 3e4;
@@ -968,7 +1170,7 @@ var HEARTBEAT_FRESH_MS = 9e4;
 var HEARTBEAT_RETRY_CAP_MS = 3e4;
 var INGESTION_RETRY_BASE_MS = 5e3;
 var INGESTION_RETRY_CAP_MS = 15e3;
-var DAEMON_HEALTH_PATH = join6(homedir4(), ".config", "prim", "daemon-health.json");
+var DAEMON_HEALTH_PATH = join7(homedir5(), ".config", "prim", "daemon-health.json");
 function createDaemonHealthState(version, pid, startedAt2) {
   return {
     schemaVersion: 1,
@@ -1006,11 +1208,11 @@ function ingestionRetryDelayMs(consecutiveFailures, random = Math.random) {
   return retryDelayMs(consecutiveFailures, INGESTION_RETRY_CAP_MS, random);
 }
 function writeDaemonHealthState(state, path = DAEMON_HEALTH_PATH) {
-  const dir = dirname5(path);
-  if (!existsSync4(dir)) {
+  const dir = dirname6(path);
+  if (!existsSync5(dir)) {
     mkdirSync4(dir, { recursive: true, mode: CONFIG_DIR_MODE2 });
   }
-  const tmp = join6(dir, `.${process.pid}.daemon-health.tmp`);
+  const tmp = join7(dir, `.${process.pid}.daemon-health.tmp`);
   writeFileSync3(tmp, `${JSON.stringify(state, null, 2)}
 `, { mode: HEALTH_FILE_MODE });
   chmodSync2(tmp, HEALTH_FILE_MODE);
@@ -1021,22 +1223,22 @@ function writeDaemonHealthState(state, path = DAEMON_HEALTH_PATH) {
 import { randomUUID } from "crypto";
 import {
   chmodSync as chmodSync3,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   renameSync as renameSync4,
   rmSync as rmSync3,
   statSync as statSync2,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync4
 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var DIR_MODE = 448;
 var FILE_MODE2 = 384;
 var DAEMON_STARTUP_GRACE_MS = 5e3;
 function readLockRecord(path) {
   try {
-    const value = JSON.parse(readFileSync4(path, "utf-8"));
+    const value = JSON.parse(readFileSync5(path, "utf-8"));
     if (Number.isInteger(value.pid) && typeof value.instanceId === "string" && typeof value.startedAt === "number") {
       return value;
     }
@@ -1046,7 +1248,7 @@ function readLockRecord(path) {
 }
 function numericPid(path) {
   try {
-    const pid = Number(readFileSync4(path, "utf-8").trim());
+    const pid = Number(readFileSync5(path, "utf-8").trim());
     return Number.isInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
     return;
@@ -1061,10 +1263,10 @@ function daemonProcessIsAlive(pid) {
   }
 }
 function readDaemonOwner(configDir) {
-  return readLockRecord(join7(configDir, "daemon.lock", "owner.json"));
+  return readLockRecord(join8(configDir, "daemon.lock", "owner.json"));
 }
 function readDaemonPid(configDir) {
-  const path = join7(configDir, "daemon.pid");
+  const path = join8(configDir, "daemon.pid");
   const pid = numericPid(path);
   if (pid === void 0) {
     return;
@@ -1079,11 +1281,11 @@ function acquireDaemonOwnership(configDir, opts = {}) {
   const pid = opts.pid ?? process.pid;
   const now = opts.now ?? Date.now();
   const isAlive = opts.isAlive ?? daemonProcessIsAlive;
-  const lockDir = join7(configDir, "daemon.lock");
-  const ownerPath2 = join7(lockDir, "owner.json");
-  const pidPath = join7(configDir, "daemon.pid");
+  const lockDir = join8(configDir, "daemon.lock");
+  const ownerPath2 = join8(lockDir, "owner.json");
+  const pidPath = join8(configDir, "daemon.pid");
   const instanceId = randomUUID();
-  if (!existsSync5(configDir)) {
+  if (!existsSync6(configDir)) {
     mkdirSync5(configDir, { recursive: true, mode: DIR_MODE });
   }
   for (; ; ) {
@@ -1178,9 +1380,48 @@ function releaseDaemonOwnership(ownership2, socketPath) {
   return true;
 }
 
+// src/daemon/statusline-protocol.ts
+import { isAbsolute as isAbsolute2 } from "path";
+var STATUSLINE_PROTOCOL_PREFIX = Buffer.from("prim-statusline-v1\0", "utf8");
+var STATUSLINE_REQUEST_MAX_BYTES = 64 * 1024;
+var utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+function isStatuslineRequestPrefix(buffer) {
+  const compared = Math.min(buffer.length, STATUSLINE_PROTOCOL_PREFIX.length);
+  return buffer.subarray(0, compared).equals(STATUSLINE_PROTOCOL_PREFIX.subarray(0, compared));
+}
+function parseStatuslineRequest(buffer) {
+  if (buffer.length > STATUSLINE_REQUEST_MAX_BYTES || !isStatuslineRequestPrefix(buffer)) {
+    return { state: "invalid" };
+  }
+  if (buffer.length < STATUSLINE_PROTOCOL_PREFIX.length) {
+    return { state: "incomplete" };
+  }
+  const cwdEnd = buffer.indexOf(0, STATUSLINE_PROTOCOL_PREFIX.length);
+  if (cwdEnd === -1) {
+    return { state: "incomplete" };
+  }
+  const apiUrlEnd = buffer.indexOf(0, cwdEnd + 1);
+  if (apiUrlEnd === -1) {
+    return { state: "incomplete" };
+  }
+  if (apiUrlEnd !== buffer.length - 1) {
+    return { state: "invalid" };
+  }
+  try {
+    const cwd = utf8Decoder.decode(buffer.subarray(STATUSLINE_PROTOCOL_PREFIX.length, cwdEnd));
+    const primApiUrl = utf8Decoder.decode(buffer.subarray(cwdEnd + 1, apiUrlEnd));
+    if (!cwd || !isAbsolute2(cwd)) {
+      return { state: "invalid" };
+    }
+    return { state: "complete", request: { cwd, primApiUrl } };
+  } catch {
+    return { state: "invalid" };
+  }
+}
+
 // src/daemon/server.ts
-var CONFIG_DIR = join8(homedir5(), ".config", "prim");
-var SOCK_PATH2 = join8(CONFIG_DIR, "sock");
+var CONFIG_DIR = join9(homedir6(), ".config", "prim");
+var SOCK_PATH2 = join9(CONFIG_DIR, "sock");
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var INGESTION_POLL_INTERVAL_MS = 15e3;
 var TOKEN_CHECK_INTERVAL_MS = 6e4;
@@ -1193,6 +1434,7 @@ var startedAt = Date.now();
 var client = getClient();
 var runtimeVersion = resolveRuntimeVersion();
 var daemonHealth = createDaemonHealthState(runtimeVersion, process.pid, startedAt);
+var statuslineIngestionCache = new StatuslineIngestionCache(decisionIngestionStatus);
 var activeSessionId = process.env.PRIM_DAEMON_SESSION_ID ?? `daemon-${process.pid}`;
 var lastHeartbeatAt;
 var lastOnlineCount;
@@ -1214,7 +1456,7 @@ function resolveRuntimeVersion() {
   }
   try {
     const here = fileURLToPath(new URL(".", import.meta.url));
-    const pkg = JSON.parse(readFileSync5(join8(here, "..", "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync6(join9(here, "..", "..", "package.json"), "utf-8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -1285,7 +1527,7 @@ async function takeOwnership() {
       (pid) => pid !== void 0 && daemonProcessIsAlive(pid)
     )
   );
-  if (existsSync6(SOCK_PATH2) || candidatePids.size > 0) {
+  if (existsSync7(SOCK_PATH2) || candidatePids.size > 0) {
     const snapshot = await daemonRequest(
       "status_snapshot",
       {},
@@ -1566,6 +1808,7 @@ async function dispatchRequest(req) {
         return { id, ok: true, result };
       }
       case "session_start": {
+        statuslineIngestionCache.clear();
         const sid = req.params?.sessionId;
         if (typeof sid === "string" && sid.length > 0) {
           activeSessionId = sid;
@@ -1578,6 +1821,9 @@ async function dispatchRequest(req) {
       }
       case "status_snapshot":
         return { id, ok: true, result: handleStatusSnapshot(req.params ?? {}) };
+      case "statusline_invalidate":
+        statuslineIngestionCache.clear();
+        return { id, ok: true, result: { ack: true } };
       case "ping":
         return { id, ok: true, result: { pong: true } };
       default:
@@ -1592,13 +1838,15 @@ async function dispatchRequest(req) {
   }
 }
 function handleConnection(conn) {
-  let buffer = "";
-  conn.on("data", (chunk) => {
-    buffer += chunk.toString("utf-8");
-    let newlineIdx = buffer.indexOf("\n");
+  let mode = "undecided";
+  let rawBuffer = Buffer.alloc(0);
+  let jsonBuffer = "";
+  const dispatchJson = (chunk) => {
+    jsonBuffer += chunk;
+    let newlineIdx = jsonBuffer.indexOf("\n");
     while (newlineIdx !== -1) {
-      const line = buffer.slice(0, newlineIdx);
-      buffer = buffer.slice(newlineIdx + 1);
+      const line = jsonBuffer.slice(0, newlineIdx);
+      jsonBuffer = jsonBuffer.slice(newlineIdx + 1);
       if (line.length > 0) {
         try {
           const req = JSON.parse(line);
@@ -1613,8 +1861,59 @@ function handleConnection(conn) {
         } catch {
         }
       }
-      newlineIdx = buffer.indexOf("\n");
+      newlineIdx = jsonBuffer.indexOf("\n");
+    }
+  };
+  const dispatchStatusline = () => {
+    const parsed = parseStatuslineRequest(rawBuffer);
+    if (parsed.state === "incomplete") {
+      return;
+    }
+    if (parsed.state === "invalid") {
+      conn.end();
+      return;
+    }
+    try {
+      const callerEnv = getSiteUrlForCwd(
+        parsed.request.cwd,
+        parsed.request.primApiUrl || void 0
+      );
+      const snapshot = handleStatusSnapshot({ callerEnv });
+      const line = formatStatusline(
+        runtimeVersion,
+        snapshot,
+        () => statuslineIngestionCache.get(parsed.request.cwd)
+      );
+      conn.end(line);
+    } catch {
+      conn.end();
+    }
+  };
+  conn.on("data", (chunk) => {
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    if (mode === "json") {
+      dispatchJson(bytes.toString("utf8"));
+      return;
+    }
+    rawBuffer = Buffer.concat([rawBuffer, bytes]);
+    if (mode === "statusline") {
+      if (rawBuffer.length > STATUSLINE_REQUEST_MAX_BYTES) {
+        conn.end();
+      } else {
+        dispatchStatusline();
+      }
+      return;
+    }
+    if (isStatuslineRequestPrefix(rawBuffer)) {
+      if (rawBuffer.length >= STATUSLINE_PROTOCOL_PREFIX.length) {
+        mode = "statusline";
+        dispatchStatusline();
+      }
+      return;
     }
+    mode = "json";
+    dispatchJson(rawBuffer.toString("utf8"));
+    rawBuffer = Buffer.alloc(0);
   });
   conn.on("error", () => {
   });

package/dist/hooks/post-commit.js

@@ -2,11 +2,11 @@
 import {
   commitAttributionFromEnvironment,
   toCommitMove
-} from "../chunk-QGVHLP5J.js";
+} from "../chunk-7X7SFOPJ.js";
 import {
   appendMove,
   resolveOrg
-} from "../chunk-S4LFRVGD.js";
+} from "../chunk-HIMWM526.js";
 import {
   getOrCreateWorkspaceId
 } from "../chunk-UVIWZWM6.js";
@@ -16,16 +16,34 @@ import {
   repoSyncId,
   resolveRepositoryContext
 } from "../chunk-XTNMSS4C.js";
-import "../chunk-I3HIPAIR.js";
+import "../chunk-CPX3BUOC.js";
 
 // src/hooks/post-commit.ts
 import { execFileSync, spawn } from "child_process";
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
+import { lstatSync, readFileSync } from "fs";
+import { basename, dirname, isAbsolute, join } from "path";
 import { fileURLToPath } from "url";
 var here = dirname(fileURLToPath(import.meta.url));
 var GIT_TIMEOUT_MS = 1e3;
 var FULL_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u;
+var OBSERVATION_MARKER_RE = /^prim-post-commit-observed\.[A-Za-z0-9]+$/u;
+var MAX_OBSERVATION_MARKER_AGE_MS = 10 * 60 * 1e3;
+var MAX_OBSERVATION_MARKER_FUTURE_SKEW_MS = 5e3;
+function capturedAtFromLauncher(env = process.env, now = Date.now()) {
+  const path = env.PRIM_COMMIT_OBSERVED_FILE;
+  if (!path || !isAbsolute(path) || !OBSERVATION_MARKER_RE.test(basename(path))) return;
+  try {
+    const stat = lstatSync(path);
+    const capturedAt = Math.trunc(stat.mtimeMs);
+    const uid = process.getuid?.();
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size !== 0 || stat.nlink !== 1 || (stat.mode & 63) !== 0 || uid !== void 0 && stat.uid !== uid || !Number.isSafeInteger(capturedAt) || capturedAt <= 0 || capturedAt < now - MAX_OBSERVATION_MARKER_AGE_MS || capturedAt > now + MAX_OBSERVATION_MARKER_FUTURE_SKEW_MS) {
+      return;
+    }
+    return capturedAt;
+  } catch {
+    return;
+  }
+}
 function gitText(args) {
   try {
     return execFileSync("git", args, {
@@ -117,6 +135,10 @@ function runPostCommit() {
   if (!isRepoActiveForCapture(cwd)) {
     return;
   }
+  const capturedAt = capturedAtFromLauncher();
+  if (process.env.PRIM_COMMIT_OBSERVED_FILE !== void 0 && capturedAt === void 0) {
+    return;
+  }
   const commit = readCommit();
   if (commit) {
     const repository = resolveRepositoryContext(cwd);
@@ -128,7 +150,8 @@ function runPostCommit() {
       repoFullName: githubRepositoryFullName(cwd) ?? void 0,
       repoSyncId: repoSyncId(cwd),
       workspaceId,
-      attribution
+      attribution,
+      ...capturedAt === void 0 ? {} : { capturedAt }
     });
     const { orgId } = resolveOrg({ sessionId: move.sessionId, cwd });
     appendMove(move, orgId);
@@ -148,5 +171,6 @@ if (!process.env.VITEST) {
   process.exit(0);
 }
 export {
+  capturedAtFromLauncher,
   runPostCommit
 };