@unblocklabs/unblock-memory 0.3.14 → 0.3.15

package/README.md

@@ -1,5 +1,51 @@
 # Unblock Memory
 
+## Review and diagnostics
+
+- `memory_diagnostics` reports credential **availability only**, per-agent process-local
+  whisperer counters, projection version, old indexed-session projection count, and
+  embedding readiness. Counters are bounded to 100 agents and reset on restart.
+  No prompts, excerpts, paths, keys, or provider error bodies enter these counters.
+  Parser cleanup/budget-skip counts are persisted with the latest completed
+  `memory_sync_status`; unchanged sessions are not counted again. QMD structural
+  omission counts cover this manager's embedding passes, not the whole corpus.
+- Quality-audit groups distinguish `preserve_evidence_repair`, `inspect_scaffolding`,
+  and `context_review`, reusing cached noise/evidence judgments without another call.
+  Evidence-preserving repair tasks sort first. Maintenance tasks expose indexed
+  fingerprint presence; `not_present_in_index` is **not** a verified repair and
+  never resolves or deletes the task. Chunk boundaries may simply have changed.
+- `memory_review_cluster` uses the existing `qualityAudit` opt-in/corpus allowlist.
+  It judges up to three representative and three low-membership members, deduplicates
+  the sample, and skips unapproved or >2,000-character chunks whole. Repeated defect
+  labels are investigation leads only. Stale/changed samples are rejected; useful
+  or uncertain members are retained. No tasks or sources are modified.
+- `memory_review_claim` accepts one atomic claim (up to 2,000 characters) and 1–3
+  citations `{path, from, lines}`. It reads approved indexed evidence itself (at
+  most 6,000 characters), returns supports/contradicts/insufficient_evidence with
+  confidence and source hashes, and never writes or authorizes a write. Support
+  below 0.9 confidence is marked for review. This threshold is provisional, not a
+  guarantee of truth; read original evidence and verify current-state claims.
+
+New optional configuration (corpora must already be configured):
+
+```json
+{
+  "evidenceReview": { "enabled": true, "corpora": ["memory", "knowledge", "sessions"] },
+  "memoryWhisperer": {
+    "enabled": true, "corpora": ["memory", "knowledge"], "complementaryHints": true
+  }
+}
+```
+
+Both additions default off. Claim review sends the proposed claim and approved
+source excerpts to TypeSafe; cluster review sends approved sampled excerpts.
+Complementary hints use one extra bounded call over at most four already-useful
+candidates (six directional comparisons). Only redundancy probability >=0.9
+removes a hint; distinct evidence and contradictions should remain. Provider errors
+retain baseline hints, while the existing total turn deadline/cancellation still
+suppresses late results. Missing keys or disabled TypeSafe never enable these calls.
+The retrieval corpus/session boundaries are unchanged.
+
 Workspace-native memory for OpenClaw, powered internally by `@unblocklabs/qmd`.
 It keeps one warm QMD store per agent and exposes the standard `memory_search`
 and `memory_get` tools. Search uses semantic chunking and direct QMD vector
