@primitive.ai/prim 0.1.0-alpha.66 → 0.1.0-alpha.68

package/dist/chunk-I5BHJQH2.js

@@ -0,0 +1,329 @@
+import {
+  formatStatusline,
+  packageVersion,
+  stripControlChars
+} from "./chunk-K3AYW6VZ.js";
+import {
+  decisionIngestionStatus,
+  gitToplevel
+} from "./chunk-TDRXHBEX.js";
+import {
+  getSiteUrl,
+  isSessionEnded,
+  withFileLock
+} from "./chunk-RTLFE6EZ.js";
+import {
+  daemonRequest
+} from "./chunk-UTKQTZHL.js";
+
+// src/hooks/codex-context.ts
+import { createHash, randomBytes } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/daemon/decision-digest-cache.ts
+var DECISION_DIGEST_CACHE_LIMIT = 100;
+var DECISION_DIGEST_CACHE_WINDOW = "24h";
+var DECISION_DIGEST_CACHE_PATH = `/api/cli/decisions/recent?limit=${String(DECISION_DIGEST_CACHE_LIMIT)}&since=${DECISION_DIGEST_CACHE_WINDOW}`;
+
+// src/hooks/codex-context.ts
+var CODEX_CONTEXT_TIMEOUT_MS = 250;
+var CODEX_DIGEST_LIMIT = DECISION_DIGEST_CACHE_LIMIT;
+var CODEX_DIGEST_VISIBLE_CAP = 3;
+var CODEX_DIGEST_OVERLAP_MS = 6e4;
+var CODEX_DIGEST_MAX_SEEN_IDS = 128;
+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 = [".config", "prim", "codex", "decision-digests"];
+var NO_CURSOR = -1;
+function hasVisibleCodexMessage(output) {
+  if (typeof output !== "object" || output === null || Array.isArray(output)) return false;
+  const candidate = output;
+  return Boolean(
+    candidate.systemMessage?.trim() || candidate.hookSpecificOutput?.permissionDecisionReason?.trim() || candidate.hookSpecificOutput?.additionalContext?.trim()
+  );
+}
+function appendContext(existing, context) {
+  return existing ? `${existing}
+
+${context}` : context;
+}
+function appendCodexContext(output, context) {
+  if (!context) return output;
+  const candidate = output;
+  const next = { ...output };
+  if (candidate.systemMessage) {
+    next.systemMessage = appendContext(candidate.systemMessage, context);
+  } else if (candidate.hookSpecificOutput?.permissionDecisionReason) {
+    next.systemMessage = context;
+  } else if (candidate.hookSpecificOutput?.additionalContext) {
+    next.hookSpecificOutput = {
+      ...candidate.hookSpecificOutput,
+      additionalContext: appendContext(candidate.hookSpecificOutput.additionalContext, context)
+    };
+  } else {
+    next.systemMessage = context;
+  }
+  return next;
+}
+function stateRoot() {
+  return join(homedir(), ...STATE_DIRECTORY);
+}
+function workspaceFor(cwd) {
+  try {
+    return gitToplevel(cwd) ?? cwd;
+  } catch {
+    return 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`);
+}
+function parseState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  if (record.version !== STATE_VERSION || typeof record.sessionId !== "string" || typeof record.siteUrl !== "string" || typeof record.workspace !== "string" || typeof record.startedAt !== "number" || typeof record.watermarkMs !== "number" || !Array.isArray(record.seenIds) || !record.seenIds.every((id) => typeof id === "string") || typeof record.updatedAt !== "number") {
+    return void 0;
+  }
+  return {
+    version: STATE_VERSION,
+    sessionId: record.sessionId,
+    siteUrl: record.siteUrl,
+    workspace: record.workspace,
+    startedAt: record.startedAt,
+    watermarkMs: record.watermarkMs,
+    seenIds: record.seenIds.slice(-CODEX_DIGEST_MAX_SEEN_IDS),
+    lastReport: typeof record.lastReport === "string" ? record.lastReport : void 0,
+    updatedAt: record.updatedAt
+  };
+}
+function readState(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    return parseState(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function writeState(path, state) {
+  const directory = stateRoot();
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  chmodSync(directory, 448);
+  const temporary = join(
+    directory,
+    `.${path.slice(directory.length + 1)}.tmp-${process.pid}-${randomBytes(8).toString("hex")}`
+  );
+  try {
+    writeFileSync(temporary, `${JSON.stringify(state)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    chmodSync(temporary, 384);
+    renameSync(temporary, path);
+  } finally {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+  }
+}
+function cleanupStateFiles(now) {
+  const directory = stateRoot();
+  if (!existsSync(directory)) return;
+  let names;
+  try {
+    names = readdirSync(directory);
+  } catch {
+    return;
+  }
+  const files = [];
+  const residue = [];
+  for (const name of names) {
+    const path = join(directory, name);
+    try {
+      const mtimeMs = statSync(path).mtimeMs;
+      if (name.endsWith(".json")) {
+        files.push({ path, mtimeMs });
+      } else if ((name.includes(".json.tmp-") || name.endsWith(".json.lock")) && now - mtimeMs > CODEX_DIGEST_STATE_RETENTION_MS) {
+        residue.push(path);
+      }
+    } catch {
+    }
+  }
+  const stale = files.filter((file) => now - file.mtimeMs > CODEX_DIGEST_STATE_RETENTION_MS);
+  const excess = files.filter((file) => !stale.some((candidate) => candidate.path === file.path)).sort((a, b) => a.mtimeMs - b.mtimeMs).slice(0, Math.max(0, files.length - CODEX_DIGEST_STATE_MAX_FILES));
+  for (const file of [...stale, ...excess]) {
+    try {
+      unlinkSync(file.path);
+    } catch {
+    }
+  }
+  for (const path of residue) {
+    try {
+      if (now - statSync(path).mtimeMs > CODEX_DIGEST_STATE_RETENTION_MS) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+}
+function isChangeDecision(row) {
+  return row.intentKind === void 0 || row.intentKind === "change";
+}
+function safeInline(value, fallback) {
+  const clean = stripControlChars(value ?? "").replace(/\s+/gu, " ").trim();
+  if (!clean) return fallback;
+  return clean.length <= 240 ? clean : `${clean.slice(0, 239)}\u2026`;
+}
+function renderDecisionDigest(rows, options = {}) {
+  if (rows.length === 0) return void 0;
+  const visible = rows.slice(0, CODEX_DIGEST_VISIBLE_CAP).map((row) => {
+    const author = safeInline(row.authorName, "(unknown)").replace(/[;;；‒-―−]/gu, "-");
+    const intent = safeInline(row.intent, "(untitled Decision)").replace(/[“-‟″‶〝〞]/gu, "'");
+    return `${author} \u2014 \u201C${intent}\u201D`;
+  });
+  const overflow = rows.length > CODEX_DIGEST_VISIBLE_CAP ? ` +${String(rows.length - CODEX_DIGEST_VISIBLE_CAP)}${options.pageTruncated === true ? "+" : ""}` : "";
+  return `[prim] Decisions captured since last message: ${visible.join("; ")}${overflow}`;
+}
+function reauthSnapshot(sessionId) {
+  return {
+    pid: 0,
+    uptimeMs: 0,
+    sessionId,
+    healthy: false,
+    needsReauth: true
+  };
+}
+function mergeState(latest, args) {
+  const seen = new Set(latest?.seenIds ?? []);
+  for (const id of args.seenIds) seen.add(id);
+  return {
+    version: STATE_VERSION,
+    sessionId: args.sessionId,
+    siteUrl: args.siteUrl,
+    workspace: args.workspace,
+    startedAt: latest?.startedAt ?? args.startedAt,
+    // Advance only on an observed page (server classifiedAt time), never the
+    // client clock; an unavailable feed keeps the previous cursor — or the
+    // NO_CURSOR sentinel, so the startup backlog survives until the first
+    // successful fetch.
+    watermarkMs: args.feedAvailable ? Math.max(latest?.watermarkMs ?? NO_CURSOR, args.watermarkMs) : latest?.watermarkMs ?? NO_CURSOR,
+    seenIds: [...seen].slice(-CODEX_DIGEST_MAX_SEEN_IDS),
+    lastReport: args.report,
+    updatedAt: args.now
+  };
+}
+async function commitState(path, args) {
+  try {
+    await withFileLock(
+      `${path}.lock`,
+      () => {
+        const latest = readState(path);
+        writeState(path, mergeState(latest, args));
+        cleanupStateFiles(args.now);
+      },
+      { timeoutMs: 50, pollMs: 10 }
+    );
+  } catch {
+  }
+}
+async function prepareCodexContext(options) {
+  const siteUrl = getSiteUrl();
+  const workspace = workspaceFor(options.cwd);
+  const path = statePath({ cwd: options.cwd, sessionId: options.sessionId, siteUrl });
+  const previous = readState(path);
+  const startup = options.startup === true;
+  const includeDigest = options.includeDigest !== false;
+  const startedAt = previous?.startedAt ?? Date.now();
+  const terminalAuth = isSessionEnded();
+  let snapshot = null;
+  let recent = null;
+  if (terminalAuth) {
+    snapshot = reauthSnapshot(options.sessionId);
+  } else {
+    [snapshot, recent] = await Promise.all([
+      daemonRequest(
+        "status_snapshot",
+        { callerEnv: siteUrl },
+        { timeoutMs: CODEX_CONTEXT_TIMEOUT_MS }
+      ),
+      includeDigest ? daemonRequest(
+        "decision_digest_snapshot",
+        { callerEnv: siteUrl },
+        { timeoutMs: CODEX_CONTEXT_TIMEOUT_MS }
+      ) : Promise.resolve(null)
+    ]);
+  }
+  const report = formatStatusline(
+    packageVersion() ?? "0.0.0",
+    snapshot,
+    () => decisionIngestionStatus(options.cwd),
+    { includeIngestionWhenUnavailable: true, plainLinks: true }
+  );
+  const reportChanged = startup || previous?.lastReport !== report;
+  let feedAvailable = false;
+  let freshRows = [];
+  let pageTruncated = false;
+  let pageWatermark = NO_CURSOR;
+  if (!terminalAuth && includeDigest && recent !== null) {
+    feedAvailable = recent.unavailable === void 0 && Array.isArray(recent.decisions);
+    if (feedAvailable) {
+      const seen = new Set(previous?.seenIds ?? []);
+      const lowerBound = previous !== void 0 && previous.watermarkMs >= 0 ? Math.max(0, previous.watermarkMs - CODEX_DIGEST_OVERLAP_MS) : 0;
+      freshRows = recent.decisions.filter(
+        (row) => isChangeDecision(row) && !seen.has(row.id) && typeof row.classifiedAt === "number" && row.classifiedAt >= lowerBound
+      );
+      pageTruncated = recent.decisions.length >= CODEX_DIGEST_LIMIT;
+      pageWatermark = recent.decisions.reduce(
+        (max, row) => typeof row.classifiedAt === "number" && row.classifiedAt > max ? row.classifiedAt : max,
+        NO_CURSOR
+      );
+    }
+  }
+  const digest = renderDecisionDigest(freshRows, { pageTruncated });
+  const context = [reportChanged ? report : void 0, digest].filter((value) => value !== void 0).join("\n\n") || void 0;
+  let acknowledged = false;
+  return {
+    context,
+    decisionDigest: digest,
+    feedAvailable,
+    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()
+      });
+    }
+  };
+}
+
+export {
+  hasVisibleCodexMessage,
+  appendCodexContext,
+  prepareCodexContext
+};

