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

package/README.md

@@ -238,13 +238,39 @@ installation.
 
 A supervised long-lived companion process that continuously drains captured
 Moves, accelerates decision-graph reads, 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.
+presence count. `prim setup` requires it to be live on the current version with
+an authenticated, healthy heartbeat unless the explicit `--no-daemon` opt-out is
+supplied. Hooks still fail soft if it later degrades.
+
+`prim daemon start` (and `restart`/`ensure`) does not gate on delivery. While
+Moves are past the 30s delivery SLA it reports them as draining in the
+background when the daemon's last sweep recorded no failure, or when the drains
+that failed acknowledged Moves before failing; another bucket delivering in the
+same sweep does not count. Journal buckets the daemon holds back (unbound,
+another organization, identity unavailable) read as delivery held back, and a
+failure with no progress reads as delivery failing; both are a ⚠ warning,
+still exit 0. Its JSON adds `draining`, `deliveryRetained`, `deliveryFailing`,
+and `ingestion` in those states. Start's JSON `healthy` means the start
+succeeded, so it can differ from `daemon status --json`, which stays degraded
+until the backlog drains. Setup's own health check reports a backlog the
+daemon is draining as a warning and fails on held-back buckets and on failures
+recorded without progress; standalone `prim doctor` still fails a missed SLA.
 
 ```bash
 prim daemon start      # start (stop / restart / status)
 ```
 
