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

package/dist/chunk-R26A7TWY.js

@@ -0,0 +1,36 @@
+import {
+  scheduleCollectScopeRefresh
+} from "./chunk-MAZWKJGL.js";
+
+// src/ingest-response.ts
+var IngestAcknowledgementError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IngestAcknowledgementError";
+  }
+};
+function requireDurableIngestAcknowledgement(value, expected, cwd = process.cwd()) {
+  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`
+    );
+  }
+  if (typeof response.collectScopeVersion === "number" && Number.isSafeInteger(response.collectScopeVersion) && response.collectScopeVersion >= 0) {
+    const roots = typeof cwd === "string" ? [cwd] : cwd;
+    for (const root of new Set(roots)) {
+      scheduleCollectScopeRefresh(root, response.collectScopeVersion);
+    }
+  }
+  return value;
+}
+
+export {
+  requireDurableIngestAcknowledgement
+};

package/dist/chunk-RO3F6JYV.js

@@ -0,0 +1,126 @@
+import {
+  getClient,
+  getSiteUrl,
+  terminalSafeLine
+} from "./chunk-Z7YPFWAZ.js";
+import {
+  daemonRequest
+} from "./chunk-CUE2LKLR.js";
+
+// src/daemon/proxy.ts
+var DAEMON_HTTP_TIMEOUT_MS = 1e4;
+var DAEMON_PROBE_TIMEOUT_MS = 250;
+async function daemonOrDirect(method, params, direct) {
+  const fromDaemon = await daemonRequest(
+    method,
+    { ...params, callerEnv: getSiteUrl() },
+    { timeoutMs: DAEMON_PROBE_TIMEOUT_MS }
+  );
+  if (fromDaemon !== null) {
+    return fromDaemon;
+  }
+  return await direct();
+}
+async function daemonOrDirectGet(method, path, client, timeoutMs = DAEMON_HTTP_TIMEOUT_MS) {
+  return await daemonOrDirect(
+    method,
+    { path },
+    async () => await client.get(path, {
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+  );
+}
+
+// src/hooks/decisions-check.ts
+var DECISIONS_CHECK_TIMEOUT_MS = 1e4;
+var MAX_FILES_PER_REQUEST = 25;
+var defaultDeps = { getClient };
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+async function fetchAffecting(client, batch) {
+  const params = new URLSearchParams();
+  for (const file of batch) {
+    params.append("files", file);
+  }
+  try {
+    return await daemonOrDirectGet(
+      "decisions_affecting",
+      `/api/cli/decisions/affecting?${params.toString()}`,
+      client,
+      DECISIONS_CHECK_TIMEOUT_MS
+    );
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { decisions: [], truncated: false, unavailable: `decision check failed: ${detail}` };
+  }
+}
+async function checkAffectedDecisions(filePaths, deps = defaultDeps) {
+  if (filePaths.length === 0) {
+    return { decisions: [], truncated: false };
+  }
+  const client = deps.getClient();
+  const responses = await Promise.all(
+    chunk(filePaths, MAX_FILES_PER_REQUEST).map((batch) => fetchAffecting(client, batch))
+  );
+  const byId = /* @__PURE__ */ new Map();
+  let truncated = false;
+  let unavailable;
+  for (const res of responses) {
+    if (res.unavailable !== void 0 && unavailable === void 0) {
+      unavailable = res.unavailable;
+    }
+    truncated ||= res.truncated === true;
+    for (const d of res.decisions) {
+      const existing = byId.get(d.id);
+      if (existing) {
+        existing.matchedFiles = [.../* @__PURE__ */ new Set([...existing.matchedFiles, ...d.matchedFiles])];
+      } else {
+        byId.set(d.id, { ...d, matchedFiles: [...d.matchedFiles] });
+      }
+    }
+  }
+  const result = { decisions: [...byId.values()], truncated };
+  if (unavailable !== void 0) {
+    result.unavailable = unavailable;
+  }
+  return result;
+}
+var FILES_PREVIEW_LIMIT = 3;
+function formatDecisionsWarning(result) {
+  const lines = [];
+  if (result.unavailable !== void 0) {
+    lines.push(`[prim] decision check not verified \u2014 ${terminalSafeLine(result.unavailable)}`);
+  }
+  if (result.decisions.length > 0) {
+    lines.push(
+      `[prim] ${String(result.decisions.length)} active decision(s) reference staged files:`
+    );
+    for (const d of result.decisions) {
+      const statusMark = d.status === "under_review" ? " (under review)" : "";
+      const preview = d.matchedFiles.slice(0, FILES_PREVIEW_LIMIT).map(terminalSafeLine).join(", ");
+      const overflow = d.matchedFiles.length > FILES_PREVIEW_LIMIT ? ` (+${String(d.matchedFiles.length - FILES_PREVIEW_LIMIT)} more)` : "";
+      lines.push(`  \xB7 ${terminalSafeLine(d.intent)}${statusMark}`);
+      lines.push(`    files: ${preview}${overflow}`);
+      if (d.rationale) {
+        lines.push(`    rationale: ${terminalSafeLine(d.rationale)}`);
+      }
+    }
+  }
+  if (result.truncated) {
+    lines.push(
+      "[prim] result truncated \u2014 more files than the server checks per request; not all decisions shown"
+    );
+  }
+  return lines.join("\n");
+}
+
+export {
+  daemonOrDirectGet,
+  checkAffectedDecisions,
+  formatDecisionsWarning
+};

package/dist/chunk-UZPBB7V4.js

@@ -0,0 +1,505 @@
+import {
+  formatStatusline,
+  packageVersion
+} from "./chunk-PMRDE2DA.js";
+import {
+  decisionIngestionStatus,
+  gitToplevel,
+  repositoryBindingState
+} from "./chunk-MAZWKJGL.js";
+import {
+  getSiteUrl,
+  isSessionEnded,
+  terminalSafeText,
+  withFileLock
+} from "./chunk-Z7YPFWAZ.js";
+import {
+  daemonPrincipalsMatch,
+  daemonRequest,
+  resolveDaemonPrincipal
+} from "./chunk-CUE2LKLR.js";
+import {
+  primConfigDirectory
+} from "./chunk-3EEFL6NJ.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 STATE_DIRECTORY = ["codex", "decision-digests"];
+var DRAFT_STATE_VERSION = 2;
+var DRAFT_STATE_DIRECTORY = ["codex", "decision-draft-deliveries"];
+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(primConfigDirectory(), ...STATE_DIRECTORY);
+}
+function draftStateRoot() {
+  return join(primConfigDirectory(), ...DRAFT_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 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(), `${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) {
+  try {
+    await withFileLock(
+      `${path}.lock`,
+      () => {
+        const latest = readState(path);
+        writeStateFile(path, stateRoot(), mergeState(latest, args));
+        cleanupStateFiles(stateRoot(), 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) {
+  try {
+    let next;
+    await withFileLock(
+      `${path}.lock`,
+      () => {
+        const latest = readDraftState(path);
+        next = mergeDraftState(latest, args);
+        writeStateFile(path, draftStateRoot(), next);
+        cleanupStateFiles(draftStateRoot(), args.now);
+      },
+      { timeoutMs: 50, pollMs: 10 }
+    );
+    return next;
+  } catch {
+    return void 0;
+  }
+}
+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 principal = resolveDaemonPrincipal();
+  const privatePath = principal ? draftStatePath({
+    cwd: options.cwd,
+    sessionId: options.sessionId,
+    siteUrl,
+    principalId: principal.principalId,
+    organizationId: principal.organizationId,
+    credentialFingerprint: principal.credentialFingerprint
+  }) : 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()
+      });
+      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()
+        });
+      }
+      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
+};