package/dist/chunk-K3AYW6VZ.js

@@ -0,0 +1,300 @@
+// src/lib/bin-path.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, isAbsolute, join } from "path";
+import { fileURLToPath } from "url";
+var PKG_NAME = "@primitive.ai/prim";
+var ROOT_WALK_LIMIT = 6;
+var NPX_FALLBACK = `npx --yes -p ${PKG_NAME}@latest`;
+var resolvedRoot;
+function locateRoot() {
+  if (resolvedRoot !== void 0) {
+    return resolvedRoot;
+  }
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < ROOT_WALK_LIMIT; depth++) {
+    const manifestPath = join(dir, "package.json");
+    if (existsSync(manifestPath)) {
+      try {
+        const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+        if (manifest.name === PKG_NAME && manifest.bin) {
+          resolvedRoot = { dir, version: manifest.version, bin: manifest.bin };
+          return resolvedRoot;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  resolvedRoot = null;
+  return resolvedRoot;
+}
+function binFile(bin) {
+  const root = locateRoot();
+  const rel = root?.bin[bin];
+  if (!root || !rel) {
+    return null;
+  }
+  return isAbsolute(rel) ? rel : join(root.dir, rel);
+}
+function packageVersion() {
+  return locateRoot()?.version ?? null;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function pinnedHookCommand(bin, args = "") {
+  const version = packageVersion();
+  if (!version) throw new Error("cannot determine Primitive package version");
+  const suffix = args ? ` ${args}` : "";
+  const fallback = `npx --yes -p ${PKG_NAME}@${version} ${bin}${suffix}`;
+  const file = binFile(bin);
+  if (!file) return fallback;
+  return `if [ -x ${shellQuote(process.execPath)} ] && [ -f ${shellQuote(file)} ]; then ${shellQuote(process.execPath)} ${shellQuote(file)}${suffix}; else ${fallback}; fi`;
+}
+function detachedHookShimCommand(bin, args = "") {
+  return `payload=$(cat); { trap '' HUP; export npm_config_fetch_retries=2 npm_config_fetch_retry_mintimeout=10000 npm_config_fetch_retry_maxtimeout=10000 npm_config_fetch_timeout=60000; printf '%s' "$payload" | { ${pinnedHookCommand(bin, args)}; }; } </dev/null >/dev/null 2>&1 &`;
+}
+function commandMatchesBin(command, bin) {
+  if (!command) {
+    return false;
+  }
+  const c = command.trim();
+  if (c === bin || c.startsWith(`${bin} `)) {
+    return true;
+  }
+  const exactBin = new RegExp(`(?:^|\\s)${bin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:\\s|;|$)`);
+  return c.includes(`command -v ${bin} `) || c.includes(`-p ${PKG_NAME}@`) && exactBin.test(c);
+}
+
+// src/lib/bin-cache.ts
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var CACHED_BINS = [
+  "prim",
+  "prim-hook",
+  "prim-pre-tool-use",
+  "prim-post-tool-use",
+  "prim-post-commit",
+  "prim-post-rewrite"
+];
+function binCacheDir() {
+  const base = process.env.XDG_CACHE_HOME || join2(homedir(), ".cache");
+  return join2(base, "prim", "bin");
+}
+function writeAtomic(path, content) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, content, { mode: 384 });
+  renameSync(tmp, path);
+}
+function warmBinCache() {
+  try {
+    if (process.env.PRIM_BIN_CACHE_HIT) {
+      return;
+    }
+    if (process.env.PRIM_BIN_CACHE === "0") {
+      return;
+    }
+    const dir = binCacheDir();
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    writeAtomic(join2(dir, "node"), process.execPath);
+    for (const bin of CACHED_BINS) {
+      const file = binFile(bin);
+      if (file) {
+        writeAtomic(join2(dir, bin), file);
+      }
+    }
+  } catch {
+  }
+}
+
+// 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";
+}
+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;
+}
+var MAX_HEALTH_ERROR_LENGTH = 240;
+function boundedHealthError(value) {
+  if (!value) return void 0;
+  const clean = stripControlChars(value).replace(/\s+/g, " ").trim();
+  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, "");
+}
+
+// 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, plain) {
+  const url = validDecisionUrl(decisionUrl);
+  if (plain || !url) {
+    return label;
+  }
+  return `\x1B]8;;${url}\x07\x1B[34;4m${label}\x1B[0m\x1B]8;;\x07`;
+}
+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, plainLinks = false) {
+  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, plainLinks);
+    }),
+    cap
+  );
+}
+
+// src/lib/statusline-render.ts
+var STATUSLINE_NAME_CAP = 3;
+function formatStatusline(version, snapshot, resolveIngestionStatus, options = {}) {
+  const ingestionSuffix = (status) => status === void 0 ? "" : ` \xB7 Decision ingestion ${status}`;
+  const ingestionStatus = snapshot === null || snapshot.healthy === false ? options.includeIngestionWhenUnavailable ? resolveIngestionStatus() : void 0 : resolveIngestionStatus();
+  if (!snapshot) {
+    return `primitive ${version} (daemon: down${ingestionSuffix(ingestionStatus)})`;
+  }
+  if (snapshot.healthy === false) {
+    if (snapshot.needsReauth) {
+      return `primitive ${version} (daemon: paused \xB7 run \`prim auth login\`${ingestionSuffix(ingestionStatus)})`;
+    }
+    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` : ""}${ingestionSuffix(ingestionStatus)})`;
+    }
+    if (snapshot.heartbeat?.healthy === false) {
+      return `primitive ${version} (daemon: degraded \xB7 presence: unavailable${ingestionSuffix(ingestionStatus)})`;
+    }
+    return `primitive ${version} (daemon: starting${ingestionSuffix(ingestionStatus)})`;
+  }
+  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, options.plainLinks === true)}`;
+  } 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})`;
+}
+
+export {
+  color,
+  dim,
+  bold,
+  colorForArea,
+  stripControlChars,
+  boundedHealthError,
+  stripAnsi,
+  binFile,
+  packageVersion,
+  pinnedHookCommand,
+  detachedHookShimCommand,
+  commandMatchesBin,
+  formatTeammates,
+  warmBinCache,
+  formatStatusline
+};