@@ -34,6 +80,27 @@ remain opt-in and should stay outside file-corpus globs (new default:
 messages. Truncated sessions stay explicitly incomplete; enabling archive
 enrichment is not part of this version.
 
+### Conservative ingestion cleanup
+
+Session projections unwrap complete, recognized task/attachment envelopes while
+keeping the actual result, task/status, filename, MIME type, and untrusted-content
+label. Internal task cleanup requires structured inter-session provenance, not
+just matching text. Unknown formats, malformed envelopes, and code examples stay
+intact. Assistant messages and Loggie's separate projection path are unaffected.
+Raw session events and workspace memory files are never rewritten.
+Attachment matching has a fixed work budget; oversized or repeatedly nested/
+incomplete envelopes leave the entire message unchanged rather than blocking sync.
+
+The companion QMD semantic-chunking update skips only source-confirmed standalone
+REM heading/marker spans and orphan closing fences. Reflections and useful text
+remain searchable, with original source offsets. These are deterministic rules,
+not TypeSafe judgments; audit flags never authorize automatic memory deletion.
+
+This release pins QMD 2.9.6. Projector/chunker version changes refresh derived
+projections and embeddings on their next normal sync; the first sync may take
+longer while re-embedding. No manual deletion of source memories or review tasks
+is needed.
+
 ## Installation
 
 From npm:

package/dist/src/abortable.d.ts

@@ -0,0 +1,2 @@
+/** Stop waiting without cancelling shared work that other callers still need. */
+export declare function abortable<T>(pending: Promise<T>, signal?: AbortSignal): Promise<T>;

package/dist/src/abortable.js

@@ -0,0 +1,21 @@
+/** Stop waiting without cancelling shared work that other callers still need. */
+export async function abortable(pending, signal) {
+    if (!signal)
+        return pending;
+    let onAbort = () => { };
+    const cancelled = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener("abort", onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+    try {
+        // Observe late failures even when cancellation wins the race.
+        const result = await Promise.race([pending, cancelled]);
+        signal.throwIfAborted();
+        return result;
+    }
+    finally {
+        signal.removeEventListener("abort", onAbort);
+    }
+}

package/dist/src/cluster-review.d.ts

@@ -0,0 +1,47 @@
+import type { QMDStore } from "@unblocklabs/qmd";
+import { type ResolvedSource } from "./sources.js";
+/** Inspect center and edge samples; never extrapolate their labels to the rest of a cluster. */
+export declare function reviewClusterIngestion(params: {
+    db: QMDStore["internal"]["db"];
+    sources: readonly ResolvedSource[];
+    clusterId: string;
+    apiKey: string;
+    timeoutMs: number;
+    signal: AbortSignal;
+    read?: <T>(run: () => T) => Promise<T>;
+}): Promise<{
+    status: "unavailable";
+    reason: string;
+    sample?: undefined;
+    considered?: undefined;
+    runId?: undefined;
+    clusterSize?: undefined;
+} | {
+    status: "ok";
+    runId: string;
+    clusterId: string;
+    members: {
+        flagged: boolean;
+        defect: "encoding" | "wrapper" | "boilerplate" | "none_or_uncertain";
+        confidence: number;
+        path: string;
+        hash: string;
+        seq: number;
+        from: number;
+        fingerprint: string;
+    }[];
+    recurring: {
+        defect: string;
+        examples: {
+            path: string;
+            from: number;
+            fingerprint: string;
+        }[];
+    }[];
+    sampled: number;
+    considered: number;
+    clusterSize: number | undefined;
+    policy: string;
+    scope: string;
+    reason?: undefined;
+}>;

package/dist/src/cluster-review.js

@@ -0,0 +1,64 @@
+import { readAnalysisSummary, readCluster } from "./analysis.js";
+import { parseSafeVirtualPath } from "./sources.js";
+import { reviewClusterDefects } from "./typesafe-review.js";
+import { chunkFingerprint } from "./curation.js";
+/** Inspect center and edge samples; never extrapolate their labels to the rest of a cluster. */
+export async function reviewClusterIngestion(params) {
+    params.signal.throwIfAborted();
+    const sources = new Map(params.sources.filter(source => source.kind !== "skills").map(source => [source.collection, source]));
+    const read = params.read ?? (async (run) => run());
+    const snapshot = await read(() => {
+        const center = readCluster(params.db, params.clusterId, 3, 0, "representative");
+        if (center.status !== "ok" || center.stale)
+            return { status: "unavailable", reason: "Cluster missing or stale; refresh analysis first" };
+        const edge = readCluster(params.db, params.clusterId, 3, 0, "score_asc");
+        const candidates = [...new Map([...(center.members ?? []), ...(edge.members ?? [])].map(member => [`${member.hash}:${member.seq}`, member])).values()];
+        const sample = candidates.flatMap(member => {
+            const path = member.sourcePaths.find(path => parseSafeVirtualPath(path, sources));
+            if (!path)
+                return [];
+            const safe = parseSafeVirtualPath(path, sources);
+            // Reload the full chunk; analysis previews may be truncated. Never judge a silently cut prefix.
+            const row = params.db.prepare(`SELECT c.doc, v.pos, v.chunk_len FROM documents d JOIN content c ON c.hash = d.hash
+        JOIN content_vectors v ON v.hash = d.hash WHERE d.active = 1 AND d.collection = ? AND d.path = ? AND d.hash = ? AND v.seq = ?`)
+                .get(safe.source.collection, safe.relativePath, member.hash, member.seq);
+            if (!row || row.pos < 0 || row.chunk_len < 1 || row.pos + row.chunk_len > row.doc.length || row.chunk_len > 2000)
+                return [];
+            const text = row.doc.slice(row.pos, row.pos + row.chunk_len);
+            return [{ path, hash: member.hash, seq: member.seq, from: row.doc.slice(0, row.pos).split("\n").length,
+                    fingerprint: chunkFingerprint(text), text }];
+        });
+        return { status: "ready", sample, considered: candidates.length, runId: center.runId, clusterSize: center.cluster?.availableSize };
+    });
+    if (snapshot.status !== "ready")
+        return snapshot;
+    const { sample } = snapshot;
+    if (!sample.length)
+        return { status: "unavailable", reason: "No complete bounded members in approved corpora" };
+    const judgments = await reviewClusterDefects({ ...params, excerpts: sample.map(member => member.text) });
+    params.signal.throwIfAborted();
+    return read(() => {
+        const current = readAnalysisSummary(params.db);
+        if (!current || current.stale || current.runId !== snapshot.runId)
+            return { status: "unavailable", reason: "Analysis changed during review; retry" };
+        for (const member of sample) {
+            const safe = parseSafeVirtualPath(member.path, sources);
+            if (!safe)
+                return { status: "unavailable", reason: "Source scope changed; retry" };
+            const row = params.db.prepare(`SELECT c.doc, v.pos, v.chunk_len FROM documents d JOIN content c ON c.hash = d.hash
+        JOIN content_vectors v ON v.hash = d.hash WHERE d.active = 1 AND d.collection = ? AND d.path = ? AND d.hash = ? AND v.seq = ?`)
+                .get(safe.source.collection, safe.relativePath, member.hash, member.seq);
+            if (!row || chunkFingerprint(row.doc.slice(row.pos, row.pos + row.chunk_len)) !== member.fingerprint)
+                return { status: "unavailable", reason: "Sample changed during review; retry" };
+        }
+        const members = sample.map(({ text: _text, ...member }, index) => ({ ...member, ...judgments[index],
+            flagged: judgments[index].defect !== "none_or_uncertain" && judgments[index].confidence >= 0.9 }));
+        const recurring = ["wrapper", "encoding", "boilerplate"].flatMap(defect => {
+            const examples = members.filter(member => member.flagged && member.defect === defect);
+            return examples.length >= 2 ? [{ defect, examples: examples.map(member => ({ path: member.path, from: member.from, fingerprint: member.fingerprint })) }] : [];
+        });
+        return { status: "ok", runId: snapshot.runId, clusterId: params.clusterId, members, recurring,
+            sampled: sample.length, considered: snapshot.considered, clusterSize: snapshot.clusterSize,
+            policy: "jev-1.13.0:cluster-defects-v1", scope: "Center/edge sample of approved complete chunks only. Recurring labels are hypotheses, not proof of a shared cause or permission to change any member. Unreviewed members remain unknown." };
+    });
+}

package/dist/src/config.d.ts

@@ -36,6 +36,10 @@ export type UnblockMemoryConfig = {
         corpora: readonly string[];
         minNoise: number;
     };
+    evidenceReview: {
+        enabled: boolean;
+        corpora: readonly string[];
+    };
     people: {
         enabled: boolean;
         whisperer: {
@@ -54,6 +58,7 @@ export type UnblockMemoryConfig = {
     };
     memoryWhisperer: {
         enabled: boolean;
+        complementaryHints: boolean;
         corpora: readonly string[];
         historyMessages: number;
         minUsefulness: number;

package/dist/src/config.js

@@ -79,7 +79,7 @@ const DEFAULT_SKILL_WHISPERER = {
     cooldownTurns: 10,
 };
 const DEFAULT_MEMORY_WHISPERER = {
-    enabled: false, corpora: [], historyMessages: 5, minUsefulness: 0.9,
+    enabled: false, complementaryHints: false, corpora: [], historyMessages: 5, minUsefulness: 0.9,
     maxHints: 2, cooldownTurns: 10, timeoutMs: 3000,
 };
 function resolveMemoryWhisperer(value, corpora) {
@@ -93,6 +93,9 @@ function resolveMemoryWhisperer(value, corpora) {
     const enabled = config.enabled ?? false;
     if (typeof enabled !== "boolean")
         throw new Error("unblock-memory memoryWhisperer.enabled must be a boolean");
+    const complementaryHints = config.complementaryHints ?? false;
+    if (typeof complementaryHints !== "boolean")
+        throw new Error("memoryWhisperer.complementaryHints must be a boolean");
     const selected = config.corpora ?? [];
     if (!Array.isArray(selected) || !selected.every((name) => typeof name === "string" && corpora.some(corpus => corpus.name === name && corpus.kind !== "skills"))) {
         throw new Error("unblock-memory memoryWhisperer.corpora must list configured non-skill corpora");
@@ -112,7 +115,7 @@ function resolveMemoryWhisperer(value, corpora) {
         throw new Error("unblock-memory memoryWhisperer.minUsefulness must be between 0 and 1");
     }
     return {
-        enabled, corpora: [...new Set(selected)], historyMessages, cooldownTurns, minUsefulness,
+        enabled, complementaryHints, corpora: [...new Set(selected)], historyMessages, cooldownTurns, minUsefulness,
         maxHints: positiveInteger(config.maxHints, 2, "memoryWhisperer.maxHints", 2),
         timeoutMs: positiveInteger(config.timeoutMs, 3000, "memoryWhisperer.timeoutMs", 10_000),
     };
@@ -258,6 +261,7 @@ export function resolveConfig(value) {
             analysis: {},
             typesafe: { ...DEFAULT_TYPESAFE_CONFIG },
             qualityAudit: { ...DEFAULT_QUALITY_AUDIT },
+            evidenceReview: { enabled: false, corpora: [] },
             people: DEFAULT_PEOPLE_CONFIG,
             skillWhisperer: DEFAULT_SKILL_WHISPERER,
             memoryWhisperer: { ...DEFAULT_MEMORY_WHISPERER },
@@ -267,9 +271,23 @@ export function resolveConfig(value) {
         throw new Error("unblock-memory config must be an object");
     }
     const config = value;
-    assertOnlyKeys(config, ["corpora", "keepEmbeddingModelWarm", "analysis", "people", "skillWhisperer", "memoryWhisperer", "typesafe", "qualityAudit"], "config");
+    assertOnlyKeys(config, ["corpora", "keepEmbeddingModelWarm", "analysis", "people", "skillWhisperer", "memoryWhisperer", "typesafe", "qualityAudit", "evidenceReview"], "config");
     const corpora = resolveCorpora(config.corpora);
     const people = resolvePeople(config.people);
+    let evidenceReview = { enabled: false, corpora: [] };
+    if (config.evidenceReview !== undefined) {
+        const value = config.evidenceReview;
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("evidenceReview must be an object");
+        assertOnlyKeys(value, ["enabled", "corpora"], "evidenceReview");
+        try {
+            const approved = resolveQualityAudit(value, corpora);
+            evidenceReview = { enabled: approved.enabled, corpora: approved.corpora };
+        }
+        catch {
+            throw new Error("evidenceReview requires a boolean enabled and explicit configured non-skill corpora when enabled");
+        }
+    }
     if (config.keepEmbeddingModelWarm !== undefined &&
         typeof config.keepEmbeddingModelWarm !== "boolean") {
         throw new Error("unblock-memory keepEmbeddingModelWarm must be a boolean");
@@ -328,5 +346,6 @@ export function resolveConfig(value) {
     }
     return { corpora, keepEmbeddingModelWarm, analysis: analysisConfig, people, skillWhisperer,
         qualityAudit: resolveQualityAudit(config.qualityAudit, corpora),
+        evidenceReview,
         memoryWhisperer: resolveMemoryWhisperer(config.memoryWhisperer, corpora), typesafe: resolveTypeSafe(config.typesafe) };
 }

package/dist/src/curation.js

@@ -155,7 +155,10 @@ export class CurationStore {
         return this.#db.prepare(`
       SELECT * FROM maintenance_tasks
       WHERE status = ?
-      ORDER BY created_at, id
+      ORDER BY CASE WHEN type = 'quality_review' AND json_valid(detail) THEN
+        CASE WHEN json_extract(detail, '$.evidence') >= 0.8 AND
+          (json_extract(detail, '$.noise') >= 0.8 OR reason = 'possible_double_encoded_message') THEN 0 ELSE 1 END
+        ELSE 1 END, created_at, id
       LIMIT ?
     `).all(status, limit).map((row) => task(row));
     }

package/dist/src/diagnostics.d.ts

@@ -0,0 +1,39 @@
+type Whisperer = "skill" | "memory";
+type Outcome = "missing_key" | "typesafe_disabled" | "no_candidates" | "rejected" | "cooldown" | "emitted" | "failed" | "timed_out" | "cancelled" | "unavailable" | "payload_limit" | "redundancy_unavailable";
+/** Process-local, content-free and bounded. Agent IDs are keys, never included in snapshots. */
+export declare class WhispererDiagnostics {
+    #private;
+    record(agentId: string, whisperer: Whisperer, outcome: Outcome): void;
+    snapshot(agentId: string): {
+        skill: {
+            unavailable?: number | undefined;
+            rejected?: number | undefined;
+            failed?: number | undefined;
+            missing_key?: number | undefined;
+            typesafe_disabled?: number | undefined;
+            no_candidates?: number | undefined;
+            cooldown?: number | undefined;
+            emitted?: number | undefined;
+            timed_out?: number | undefined;
+            cancelled?: number | undefined;
+            payload_limit?: number | undefined;
+            redundancy_unavailable?: number | undefined;
+        };
+        memory: {
+            unavailable?: number | undefined;
+            rejected?: number | undefined;
+            failed?: number | undefined;
+            missing_key?: number | undefined;
+            typesafe_disabled?: number | undefined;
+            no_candidates?: number | undefined;
+            cooldown?: number | undefined;
+            emitted?: number | undefined;
+            timed_out?: number | undefined;
+            cancelled?: number | undefined;
+            payload_limit?: number | undefined;
+            redundancy_unavailable?: number | undefined;
+        };
+        scope: string;
+    };
+}
+export {};

package/dist/src/diagnostics.js

@@ -0,0 +1,18 @@
+/** Process-local, content-free and bounded. Agent IDs are keys, never included in snapshots. */
+export class WhispererDiagnostics {
+    #agents = new Map();
+    record(agentId, whisperer, outcome) {
+        let entry = this.#agents.get(agentId);
+        if (!entry) {
+            if (this.#agents.size >= 100)
+                this.#agents.delete(this.#agents.keys().next().value);
+            entry = { skill: {}, memory: {} };
+            this.#agents.set(agentId, entry);
+        }
+        entry[whisperer][outcome] = Math.min(Number.MAX_SAFE_INTEGER, (entry[whisperer][outcome] ?? 0) + 1);
+    }
+    snapshot(agentId) {
+        const entry = this.#agents.get(agentId);
+        return { skill: { ...entry?.skill }, memory: { ...entry?.memory }, scope: "process lifetime; up to 100 agents" };
+    }
+}

package/dist/src/evidence-review.d.ts

@@ -0,0 +1,41 @@
+import type { QMDStore } from "@unblocklabs/qmd";
+import { type ResolvedSource } from "./sources.js";
+export type EvidenceCitation = {
+    path: string;
+    from: number;
+    lines: number;
+};
+export declare function reviewIndexedClaim(params: {
+    db: QMDStore["internal"]["db"];
+    sources: readonly ResolvedSource[];
+    claim: string;
+    citations: readonly EvidenceCitation[];
+    apiKey: string;
+    timeoutMs: number;
+    signal: AbortSignal;
+    read?: <T>(run: () => T) => Promise<T>;
+}): Promise<{
+    status: "unavailable";
+    verdict: "insufficient_evidence";
+    needsReview: boolean;
+    reason: string;
+} | {
+    evidence: {
+        path: string;
+        from: number;
+        lines: number;
+        documentHash: string;
+        excerptHash: string;
+    }[];
+    policy: string;
+    scope: string;
+    verdict: "supports" | "contradicts" | "insufficient_evidence";
+    confidence: number;
+    probabilities: {
+        supports: number;
+        contradicts: number;
+        insufficient_evidence: number;
+    };
+    needsReview: boolean;
+    status: "ok";
+}>;

package/dist/src/evidence-review.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { parseSafeVirtualPath } from "./sources.js";
+import { reviewTypeSafeClaim } from "./typesafe-review.js";
+export async function reviewIndexedClaim(params) {
+    const unavailable = (reason) => ({ status: "unavailable", verdict: "insufficient_evidence", needsReview: true, reason });
+    if (!params.claim.trim() || params.claim.length > 2000 || !params.citations.length || params.citations.length > 3)
+        return unavailable("Invalid review bounds");
+    params.signal.throwIfAborted();
+    const sources = new Map(params.sources.filter(source => source.kind !== "skills").map(source => [source.collection, source]));
+    const read = params.read ?? (async (run) => run());
+    const snapshot = await read(() => {
+        const evidence = [];
+        for (const citation of params.citations) {
+            const safe = parseSafeVirtualPath(citation.path, sources);
+            if (!safe || !Number.isInteger(citation.from) || citation.from < 1 || !Number.isInteger(citation.lines) || citation.lines < 1 || citation.lines > 120)
+                return unavailable("Evidence is unavailable or outside approved corpora");
+            const row = params.db.prepare(`SELECT d.hash, c.doc FROM documents d JOIN content c ON c.hash = d.hash
+        WHERE d.active = 1 AND d.collection = ? AND d.path = ?`).get(safe.source.collection, safe.relativePath);
+            if (!row)
+                return unavailable("Evidence is not indexed");
+            const lines = row.doc.split("\n");
+            if (citation.from > lines.length)
+                return unavailable("Evidence range is outside the indexed source");
+            const text = lines.slice(citation.from - 1, citation.from - 1 + citation.lines).join("\n");
+            if (!text.trim())
+                return unavailable("Evidence range is empty");
+            evidence.push({ path: safe.normalized, from: citation.from, lines: Math.min(citation.lines, lines.length - citation.from + 1),
+                text, documentHash: row.hash, excerptHash: createHash("sha256").update(text).digest("hex") });
+        }
+        return { status: "ready", evidence };
+    });
+    if (snapshot.status !== "ready")
+        return snapshot;
+    const { evidence } = snapshot;
+    if (evidence.reduce((sum, item) => sum + item.text.length, 0) > 6000)
+        return unavailable("Evidence exceeds 6000 characters; choose a narrower complete passage");
+    const judgment = await reviewTypeSafeClaim({ ...params, evidence: evidence.map(item => item.text) });
+    params.signal.throwIfAborted();
+    return read(() => {
+        for (const item of evidence) {
+            const safe = parseSafeVirtualPath(item.path, sources);
+            if (!safe || !params.db.prepare("SELECT 1 FROM documents WHERE active = 1 AND collection = ? AND path = ? AND hash = ?")
+                .get(safe.source.collection, safe.relativePath, item.documentHash))
+                return unavailable("Indexed evidence changed during review; retry");
+        }
+        return { status: "ok", ...judgment,
+            evidence: evidence.map(({ text: _text, ...citation }) => citation),
+            policy: "jev-1.13.0:claim-v1", scope: "Advisory support check against cited indexed excerpts only, not current truth or authorization to write. Verify original sources and identity before promotion." };
+    });
+}

package/dist/src/manager.d.ts

@@ -2,10 +2,13 @@ import type { QMDStore, VectorSearchResult } from "@unblocklabs/qmd";
 import { type AnalysisRunner, type MemoryAnalysisSummary, type MemoryClusterDetail, type MemoryClusterList, type MemoryClusterSort, type MemoryReclusterOptions } from "./analysis.js";
 import type { CorpusMemorySearchResult, CorpusSearchOptions, MemoryEmbeddingProbeResult, MemoryProviderStatus, MemoryReadResult, MemoryRequestContext, MemorySearchManagerContract, MemorySyncParams } from "./contracts.js";
 import type { ChatType } from "./config.js";
-import { type MaintenanceStatus, type TemporalBasis } from "./curation.js";
+import { type MaintenanceStatus, type MaintenanceTask, type TemporalBasis } from "./curation.js";
 import { type SessionSyncResult } from "./session-sync.js";
 import { type ResolvedSource } from "./sources.js";
 import { type QualityCursor } from "./quality-audit.js";
+import { qualityTaskPresence } from "./quality-triage.js";
+import { reviewIndexedClaim } from "./evidence-review.js";
+import { reviewClusterIngestion } from "./cluster-review.js";
 export type ManagerStore = Pick<QMDStore, "update" | "embed" | "getStatus" | "listCollections" | "searchLex" | "vsearch" | "get" | "getDocumentBody" | "close">;
 export type ManagerSessionConfig = {
     agentId: string;
@@ -40,6 +43,15 @@ export declare function expandSessionSearchHit(result: Pick<VectorSearchResult,
 }>;
 export declare class QmdMemoryManager implements MemorySearchManagerContract {
     #private;
+    diagnostics(): Promise<{
+        projectorVersion: number;
+        semanticChunkingVersion: number | null | undefined;
+        sessionsNeedingProjection: number;
+        needsEmbedding: number;
+        embeddingReady: boolean;
+        structuralChunksOmitted: number | null;
+        scope: string;
+    }>;
     constructor(params: {
         dbPath: string;
         curationPath?: string;
@@ -56,6 +68,71 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
     syncSessions(force?: boolean, onPhase?: (phase: "projecting" | "indexing") => void): Promise<SessionSyncResult>;
     recluster(options?: MemoryReclusterOptions, signal?: AbortSignal): Promise<MemoryAnalysisSummary>;
     listClusters(limit?: number): Promise<MemoryClusterList>;
+    reviewClaim(params: Omit<Parameters<typeof reviewIndexedClaim>[0], "db" | "sources" | "read"> & {
+        corpora: readonly string[];
+    }): Promise<{
+        status: "unavailable";
+        verdict: "insufficient_evidence";
+        needsReview: boolean;
+        reason: string;
+    } | {
+        evidence: {
+            path: string;
+            from: number;
+            lines: number;
+            documentHash: string;
+            excerptHash: string;
+        }[];
+        policy: string;
+        scope: string;
+        verdict: "supports" | "contradicts" | "insufficient_evidence";
+        confidence: number;
+        probabilities: {
+            supports: number;
+            contradicts: number;
+            insufficient_evidence: number;
+        };
+        needsReview: boolean;
+        status: "ok";
+    }>;
+    reviewCluster(params: Omit<Parameters<typeof reviewClusterIngestion>[0], "db" | "sources" | "read"> & {
+        corpora: readonly string[];
+    }): Promise<{
+        status: "unavailable";
+        reason: string;
+        sample?: undefined;
+        considered?: undefined;
+        runId?: undefined;
+        clusterSize?: undefined;
+    } | {
+        status: "ok";
+        runId: string;
+        clusterId: string;
+        members: {
+            flagged: boolean;
+            defect: "encoding" | "wrapper" | "boilerplate" | "none_or_uncertain";
+            confidence: number;
+            path: string;
+            hash: string;
+            seq: number;
+            from: number;
+            fingerprint: string;
+        }[];
+        recurring: {
+            defect: string;
+            examples: {
+                path: string;
+                from: number;
+                fingerprint: string;
+            }[];
+        }[];
+        sampled: number;
+        considered: number;
+        clusterSize: number | undefined;
+        policy: string;
+        scope: string;
+        reason?: undefined;
+    }>;
     fetchCluster(params: {
         clusterId: string;
         topK?: number;
@@ -65,7 +142,9 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
     listMaintenanceTasks(params?: {
         status?: MaintenanceStatus;
         limit?: number;
-    }): import("./curation.js").MaintenanceTask[];
+    }): Promise<(MaintenanceTask & {
+        indexPresence?: ReturnType<typeof qualityTaskPresence>;
+    })[]>;
     auditQuality(params: {
         corpora: readonly string[];
         apiKey: string;
@@ -89,7 +168,8 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
             source: string;
             reason: string;
             pending: number;
-            examples: import("./curation.js").MaintenanceTask[];
+            examples: MaintenanceTask[];
+            triage: ReturnType<typeof import("./quality-triage.js").qualityTriage>;
         }[];
         policy: string;
         scope: string;
@@ -108,7 +188,7 @@ export declare class QmdMemoryManager implements MemorySearchManagerContract {
             basis: TemporalBasis;
             evidence: string;
         };
-    }): import("./curation.js").MaintenanceTask | undefined;
+    }): MaintenanceTask | undefined;
     search(query: string, opts?: CorpusSearchOptions): Promise<CorpusMemorySearchResult[]>;
     searchSkills(query: string, minScore: number, limit: number): Promise<SkillSearchCandidate[]>;
     readFile(params: {