@unblocklabs/unblock-memory 0.7.1 → 0.7.3

package/dist/src/analysis.js

@@ -200,22 +200,21 @@ export function latestAnalysisCollections(db) {
         return undefined;
     }
 }
-function count(db, sql, runId) {
-    return db.prepare(sql).get(runId)?.count ?? 0;
-}
 function analysisSummary(db, run) {
-    const clusters = count(db, "SELECT COUNT(*) AS count FROM memory_analysis_clusters WHERE run_id = ?", run.id);
-    const members = count(db, "SELECT COUNT(*) AS count FROM memory_analysis_memberships WHERE run_id = ?", run.id);
-    const expectedNonNoise = count(db, "SELECT COALESCE(SUM(size), 0) AS count FROM memory_analysis_clusters WHERE run_id = ?", run.id);
-    const nonNoise = count(db, "SELECT COUNT(*) AS count FROM memory_analysis_memberships WHERE run_id = ? AND cluster_id <> -1", run.id);
-    const noise = count(db, "SELECT COUNT(*) AS count FROM memory_analysis_memberships WHERE run_id = ? AND cluster_id = -1", run.id);
-    const unassigned = count(db, `
-    SELECT COUNT(*) AS count
+    const { clusters, expectedNonNoise } = db.prepare(`
+    SELECT COUNT(*) AS clusters, COALESCE(SUM(size), 0) AS expectedNonNoise
+    FROM memory_analysis_clusters WHERE run_id = ?
+  `).get(run.id);
+    const { members, nonNoise, noise, unassigned } = db.prepare(`
+    SELECT COUNT(*) AS members,
+      COALESCE(SUM(m.cluster_id <> -1), 0) AS nonNoise,
+      COALESCE(SUM(m.cluster_id = -1), 0) AS noise,
+      COALESCE(SUM(m.cluster_id <> -1 AND c.cluster_id IS NULL), 0) AS unassigned
     FROM memory_analysis_memberships m
     LEFT JOIN memory_analysis_clusters c
       ON c.run_id = m.run_id AND c.cluster_id = m.cluster_id
-    WHERE m.run_id = ? AND m.cluster_id <> -1 AND c.cluster_id IS NULL
-  `, run.id);
+    WHERE m.run_id = ?
+  `).get(run.id);
     if (nonNoise !== expectedNonNoise || members !== nonNoise + noise || unassigned > 0)
         return undefined;
     return {
@@ -261,8 +260,8 @@ function byteSlice(text, maxBytes) {
         return "";
     return bytes.subarray(0, maxBytes - 3).toString("utf8").replace(/\uFFFD$/u, "") + "…";
 }
-function members(db, runId, clusterId, limit, offset = 0, sort = "representative", maxExcerptBytes = MAX_EXCERPT_BYTES, maxTotalBytes = MAX_TOTAL_EXCERPT_BYTES, maxTotalAliases = MAX_TOTAL_ALIASES, temporal = {}) {
-    const representativeOrder = clusterId === -1
+function representativeOrder(clusterId) {
+    return clusterId === -1
         ? "m.outlier_score DESC, m.hash, m.seq"
         : `CASE WHEN m.representative_rank IS NULL THEN 1 ELSE 0 END,
        m.representative_rank,
@@ -270,9 +269,11 @@ function members(db, runId, clusterId, limit, offset = 0, sort = "representative
        m.outlier_score,
        m.hash,
        m.seq`;
+}
+function members(db, runId, clusterId, limit, offset = 0, sort = "representative", maxExcerptBytes = MAX_EXCERPT_BYTES, maxTotalBytes = MAX_TOTAL_EXCERPT_BYTES, maxTotalAliases = MAX_TOTAL_ALIASES, temporal = {}) {
     const score = clusterId === -1 ? "m.outlier_score" : "m.probability";
     const order = {
-        representative: representativeOrder,
+        representative: representativeOrder(clusterId),
         score_desc: `${score} DESC, m.hash, m.seq`,
         score_asc: `${score} ASC, m.hash, m.seq`,
         date_desc: "julianday(COALESCE(m.event_time, m.source_modified_at)) DESC, m.hash, m.seq",
@@ -396,24 +397,34 @@ function readMetadata(run) {
     }
     return { stale: false, staleSince: null, analyzedAt: run.completed_at };
 }
+function clusterPreview(db, runId, clusterId, maxBytes, aliasLimit) {
+    const row = db.prepare(`
+    SELECT m.hash, m.seq, m.probability, m.pos, m.chunk_len, m.doc
+    FROM memory_analysis_available_memberships m
+    WHERE m.run_id = ? AND m.cluster_id = ?
+    ORDER BY ${representativeOrder(clusterId)}
+    LIMIT 1
+  `).get(runId, clusterId);
+    if (!row)
+        return undefined;
+    return {
+        hash: row.hash,
+        seq: row.seq,
+        probability: row.probability,
+        text: byteSlice(row.doc.slice(row.pos, row.pos + row.chunk_len), maxBytes),
+        sourcePaths: sourcePaths(db, row.hash, Math.min(MAX_ALIASES_PER_MEMBER, aliasLimit)),
+    };
+}
 function toSummary(db, run, row, includePreview, previewBytes = 600, aliasLimit = MAX_TOTAL_ALIASES) {
     const preview = includePreview
-        ? members(db, run.id, row.cluster_id, 1, 0, "representative", previewBytes, previewBytes, aliasLimit)[0]
+        ? clusterPreview(db, run.id, row.cluster_id, previewBytes, aliasLimit)
         : undefined;
     return {
         clusterId: clusterReference(run.id, row.cluster_id),
         size: row.size,
         availableSize: row.available_size,
         meanProbability: row.mean_probability,
-        ...(preview ? {
-            preview: {
-                hash: preview.hash,
-                seq: preview.seq,
-                probability: preview.probability,
-                text: preview.text,
-                sourcePaths: preview.sourcePaths,
-            },
-        } : {}),
+        ...(preview ? { preview } : {}),
     };
 }
 function noiseRow(db, runId) {

package/dist/src/config.js

@@ -291,23 +291,8 @@ function resolvePeople(value) {
     };
 }
 export function resolveConfig(value) {
-    if (value === undefined || value === null) {
-        return {
-            corpora: DEFAULT_CORPORA,
-            extraction: resolveExtraction(undefined, DEFAULT_CORPORA),
-            keepEmbeddingModelWarm: true,
-            analysis: {},
-            typesafe: { ...DEFAULT_TYPESAFE_CONFIG },
-            qualityAudit: { ...DEFAULT_QUALITY_AUDIT },
-            evidenceReview: { enabled: false, corpora: [] },
-            responseAudit: resolveResponseAudit(undefined, DEFAULT_CORPORA),
-            insideOut: resolveInsideOut(undefined),
-            peoplePrimer: resolvePeoplePrimer(undefined, DEFAULT_CORPORA, false),
-            people: DEFAULT_PEOPLE_CONFIG,
-            skillWhisperer: DEFAULT_SKILL_WHISPERER,
-            memoryWhisperer: { ...DEFAULT_MEMORY_WHISPERER, api: resolveQueryApi(undefined) },
-        };
-    }
+    if (value === undefined || value === null)
+        value = {};
     if (typeof value !== "object" || Array.isArray(value)) {
         throw new Error("unblock-memory config must be an object");
     }

package/dist/src/contracts.d.ts

@@ -29,7 +29,7 @@ export type SessionSearchFilter = {
     conversationId?: string;
 };
 export type MemoryRequestContext = Pick<OpenClawPluginToolContext, "sessionKey" | "sessionId" | "messageChannel" | "agentAccountId" | "nativeChannelId" | "deliveryContext">;
-export type CorpusSearchOptions = NonNullable<Parameters<MemorySearchManagerContract["search"]>[1]> & {
+export type CorpusSearchOptions = Omit<NonNullable<Parameters<MemorySearchManagerContract["search"]>[1]>, "lexicalOnly"> & {
     corpora?: readonly string[];
     /** Internal vector-hint budget; oversized matched chunks are omitted, never sliced. */
     maxSnippetChars?: number;

package/dist/src/extraction-chunk.d.ts

@@ -25,5 +25,6 @@ export declare function readExtractionChunk(params: {
     newIds: string[];
     entryCount: number;
     fence: string;
+    exhausted: boolean;
     cursor: string;
 }>;

package/dist/src/extraction-chunk.js

@@ -98,6 +98,7 @@ export async function readExtractionChunk(params) {
         const finish = (index, offset = 0) => {
             const next = page.messages[index];
             return { kind: "page", messages, newIds, entryCount, fence: startingFence ?? page.cursor,
+                exhausted: !next && !page.hasMore,
                 cursor: next ? PREFIX + JSON.stringify({ before, fence: page.cursor, index, offset, id: next.id, hash: digest(next) }) : page.cursor };
         };
         for (let i = resume?.index ?? 0; i < page.messages.length; i++) {

package/dist/src/extraction-model.js

@@ -2,7 +2,7 @@ import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { Tiktoken } from "js-tiktoken/lite";
 import o200kBase from "js-tiktoken/ranks/o200k_base";
-import { requestTypeSafe } from "./typesafe-client.js";
+import { requestTypeSafe, TYPESAFE_NOUL_SCHEMA as noul } from "./typesafe-client.js";
 export const EXTRACTION_VERSION = "lasting-facts-v11";
 // Jev allows 32k for state plus its longest question. Leave room for validation
 // instructions, proposal evidence and tokenizer differences, not just Luna input.
@@ -34,6 +34,7 @@ Only extract facts supported by at least one NEW message. Context-only messages
 If a fact is already in existing memories, omit it. Source dates control chronology, not processing order: during backfill, never replace a newer observed fact with an older one, or emit the older value as an undated duplicate. If new evidence clearly corrects/changes an existing memory, set replaces to its exact id and emit the concise replacement. Otherwise replaces is null. Never replace unrelated facts. If a previous claim is explicitly withdrawn without a replacement, retain a concise qualified correction rather than inventing a value.
 Cite exact contiguous substrings copied from the supplied messages using their ids. Preserve Markdown markers, mentions, whitespace and punctuation inside each quote. Never join separated spans into one quote or clean up its formatting. Prefer short exact spans; use separate evidence entries when needed. Include enough evidence to resolve corrections and speaker attribution. Output an empty memories array when nothing qualifies. Do not fill a quota.`;
 let tokenizer;
+let promptTokens;
 // o200k_base is an explicit budgeting proxy, not a claim about the host's private tokenizer.
 function extractionTokens(text) {
     return (tokenizer ??= new Tiktoken(o200kBase)).encode(text, [], []).length;
@@ -45,7 +46,7 @@ function extractionInput(messages, newIds, existing) {
     return JSON.stringify({ messages: messages.map(datedMessage), newMessageIds: newIds, existing, schema: proposalSchema });
 }
 export function extractionOverhead(existing) {
-    return extractionTokens(EXTRACTION_PROMPT) + extractionTokens(extractionInput([], [], existing)) + 512;
+    return (promptTokens ??= extractionTokens(EXTRACTION_PROMPT)) + extractionTokens(extractionInput([], [], existing)) + 512;
 }
 export function extractionMessageTokens(message) {
     return extractionTokens(JSON.stringify(datedMessage(message))) + extractionTokens(JSON.stringify(message.id)) + 8;
@@ -84,8 +85,8 @@ export async function extractWithLuna(runtime, agentId, messages, newIds, existi
 const judgments = Type.Object({ answers: Type.Object({
         supported: Type.Object({ type: Type.Literal("choice"), choice: Type.Union([Type.Literal("supported"), Type.Literal("contradicted"), Type.Literal("unsupported")]),
             probabilities: Type.Object({ supported: Type.Number({ minimum: 0, maximum: 1 }), contradicted: Type.Number({ minimum: 0, maximum: 1 }), unsupported: Type.Number({ minimum: 0, maximum: 1 }) }) }),
-        useful: Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) }),
-        replacement: Type.Optional(Type.Object({ type: Type.Literal("noul"), noul: Type.Number({ minimum: 0, maximum: 1 }) })),
+        useful: noul,
+        replacement: Type.Optional(noul),
     }) });
 export async function validateExtractedMemory(params) {
     const { proposal, messages, existing } = params;

package/dist/src/extraction-runtime.js

@@ -7,6 +7,7 @@ import { resolveAgentDir, resolveStateDir } from "openclaw/plugin-sdk/memory-cor
 import { MEMORY_DATABASE, hasMemoryTable } from "./memory-database.js";
 import { ExtractionStore } from "./extraction-store.js";
 import { extractionSessions } from "./extraction-source.js";
+import { dateOption } from "./date-option.js";
 export function registerExtraction(api, config, runtime) {
     let lifetime = new AbortController();
     let timer, running;
@@ -36,13 +37,7 @@ export function registerExtraction(api, config, runtime) {
             .option("--since <date>", "Explicit bounded backfill from YYYY-MM-DD UTC; repeat to resume")
             .option("--session <id>", "Restrict this run to one session")
             .action(async (opts) => {
-            let since;
-            if (opts.since !== undefined) {
-                since = Date.parse(opts.since);
-                if (!/^\d{4}-\d{2}-\d{2}$/.test(opts.since) || !Number.isFinite(since) || new Date(since).toISOString().slice(0, 10) !== opts.since) {
-                    throw new Error("since must be a valid YYYY-MM-DD UTC date");
-                }
-            }
+            const since = opts.since === undefined ? undefined : dateOption(opts.since, 0);
             try {
                 // Native harnesses live in the Gateway, not the cold CLI metadata loader.
                 const result = await callGatewayFromCli("unblock-memory.extract", { timeout: "600000" }, { agentId: opts.agent, ...(since === undefined ? {} : { since }), ...(opts.session ? { sessionId: opts.session } : {}) });

package/dist/src/extraction-source.js

@@ -11,13 +11,17 @@ export function extractionSessions(databasePath, agentId, chatTypes) {
         }
         return db.prepare(`SELECT w.session_id,w.session_key,w.chat_type,COALESCE(w.channel,c.channel) AS provider,
       COALESCE(w.account_id,c.account_id) AS account_id,COALESCE(c.native_channel_id,c.native_direct_user_id,c.peer_id,w.primary_conversation_id) AS conversation_id,
-      COALESCE(w.started_at,w.created_at) AS started_at, COALESCE(w.transcript_updated_at,w.updated_at,w.created_at) AS changed_at FROM session_windows w
+      COALESCE(w.started_at,w.created_at) AS started_at, COALESCE(w.transcript_updated_at,w.updated_at,w.created_at) AS changed_at,
+      r.generation,(SELECT MAX(seq) FROM transcript_events WHERE session_id=w.session_id) AS tail FROM session_windows w
       LEFT JOIN conversations c ON c.conversation_id=w.primary_conversation_id
+      LEFT JOIN transcript_rewrite_watermarks r ON r.session_id=w.session_id
       WHERE w.chat_type IN (${chatTypes.map(() => "?").join(",")}) ORDER BY w.created_at,w.session_id`)
             .all(...chatTypes).map(r => ({ sessionId: String(r.session_id), sessionKey: String(r.session_key),
             chatType: r.chat_type, provider: r.provider === null ? undefined : String(r.provider),
             accountId: r.account_id === null ? undefined : String(r.account_id),
-            conversationId: r.conversation_id === null ? undefined : String(r.conversation_id), startedAt: Number(r.started_at), changedAt: Number(r.changed_at) }));
+            conversationId: r.conversation_id === null ? undefined : String(r.conversation_id), startedAt: Number(r.started_at), changedAt: Number(r.changed_at),
+            // The host uses this append-stable watermark for transcript cache validation.
+            sourceRevision: r.generation === null ? undefined : JSON.stringify([r.generation, r.tail]) }));
     }
     finally {
         db.close();

package/dist/src/extraction-store.d.ts

@@ -3,11 +3,13 @@ import type { SessionMetadata } from "./session-projector.js";
 export type ExtractionSession = SessionMetadata & {
     sessionKey: string;
     changedAt?: number;
+    sourceRevision?: string;
 };
 type Checkpoint = {
     cursor: string | null;
     context: ExtractionMessage[];
     since: number;
+    completeRevision: string | null;
 };
 export type ExtractedRecord = {
     id: string;
@@ -42,6 +44,7 @@ export declare class ExtractionStore {
         }[];
         owner: string;
         version: string;
+        completeRevision?: string;
     }): number;
     error(sessionId: string, code: string): void;
     report(): {

package/dist/src/extraction-store.js

@@ -20,7 +20,7 @@ export class ExtractionStore {
         session_id TEXT PRIMARY KEY, metadata TEXT NOT NULL CHECK(json_valid(metadata)), cursor TEXT,
         extract_since INTEGER NOT NULL,
         context TEXT NOT NULL DEFAULT '[]' CHECK(json_valid(context)), updated_at INTEGER NOT NULL,
-        error TEXT
+        error TEXT, complete_revision TEXT
       ) STRICT;
       CREATE TABLE IF NOT EXISTS extracted_memories (
         id TEXT NOT NULL, revision INTEGER NOT NULL, session_id TEXT NOT NULL REFERENCES extraction_sessions(session_id),
@@ -33,6 +33,9 @@ export class ExtractionStore {
       CREATE UNIQUE INDEX IF NOT EXISTS extracted_duplicate ON extracted_memories(session_id,digest) WHERE status='active';
       INSERT OR IGNORE INTO memory_schema VALUES('extraction',1);
     `);
+            if (!this.db.prepare("SELECT 1 FROM pragma_table_info('extraction_sessions') WHERE name='complete_revision'").get()) {
+                this.db.exec("ALTER TABLE extraction_sessions ADD COLUMN complete_revision TEXT");
+            }
             this.db.prepare("INSERT OR IGNORE INTO extraction_worker(id,live_since) VALUES(1,?)").run(Date.now());
         }
         catch (error) {
@@ -58,23 +61,24 @@ export class ExtractionStore {
     checkpoint(session, since) {
         this.db.prepare(`INSERT INTO extraction_sessions(session_id,metadata,updated_at,extract_since) VALUES(?,?,?,?)
       ON CONFLICT(session_id) DO UPDATE SET metadata=excluded.metadata`).run(session.sessionId, JSON.stringify(session), Date.now(), since ?? this.liveSince());
-        const row = this.db.prepare("SELECT cursor,context,extract_since FROM extraction_sessions WHERE session_id=?").get(session.sessionId);
+        const row = this.db.prepare("SELECT cursor,context,extract_since,complete_revision FROM extraction_sessions WHERE session_id=?").get(session.sessionId);
         if (since !== undefined && since < Number(row.extract_since)) {
             // A broader explicitly approved backfill replays this session. Existing facts are
             // supplied to Luna and exact duplicates are ignored; history is never deleted.
-            this.db.prepare("UPDATE extraction_sessions SET cursor=NULL,context='[]',extract_since=? WHERE session_id=?").run(since, session.sessionId);
-            return { cursor: null, context: [], since };
+            this.db.prepare("UPDATE extraction_sessions SET cursor=NULL,context='[]',complete_revision=NULL,extract_since=? WHERE session_id=?").run(since, session.sessionId);
+            return { cursor: null, context: [], since, completeRevision: null };
         }
-        return { cursor: row.cursor, context: JSON.parse(String(row.context)), since: Number(row.extract_since) };
+        return { cursor: row.cursor, context: JSON.parse(String(row.context)), since: Number(row.extract_since),
+            completeRevision: row.complete_revision };
     }
     records(sessionId, paths) {
         const keys = paths?.filter(path => /^[a-f0-9-]+\/[1-9]\d*$/.test(path)).map(path => path.split("/"));
         if (keys && !keys.length)
             return [];
         return this.db.prepare(`SELECT m.*,s.metadata FROM extracted_memories m JOIN extraction_sessions s USING(session_id)
-      WHERE status='active' AND (? IS NULL OR session_id=?)
+      WHERE status='active' ${sessionId === undefined ? "" : "AND session_id=?"}
       ${keys ? `AND (m.id,m.revision) IN (VALUES ${keys.map(() => "(?,?)").join(",")})` : ""}
-      ORDER BY observed_at,id`).all(sessionId ?? null, sessionId ?? null, ...(keys?.flat() ?? []))
+      ORDER BY observed_at,id`).all(...(sessionId === undefined ? [] : [sessionId]), ...(keys?.flat() ?? []))
             .map(r => ({ id: String(r.id), revision: Number(r.revision), text: String(r.text), sessionId: String(r.session_id),
             observedAt: Number(r.observed_at), evidence: JSON.parse(String(r.evidence)), metadata: JSON.parse(String(r.metadata)), judgment: JSON.parse(String(r.judgment)) }));
     }
@@ -83,7 +87,7 @@ export class ExtractionStore {
         try {
             this.renew(owner);
             this.db.prepare("UPDATE extracted_memories SET status='withdrawn' WHERE session_id=? AND status='active'").run(sessionId);
-            this.db.prepare("UPDATE extraction_sessions SET cursor=?,context='[]',error=NULL WHERE session_id=?").run(cursor, sessionId);
+            this.db.prepare("UPDATE extraction_sessions SET cursor=?,context='[]',complete_revision=NULL,error=NULL WHERE session_id=?").run(cursor, sessionId);
             this.db.exec("COMMIT");
         }
         catch (error) {
@@ -119,8 +123,8 @@ export class ExtractionStore {
                     .run(id, revision, params.session.sessionId, proposal.text.trim(), digest, JSON.stringify(proposal.evidence), observedAt, JSON.stringify(judgment), params.version, Date.now());
                 written++;
             }
-            this.db.prepare("UPDATE extraction_sessions SET cursor=?,context=?,updated_at=?,error=NULL WHERE session_id=?")
-                .run(params.cursor, JSON.stringify(params.context), Date.now(), params.session.sessionId);
+            this.db.prepare("UPDATE extraction_sessions SET cursor=?,context=?,updated_at=?,complete_revision=?,error=NULL WHERE session_id=?")
+                .run(params.cursor, JSON.stringify(params.context), Date.now(), params.completeRevision ?? null, params.session.sessionId);
             this.db.exec("COMMIT");
             return written;
         }

package/dist/src/extraction-worker.js

@@ -32,9 +32,10 @@ export async function runExtraction(params) {
         const visible = new Set(sessions.map(s => s.sessionId));
         if (params.sessionId && !visible.has(params.sessionId))
             throw new Error("Unknown or unapproved extraction session");
-        for (const memory of store.records())
-            if (!visible.has(memory.sessionId))
-                store.reset(memory.sessionId, null, owner);
+        for (const { session_id } of store.db.prepare("SELECT DISTINCT session_id FROM extracted_memories WHERE status='active'").all()) {
+            if (!visible.has(String(session_id)))
+                store.reset(String(session_id), null, owner);
+        }
         // Oldest last-checked first: bounded runs must not starve later sessions.
         const checked = new Map(store.db.prepare("SELECT session_id,updated_at FROM extraction_sessions").all()
             .map(r => [String(r.session_id), Number(r.updated_at)]));
@@ -48,6 +49,10 @@ export async function runExtraction(params) {
             if (processed >= config.maxBatches)
                 break;
             const checkpoint = store.checkpoint(session, params.since);
+            if (session.sourceRevision !== undefined && checkpoint.completeRevision === session.sourceRevision) {
+                unchanged++;
+                continue;
+            }
             let stage = "read";
             try {
                 const existing = store.records(session.sessionId);
@@ -69,7 +74,8 @@ export async function runExtraction(params) {
                     continue;
                 }
                 if (!page.entryCount) {
-                    store.db.prepare("UPDATE extraction_sessions SET updated_at=? WHERE session_id=?").run(Date.now(), session.sessionId);
+                    store.db.prepare("UPDATE extraction_sessions SET updated_at=?,complete_revision=? WHERE session_id=?")
+                        .run(Date.now(), page.exhausted ? session.sourceRevision ?? null : null, session.sessionId);
                     unchanged++;
                     continue;
                 }
@@ -82,17 +88,26 @@ export async function runExtraction(params) {
                 const proposals = newIds.length ? await (params.extract ?? extractWithLuna)(params.runtime, params.agentId, messages, newIds, existing.map(m => ({ id: m.id, text: m.text, observedAt: m.observedAt })), signal) : [];
                 const accepted = [];
                 stage = "validate";
-                for (const proposal of proposals) {
+                for (let start = 0; start < proposals.length; start += 4) {
                     signal.throwIfAborted();
-                    const judgment = await (params.validate ?? validateExtractedMemory)({ proposal, messages, newIds,
-                        existing, apiKey, signal, thresholds: config });
-                    const observedAt = judgment.accepted ? Math.max(...proposal.evidence.map(e => messages.find(m => m.id === e.messageId).timestamp)) : 0;
-                    const prior = existing.find(m => m.id === proposal.replaces);
-                    if (judgment.accepted && (!prior || prior.observedAt <= observedAt))
-                        accepted.push({ proposal: { ...proposal,
-                                evidence: proposal.evidence.map(e => ({ ...e, messageId: messages.find(m => m.id === e.messageId).sourceMessageId ?? e.messageId })) }, judgment, observedAt });
-                    else
-                        rejectedCount++;
+                    // Isolated judgments overlap, but failed chunks drain before their lease is released.
+                    const judgments = await Promise.allSettled(proposals.slice(start, start + 4).map(async (proposal) => ({ proposal,
+                        judgment: await (params.validate ?? validateExtractedMemory)({ proposal, messages, newIds, existing, apiKey, signal, thresholds: config }) })));
+                    const failure = judgments.find(result => result.status === "rejected");
+                    if (failure)
+                        throw failure.reason;
+                    for (const result of judgments) {
+                        if (result.status !== "fulfilled")
+                            continue;
+                        const { proposal, judgment } = result.value;
+                        const observedAt = judgment.accepted ? Math.max(...proposal.evidence.map(e => messages.find(m => m.id === e.messageId).timestamp)) : 0;
+                        const prior = existing.find(m => m.id === proposal.replaces);
+                        if (judgment.accepted && (!prior || prior.observedAt <= observedAt))
+                            accepted.push({ proposal: { ...proposal,
+                                    evidence: proposal.evidence.map(e => ({ ...e, messageId: messages.find(m => m.id === e.messageId).sourceMessageId ?? e.messageId })) }, judgment, observedAt });
+                        else
+                            rejectedCount++;
+                    }
                 }
                 // A branch rewrite during inference invalidates its proposals. Appends are safe and processed next time.
                 const check = await readPage(params.agentId, params.agentName, session, page.fence);
@@ -107,7 +122,8 @@ export async function runExtraction(params) {
                 const context = extractionHistory(messages, config.historyMessages);
                 stage = "commit";
                 const written = store.commit({ session, expected: checkpoint.cursor, cursor: page.cursor,
-                    context, accepted, owner, version: EXTRACTION_VERSION });
+                    context, accepted, owner, version: EXTRACTION_VERSION,
+                    completeRevision: page.exhausted ? session.sourceRevision : undefined });
                 processed++;
                 acceptedCount += written;
             }

package/dist/src/manager.d.ts

@@ -12,7 +12,7 @@ import { reviewIndexedClaim } from "./evidence-review.js";
 import { reviewClusterIngestion } from "./cluster-review.js";
 import type { QueryPair } from "./query-contract.js";
 export { expandSessionSearchHit } from "./memory-passage.js";
-export type ManagerStore = Pick<QMDStore, "update" | "embed" | "getStatus" | "listCollections" | "searchLex" | "vsearch" | "get" | "getDocumentBody" | "close">;
+export type ManagerStore = Pick<QMDStore, "update" | "embed" | "getStatus" | "listCollections" | "vsearch" | "get" | "close">;
 export type ManagerSessionConfig = {
     agentId: string;
     agentName: string;