package/dist/{chunk-CPX3BUOC.js → chunk-RTLFE6EZ.js}

@@ -422,10 +422,12 @@ function refreshToken(options = {}) {
 }
 var HttpError = class extends Error {
   status;
-  constructor(status, message) {
+  body;
+  constructor(status, message, body) {
     super(message);
     this.name = "HttpError";
     this.status = status;
+    this.body = body;
   }
 };
 var _cachedCredential;
@@ -486,7 +488,9 @@ async function request(method, path, body, options) {
       throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
     }
     const errorBody = await response.json().catch(() => null);
-    throw new HttpError(response.status, errorBody?.error ?? `HTTP ${response.status}`);
+    const errorRecord = typeof errorBody === "object" && errorBody !== null && !Array.isArray(errorBody) ? errorBody : void 0;
+    const message = typeof errorRecord?.error === "string" ? errorRecord.error : `HTTP ${response.status}`;
+    throw new HttpError(response.status, message, errorBody);
   }
   return response.json();
 }

package/dist/{chunk-KHZNYEUV.js → chunk-U6L2RU67.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-CPX3BUOC.js";
+} from "./chunk-RTLFE6EZ.js";
 
 // src/decisions/feedback.ts
 var FEEDBACK_PROTOCOL_VERSION = 1;

package/dist/{chunk-HIMWM526.js → chunk-UN5O5SYG.js}

@@ -1,6 +1,6 @@
 import {
   getSiteUrl
-} from "./chunk-CPX3BUOC.js";
+} from "./chunk-RTLFE6EZ.js";
 
 // src/journal.ts
 import {

package/dist/chunk-XGADQPCI.js

@@ -0,0 +1,26 @@
+// src/ingest-response.ts
+var IngestAcknowledgementError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IngestAcknowledgementError";
+  }
+};
+function requireDurableIngestAcknowledgement(value, expected) {
+  if (typeof value !== "object" || value === null) {
+    throw new IngestAcknowledgementError("ingest response was not an object");
+  }
+  const response = value;
+  if (response.disposition !== "persisted") {
+    throw new IngestAcknowledgementError("ingest response did not confirm persistence");
+  }
+  if (response.acknowledged !== expected) {
+    throw new IngestAcknowledgementError(
+      `ingest acknowledged ${String(response.acknowledged)} of ${String(expected)} moves`
+    );
+  }
+  return value;
+}
+
+export {
+  requireDurableIngestAcknowledgement
+};