@remnic/core 9.38.2 → 9.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.38.2",
+  "version": "9.39.0",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3086,7 +3086,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.38.2"
+    "@remnic/coding-graph": "^9.39.0"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/maintenance/projection-support.ts

@@ -6,7 +6,22 @@
  */
 
 import path from "node:path";
-import { openProjectionReadonly } from "../memory-projection-store.js";
+import {
+  openProjectionReadonly,
+  readProjectedEntityMentions,
+  readProjectedGovernanceRecord,
+  readProjectedNativeKnowledgeChunks,
+  type MemoryProjectionGovernanceAppliedActionRow,
+  type MemoryProjectionGovernanceReviewQueueRow,
+  type ProjectedEntityMentionRow,
+  type ProjectedNativeKnowledgeChunkRow,
+} from "../memory-projection-store.js";
+import {
+  isFrontmatterDerivedLifecycleEventType,
+  memoryLifecycleEventProjectionIdentity,
+} from "../memory-lifecycle-ledger-utils.js";
+import type { MemoryLifecycleEvent } from "../types.js";
+import type { BetterSqlite3Database } from "../runtime/better-sqlite.js";
 
 /** Read the projection meta rebuiltAt timestamp; null when absent/unopenable. */
 export function readProjectionRebuiltAt(memoryDir: string): string | null {
@@ -24,6 +39,172 @@ export function readProjectionRebuiltAt(memoryDir: string): string | null {
   }
 }
 
