@primitive.ai/prim 0.1.0-alpha.92 → 0.1.0-alpha.94

package/dist/{chunk-FBAYCS3X.js → chunk-DXJQR4QI.js}

@@ -1,27 +1,120 @@
 import {
   getSiteUrl
-} from "./chunk-PCVGBE5B.js";
+} from "./chunk-G2VMA2QO.js";
 import {
+  atomicWriteFile,
+  ensureDurableDirectory,
   jwtOrganizationId,
   primConfigDirectory,
   resolveAuthCredential
-} from "./chunk-67VNLLBN.js";
+} from "./chunk-2GP5UFV7.js";
 
 // src/journal.ts
 import {
   appendFileSync,
   closeSync,
-  existsSync,
+  existsSync as existsSync2,
   fstatSync,
   mkdirSync,
   openSync,
   opendirSync,
-  readFileSync,
+  readFileSync as readFileSync2,
   readSync,
-  readdirSync
+  readdirSync as readdirSync2
 } from "fs";
-import { dirname, join } from "path";
-var JOURNAL_DIR = join(primConfigDirectory(), "moves");
+import { dirname as dirname2, join as join2 } from "path";
+
+// src/drain-progress.ts
+import {
+  chmodSync,
+  existsSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  rmdirSync
+} from "fs";
+import { basename, dirname, join } from "path";
+var DIRECTORY_MODE = 448;
+var FILE_MODE = 384;
+var DRAIN_PROGRESS_DIRNAME = "drain-progress";
+var CHECKPOINT_NAME = /^(.+)\.json(?:\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp)?$/;
+function rotationIdentity(stat) {
+  return { size: stat.size, ino: stat.ino, dev: stat.dev };
+}
+function drainProgressDirectory(flushingPath) {
+  return join(dirname(flushingPath), DRAIN_PROGRESS_DIRNAME);
+}
+function drainProgressPath(flushingPath) {
+  return join(drainProgressDirectory(flushingPath), `${basename(flushingPath)}.json`);
+}
+function isByteCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function drainResumeOffset(flushingPath, rotation) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(drainProgressPath(flushingPath), "utf8"));
+  } catch {
+    return 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return 0;
+  }
+  const { v, offset, size, ino, dev } = parsed;
+  if (v !== 2 || ino !== rotation.ino || dev !== rotation.dev || size !== rotation.size || !isByteCount(offset) || offset > rotation.size) {
+    return 0;
+  }
+  return offset;
+}
+function writeDrainCheckpoint(flushingPath, checkpoint) {
+  const directory = drainProgressDirectory(flushingPath);
+  ensureDurableDirectory(directory, DIRECTORY_MODE);
+  chmodSync(directory, DIRECTORY_MODE);
+  atomicWriteFile(drainProgressPath(flushingPath), `${JSON.stringify(checkpoint)}
+`, {
+    mode: FILE_MODE
+  });
+}
+function removeEmptyDirectory(directory) {
+  try {
+    rmdirSync(directory);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function removeDrainCheckpoint(flushingPath) {
+  rmSync(drainProgressPath(flushingPath), { force: true });
+  removeEmptyDirectory(drainProgressDirectory(flushingPath));
+}
+function sweepOrphanedDrainCheckpoints(bucketDirectory) {
+  const directory = join(bucketDirectory, DRAIN_PROGRESS_DIRNAME);
+  let names;
+  try {
+    names = readdirSync(directory);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const rotation = CHECKPOINT_NAME.exec(name)?.[1];
+    if (rotation === void 0 || existsSync(join(bucketDirectory, rotation))) {
+      continue;
+    }
+    try {
+      rmSync(join(directory, name), { force: true });
+    } catch {
+    }
+  }
+  try {
+    removeEmptyDirectory(directory);
+  } catch {
+  }
+}
+
+// src/journal.ts
+var JOURNAL_DIR = join2(primConfigDirectory(), "moves");
 var UNBOUND_BUCKET = "_unbound";
 var JOURNAL_BASENAME = "journal.ndjson";
 var JOURNAL_STATS_SAMPLE_BYTES = 64 * 1024;
@@ -34,26 +127,26 @@ function envSlug(apiUrl) {
   return slug;
 }
 function currentEnvDir() {
-  return join(JOURNAL_DIR, envSlug(getSiteUrl()));
+  return join2(JOURNAL_DIR, envSlug(getSiteUrl()));
 }
 var DIR_MODE = 448;
-var FILE_MODE = 384;
+var FILE_MODE2 = 384;
 var SAFE_BUCKET = /^[A-Za-z0-9_-]+$/;
 var RESERVED_BUCKETS = /* @__PURE__ */ new Set([UNBOUND_BUCKET, "_legacy"]);
 function appendMoveToPath(path, move) {
-  const dir = dirname(path);
-  if (!existsSync(dir)) {
+  const dir = dirname2(path);
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true, mode: DIR_MODE });
   }
   appendFileSync(path, `${JSON.stringify(move)}
-`, { mode: FILE_MODE });
+`, { mode: FILE_MODE2 });
 }
 function bucketDir(orgId) {
   const safe = orgId !== void 0 && SAFE_BUCKET.test(orgId) && !RESERVED_BUCKETS.has(orgId);
-  return join(currentEnvDir(), safe ? orgId : UNBOUND_BUCKET);
+  return join2(currentEnvDir(), safe ? orgId : UNBOUND_BUCKET);
 }
 function journalPath(orgId) {
-  return join(bucketDir(orgId), JOURNAL_BASENAME);
+  return join2(bucketDir(orgId), JOURNAL_BASENAME);
 }
 function appendMove(move, orgId) {
   appendMoveToPath(journalPath(orgId), move);
@@ -72,23 +165,23 @@ function parseMoves(content) {
   return moves;
 }
 function readMovesFromPath(path) {
-  if (!existsSync(path)) {
+  if (!existsSync2(path)) {
     return [];
   }
-  return parseMoves(readFileSync(path, "utf-8"));
+  return parseMoves(readFileSync2(path, "utf-8"));
 }
 function listBuckets() {
   const out = [];
   const envDir = currentEnvDir();
-  if (!existsSync(envDir)) {
+  if (!existsSync2(envDir)) {
     return out;
   }
-  for (const entry of readdirSync(envDir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(envDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) {
       continue;
     }
-    const path = join(envDir, entry.name, JOURNAL_BASENAME);
-    if (existsSync(path)) {
+    const path = join2(envDir, entry.name, JOURNAL_BASENAME);
+    if (existsSync2(path)) {
       out.push({ bucket: entry.name, path });
     }
   }
@@ -105,22 +198,23 @@ function oldestCapturedAt(moves) {
   }
   return oldest;
 }
-function sampleJournalFile(path, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
+function sampleJournalFile(path, maxBytes = JOURNAL_STATS_SAMPLE_BYTES, options = {}) {
   const fd = openSync(path, "r");
   try {
     const initial = fstatSync(fd);
-    const target = Math.min(initial.size, Math.max(0, maxBytes));
+    const start = options.fromDrainCheckpoint ? drainResumeOffset(path, rotationIdentity(initial)) : 0;
+    const target = Math.min(initial.size - start, Math.max(0, maxBytes));
     const buffer = Buffer.allocUnsafe(target);
     let sampledBytes = 0;
     while (sampledBytes < target) {
-      const count = readSync(fd, buffer, sampledBytes, target - sampledBytes, sampledBytes);
+      const count = readSync(fd, buffer, sampledBytes, target - sampledBytes, start + sampledBytes);
       if (count === 0) {
         break;
       }
       sampledBytes += count;
     }
     const stat = fstatSync(fd);
-    const sampled = stat.size > sampledBytes;
+    const sampled = stat.size - start > sampledBytes;
     let content = buffer.subarray(0, sampledBytes).toString("utf-8");
     if (sampled) {
       const lastNewline = content.lastIndexOf("\n");
@@ -130,6 +224,7 @@ function sampleJournalFile(path, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
     const moves = parseMoves(content);
     return {
       sizeBytes: stat.size,
+      pendingBytes: Math.max(0, stat.size - start),
       mtimeMs: stat.mtimeMs,
       lineCount: sampled && stat.size > 0 ? Math.max(1, lines.length) : lines.length,
       oldestCapturedAt: oldestCapturedAt(moves),
@@ -148,7 +243,7 @@ function parseFlushingPid(name) {
   return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
 }
 function listFlushingInDir(dir, bucket, options = {}) {
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     return [];
   }
   const out = [];
@@ -162,10 +257,10 @@ function listFlushingInDir(dir, bucket, options = {}) {
         entry = entries.readSync();
         continue;
       }
-      const path = join(dir, entry.name);
+      const path = join2(dir, entry.name);
       let sample;
       try {
-        sample = sampleJournalFile(path, remainingBytes);
+        sample = sampleJournalFile(path, remainingBytes, { fromDrainCheckpoint: true });
       } catch (err) {
         if (err.code === "ENOENT") {
           entry = entries.readSync();
@@ -189,18 +284,18 @@ function listFlushingInDir(dir, bucket, options = {}) {
 }
 function listFlushing(options = {}) {
   const envDir = currentEnvDir();
-  if (!existsSync(envDir)) {
+  if (!existsSync2(envDir)) {
     return [];
   }
   const out = [];
   let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
   const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
-  for (const entry of readdirSync(envDir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(envDir, { withFileTypes: true })) {
     if (out.length >= maxFiles) {
       break;
     }
     if (entry.isDirectory()) {
-      const found = listFlushingInDir(join(envDir, entry.name), entry.name, {
+      const found = listFlushingInDir(join2(envDir, entry.name), entry.name, {
         sampleBytes: remainingBytes,
         maxFiles: maxFiles - out.length
       });
@@ -213,6 +308,17 @@ function listFlushing(options = {}) {
   }
   return out;
 }
+function sweepOrphanedDrainProgress() {
+  const envDir = currentEnvDir();
+  if (!existsSync2(envDir)) {
+    return;
+  }
+  for (const entry of readdirSync2(envDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      sweepOrphanedDrainCheckpoints(join2(envDir, entry.name));
+    }
+  }
+}
 function bucketStats(options = {}) {
   const out = [];
   let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
@@ -258,17 +364,17 @@ function pendingJournalStats() {
 }
 
 // src/binding.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
 var PRIM_CONFIG_DIR = primConfigDirectory();
-var SESSIONS_DIR = join2(PRIM_CONFIG_DIR, "sessions");
+var SESSIONS_DIR = join3(PRIM_CONFIG_DIR, "sessions");
 var WORKSPACE_FILE = ".prim/workspace.json";
 function readJsonSafe(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return;
   }
   try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
+    return JSON.parse(readFileSync3(path, "utf-8"));
   } catch {
     return;
   }
@@ -277,17 +383,17 @@ function fromSessionMarker(sessionId) {
   if (!sessionId) {
     return;
   }
-  const marker = readJsonSafe(join2(SESSIONS_DIR, `${sessionId}.json`));
+  const marker = readJsonSafe(join3(SESSIONS_DIR, `${sessionId}.json`));
   return marker?.orgId;
 }
 function fromWorkspaceFile(startDir) {
   let dir = startDir;
   while (true) {
-    const config = readJsonSafe(join2(dir, WORKSPACE_FILE));
+    const config = readJsonSafe(join3(dir, WORKSPACE_FILE));
     if (config?.orgId) {
       return config.orgId;
     }
-    const parent = dirname2(dir);
+    const parent = dirname3(dir);
     if (parent === dir) {
       return;
     }
@@ -315,11 +421,17 @@ function resolveOrg(args) {
 }
 
 export {
+  rotationIdentity,
+  drainResumeOffset,
+  writeDrainCheckpoint,
+  removeDrainCheckpoint,
   JOURNAL_DIR,
+  envSlug,
   appendMove,
   readMovesFromPath,
   listBuckets,
   listFlushing,
+  sweepOrphanedDrainProgress,
   bucketStats,
   pendingJournalStats,
   SESSIONS_DIR,

package/dist/chunk-FXF4JWK2.js

@@ -0,0 +1,162 @@
+import {
+  repoActiveFlag
+} from "./chunk-DSWT6BCC.js";
+import {
+  atomicWriteFile
+} from "./chunk-2GP5UFV7.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 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,
+  recordPostCommitFired,
+  recordHooksWired,
+  clearHooksWired,
+  inspectPostCommitFiring
+};

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

@@ -19,7 +19,7 @@ import {
   resolveAuthCredential,
   withFileLock,
   workosConnectTokenEndpoint
-} from "./chunk-67VNLLBN.js";
+} from "./chunk-2GP5UFV7.js";
 
 // src/lib/terminal-safe.ts
 function replaceIsolatedSurrogates(value) {
@@ -645,6 +645,7 @@ export {
   isTerminalSafeText,
   stripControlChars,
   getSiteUrl,
+  getSiteUrlForEnvironment,
   getTokenExpiresAt,
   isSessionEnded,
   commitCredentials,

package/dist/{chunk-NAHHFSLH.js → chunk-ICM2XCXS.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-EZXEWFDG.js";
 import {
   scrubEnvironmentPaths
-} from "./chunk-OAAP2MY6.js";
+} from "./chunk-K7D2EYBS.js";
 import {
   isValidRepoSyncId
-} from "./chunk-M6RIJVRE.js";
+} from "./chunk-DSWT6BCC.js";
 
 // src/hooks/prim-hook-core.ts
 import { createHash, randomUUID } from "crypto";

package/dist/{chunk-5HRR4AOR.js → chunk-IMK4JKTA.js}

@@ -2,7 +2,7 @@ import {
   cursorHooksPath,
   hasExactCursorHandler,
   readCursorHooks
-} from "./chunk-26P57LAR.js";
+} from "./chunk-AXQQMX2U.js";
 import {
   resolveRepositoryContext
 } from "./chunk-H4UNYFUC.js";

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

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

package/dist/{chunk-ADUTW66W.js → chunk-O7YAW7G6.js}

@@ -1,18 +1,18 @@
 import {
   formatStatusline
-} from "./chunk-WX52U7Z2.js";
+} from "./chunk-ZU563PQI.js";
 import {
   decisionIngestionStatus,
   repositoryBindingState
-} from "./chunk-M6RIJVRE.js";
+} from "./chunk-DSWT6BCC.js";
 import {
   getSiteUrl,
   isSessionEnded,
   terminalSafeText
-} from "./chunk-PCVGBE5B.js";
+} from "./chunk-G2VMA2QO.js";
 import {
   packageVersion
-} from "./chunk-26P57LAR.js";
+} from "./chunk-AXQQMX2U.js";
 import {
   gitToplevel
 } from "./chunk-H4UNYFUC.js";
@@ -20,11 +20,11 @@ import {
   daemonPrincipalsMatch,
   daemonRequest,
   resolveDaemonPrincipal
-} from "./chunk-KFXF2V5G.js";
+} from "./chunk-OTHKG76J.js";
 import {
   primConfigDirectory,
   withFileLock
-} from "./chunk-67VNLLBN.js";
+} from "./chunk-2GP5UFV7.js";
 
 // src/hooks/codex-context.ts
 import { createHash, randomBytes as randomBytes2 } from "crypto";

package/dist/{chunk-5AFRMOPX.js → chunk-OH3EZXYX.js}

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

package/dist/{chunk-KFXF2V5G.js → chunk-OTHKG76J.js}

@@ -2,7 +2,7 @@ import {
   decodeJwtPayload,
   primConfigDirectory,
   resolveAuthCredential
-} from "./chunk-67VNLLBN.js";
+} from "./chunk-2GP5UFV7.js";
 
 // src/daemon/client.ts
 import { createConnection } from "net";

package/dist/chunk-OYHYCK4K.js

@@ -0,0 +1,13 @@
+// src/lib/unattended.ts
+var UNATTENDED_ENV = "PRIM_UNATTENDED";
+function unattendedEnv(env = process.env) {
+  return { ...env, [UNATTENDED_ENV]: "1" };
+}
+function isUnattended(env = process.env) {
+  return env[UNATTENDED_ENV] === "1";
+}
+
+export {
+  unattendedEnv,
+  isUnattended
+};

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

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

package/dist/{chunk-5GYQ4J3D.js → chunk-UKUAAAXE.js}

@@ -2,10 +2,10 @@ import {
   getClient,
   getSiteUrl,
   terminalSafeLine
-} from "./chunk-PCVGBE5B.js";
+} from "./chunk-G2VMA2QO.js";
 import {
   daemonRequest
-} from "./chunk-KFXF2V5G.js";
+} from "./chunk-OTHKG76J.js";
 
 // src/daemon/proxy.ts
 var DAEMON_HTTP_TIMEOUT_MS = 1e4;