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

package/dist/hook-runtime/daemon/server.js

@@ -52,9 +52,9 @@ var require_ucs2length = __commonJS({
 });
 
 // src/daemon/server.ts
-import { chmodSync as chmodSync6, existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync8, unlinkSync as unlinkSync3 } from "fs";
+import { chmodSync as chmodSync7, existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync9, unlinkSync as unlinkSync3 } from "fs";
 import { createServer } from "net";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { fileURLToPath } from "url";
 
 // src/client.ts
@@ -1112,8 +1112,8 @@ async function getPinnedClient(options = {}) {
 }
 
 // src/flusher.ts
-import { createReadStream, renameSync as renameSync3, unlinkSync } from "fs";
-import { dirname as dirname7, join as join8 } from "path";
+import { createReadStream, renameSync as renameSync3, statSync as statSync2, unlinkSync } from "fs";
+import { dirname as dirname8, join as join9 } from "path";
 
 // src/dead-letter.ts
 import { createHash as createHash3, randomBytes as randomBytes2 } from "crypto";
@@ -1213,6 +1213,95 @@ function quarantineRawLine(flushingPath, rawLine, now = Date.now, options = {})
   return record;
 }
 
+// src/drain-progress.ts
+import {
+  chmodSync as chmodSync3,
+  existsSync as existsSync4,
+  readFileSync as readFileSync4,
+  readdirSync,
+  rmSync as rmSync5,
+  rmdirSync
+} from "fs";
+import { basename, dirname as dirname5, join as join6 } from "path";
+var DIRECTORY_MODE3 = 448;
+var FILE_MODE3 = 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 join6(dirname5(flushingPath), DRAIN_PROGRESS_DIRNAME);
+}
+function drainProgressPath(flushingPath) {
+  return join6(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(readFileSync4(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_MODE3);
+  chmodSync3(directory, DIRECTORY_MODE3);
+  atomicWriteFile(drainProgressPath(flushingPath), `${JSON.stringify(checkpoint)}
+`, {
+    mode: FILE_MODE3
+  });
+}
+function removeEmptyDirectory(directory) {
+  try {
+    rmdirSync(directory);
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function removeDrainCheckpoint(flushingPath) {
+  rmSync5(drainProgressPath(flushingPath), { force: true });
+  removeEmptyDirectory(drainProgressDirectory(flushingPath));
+}
+function sweepOrphanedDrainCheckpoints(bucketDirectory) {
+  const directory = join6(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 || existsSync4(join6(bucketDirectory, rotation))) {
+      continue;
+    }
+    try {
+      rmSync5(join6(directory, name), { force: true });
+    } catch {
+    }
+  }
+  try {
+    removeEmptyDirectory(directory);
+  } catch {
+  }
+}
+
 // src/generated/cli-http-v1.validators.js
 var import_ucs2length = __toESM(require_ucs2length(), 1);
 var schema33 = { "type": "object", "properties": { "authenticated": { "type": "boolean", "const": true }, "organizationBindingVersion": { "type": "number", "const": 1 }, "captureAuthorityKind": { "type": "string", "enum": ["workos", "service_token"] }, "organizationId": { "anyOf": [{ "type": "string", "minLength": 1 }, { "type": "null" }] }, "workosOrganizationId": { "anyOf": [{ "type": "string", "minLength": 1 }, { "type": "null" }] } }, "required": ["authenticated", "organizationBindingVersion", "captureAuthorityKind", "organizationId", "workosOrganizationId"], "additionalProperties": false };
@@ -19003,15 +19092,15 @@ validate68.evaluated = { "props": true, "dynamicProps": false, "dynamicItems": f
 
 // src/lib/activation.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/lib/git.ts
 import { execFileSync } from "child_process";
 import { createHash as createHash4 } from "crypto";
 import { lstatSync, realpathSync } from "fs";
-import { basename, dirname as dirname5, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute2, relative, resolve as resolve2, sep } from "path";
 var GIT_TIMEOUT_MS = 1e3;
 var GITHUB_OWNER_PATTERN = /^(?![A-Za-z0-9-]*--)[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/u;
 var GITHUB_REPOSITORY_PATTERN = /^[A-Za-z0-9._-]{1,100}$/u;
@@ -19121,10 +19210,10 @@ function hasProjectPrimInstall(cwd) {
   const root = gitToplevel(cwd);
   if (root === null || root === homedir2()) return false;
   for (const rel of PROJECT_INSTALL_FILES) {
-    const path = join6(root, rel);
-    if (existsSync4(path)) {
+    const path = join7(root, rel);
+    if (existsSync5(path)) {
       try {
-        const content = readFileSync4(path, "utf-8");
+        const content = readFileSync5(path, "utf-8");
         if (PRIM_HOOK_BINS.some((bin) => content.includes(bin))) return true;
       } catch {
       }
@@ -19393,6 +19482,13 @@ function parseOrganizationBinding(value) {
     }
   };
 }
+function summarizeRetainedBuckets(retained) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of retained) {
+    counts.set(item.reason, (counts.get(item.reason) ?? 0) + 1);
+  }
+  return [...counts].sort(([left], [right]) => left.localeCompare(right)).map(([reason, count]) => `${reason}:${String(count)}`).join(", ");
+}
 function classifyJournalBuckets(buckets, binding) {
   const deliverableBuckets = /* @__PURE__ */ new Set();
   const retainedBuckets = [];
@@ -19467,17 +19563,17 @@ async function inspectJournalDelivery(buckets, options = {}) {
 import {
   appendFileSync,
   closeSync as closeSync3,
-  existsSync as existsSync5,
+  existsSync as existsSync6,
   fstatSync,
   mkdirSync as mkdirSync5,
   openSync as openSync3,
   opendirSync,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   readSync,
-  readdirSync
+  readdirSync as readdirSync2
 } from "fs";
-import { dirname as dirname6, join as join7 } from "path";
-var JOURNAL_DIR = join7(primConfigDirectory(), "moves");
+import { dirname as dirname7, join as join8 } from "path";
+var JOURNAL_DIR = join8(primConfigDirectory(), "moves");
 var JOURNAL_BASENAME = "journal.ndjson";
 var JOURNAL_STATS_SAMPLE_BYTES = 64 * 1024;
 var PENDING_STATS_MAX_FILES = 128;
@@ -19489,7 +19585,7 @@ function envSlug(apiUrl) {
   return slug;
 }
 function currentEnvDir() {
-  return join7(JOURNAL_DIR, envSlug(getSiteUrl()));
+  return join8(JOURNAL_DIR, envSlug(getSiteUrl()));
 }
 function parseMoves(content) {
   const moves = [];
@@ -19507,15 +19603,15 @@ function parseMoves(content) {
 function listBuckets() {
   const out = [];
   const envDir = currentEnvDir();
-  if (!existsSync5(envDir)) {
+  if (!existsSync6(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 = join7(envDir, entry.name, JOURNAL_BASENAME);
-    if (existsSync5(path)) {
+    const path = join8(envDir, entry.name, JOURNAL_BASENAME);
+    if (existsSync6(path)) {
       out.push({ bucket: entry.name, path });
     }
   }
@@ -19532,22 +19628,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 = openSync3(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");
@@ -19557,6 +19654,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),
@@ -19575,7 +19673,7 @@ function parseFlushingPid(name) {
   return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
 }
 function listFlushingInDir(dir, bucket, options = {}) {
-  if (!existsSync5(dir)) {
+  if (!existsSync6(dir)) {
     return [];
   }
   const out = [];
@@ -19589,10 +19687,10 @@ function listFlushingInDir(dir, bucket, options = {}) {
         entry = entries.readSync();
         continue;
       }
-      const path = join7(dir, entry.name);
+      const path = join8(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();
@@ -19616,18 +19714,18 @@ function listFlushingInDir(dir, bucket, options = {}) {
 }
 function listFlushing(options = {}) {
   const envDir = currentEnvDir();
-  if (!existsSync5(envDir)) {
+  if (!existsSync6(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(join7(envDir, entry.name), entry.name, {
+      const found = listFlushingInDir(join8(envDir, entry.name), entry.name, {
         sampleBytes: remainingBytes,
         maxFiles: maxFiles - out.length
       });
@@ -19640,6 +19738,17 @@ function listFlushing(options = {}) {
   }
   return out;
 }
+function sweepOrphanedDrainProgress() {
+  const envDir = currentEnvDir();
+  if (!existsSync6(envDir)) {
+    return;
+  }
+  for (const entry of readdirSync2(envDir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      sweepOrphanedDrainCheckpoints(join8(envDir, entry.name));
+    }
+  }
+}
 function bucketStats(options = {}) {
   const out = [];
   let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
@@ -19686,8 +19795,12 @@ function pendingJournalStats() {
 
 // src/flusher.ts
 var BATCH_SIZE = 500;
+var BATCH_MAX_BYTES = 1048576;
 var HTTP_TIMEOUT_MS = 1e4;
 var ORPHAN_QUARANTINE_MS = 6e4;
+function exceedsBatchBytes(count, bytes, nextBytes, maxBytes) {
+  return count > 0 && bytes + nextBytes > maxBytes;
+}
 function addDrainCounts(left, right) {
   return {
     flushed: left.flushed + right.flushed,
@@ -19737,23 +19850,25 @@ function mayBeBatchSizeFailure(error) {
   }
   return error instanceof Error && error.name === "TimeoutError";
 }
-async function* rawJournalLines(input) {
+async function* rawJournalLines(input, offset) {
   let pending = [];
   let pendingBytes = 0;
+  let end = offset;
   for await (const value of input) {
     const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
     let start = 0;
     let newline = chunk.indexOf(10, start);
     while (newline !== -1) {
       const tail = chunk.subarray(start, newline + 1);
-      if (pending.length === 0) {
-        yield tail;
-      } else {
+      let line = tail;
+      if (pending.length > 0) {
         pending.push(tail);
-        yield Buffer.concat(pending, pendingBytes + tail.length);
+        line = Buffer.concat(pending, pendingBytes + tail.length);
         pending = [];
         pendingBytes = 0;
       }
+      end += line.length;
+      yield { bytes: line, end };
       start = newline + 1;
       newline = chunk.indexOf(10, start);
     }
@@ -19764,18 +19879,43 @@ async function* rawJournalLines(input) {
     }
   }
   if (pendingBytes > 0) {
-    yield pending.length === 1 ? pending[0] : Buffer.concat(pending, pendingBytes);
+    const bytes = pending.length === 1 ? pending[0] : Buffer.concat(pending, pendingBytes);
+    yield { bytes, end: end + pendingBytes };
   }
 }
+var drainProgressWarned = false;
 async function drainFlushingPath(flushingPath, client2, binding, options = {}) {
+  const rotation = rotationIdentity(statSync2(flushingPath));
+  const resumeAt = drainResumeOffset(flushingPath, rotation);
+  const recordProgress = (end) => {
+    if (end === void 0 || end >= rotation.size) {
+      return;
+    }
+    try {
+      writeDrainCheckpoint(flushingPath, { v: 2, offset: end, ...rotation });
+      drainProgressWarned = false;
+    } catch (error) {
+      if (!drainProgressWarned) {
+        drainProgressWarned = true;
+        process.stderr.write(
+          `[prim] could not record drain progress: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+      }
+    }
+  };
+  const reportProgress = (delta) => {
+    options.onProgress?.(delta);
+    return delta;
+  };
   const postBatch = async (batch2) => {
+    const moves = batch2.map((entry) => entry.move);
     try {
-      const request2 = buildOrganizationBoundMoveRequest(batch2, binding);
+      const request2 = buildOrganizationBoundMoveRequest(moves, binding);
       const response = await client2.post("/api/cli/moves/ingest", request2, {
         signal: AbortSignal.timeout(HTTP_TIMEOUT_MS)
       });
-      requireDurableIngestAcknowledgement(response, batch2.length, collectionScopeRoots(batch2));
-      return { flushed: batch2.length, quarantined: 0 };
+      requireDurableIngestAcknowledgement(response, moves.length, collectionScopeRoots(moves));
     } catch (error) {
       const reason = deadLetterReason(error);
       if (!(reason || mayBeBatchSizeFailure(error))) {
@@ -19790,33 +19930,43 @@ async function drainFlushingPath(flushingPath, client2, binding, options = {}) {
       if (!reason) {
         throw error;
       }
-      const [move] = batch2;
+      const [entry] = batch2;
       const quarantined = quarantineMove(
         flushingPath,
-        move,
+        entry.move,
         reason,
         Date.now,
         options.deadLetterPersistence
       );
+      recordProgress(entry.end);
       process.stderr.write(
         `[prim] quarantined rejected move ${quarantined.quarantineId.slice(0, 12)} (${reason})
 `
       );
-      return { flushed: 0, quarantined: 1 };
+      return reportProgress({ flushed: 0, quarantined: 1 });
     }
+    recordProgress(batch2.at(-1)?.end);
+    return reportProgress({ flushed: batch2.length, quarantined: 0 });
   };
-  const input = createReadStream(flushingPath);
+  const input = createReadStream(flushingPath, { start: resumeAt });
   const decoder = new TextDecoder("utf-8", { fatal: true });
   let batch = [];
+  let batchBytes = 0;
   let counts = { flushed: 0, quarantined: 0 };
+  const postPending = async () => {
+    counts = addDrainCounts(counts, await postBatch(batch));
+    batch = [];
+    batchBytes = 0;
+  };
   try {
-    for await (const rawLine of rawJournalLines(input)) {
+    for await (const { bytes: rawLine, end } of rawJournalLines(input, resumeAt)) {
       if (rawLine.length === 1 && rawLine[0] === 10 || rawLine.length === 2 && rawLine[0] === 13 && rawLine[1] === 10) {
         continue;
       }
+      let move;
       try {
         const line = decoder.decode(rawLine);
-        batch.push(JSON.parse(line));
+        move = JSON.parse(line);
       } catch {
         const quarantined = quarantineRawLine(
           flushingPath,
@@ -19828,24 +19978,35 @@ async function drainFlushingPath(flushingPath, client2, binding, options = {}) {
           `[prim] quarantined invalid journal line ${quarantined.quarantineId.slice(0, 12)} (invalid_move)
 `
         );
-        counts.quarantined += 1;
+        counts = addDrainCounts(counts, reportProgress({ flushed: 0, quarantined: 1 }));
+        if (batch.length === 0) {
+          recordProgress(end);
+        }
         continue;
       }
-      if (batch.length === BATCH_SIZE) {
-        counts = addDrainCounts(counts, await postBatch(batch));
-        batch = [];
+      if (exceedsBatchBytes(batch.length, batchBytes, rawLine.length, BATCH_MAX_BYTES)) {
+        await postPending();
+      }
+      batch.push({ move, end });
+      batchBytes += rawLine.length;
+      if (batch.length >= BATCH_SIZE) {
+        await postPending();
       }
     }
     if (batch.length > 0) {
-      counts = addDrainCounts(counts, await postBatch(batch));
+      await postPending();
     }
   } finally {
     input.destroy();
   }
   unlinkSync(flushingPath);
+  try {
+    removeDrainCheckpoint(flushingPath);
+  } catch {
+  }
   return counts;
 }
-async function drainPath(path, client2, binding) {
+async function drainPath(path, client2, binding, onProgress) {
   const tmpPath = `${path}.flushing.${String(Date.now())}.${String(process.pid)}`;
   try {
     renameSync3(path, tmpPath);
@@ -19855,7 +20016,19 @@ async function drainPath(path, client2, binding) {
     }
     throw err;
   }
-  return drainFlushingPath(tmpPath, client2, binding);
+  return drainFlushingPath(tmpPath, client2, binding, { onProgress });
+}
+async function settleDrain(drain) {
+  let progress = { flushed: 0, quarantined: 0 };
+  try {
+    return {
+      counts: await drain((delta) => {
+        progress = addDrainCounts(progress, delta);
+      })
+    };
+  } catch (error) {
+    return { counts: progress, failure: { error } };
+  }
 }
 function selectRecoverable(files, now, opts = {}) {
   const quarantineMs = opts.quarantineMs ?? ORPHAN_QUARANTINE_MS;
@@ -19872,7 +20045,8 @@ async function recoverOrphans(candidates, options) {
     flushed: 0,
     quarantined: 0,
     errors: [],
-    failedBuckets: /* @__PURE__ */ new Set()
+    failedBuckets: /* @__PURE__ */ new Set(),
+    failedDrainFlushed: 0
   };
   const recoverable = selectRecoverable(candidates, options.now ?? Date.now(), {
     ownerPid: options.ownerPid ?? process.pid,
@@ -19883,28 +20057,41 @@ async function recoverOrphans(candidates, options) {
     if (summary.failedBuckets.has(file.bucket)) {
       continue;
     }
-    try {
-      const counts = await drain(file.path);
-      summary.flushed += counts.flushed;
-      summary.quarantined += counts.quarantined;
-    } catch (err) {
-      summary.errors.push(err);
+    const { counts, failure } = await settleDrain((onProgress) => drain(file.path, onProgress));
+    summary.flushed += counts.flushed;
+    summary.quarantined += counts.quarantined;
+    if (failure) {
+      summary.failedDrainFlushed += counts.flushed;
+      summary.errors.push(failure.error);
       summary.failedBuckets.add(file.bucket);
     }
   }
   return summary;
 }
 var FlushError = class extends Error {
+  /** Moves the whole sweep acknowledged, across every drain it ran. */
   flushed;
   quarantined;
-  constructor(cause, flushed, quarantined) {
+  /** Buckets the failed sweep held back without sending, as on success. */
+  retained;
+  /**
+   * Of `flushed`, the Moves acknowledged by the drains that failed, before
+   * they failed. Only this shows the failure itself is advancing: `flushed`
+   * also counts other buckets' drains, so a bucket whose drain fails every
+   * time would read as progress while a sibling bucket kept delivering.
+   */
+  failedDrainFlushed;
+  constructor(cause, flushed, quarantined, retained = [], failedDrainFlushed = 0) {
     super(cause instanceof Error ? cause.message : String(cause), { cause });
     this.name = "FlushError";
     this.flushed = flushed;
     this.quarantined = quarantined;
+    this.retained = retained;
+    this.failedDrainFlushed = failedDrainFlushed;
   }
 };
 async function flushOnce() {
+  sweepOrphanedDrainProgress();
   const orphanCandidates = listFlushing({ sampleBytes: 0 });
   const liveBuckets = listBuckets();
   if (orphanCandidates.length === 0 && liveBuckets.length === 0) {
@@ -19921,10 +20108,11 @@ async function flushOnce() {
   const binding = inspection.binding;
   const recovered = await recoverOrphans(
     orphanCandidates.filter((file) => inspection.deliverableBuckets.has(file.bucket)),
-    { drain: (path) => drainFlushingPath(path, client2, binding) }
+    { drain: (path, onProgress) => drainFlushingPath(path, client2, binding, { onProgress }) }
   );
   let total = recovered.flushed;
   let quarantined = recovered.quarantined;
+  let failedDrainFlushed = recovered.failedDrainFlushed;
   const errors = recovered.errors;
   for (const { bucket, path } of liveBuckets) {
     if (!inspection.deliverableBuckets.has(bucket)) {
@@ -19933,21 +20121,29 @@ async function flushOnce() {
     if (recovered.failedBuckets.has(bucket)) {
       continue;
     }
-    try {
-      const counts = await drainPath(path, client2, binding);
-      total += counts.flushed;
-      quarantined += counts.quarantined;
-    } catch (err) {
-      errors.push(err);
+    const { counts, failure } = await settleDrain(
+      (onProgress) => drainPath(path, client2, binding, onProgress)
+    );
+    total += counts.flushed;
+    quarantined += counts.quarantined;
+    if (failure) {
+      failedDrainFlushed += counts.flushed;
+      errors.push(failure.error);
     }
   }
   if (errors.length > 0) {
-    throw new FlushError(errors[0], total, quarantined);
+    throw new FlushError(
+      errors[0],
+      total,
+      quarantined,
+      inspection.retainedBuckets,
+      failedDrainFlushed
+    );
   }
   return inspection.retainedBuckets.length > 0 ? { flushed: total, quarantined, retained: inspection.retainedBuckets } : { flushed: total, quarantined };
 }
 var flushInFlight;
-var FLUSH_LOCK_PATH = join8(dirname7(JOURNAL_DIR), ".flush.lock");
+var FLUSH_LOCK_PATH = join9(dirname8(JOURNAL_DIR), ".flush.lock");
 var FLUSH_LOCK_TIMEOUT_MS = 250;
 function isFlushLockContended(error) {
   return error instanceof Error && error.message.startsWith("timed out waiting for file lock");
@@ -19971,6 +20167,30 @@ function flush() {
   flushInFlight = attempt;
   return attempt;
 }
+function hasPendingDrainWork(stats) {
+  return stats.pendingCount > 0 || stats.sampled || stats.strandedFileCount > 0;
+}
+
+// src/lib/delivery-backlog.ts
+var MS_PER_SECOND = 1e3;
+var MS_PER_MINUTE = 60 * MS_PER_SECOND;
+var MS_PER_HOUR = 60 * MS_PER_MINUTE;
+var MS_PER_DAY = 24 * MS_PER_HOUR;
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return isNonNegativeInteger(value) && value > 0;
+}
+function deliveryBacklogState(ingestion) {
+  if (ingestion?.healthy !== false) return void 0;
+  const failures = ingestion.consecutiveFailures;
+  const failedWithoutProgress = failures !== 0 && !(isPositiveInteger(failures) && isPositiveInteger(ingestion.lastFailedDrainAcknowledgedCount));
+  if (failedWithoutProgress) return "failing";
+  const retained = ingestion.lastRetainedBucketCount;
+  if (!isNonNegativeInteger(retained)) return "failing";
+  return retained > 0 ? "retained" : "draining";
+}
 
 // src/lib/presence.ts
 var DECISION_ORIGIN = "https://app.getprimitive.ai";
@@ -20046,7 +20266,8 @@ function formatStatusline(version, snapshot, resolveIngestionStatus, options = {
     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)})`;
+      const delivery = deliveryBacklogState(snapshot.ingestion) === "draining" && snapshot.heartbeat?.healthy === true ? "draining" : "stalled";
+      return `primitive ${version} (daemon: degraded \xB7 delivery: ${delivery}${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)})`;
@@ -20124,8 +20345,8 @@ var StatuslineIngestionCache = class {
 
 // src/daemon/client-instance-id.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { chmodSync as chmodSync3, lstatSync as lstatSync2, readFileSync as readFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { chmodSync as chmodSync4, lstatSync as lstatSync2, readFileSync as readFileSync7 } from "fs";
+import { join as join10 } from "path";
 var CONFIG_DIRECTORY_MODE = 448;
 var INSTANCE_FILE_MODE = 384;
 var INSTANCE_ENTROPY_BYTES = 32;
@@ -20142,7 +20363,7 @@ function ensurePrivateConfigDirectory(configDir) {
   if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
     throw new Error("prim config path must be a private directory");
   }
-  chmodSync3(configDir, CONFIG_DIRECTORY_MODE);
+  chmodSync4(configDir, CONFIG_DIRECTORY_MODE);
   syncDirectory(configDir);
 }
 function readExisting(path) {
@@ -20158,11 +20379,11 @@ function readExisting(path) {
   if (!metadata.isFile() || metadata.isSymbolicLink()) {
     throw new Error("stored client instance identity is invalid");
   }
-  chmodSync3(path, INSTANCE_FILE_MODE);
+  chmodSync4(path, INSTANCE_FILE_MODE);
   if (metadata.size > MAX_STORED_BYTES) {
     throw new Error("stored client instance identity is invalid");
   }
-  const raw = readFileSync6(path, "utf8");
+  const raw = readFileSync7(path, "utf8");
   const value = raw.endsWith("\n") ? raw.slice(0, -1) : raw;
   if (raw !== value && raw !== `${value}
 ` || !isClientInstanceId(value)) {
@@ -20176,8 +20397,8 @@ function atomicWrite2(path, value) {
 }
 async function getOrCreateClientInstanceId(options) {
   const configDir = options.configDir;
-  const path = join9(configDir, "client_instance_id");
-  const lockPath = join9(configDir, "client-instance.lock");
+  const path = join10(configDir, "client_instance_id");
+  const lockPath = join10(configDir, "client-instance.lock");
   ensurePrivateConfigDirectory(configDir);
   return withFileLock(
     lockPath,
@@ -20201,7 +20422,7 @@ async function getOrCreateClientInstanceId(options) {
 
 // src/daemon/client.ts
 import { createConnection } from "net";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 
 // src/daemon/principal.ts
 import { createHash as createHash5 } from "crypto";
@@ -20278,7 +20499,7 @@ function parseDaemonResponseEnvelope(value) {
 }
 
 // src/daemon/client.ts
-var SOCK_PATH = join10(primConfigDirectory(), "sock");
+var SOCK_PATH = join11(primConfigDirectory(), "sock");
 var DEFAULT_TIMEOUT_MS2 = 250;
 var nextRequestId = 1;
 function daemonRequest(method, params = {}, opts = {}) {
@@ -20547,8 +20768,8 @@ function assertCallerEnvMatches(callerEnv, boundEnv) {
 }
 
 // src/daemon/health.ts
-import { chmodSync as chmodSync4, existsSync as existsSync6, mkdirSync as mkdirSync6, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+import { chmodSync as chmodSync5, existsSync as existsSync7, mkdirSync as mkdirSync6, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname9, join as join12 } from "path";
 var CONFIG_DIR_MODE2 = 448;
 var HEALTH_FILE_MODE = 384;
 var INGESTION_SLA_MS = 3e4;
@@ -20556,12 +20777,13 @@ var HEARTBEAT_FRESH_MS = 9e4;
 var HEARTBEAT_RETRY_CAP_MS = 3e4;
 var INGESTION_RETRY_BASE_MS = 5e3;
 var INGESTION_RETRY_CAP_MS = 15e3;
-var DAEMON_HEALTH_PATH = join11(primConfigDirectory(), "daemon-health.json");
-function createDaemonHealthState(version, pid, startedAt2) {
+var DAEMON_HEALTH_PATH = join12(primConfigDirectory(), "daemon-health.json");
+function createDaemonHealthState(version, pid, startedAt2, siteUrl) {
   return {
     schemaVersion: 1,
     version,
     pid,
+    siteUrl,
     startedAt: startedAt2,
     updatedAt: startedAt2,
     healthy: false,
@@ -20572,7 +20794,9 @@ function createDaemonHealthState(version, pid, startedAt2) {
       pendingCount: 0,
       pendingSampled: false,
       strandedCount: 0,
-      lastAcknowledgedCount: 0
+      lastAcknowledgedCount: 0,
+      lastFailedDrainAcknowledgedCount: 0,
+      lastRetainedBucketCount: 0
     }
   };
 }
@@ -20594,37 +20818,37 @@ function ingestionRetryDelayMs(consecutiveFailures, random = Math.random) {
   return retryDelayMs(consecutiveFailures, INGESTION_RETRY_CAP_MS, random);
 }
 function writeDaemonHealthState(state, path = DAEMON_HEALTH_PATH) {
-  const dir = dirname8(path);
-  if (!existsSync6(dir)) {
+  const dir = dirname9(path);
+  if (!existsSync7(dir)) {
     mkdirSync6(dir, { recursive: true, mode: CONFIG_DIR_MODE2 });
   }
-  const tmp = join11(dir, `.${process.pid}.daemon-health.tmp`);
+  const tmp = join12(dir, `.${process.pid}.daemon-health.tmp`);
   writeFileSync4(tmp, `${JSON.stringify(state, null, 2)}
 `, { mode: HEALTH_FILE_MODE });
-  chmodSync4(tmp, HEALTH_FILE_MODE);
+  chmodSync5(tmp, HEALTH_FILE_MODE);
   renameSync4(tmp, path);
 }
 
 // src/daemon/instance-lock.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import {
-  chmodSync as chmodSync5,
-  existsSync as existsSync7,
+  chmodSync as chmodSync6,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   renameSync as renameSync5,
-  rmSync as rmSync5,
-  statSync as statSync2,
+  rmSync as rmSync6,
+  statSync as statSync3,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync5
 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 var DIR_MODE = 448;
-var FILE_MODE3 = 384;
+var FILE_MODE4 = 384;
 var DAEMON_STARTUP_GRACE_MS = 5e3;
 function readLockRecord(path) {
   try {
-    const value = JSON.parse(readFileSync7(path, "utf-8"));
+    const value = JSON.parse(readFileSync8(path, "utf-8"));
     if (Number.isSafeInteger(value.pid) && value.pid > 0 && typeof value.instanceId === "string" && typeof value.startedAt === "number") {
       return value;
     }
@@ -20634,23 +20858,23 @@ function readLockRecord(path) {
 }
 function numericPid(path) {
   try {
-    const pid = Number(readFileSync7(path, "utf-8").trim());
+    const pid = Number(readFileSync8(path, "utf-8").trim());
     return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
   } catch {
     return;
   }
 }
 function readDaemonOwner(configDir) {
-  return readLockRecord(join12(configDir, "daemon.lock", "owner.json"));
+  return readLockRecord(join13(configDir, "daemon.lock", "owner.json"));
 }
 function readDaemonPid(configDir) {
-  const path = join12(configDir, "daemon.pid");
+  const path = join13(configDir, "daemon.pid");
   const pid = numericPid(path);
   if (pid === void 0) {
     return;
   }
   try {
-    return { pid, mtimeMs: statSync2(path).mtimeMs };
+    return { pid, mtimeMs: statSync3(path).mtimeMs };
   } catch {
     return;
   }
@@ -20659,11 +20883,11 @@ function acquireDaemonOwnership(configDir, opts = {}) {
   const pid = opts.pid ?? process.pid;
   const now = opts.now ?? Date.now();
   const isAlive = opts.isAlive ?? processIsAlive;
-  const lockDir = join12(configDir, "daemon.lock");
-  const ownerPath2 = join12(lockDir, "owner.json");
-  const pidPath = join12(configDir, "daemon.pid");
+  const lockDir = join13(configDir, "daemon.lock");
+  const ownerPath2 = join13(lockDir, "owner.json");
+  const pidPath = join13(configDir, "daemon.pid");
   const instanceId = randomUUID2();
-  if (!existsSync7(configDir)) {
+  if (!existsSync8(configDir)) {
     mkdirSync7(configDir, { recursive: true, mode: DIR_MODE });
   }
   for (; ; ) {
@@ -20681,7 +20905,7 @@ function acquireDaemonOwnership(configDir, opts = {}) {
       if (!existing) {
         let mtimeMs;
         try {
-          mtimeMs = statSync2(lockDir).mtimeMs;
+          mtimeMs = statSync3(lockDir).mtimeMs;
         } catch (statErr) {
           if (statErr.code === "ENOENT") {
             continue;
@@ -20695,7 +20919,7 @@ function acquireDaemonOwnership(configDir, opts = {}) {
       const stale = `${lockDir}.stale.${String(pid)}.${instanceId}`;
       try {
         renameSync5(lockDir, stale);
-        rmSync5(stale, { recursive: true, force: true });
+        rmSync6(stale, { recursive: true, force: true });
       } catch (renameErr) {
         if (renameErr.code !== "ENOENT") {
           throw renameErr;
@@ -20713,15 +20937,15 @@ function acquireDaemonOwnership(configDir, opts = {}) {
   };
   const record = { pid, instanceId, startedAt: now };
   writeFileSync5(ownerPath2, `${JSON.stringify(record)}
-`, { mode: FILE_MODE3 });
-  chmodSync5(ownerPath2, FILE_MODE3);
+`, { mode: FILE_MODE4 });
+  chmodSync6(ownerPath2, FILE_MODE4);
   const legacyPid = numericPid(pidPath);
   if (legacyPid !== void 0 && legacyPid !== pid && isAlive(legacyPid)) {
-    rmSync5(lockDir, { recursive: true, force: true });
+    rmSync6(lockDir, { recursive: true, force: true });
     throw new Error(`daemon already running (pid=${String(legacyPid)})`);
   }
-  writeFileSync5(pidPath, String(pid), { mode: FILE_MODE3 });
-  chmodSync5(pidPath, FILE_MODE3);
+  writeFileSync5(pidPath, String(pid), { mode: FILE_MODE4 });
+  chmodSync6(pidPath, FILE_MODE4);
   return ownership2;
 }
 function ownsDaemonInstance(ownership2) {
@@ -20751,7 +20975,7 @@ function releaseDaemonOwnership(ownership2, socketPath) {
       }
     }
   }
-  rmSync5(ownership2.lockDir, { recursive: true, force: true });
+  rmSync6(ownership2.lockDir, { recursive: true, force: true });
   if (cleanupError) {
     throw cleanupError;
   }
@@ -20846,7 +21070,7 @@ function parseStatuslineRequest(buffer) {
 
 // src/daemon/server.ts
 var CONFIG_DIR = primConfigDirectory();
-var SOCK_PATH2 = join13(CONFIG_DIR, "sock");
+var SOCK_PATH2 = join14(CONFIG_DIR, "sock");
 var CONFIG_DIR_MODE3 = 448;
 var SOCKET_MODE = 384;
 var MAX_SOCKET_CONNECTIONS = 64;
@@ -20863,7 +21087,7 @@ var EXIT_CRASH = 1;
 var startedAt = Date.now();
 var client = getClient();
 var runtimeVersion = resolveRuntimeVersion();
-var daemonHealth = createDaemonHealthState(runtimeVersion, process.pid, startedAt);
+var daemonHealth = createDaemonHealthState(runtimeVersion, process.pid, startedAt, getSiteUrl());
 var statuslineIngestionCache = new StatuslineIngestionCache(decisionIngestionStatus, {
   resolveRepositoryBindingState: repositoryBindingState
 });
@@ -20915,7 +21139,7 @@ function resolveRuntimeVersion() {
   }
   try {
     const here = fileURLToPath(new URL(".", import.meta.url));
-    const pkg = JSON.parse(readFileSync8(join13(here, "..", "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync9(join14(here, "..", "..", "package.json"), "utf-8"));
     return pkg.version ?? "unknown";
   } catch {
     return "unknown";
@@ -20933,6 +21157,7 @@ function purgePrincipalScopedState() {
   lastOnlineNames = void 0;
   lastOnlineTeammates = void 0;
   lastOkAtLocal = void 0;
+  clearSweepRecord();
 }
 function synchronizeDaemonCredential() {
   const token = resolveAuthCredential()?.token;
@@ -20940,6 +21165,7 @@ function synchronizeDaemonCredential() {
   if (credentialKey !== activeCredentialKey) {
     activeCredentialKey = credentialKey;
     purgePrincipalScopedState();
+    persistHealth();
   }
   return resolveDaemonPrincipal(token);
 }
@@ -20953,7 +21179,7 @@ function assertCallerPrincipalMatches(caller) {
 }
 function ensureDaemonDirectoryPermissions() {
   mkdirSync8(CONFIG_DIR, { recursive: true, mode: CONFIG_DIR_MODE3 });
-  chmodSync6(CONFIG_DIR, CONFIG_DIR_MODE3);
+  chmodSync7(CONFIG_DIR, CONFIG_DIR_MODE3);
 }
 function persistHealth() {
   refreshDaemonHealth(daemonHealth, Date.now());
@@ -20971,6 +21197,15 @@ function updatePendingHealth() {
   daemonHealth.ingestion.pendingSampled = pending.sampled;
   daemonHealth.ingestion.oldestPendingAt = pending.oldestPendingAt;
   daemonHealth.ingestion.strandedCount = pending.strandedCount;
+  return pending;
+}
+function recordRetainedBuckets(retained) {
+  daemonHealth.ingestion.lastRetainedBucketCount = retained.length;
+  daemonHealth.ingestion.lastRetainedReasons = retained.length > 0 ? summarizeRetainedBuckets(retained) : void 0;
+}
+function clearSweepRecord() {
+  daemonHealth.ingestion.lastFailedDrainAcknowledgedCount = 0;
+  recordRetainedBuckets([]);
 }
 function enterReauthHold() {
   if (reauthHold) {
@@ -21006,6 +21241,8 @@ function exitReauthHold() {
   daemonHealth.ingestion.consecutiveFailures = 0;
   daemonHealth.heartbeat.lastError = void 0;
   daemonHealth.ingestion.lastError = void 0;
+  clearSweepRecord();
+  daemonHealth.heartbeat.lastSuccessAt = void 0;
   persistHealth();
   process.stderr.write(
     "[prim-daemon] re-authentication detected \u2014 resuming heartbeat + ingestion + Decision cache\n"
@@ -21014,6 +21251,11 @@ function exitReauthHold() {
   void runIngestionLoop();
   void runDecisionDigestLoop();
 }
+function resumeIfReauthenticated() {
+  if (reauthHold && !isSessionEnded() && resolveAuthCredential()) {
+    exitReauthHold();
+  }
+}
 async function takeOwnership() {
   const now = Date.now();
   const recordedOwner = readDaemonOwner(CONFIG_DIR);
@@ -21023,7 +21265,7 @@ async function takeOwnership() {
       (pid) => pid !== void 0 && processIsAlive(pid)
     )
   );
-  if (existsSync8(SOCK_PATH2) || candidatePids.size > 0) {
+  if (existsSync9(SOCK_PATH2) || candidatePids.size > 0) {
     const snapshot = await daemonRequest(
       "status_snapshot",
       {},
@@ -21178,22 +21420,26 @@ function scheduleIngestion(delayMs) {
 }
 async function runIngestionLoop() {
   synchronizeDaemonCredential();
+  let pending;
   try {
-    updatePendingHealth();
+    pending = updatePendingHealth();
   } catch (err) {
     const failures = daemonHealth.ingestion.consecutiveFailures + 1;
     const delay = ingestionRetryDelayMs(failures);
     daemonHealth.ingestion.consecutiveFailures = failures;
     daemonHealth.ingestion.lastError = `journal scan failed: ${errorMessage2(err)}`;
     daemonHealth.ingestion.nextRetryAt = Date.now() + delay;
+    daemonHealth.ingestion.lastAcknowledgedCount = 0;
+    daemonHealth.ingestion.lastFailedDrainAcknowledgedCount = 0;
     persistHealth();
     scheduleIngestion(delay);
     return;
   }
-  if (daemonHealth.ingestion.pendingCount === 0 && !daemonHealth.ingestion.pendingSampled) {
+  if (!hasPendingDrainWork(pending)) {
     daemonHealth.ingestion.consecutiveFailures = 0;
     daemonHealth.ingestion.lastError = void 0;
     daemonHealth.ingestion.nextRetryAt = void 0;
+    clearSweepRecord();
     persistHealth();
     scheduleIngestion(INGESTION_POLL_INTERVAL_MS);
     return;
@@ -21209,8 +21455,10 @@ async function runIngestionLoop() {
     }
     daemonHealth.ingestion.lastSuccessAt = Date.now();
     daemonHealth.ingestion.lastAcknowledgedCount = result.flushed;
+    daemonHealth.ingestion.lastFailedDrainAcknowledgedCount = 0;
     daemonHealth.ingestion.consecutiveFailures = 0;
     daemonHealth.ingestion.lastError = void 0;
+    recordRetainedBuckets(result.retained ?? []);
     updatePendingHealth();
     persistHealth();
     scheduleIngestion(INGESTION_POLL_INTERVAL_MS);
@@ -21218,6 +21466,8 @@ async function runIngestionLoop() {
     const failures = daemonHealth.ingestion.consecutiveFailures + 1;
     const delay = ingestionRetryDelayMs(failures);
     daemonHealth.ingestion.lastAcknowledgedCount = err instanceof FlushError ? err.flushed : 0;
+    daemonHealth.ingestion.lastFailedDrainAcknowledgedCount = err instanceof FlushError ? err.failedDrainFlushed : 0;
+    if (err instanceof FlushError) recordRetainedBuckets(err.retained);
     daemonHealth.ingestion.consecutiveFailures = failures;
     daemonHealth.ingestion.lastError = errorMessage2(err);
     daemonHealth.ingestion.nextRetryAt = Date.now() + delay;
@@ -21276,6 +21526,7 @@ async function proxyGet(params, allowedPrefix, caller) {
   return result;
 }
 function handleStatusSnapshot(params, caller, enforcePrincipal = false) {
+  resumeIfReauthenticated();
   const daemonPrincipal = synchronizeDaemonCredential();
   const wasHealthy = daemonHealth.healthy;
   const heartbeatWasHealthy = daemonHealth.heartbeat.healthy;
@@ -21552,7 +21803,7 @@ function startSocketServer() {
   });
   socketServer.listen(SOCK_PATH2, () => {
     try {
-      chmodSync6(SOCK_PATH2, SOCKET_MODE);
+      chmodSync7(SOCK_PATH2, SOCKET_MODE);
     } catch (err) {
       shutdown(EXIT_CRASH, `[prim-daemon] failed to secure socket: ${errorMessage2(err)}`);
       return;
@@ -21579,9 +21830,7 @@ function startTimers() {
 }
 async function runTokenCheckLoop() {
   if (reauthHold) {
-    if (!isSessionEnded() && resolveAuthCredential()) {
-      exitReauthHold();
-    }
+    resumeIfReauthenticated();
   } else {
     await ensureTokenFresh();
     synchronizeDaemonCredential();