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

package/dist/chunk-VW3FDYRT.js

@@ -0,0 +1,517 @@
+import {
+  formatStatusline
+} from "./chunk-WX52U7Z2.js";
+import {
+  decisionIngestionStatus,
+  repositoryBindingState
+} from "./chunk-M6RIJVRE.js";
+import {
+  getSiteUrl,
+  isSessionEnded,
+  terminalSafeText
+} from "./chunk-PCVGBE5B.js";
+import {
+  packageVersion
+} from "./chunk-EWZMDD44.js";
+import {
+  gitToplevel
+} from "./chunk-H4UNYFUC.js";
+import {
+  daemonPrincipalsMatch,
+  daemonRequest,
+  resolveDaemonPrincipal
+} from "./chunk-KFXF2V5G.js";
+import {
+  primConfigDirectory,
+  withFileLock
+} from "./chunk-67VNLLBN.js";
+
+// src/hooks/codex-context.ts
+import { createHash, randomBytes as randomBytes2 } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+
+// src/daemon/decision-digest-cache.ts
+import { randomBytes } from "crypto";
+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}`;
+var DECISION_DRAFT_DIGEST_CACHE_PATH = `${DECISION_DIGEST_CACHE_PATH}&drafts=true`;
+var SAFE_PRIVATE_DRAFT_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/u;
+function isActionablePrivateDraft(row) {
+  if (typeof row !== "object" || row === null || Array.isArray(row)) return false;
+  const candidate = row;
+  return typeof candidate.id === "string" && SAFE_PRIVATE_DRAFT_ID.test(candidate.id) && typeof candidate.intent === "string" && candidate.authorIsSelf === true && candidate.stage === "draft" && (candidate.intentKind === void 0 || candidate.intentKind === "change");
+}
+
+// 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_DRAFT_DIGEST_MAX_SEEN_IDS = 4096;
+var CODEX_DIGEST_STATE_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var CODEX_DIGEST_STATE_MAX_FILES = 256;
+var STATE_VERSION = 1;
+var DRAFT_STATE_VERSION = 2;
+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(namespace) {
+  return join(primConfigDirectory(), namespace, "decision-digests");
+}
+function draftStateRoot(namespace) {
+  return join(primConfigDirectory(), namespace, "decision-draft-deliveries");
+}
+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(args.namespace), `${key}.json`);
+}
+function draftStatePath(args) {
+  const identity = `${args.siteUrl}\0${workspaceFor(args.cwd)}\0${args.sessionId}\0${args.principalId}\0${args.organizationId}\0${args.credentialFingerprint}`;
+  const key = createHash("sha256").update(identity).digest("hex");
+  return join(draftStateRoot(args.namespace), `${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 parseDraftState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  if (record.version !== DRAFT_STATE_VERSION || typeof record.sessionId !== "string" || typeof record.siteUrl !== "string" || typeof record.workspace !== "string" || typeof record.principalId !== "string" || typeof record.organizationId !== "string" || typeof record.credentialFingerprint !== "string" || !Array.isArray(record.seenDraftIds) || !record.seenDraftIds.every((id) => typeof id === "string") || typeof record.updatedAt !== "number") {
+    return void 0;
+  }
+  return {
+    version: DRAFT_STATE_VERSION,
+    sessionId: record.sessionId,
+    siteUrl: record.siteUrl,
+    workspace: record.workspace,
+    principalId: record.principalId,
+    organizationId: record.organizationId,
+    credentialFingerprint: record.credentialFingerprint,
+    seenDraftIds: record.seenDraftIds.slice(-CODEX_DRAFT_DIGEST_MAX_SEEN_IDS),
+    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 readDraftState(path) {
+  if (!existsSync(path)) return void 0;
+  try {
+    return parseDraftState(JSON.parse(readFileSync(path, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+function writeStateFile(path, directory, state) {
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  chmodSync(directory, 448);
+  const temporary = join(
+    directory,
+    `.${path.slice(directory.length + 1)}.tmp-${process.pid}-${randomBytes2(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(directory, now) {
+  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 = terminalSafeText(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 actionablePrivateDrafts(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const actionable = [];
+  for (const row of rows) {
+    if (!isActionablePrivateDraft(row) || seen.has(row.id)) continue;
+    seen.add(row.id);
+    actionable.push(row);
+  }
+  return actionable;
+}
+function renderDecisionDraftDigest(rows, options = {}) {
+  const eligible = actionablePrivateDrafts(rows);
+  if (eligible.length === 0) return void 0;
+  const visible = eligible.slice(0, CODEX_DIGEST_VISIBLE_CAP);
+  const lines = visible.flatMap((row) => {
+    const intent = safeInline(row.intent, "(untitled Decision)").replace(/[“-‟″‶〝〞]/gu, "'");
+    return [
+      `[prim] private Decision ${row.id} \xB7 stage: draft \xB7 \u201C${intent}\u201D`,
+      `[prim] Run \`prim decisions publish ${row.id}\` to share it with your team.`
+    ];
+  });
+  if (eligible.length > visible.length) {
+    const suffix = options.pageTruncated === true ? "+" : "";
+    lines.push(
+      `[prim] +${String(eligible.length - visible.length)}${suffix} private Decision drafts remain for later messages.`
+    );
+  }
+  return { message: lines.join("\n"), deliveredIds: visible.map((row) => row.id) };
+}
+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, namespace) {
+  try {
+    await withFileLock(
+      `${path}.lock`,
+      () => {
+        const latest = readState(path);
+        writeStateFile(path, stateRoot(namespace), mergeState(latest, args));
+        cleanupStateFiles(stateRoot(namespace), args.now);
+      },
+      { timeoutMs: 50, pollMs: 10 }
+    );
+  } catch {
+  }
+}
+function mergeDraftState(latest, args) {
+  const seen = new Set(latest?.seenDraftIds ?? []);
+  for (const id of args.deliveredIds) seen.add(id);
+  return {
+    version: DRAFT_STATE_VERSION,
+    sessionId: args.sessionId,
+    siteUrl: args.siteUrl,
+    workspace: args.workspace,
+    principalId: args.principalId,
+    organizationId: args.organizationId,
+    credentialFingerprint: args.credentialFingerprint,
+    seenDraftIds: [...seen].slice(-CODEX_DRAFT_DIGEST_MAX_SEEN_IDS),
+    updatedAt: args.now
+  };
+}
+async function commitDraftState(path, args, namespace) {
+  try {
+    let next;
+    await withFileLock(
+      `${path}.lock`,
+      () => {
+        const latest = readDraftState(path);
+        next = mergeDraftState(latest, args);
+        writeStateFile(path, draftStateRoot(namespace), next);
+        cleanupStateFiles(draftStateRoot(namespace), args.now);
+      },
+      { timeoutMs: 50, pollMs: 10 }
+    );
+    return next;
+  } catch {
+    return void 0;
+  }
+}
+async function prepareCodexContext(options) {
+  const namespace = options.namespace ?? "codex";
+  const siteUrl = getSiteUrl();
+  const workspace = workspaceFor(options.cwd);
+  const path = statePath({ cwd: options.cwd, sessionId: options.sessionId, siteUrl, namespace });
+  const previous = readState(path);
+  const principal = resolveDaemonPrincipal();
+  const privatePath = principal ? draftStatePath({
+    cwd: options.cwd,
+    sessionId: options.sessionId,
+    siteUrl,
+    principalId: principal.principalId,
+    organizationId: principal.organizationId,
+    credentialFingerprint: principal.credentialFingerprint,
+    namespace
+  }) : void 0;
+  const previousDraft = privatePath ? readDraftState(privatePath) : void 0;
+  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;
+  let recentDrafts = null;
+  if (terminalAuth) {
+    snapshot = reauthSnapshot(options.sessionId);
+  } else {
+    [snapshot, recent, recentDrafts] = 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),
+      includeDigest && principal !== void 0 ? daemonRequest(
+        "decision_draft_digest_snapshot",
+        { callerEnv: siteUrl },
+        { timeoutMs: CODEX_CONTEXT_TIMEOUT_MS }
+      ) : Promise.resolve(null)
+    ]);
+    if (principal !== void 0 && !daemonPrincipalsMatch(principal, resolveDaemonPrincipal())) {
+      snapshot = null;
+      recent = null;
+      recentDrafts = null;
+    }
+  }
+  let ingestionStatus;
+  const resolveIngestionStatus = () => {
+    ingestionStatus ??= decisionIngestionStatus(options.cwd);
+    return ingestionStatus;
+  };
+  const report = formatStatusline(packageVersion() ?? "0.0.0", snapshot, resolveIngestionStatus, {
+    includeIngestionWhenUnavailable: true,
+    plainLinks: true,
+    resolveRepositoryBindingState: () => resolveIngestionStatus() === "enabled" ? repositoryBindingState(options.cwd) : void 0
+  });
+  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 });
+  let draftDigest;
+  let draftPageToken;
+  let draftPageActionableIds = [];
+  if (!terminalAuth && includeDigest && privatePath !== void 0 && recentDrafts !== null && recentDrafts.unavailable === void 0 && Array.isArray(recentDrafts.decisions)) {
+    const allActionableDrafts = actionablePrivateDrafts(recentDrafts.decisions);
+    const seenDrafts = new Set(previousDraft?.seenDraftIds ?? []);
+    const freshDrafts = allActionableDrafts.filter((row) => !seenDrafts.has(row.id));
+    draftDigest = renderDecisionDraftDigest(freshDrafts, {
+      pageTruncated: recentDrafts.pageDone === false
+    });
+    draftPageToken = typeof recentDrafts.pageToken === "string" ? recentDrafts.pageToken : void 0;
+    draftPageActionableIds = allActionableDrafts.map((row) => row.id);
+  }
+  const combinedDigest = [digest, draftDigest?.message].filter((value) => value !== void 0).join("\n\n");
+  const context = [reportChanged ? report : void 0, combinedDigest || void 0].filter((value) => value !== void 0).join("\n\n") || void 0;
+  let acknowledged = false;
+  return {
+    context,
+    decisionDigest: combinedDigest || void 0,
+    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()
+        },
+        namespace
+      );
+      if (privatePath === void 0 || principal === void 0 || draftPageToken === void 0) {
+        return;
+      }
+      let persistedDraft = previousDraft;
+      if (draftDigest?.deliveredIds.length) {
+        persistedDraft = await commitDraftState(
+          privatePath,
+          {
+            sessionId: options.sessionId,
+            siteUrl,
+            workspace,
+            principalId: principal.principalId,
+            organizationId: principal.organizationId,
+            credentialFingerprint: principal.credentialFingerprint,
+            deliveredIds: draftDigest.deliveredIds,
+            now: Date.now()
+          },
+          namespace
+        );
+      }
+      const seenDrafts = new Set(persistedDraft?.seenDraftIds ?? []);
+      const deliveredOnThisPage = draftPageActionableIds.filter((id) => seenDrafts.has(id));
+      await daemonRequest(
+        "decision_draft_digest_acknowledge",
+        {
+          callerEnv: siteUrl,
+          pageToken: draftPageToken,
+          deliveredIds: deliveredOnThisPage
+        },
+        { timeoutMs: CODEX_CONTEXT_TIMEOUT_MS }
+      );
+    }
+  };
+}
+
+export {
+  hasVisibleCodexMessage,
+  appendCodexContext,
+  prepareCodexContext
+};