+Ordinary commands may upgrade an older daemon in the background. When an
+installed CLI runs an attended, allowlisted command (for example `auth`,
+`decisions`, `moves`, `skill`, or an agent's `install`/`status`) on macOS and
+finds the launchd daemon on an older version, or on its own version but unable
+to run (say, after a Node upgrade deleted the binary it pinned), it starts a
+detached `prim daemon ensure`, at most once an hour whatever version it
+targets. It never downgrades, never repoints the daemon at another deployment
+or config root, and never runs from hooks or their background drains, `daemon`,
+`doctor`, `setup` or its steps, `auth clear`, removal commands, a development
+checkout, or as root. Set `PRIM_DAEMON_DRIFT_HEAL=0` to turn it off.
+
 ### Decisions
 
 Read and respond to the decision graph.
@@ -338,6 +364,12 @@ prim moves tail           # Pretty-print recent journal entries
 prim moves flush          # Drain the local journals to the server (also runs from hooks)
 ```
 
+Any other command except `uninstall` and a `setup` that starts the daemon (or
+one of its steps) that finds Moves waiting over a minute (or cannot tell how
+long) hands them to a detached background `prim moves flush` and never waits for
+it. It starts none while a live daemon on the same version and deployment, with
+a healthy heartbeat and no recorded ingestion failure, already owns the drain.
+
 ### Skill
 
 ```bash

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

@@ -782,6 +782,7 @@ export {
   jwtOrganizationId,
   syncDirectory,
   syncFile,
+  ensureDurableDirectory,
   atomicWriteFile,
   processIsAlive,
   withFileLockSync,

package/dist/{chunk-VW3FDYRT.js → chunk-36TWVNBE.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-EWZMDD44.js";
+} from "./chunk-X64HTHUF.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-HU4PW6I6.js → chunk-C3VAA5CG.js}

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

package/dist/{chunk-FOLKHXLJ.js → chunk-DCJN6LZH.js}

@@ -1,18 +1,21 @@
+import {
+  unattendedEnv
+} from "./chunk-OYHYCK4K.js";
 import {
   isValidRepoSyncId,
   setRepoSyncId,
   setRepositoryBindingState
-} from "./chunk-M6RIJVRE.js";
+} from "./chunk-DSWT6BCC.js";
 import {
   HttpError,
   getClient
-} from "./chunk-PCVGBE5B.js";
+} from "./chunk-G2VMA2QO.js";
 import {
   binFile,
   compareSemver,
   cursorConfigDirectory,
   pinnedNpxCommand
-} from "./chunk-EWZMDD44.js";
+} from "./chunk-X64HTHUF.js";
 import {
   gitToplevel,
   githubRepositoryFullName
@@ -20,7 +23,7 @@ import {
 import {
   atomicWriteFile,
   withFileLock
-} from "./chunk-67VNLLBN.js";
+} from "./chunk-2GP5UFV7.js";
 
 // src/lib/bin-cache.ts
 import { chmodSync, mkdirSync } from "fs";
@@ -1504,6 +1507,34 @@ async function bindRepository(root, options) {
   return bindRepositoryWithClient(root, getClient(), options);
 }
 
+// src/daemon/self-heal.ts
+import { spawn } from "child_process";
+function kickDaemonEnsure(options = {}) {
+  const primEntry = options.primEntry === void 0 ? binFile("prim") : options.primEntry;
+  if (!primEntry) {
+    return false;
+  }
+  try {
+    const args = [primEntry, "daemon", "ensure"];
+    if (options.latestBootstrap ?? (options.platform ?? process.platform) === "darwin") {
+      args.push("--latest-bootstrap");
+    }
+    const child = (options.spawnProcess ?? spawn)(
+      options.nodeEntry ?? process.execPath,
+      args,
+      // Unattended: neither SessionStart's repair nor a drift heal is a person
+      // running prim, so the child (and its descendants) never heal in turn.
+      { detached: true, stdio: "ignore", env: unattendedEnv() }
+    );
+    child.once("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export {
   warmBinCache,
   postCommitHookBlock,
@@ -1525,5 +1556,6 @@ export {
   refreshClaudePlugins,
   hasUsableCodexGuidance,
   hasUsableCursorSkill,
-  registerSkillCommands
+  registerSkillCommands,
+  kickDaemonEnsure
 };

package/dist/{chunk-M6RIJVRE.js → chunk-DSWT6BCC.js}

@@ -1,6 +1,7 @@
 import {
-  getClient
-} from "./chunk-PCVGBE5B.js";
+  getClient,
+  terminalSafeLine
+} from "./chunk-G2VMA2QO.js";
 import {
   gitToplevel,
   githubRepositoryFullName
@@ -8,7 +9,7 @@ import {
 import {
   __commonJS,
   __toESM
-} from "./chunk-67VNLLBN.js";
+} from "./chunk-2GP5UFV7.js";
 
 // node_modules/.pnpm/ajv@8.20.0/node_modules/ajv/dist/runtime/ucs2length.js
 var require_ucs2length = __commonJS({
@@ -18331,6 +18332,73 @@ function scheduleCollectScopeRefresh(cwd, collectScopeVersion, dependencies = de
   scheduledRefreshes.set(cwd, refresh);
 }
 
+// src/lib/ansi.ts
+var ANSI_CODES = {
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  // 256-color approximation of the orange trigger marker (xterm 208).
+  orange: "\x1B[38;5;208m",
+  gray: "\x1B[90m"
+};
+var ANSI_RESET = "\x1B[0m";
+var ANSI_DIM = "\x1B[2m";
+var ANSI_BOLD = "\x1B[1m";
+function supportsColor() {
+  if (process.env.NO_COLOR !== void 0 && process.env.NO_COLOR !== "") {
+    return false;
+  }
+  return process.stderr.isTTY === true;
+}
+function color(text, c) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${ANSI_CODES[c]}${text}${ANSI_RESET}`;
+}
+function dim(text) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${ANSI_DIM}${text}${ANSI_RESET}`;
+}
+function bold(text) {
+  if (!supportsColor()) {
+    return text;
+  }
+  return `${ANSI_BOLD}${text}${ANSI_RESET}`;
+}
+var AREA_COLORS = {
+  auth: "yellow",
+  data: "magenta",
+  mobile: "blue",
+  infra: "cyan",
+  ui: "green",
+  billing: "orange",
+  api: "blue",
+  docs: "gray",
+  testing: "gray"
+};
+function colorForArea(area) {
+  if (!area) {
+    return "gray";
+  }
+  return AREA_COLORS[area] ?? "gray";
+}
+var MAX_HEALTH_ERROR_LENGTH = 240;
+function boundedHealthError(value) {
+  if (!value) return void 0;
+  const clean = terminalSafeLine(value);
+  if (!clean) return void 0;
+  return clean.length <= MAX_HEALTH_ERROR_LENGTH ? clean : `${clean.slice(0, MAX_HEALTH_ERROR_LENGTH - 1)}\u2026`;
+}
+function stripAnsi(text) {
+  return text.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
 export {
   repoActiveFlag,
   isRepoActive,
@@ -18354,5 +18422,11 @@ export {
   isGitHubInstallIntentStatusResponse,
   cachedCollectScopeAdmits,
   fetchAndCacheCollectScope,
-  scheduleCollectScopeRefresh
+  scheduleCollectScopeRefresh,
+  color,
+  dim,
+  bold,
+  colorForArea,
+  boundedHealthError,
+  stripAnsi
 };

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-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-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";