+/** Format projection age description string for fallback warning telemetry. */
+export function formatProjectionAge(rebuiltAt: string | null): string {
+  if (!rebuiltAt) return "projection never rebuilt";
+  const ageMs = Date.now() - Date.parse(rebuiltAt);
+  if (!Number.isFinite(ageMs)) return `projection rebuiltAt=${rebuiltAt}`;
+  const ageMin = Math.max(0, Math.round(ageMs / 60_000));
+  const age = ageMin >= 120 ? `${Math.round(ageMin / 60)}h` : `${ageMin}m`;
+  return `projection ${age} stale, last rebuilt ${rebuiltAt}`;
+}
+
+export interface ProjectionLifecycleLedgerHighWater {
+  eventCount: number;
+  sourceEventCount: number;
+}
+
+function readProjectionHighWaterFromDb(
+  db: BetterSqlite3Database,
+): ProjectionLifecycleLedgerHighWater | null {
+  const sourceRow = db.prepare(
+    "SELECT value FROM meta WHERE key = 'sourceLifecycleLedgerEventCount'",
+  ).get() as { value?: unknown } | undefined;
+  const projectedRow = db.prepare(
+    "SELECT value FROM meta WHERE key = 'projectedLifecycleLedgerEventCount'",
+  ).get() as { value?: unknown } | undefined;
+  if (
+    typeof sourceRow?.value !== "string"
+    || !/^\d+$/.test(sourceRow.value)
+    || typeof projectedRow?.value !== "string"
+    || !/^\d+$/.test(projectedRow.value)
+  ) return null;
+  const sourceEventCount = Number(sourceRow.value);
+  const eventCount = Number(projectedRow.value);
+  if (!Number.isSafeInteger(sourceEventCount) || !Number.isSafeInteger(eventCount)) return null;
+  return { eventCount, sourceEventCount };
+}
+
+export function readProjectionLifecycleLedgerHighWater(
+  memoryDir: string,
+): ProjectionLifecycleLedgerHighWater | null {
+  const db = openProjectionReadonly(memoryDir);
+  if (!db) return null;
+  try {
+    return readProjectionHighWaterFromDb(db);
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+export interface ProjectionLifecycleLedgerLagTracker {
+  highWater: ProjectionLifecycleLedgerHighWater;
+  record(event: MemoryLifecycleEvent): { unique: boolean; projected: boolean };
+  close(): void;
+}
+
+export function openProjectionLifecycleLedgerLagTracker(
+  memoryDir: string,
+): ProjectionLifecycleLedgerLagTracker | null {
+  const db = openProjectionReadonly(memoryDir);
+  if (!db) return null;
+  try {
+    const highWater = readProjectionHighWaterFromDb(db);
+    if (!highWater) {
+      db.close();
+      return null;
+    }
+    db.pragma("temp_store = FILE");
+    db.exec(`
+      CREATE TEMP TABLE projection_lag_current_identity (
+        identity TEXT PRIMARY KEY
+      ) WITHOUT ROWID;
+    `);
+    db.pragma("temp.cache_size = -1024");
+    const insertCurrent = db.prepare(
+      "INSERT OR IGNORE INTO projection_lag_current_identity(identity) VALUES (?)",
+    );
+    const findProjectedEvent = db.prepare(
+      "SELECT 1 FROM memory_timeline WHERE event_id = ? LIMIT 1",
+    );
+    const findProjectedFrontmatterEvent = db.prepare(`
+      SELECT 1
+      FROM memory_timeline
+      WHERE memory_id = ? AND event_type = ? AND timestamp = ?
+      LIMIT 1
+    `);
+    return {
+      highWater,
+      record(event) {
+        if (!event.memoryId.trim()) return { unique: false, projected: false };
+        const identity = memoryLifecycleEventProjectionIdentity(event);
+        const inserted = insertCurrent.run(identity);
+        if (inserted.changes === 0) return { unique: false, projected: false };
+        const projected = isFrontmatterDerivedLifecycleEventType(event.eventType)
+          ? findProjectedFrontmatterEvent.get(event.memoryId, event.eventType, event.timestamp)
+          : findProjectedEvent.get(event.eventId);
+        return { unique: true, projected: projected !== undefined };
+      },
+      close: () => db.close(),
+    };
+  } catch {
+    db.close();
+    return null;
+  }
+}
+/** Write the high-water ledger marker counts to projection meta store. */
+export function writeProjectionMetaHighWater(
+  insertMeta: { run: (key: string, value: string) => void },
+  sourceLifecycleLedgerEventCount: number,
+  timelineRows: MemoryLifecycleEvent[],
+): void {
+  insertMeta.run("sourceLifecycleLedgerEventCount", String(sourceLifecycleLedgerEventCount));
+  insertMeta.run(
+    "projectedLifecycleLedgerEventCount",
+    String(new Set(timelineRows.map(memoryLifecycleEventProjectionIdentity)).size),
+  );
+}
+
+export function readProjectedEntityMentionRows(
+  memoryDir: string,
+): { projectionExists: boolean; rows: ProjectedEntityMentionRow[] } {
+  const rows = readProjectedEntityMentions(memoryDir);
+  if (rows === null) return { projectionExists: false, rows: [] };
+  return { projectionExists: true, rows };
+}
+
+export function readProjectedNativeKnowledgeRows(
+  memoryDir: string,
+): { projectionExists: boolean; rows: ProjectedNativeKnowledgeChunkRow[] } {
+  const rows = readProjectedNativeKnowledgeChunks(memoryDir);
+  if (rows === null) return { projectionExists: false, rows: [] };
+  return { projectionExists: true, rows };
+}
+
+export function readProjectedGovernanceRows(memoryDir: string): {
+  projectionExists: boolean;
+  runId: string | null;
+  summary: unknown;
+  metrics: unknown;
+  reviewQueueRows: MemoryProjectionGovernanceReviewQueueRow[];
+  appliedActionRows: MemoryProjectionGovernanceAppliedActionRow[];
+  report: string;
+} {
+  const record = readProjectedGovernanceRecord(memoryDir);
+  if (record === null) {
+    return {
+      projectionExists: false,
+      runId: null,
+      summary: undefined,
+      metrics: undefined,
+      reviewQueueRows: [],
+      appliedActionRows: [],
+      report: "",
+    };
+  }
+  return {
+    projectionExists: true,
+    runId: record.runId,
+    summary: record.summary,
+    metrics: record.metrics,
+    reviewQueueRows: record.reviewQueueRows,
+    appliedActionRows: record.appliedActionRows,
+    report: record.report,
+  };
+}
+
 /**
  * Assert an optionally injected storage (e.g. the daemon's live unlocked
  * secure-store instance) is rooted at `memoryDir`, and hand it back. Shared
@@ -54,3 +235,13 @@ export interface SkippedDuplicateMemory {
 export interface SkippedBlankIdMemory {
   path: string;
 }
+export interface SkippedDuplicateTimelineEvent {
+  eventId: string;
+  keptPath: string;
+  skippedPath: string;
+}
+
+export interface SkippedBlankIdTimelineEvent {
+  eventId: string;
+  path: string;
+}

package/src/maintenance/rebuild-memory-lifecycle-ledger.ts

@@ -11,23 +11,14 @@ import {
   buildLifecycleEventsForMemory,
   compareMemoryLifecycleEvents,
   sortMemoryLifecycleEvents,
+  isFrontmatterDerivedLifecycleEventType,
+  memoryLifecycleEventProjectionIdentity,
   memoryLifecycleLedgerLockPath,
   MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,
 } from "../memory-lifecycle-ledger-utils.js";
 import { withHeldFileLock, type HeldFileLockOptions, type HeldFileLockController } from "../utils/serialize-mutations.js";
 import { probeEncryptedRegularFileHeader } from "../secure-store/secure-fs.js";
 
-/**
- * Event types `buildLifecycleEventsForMemory` reconstructs from frontmatter.
- * Everything else in the ledger is append-only history with no frontmatter
- * equivalent and must be carried over by a preserving rebuild (issue #1910).
- */
-const FRONTMATTER_DERIVED_EVENT_TYPES: Record<string, true> = {
-  created: true,
-  updated: true,
-  superseded: true,
-  archived: true,
-};
 
 export interface RebuildMemoryLifecycleLedgerOptions {
   memoryDir: string;
@@ -322,17 +313,15 @@ export async function rebuildMemoryLifecycleLedger(
       // retried append of the same logical event still collapses to one. Rows
       // that are not frontmatter-derived are append-only history with no
       // reconstruction — always carried over, deduped by eventId in the merge.
-      const contentKey = (event: MemoryLifecycleEvent): string =>
-        `${event.memoryId}\u0000${event.eventType}\u0000${event.timestamp}`;
-      const reconstructedKeys = new Set(events.map(contentKey));
+      const reconstructedKeys = new Set(events.map(memoryLifecycleEventProjectionIdentity));
       const racedFrontmatterByKey = new Map<string, MemoryLifecycleEvent>();
       const appendOnly: MemoryLifecycleEvent[] = [];
       for (const event of existing) {
-        if (!FRONTMATTER_DERIVED_EVENT_TYPES[event.eventType]) {
+        if (!isFrontmatterDerivedLifecycleEventType(event.eventType)) {
           appendOnly.push(event);
           continue;
         }
-        const key = contentKey(event);
+        const key = memoryLifecycleEventProjectionIdentity(event);
         if (reconstructedKeys.has(key)) continue; // collapsed into reconstruction
         if (!racedFrontmatterByKey.has(key)) racedFrontmatterByKey.set(key, event);
       }

package/src/maintenance/rebuild-memory-projection.ts

@@ -18,6 +18,7 @@ import {
   buildLifecycleEventsForMemory,
   inferMemoryStatus,
   MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  memoryLifecycleEventProjectionIdentity,
   sortMemoryLifecycleEvents,
   toMemoryPathRel,
 } from "../memory-lifecycle-ledger-utils.js";
@@ -55,20 +56,26 @@ export interface RebuildMemoryProjectionOptions {
   updatedBefore?: string;
 }
 
-export type { SkippedBlankIdMemory, SkippedDuplicateMemory } from "./projection-support.js";
-import { assertInjectedStorageRooted } from "./projection-support.js";
-import type { SkippedBlankIdMemory, SkippedDuplicateMemory } from "./projection-support.js";
-
-export interface SkippedDuplicateTimelineEvent {
-  eventId: string;
-  keptPath: string;
-  skippedPath: string;
-}
+export type {
+  SkippedBlankIdMemory,
+  SkippedBlankIdTimelineEvent,
+  SkippedDuplicateMemory,
+  SkippedDuplicateTimelineEvent,
+} from "./projection-support.js";
+import {
+  assertInjectedStorageRooted,
+  readProjectedEntityMentionRows,
+  readProjectedGovernanceRows,
+  readProjectedNativeKnowledgeRows,
+  writeProjectionMetaHighWater,
+} from "./projection-support.js";
+import type {
+  SkippedBlankIdMemory,
+  SkippedBlankIdTimelineEvent,
+  SkippedDuplicateMemory,
+  SkippedDuplicateTimelineEvent,
+} from "./projection-support.js";
 
-export interface SkippedBlankIdTimelineEvent {
-  eventId: string;
-  path: string;
-}
 
 export interface RebuildMemoryProjectionResult {
   dryRun: boolean;
@@ -569,6 +576,7 @@ async function loadAuthoritativeProjectionSnapshot(options: {
     }
     | null;
   usedLifecycleLedger: boolean;
+  sourceLifecycleLedgerEventCount: number;
   scope: {
     updatedAfter: string | null;
     updatedBefore: string | null;
@@ -607,6 +615,9 @@ async function loadAuthoritativeProjectionSnapshot(options: {
   );
   const events = deduplicatedTimeline.events;
   const usedLifecycleLedger = timeline.usedLifecycleLedger;
+  const sourceLifecycleLedgerEventCount = new Set(
+    lifecycleEvents.map(memoryLifecycleEventProjectionIdentity),
+  ).size;
   const currentRows = projectionMemories.map((memory) => toCurrentStateRow(options.memoryDir, memory));
   const scope = normalizeProjectionScope(options);
   const scopedMemories = filterMemoriesForProjectionScope(projectionMemories, scope);
@@ -645,6 +656,7 @@ async function loadAuthoritativeProjectionSnapshot(options: {
     nativeKnowledgeRows,
     governance,
     usedLifecycleLedger,
+    sourceLifecycleLedgerEventCount,
     scope,
     skippedDuplicateMemories: selected.skippedDuplicateMemories,
     skippedBlankIdMemories: selected.skippedBlankIdMemories,
@@ -733,53 +745,6 @@ function readProjectedTimelineRows(
   }
 }
 
-function readProjectedEntityMentionRows(
-  memoryDir: string,
-): { projectionExists: boolean; rows: ProjectedEntityMentionRow[] } {
-  const rows = readProjectedEntityMentions(memoryDir);
-  if (rows === null) return { projectionExists: false, rows: [] };
-  return { projectionExists: true, rows };
-}
-
-function readProjectedNativeKnowledgeRows(
-  memoryDir: string,
-): { projectionExists: boolean; rows: ProjectedNativeKnowledgeChunkRow[] } {
-  const rows = readProjectedNativeKnowledgeChunks(memoryDir);
-  if (rows === null) return { projectionExists: false, rows: [] };
-  return { projectionExists: true, rows };
-}
-
-function readProjectedGovernanceRows(memoryDir: string): {
-  projectionExists: boolean;
-  runId: string | null;
-  summary: unknown;
-  metrics: unknown;
-  reviewQueueRows: MemoryProjectionGovernanceReviewQueueRow[];
-  appliedActionRows: MemoryProjectionGovernanceAppliedActionRow[];
-  report: string;
-} {
-  const record = readProjectedGovernanceRecord(memoryDir);
-  if (record === null) {
-    return {
-      projectionExists: false,
-      runId: null,
-      summary: undefined,
-      metrics: undefined,
-      reviewQueueRows: [],
-      appliedActionRows: [],
-      report: "",
-    };
-  }
-  return {
-    projectionExists: true,
-    runId: record.runId,
-    summary: record.summary,
-    metrics: record.metrics,
-    reviewQueueRows: record.reviewQueueRows,
-    appliedActionRows: record.appliedActionRows,
-    report: record.report,
-  };
-}
 
 function writeProjectionDb(
   dbPath: string,
@@ -790,6 +755,7 @@ function writeProjectionDb(
   nativeKnowledgeRows: ProjectedNativeKnowledgeChunkRow[],
   governance: Awaited<ReturnType<typeof loadLatestGovernanceProjection>>,
   usedLifecycleLedger: boolean,
+  sourceLifecycleLedgerEventCount: number,
 ): void {
   const db = openBetterSqlite3(dbPath);
   const memoryDir = path.dirname(path.dirname(dbPath));
@@ -800,6 +766,7 @@ function writeProjectionDb(
     insertMeta.run("schemaVersion", String(MEMORY_PROJECTION_SCHEMA_VERSION));
     insertMeta.run("rebuiltAt", nowIso);
     insertMeta.run("usedLifecycleLedger", usedLifecycleLedger ? "true" : "false");
+    writeProjectionMetaHighWater(insertMeta, sourceLifecycleLedgerEventCount, timelineRows);
     insertMeta.run("latestGovernanceRunId", governance?.runId ?? "");
 
     const insertCurrent = db.prepare(`
@@ -1161,6 +1128,7 @@ export async function rebuildMemoryProjection(
       nextNativeKnowledgeRows,
       nextGovernance,
       snapshot.usedLifecycleLedger,
+      snapshot.sourceLifecycleLedgerEventCount,
     );
     backupPath = await backupExistingProjection(options.memoryDir, outputPath, now);
     backupPath = await commitPreparedFileAtomically(tempPath, outputPath, backupPath);

package/src/memory-lifecycle-ledger-utils.ts

@@ -24,6 +24,27 @@ export const MEMORY_LIFECYCLE_EVENT_SORT_ORDER: Record<MemoryLifecycleEventType,
   archived: 10,
 };
 
+const FRONTMATTER_DERIVED_EVENT_TYPES: Record<string, true> = {
+  created: true,
+  updated: true,
+  superseded: true,
+  archived: true,
+};
+
+export function isFrontmatterDerivedLifecycleEventType(eventType: string): boolean {
+  return FRONTMATTER_DERIVED_EVENT_TYPES[eventType] === true;
+}
+
+export function memoryLifecycleEventProjectionIdentity(event: {
+  eventId: string;
+  memoryId: string;
+  eventType: string;
+  timestamp: string;
+}): string {
+  if (!isFrontmatterDerivedLifecycleEventType(event.eventType)) return `event\u0000${event.eventId}`;
+  return `frontmatter\u0000${event.memoryId}\u0000${event.eventType}\u0000${event.timestamp}`;
+}
+
 /**
  * Deterministic sort rank for a lifecycle event type. The ledger readers admit
  * any structurally valid row (permissive `eventType`, issue #1910), so an

package/src/orchestration/extraction-run-helpers.ts

@@ -307,3 +307,50 @@ export async function runExtractionPostPersist(
   if (deadlineError) throw deadlineError;
   return { meta, metadataFailed };
 }
+
+/**
+ * Advance the extraction liveness watermark for a successfully parsed empty
+ * extraction (#2223) and record its processed fingerprint when applicable.
+ * Fingerprinted/import runs treat the metadata save as load-bearing (dedupe
+ * state) and propagate failures; normal live runs treat the stamp as
+ * diagnostic liveness and fail open. Deadline errors always propagate.
+ */
+export async function commitEmptySuccessExtraction(args: {
+  storage: StorageManager;
+  meta: MetaState | null;
+  extractionFingerprint: string | null;
+  shouldPersistProcessedFingerprint: boolean;
+  hasExtractionFailure: boolean;
+  recordProcessedExtractionFingerprint: (storage: StorageManager, fingerprint: string, meta: MetaState) => Promise<unknown>;
+  runDeadlineAware: <T>(operation: () => Promise<T>, phase: string, clearTimerOnError?: boolean) => Promise<T>;
+  isDeadlineError: (error: unknown) => boolean;
+}): Promise<void> {
+  const {
+    storage,
+    meta: existingMeta,
+    extractionFingerprint,
+    shouldPersistProcessedFingerprint,
+    hasExtractionFailure,
+    recordProcessedExtractionFingerprint,
+    runDeadlineAware,
+    isDeadlineError,
+  } = args;
+  let meta = existingMeta;
+  if (extractionFingerprint && shouldPersistProcessedFingerprint && !hasExtractionFailure) {
+    meta ??= await storage.loadMeta();
+    await recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
+  }
+  if (!hasExtractionFailure) {
+    const livenessStampFatal = shouldPersistProcessedFingerprint;
+    try {
+      meta ??= await runDeadlineAware(() => storage.loadMeta(), "during_empty_success_liveness_load", false);
+      meta.extractionCount += 1;
+      meta.lastExtractionAt = new Date().toISOString();
+      await runDeadlineAware(() => storage.saveMeta(meta!), "during_empty_success_liveness_save", false);
+    } catch (err) {
+      if (isDeadlineError(err)) throw err;
+      if (livenessStampFatal) throw err;
+      log.warn("runExtraction: failed to stamp empty-success liveness watermark (non-fatal)", err);
+    }
+  }
+}

package/src/orchestration/extraction-run.test.ts

@@ -980,3 +980,136 @@ test("namespace isolation: the provider breaker suppresses extraction across nam
     await h.cleanup();
   }
 });
+
+
+// ---------------------------------------------------------------------------
+// Extraction liveness watermark (#2223): a successfully parsed extraction must
+// advance lastExtractionAt even when it emits no durable objects. Normal live
+// turns do not set persistProcessedFingerprint, which is the gap case.
+// ---------------------------------------------------------------------------
+
+function emptySuccessResult(): ExtractionResult {
+  return { facts: [], profileUpdates: [], entities: [], questions: [] };
+}
+
+// Normal live turns (TurnIngestionCoordinator.processTurn path) do NOT set
+// persistProcessedFingerprint — the case the pre-#2223 watermark stamp skipped.
+function liveTurns(content: string): BufferTurn[] {
+  return [
+    { role: "user", content: `u:${content}`, timestamp: "2026-07-15T00:00:00Z" },
+    { role: "assistant", content: `a:${content}`, timestamp: "2026-07-15T00:00:01Z" },
+  ] as BufferTurn[];
+}
+
+test("extraction liveness (#2223): a normal live empty success advances lastExtractionAt without persisting memories", async () => {
+  const h = await makeHarness();
+  try {
+    const coord = h.newCoordinator();
+    h.setRespond(() => emptySuccessResult());
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+    const baselineCount = before.extractionCount;
+
+    const result = await coord.runExtraction(liveTurns("nothing-durable-here"), {
+      skipCharThreshold: true,
+      skipUserTurnThreshold: true,
+      clearBufferAfterExtraction: false,
+      bufferKey: "nothing-durable-here",
+    });
+
+    assert.equal(result.status, "skipped");
+    assert.equal(result.reason, "empty_extraction_result");
+    assert.equal(h.persistCalls(), 0, "no durable memories persisted for an empty result");
+
+    const after = await storage.loadMeta();
+    assert.equal(after.extractionCount, baselineCount + 1, "empty success increments extractionCount");
+    assert.ok(after.lastExtractionAt, "empty success stamps lastExtractionAt");
+    assert.equal(h.recordedProcessedCount(), 0, "normal live turns never record a processed fingerprint");
+  } finally {
+    await h.cleanup();
+  }
+});
+
+test("extraction liveness (#2223): a fingerprinted empty success advances the watermark once and records the fingerprint once", async () => {
+  const h = await makeHarness();
+  try {
+    const coord = h.newCoordinator();
+    h.setRespond(() => emptySuccessResult());
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+    const baselineCount = before.extractionCount;
+
+    const result = await coord.runExtraction(makeTurns("fingerprinted-empty"), {
+      skipCharThreshold: true,
+      skipUserTurnThreshold: true,
+      clearBufferAfterExtraction: false,
+      bufferKey: "fingerprinted-empty",
+    });
+
+    assert.equal(result.status, "skipped");
+    assert.equal(result.reason, "empty_extraction_result");
+    assert.equal(h.persistCalls(), 0);
+
+    const after = await storage.loadMeta();
+    assert.equal(after.extractionCount, baselineCount + 1, "fingerprinted empty success increments extractionCount exactly once");
+    assert.ok(after.lastExtractionAt, "fingerprinted empty success stamps lastExtractionAt");
+    assert.equal(h.recordedProcessedCount(), 1, "processed fingerprint recorded exactly once");
+  } finally {
+    await h.cleanup();
+  }
+});
+
+test("extraction liveness (#2223): a non-empty success advances lastExtractionAt", async () => {
+  const h = await makeHarness();
+  try {
+    const coord = h.newCoordinator();
+    h.setRespond(() => successResult());
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+    const baselineCount = before.extractionCount;
+
+    const result = await coord.runExtraction(makeTurns("durable-fact"), {
+      skipCharThreshold: true,
+      skipUserTurnThreshold: true,
+      clearBufferAfterExtraction: false,
+      bufferKey: "durable-fact",
+    });
+
+    assert.equal(result.status, "completed");
+    assert.ok(h.persistCalls() >= 1);
+
+    const after = await storage.loadMeta();
+    assert.equal(after.extractionCount, baselineCount + 1, "non-empty success increments extractionCount");
+    assert.ok(after.lastExtractionAt, "non-empty success stamps lastExtractionAt");
+  } finally {
+    await h.cleanup();
+  }
+});
+
+test("extraction liveness (#2223): a provider failure does not advance lastExtractionAt", async () => {
+  const h = await makeHarness({ extractionBreakerFailureThreshold: 100 });
+  try {
+    const coord = h.newCoordinator();
+    h.setRespond(() => failureResult("provider_retryable"));
+    const storage = await h.storageForNs("default");
+    const before = await storage.loadMeta();
+    const baselineWatermark = before.lastExtractionAt;
+    const baselineCount = before.extractionCount;
+
+    const result = await coord.runExtraction(makeTurns("failing-extraction"), {
+      skipCharThreshold: true,
+      skipUserTurnThreshold: true,
+      clearBufferAfterExtraction: false,
+      bufferKey: "failing-extraction",
+    });
+
+    assert.equal(result.status, "skipped");
+    assert.equal(result.reason, "empty_extraction_result");
+
+    const after = await storage.loadMeta();
+    assert.equal(after.lastExtractionAt, baselineWatermark, "failure must not stamp lastExtractionAt");
+    assert.equal(after.extractionCount, baselineCount, "failure must not increment extractionCount");
+  } finally {
+    await h.cleanup();
+  }
+});

package/src/orchestration/extraction-run.ts

@@ -127,6 +127,7 @@ import { raceRecallAbort, throwIfRecallAborted } from "./orchestrator-helpers.js
 import {
   capExtractionRetryStateEntries,
   combineExtractionAbortSignals,
+  commitEmptySuccessExtraction,
   computeExtractionRetryNextEligibleMs,
   deriveSourceConnector,
   deriveTopicsFromExtraction,
@@ -1015,13 +1016,16 @@ export class ExtractionRunCoordinator {
           { extractionFailure }
         );
       }
-      if (extractionFingerprint && shouldPersistProcessedFingerprint && !extractionFailure) {
-        meta ??= await storage.loadMeta();
-        await this.deps.recordProcessedExtractionFingerprint(storage, extractionFingerprint, meta);
-        meta.extractionCount += 1;
-        meta.lastExtractionAt = new Date().toISOString();
-        await storage.saveMeta(meta);
-      }
+      await commitEmptySuccessExtraction({
+        storage,
+        meta,
+        extractionFingerprint,
+        shouldPersistProcessedFingerprint,
+        hasExtractionFailure: Boolean(extractionFailure),
+        recordProcessedExtractionFingerprint: this.deps.recordProcessedExtractionFingerprint,
+        runDeadlineAware,
+        isDeadlineError: (error) => error instanceof ExtractionDeadlineError,
+      });
       // Correction-only turns that meet char/user-turn thresholds but yield
       // zero facts still need passive capture (review: "empty extraction skips
       // capture"). selfNamespace/principal already resolved above.