package/dist/chunk-WX52U7Z2.js

@@ -0,0 +1,112 @@
+import {
+  stripControlChars
+} from "./chunk-PCVGBE5B.js";
+
+// 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
+function repositoryBindingDiagnosticLabel(state) {
+  if (state === "unbound") return "GitHub repo connection: required (run `prim github connect`)";
+  if (state === "invalid") return "GitHub repo connection: invalid (run `prim doctor`)";
+  return void 0;
+}
+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?.healthy === false && snapshot.needsReauth) {
+    return `primitive ${version} (daemon: paused \xB7 run \`prim auth login\`${ingestionSuffix(ingestionStatus)})`;
+  }
+  const repositoryLabel = repositoryBindingDiagnosticLabel(
+    snapshot !== null && snapshot.healthy !== false || options.includeIngestionWhenUnavailable === true ? options.resolveRepositoryBindingState?.() : void 0
+  );
+  const repositorySuffix = repositoryLabel ? ` \xB7 ${repositoryLabel}` : "";
+  if (!snapshot) {
+    return `primitive ${version} (daemon: down${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+  }
+  if (snapshot.healthy === false) {
+    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` : ""}${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+    }
+    if (snapshot.heartbeat?.healthy === false) {
+      return `primitive ${version} (daemon: degraded \xB7 presence: unavailable${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+    }
+    return `primitive ${version} (daemon: starting${repositorySuffix}${ingestionSuffix(ingestionStatus)})`;
+  }
+  if (snapshot.envMismatch) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \xB7 presence: other env)`;
+  }
+  if (snapshot.principalMismatch) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \xB7 presence: other account)`;
+  }
+  if (snapshot.presenceStale) {
+    return `primitive ${version} (daemon: live, Decision ingestion ${ingestionStatus}${repositorySuffix} \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}${repositorySuffix} \xB7 ${team})`;
+}
+
+export {
+  formatTeammates,
+  repositoryBindingDiagnosticLabel,
+  formatStatusline
+};