@unblocklabs/unblock-memory 0.3.14 → 0.3.16

package/README.md

@@ -1,5 +1,249 @@
 # Unblock Memory
 
+## Response quality tracking (opt-in)
+
+`responseAudit` evaluates bounded human-agent exchanges in the background. It is
+separate from chunk-quality auditing and never changes memories or prompts. It
+creates private response-review tasks, not memory-curation tasks.
+Its primary purpose is tracking delivery quality over time: visible fulfillment,
+deliverable fit, clear underdelivery and its observable reason. Memory gaps are only
+an optional diagnostic lead, not a proxy for performance.
+Only approved Slack sender IDs with trusted `senderKind: human` or owner metadata
+qualify (older Slack records use unknown senderKind even for known owners).
+Explicit bots, unverified identities, internal messages, other senders and thread changes form
+hard boundaries. Synthetic delivery mirrors and gateway-injected answers are excluded.
+Assistant progress messages are grouped with the terminal answer.
+Recognized Slack envelopes are stripped even inside `upstreamUserText`; embedded
+history is not treated as current human text. Ambiguous envelopes are excluded.
+Removed history marks the context as limited; ordinary Markdown/JSON is preserved.
+Human feedback closes when the next assistant turn starts. Still-open feedback,
+no-response exchanges, incomplete/failed turns and oversized inputs are not graded.
+
+```json
+{
+  "responseAudit": {
+    "enabled": true,
+    "sentimentEnabled": true,
+    "senderIds": ["YOUR_SLACK_USER_ID"],
+    "chatTypes": ["direct"],
+    "historyMessages": 6,
+    "lookbackDays": 30,
+    "maxEpisodes": 20,
+    "intervalMinutes": 60,
+    "memoryCorpora": ["memory", "knowledge"]
+  }
+}
+```
+
+This is explicit approval to send those exchanges to TypeSafe. Sender IDs apply
+across the agent's Slack accounts; use only identities approved in all such accounts.
+`memoryCorpora` is optional and separately approves configured **file** corpora for
+memory-gap investigation. Leave it empty to send no indexed memory evidence.
+`typesafe.enabled: false` or missing credentials prevents evaluation. An interval
+of zero means manual-only. Defaults are disabled, no approved senders, direct chats,
+6 preceding visible messages, 30 days, 20 episodes per run and a 60-minute interval.
+`sentimentEnabled` defaults to **true within that opt-in audit**; it does not bypass
+approved senders or TypeSafe credentials. Set it false to omit polarity, annoyance,
+frustration and intensity questions while retaining quality/repair judgments.
+`intervalMinutes` controls their shared cadence; no second sentiment timer is needed.
+The Gateway checks a durable per-agent due time on startup and every minute (no
+agent-turn cron or separate launchd job). First enablement waits one interval;
+restarts preserve the due time and an overdue schedule gets one bounded catch-up,
+not one run per missed interval. Each attempt advances the due time before work,
+including missing-key skips, failures or interrupted runs, to prevent retry storms.
+Changing the interval recalculates the due time from the last scheduled attempt
+(or initial enablement). The Gateway must be running; manual audits do not change
+the automatic schedule. Missing/unreadable credentials skip all quality and sentiment
+inference without failing Gateway startup or normal memory functionality.
+Changing the interval does not invalidate cached results. Changing the sentiment
+toggle selects a separate reporting cohort, so older missing sentiment is not
+treated as neutral; unchanged quality/feedback stages are reused across the toggle.
+
+Operator commands (not agent tools):
+
+```sh
+openclaw memory-responses audit --agent main --dry-run
+openclaw memory-responses audit --agent main
+openclaw memory-responses report --agent main
+openclaw memory-responses report --agent main --episode EPISODE_ID
+openclaw memory-responses report --agent main --sender SLACK_USER_ID --account ACCOUNT_SCOPE --bucket day --since 2026-09-01 --until 2026-10-01
+openclaw memory-responses report --agent main --person PERSON_ID
+openclaw memory-responses tasks --agent main
+openclaw memory-responses review --agent main --id TASK_ID --status deferred --reviewer human --note "Review the linked exchanges before changing preferences"
+openclaw memory-responses annotate --agent main --date 2026-09-18 --kind prompt --note "Known prompt revision deployed"
+openclaw memory-responses retry-failed --agent main
+```
+
+Reports group by scoped human identity as well as task/model/time. Names are not
+identity keys. Existing active people-store links are resolved read-only at assessment
+time; missing links do not prevent analysis. Unknown account scopes stay isolated
+per session. No new identity fields are sent to TypeSafe. Date ranges are UTC with
+an inclusive start and exclusive end. `periodStart` identifies a day/week bucket;
+legacy `week`/`fromWeek`/`toWeek` fields remain aliases. `--task-type` and `--model`
+further narrow comparisons. Human-specific scores are not rankings of the humans:
+task difficulty, feedback habits and selection bias remain important.
+
+Session checkpoints hash bounded active source bytes; unchanged sessions skip
+extraction and all inference. Changed sessions are re-extracted within the existing
+budget, then stage hashes reuse unchanged quality, feedback, sentiment and later
+evidence judgments. Only hashes/counts are checkpointed, never a transcript copy.
+A persisted cursor rotates through discovery and tracked-session reconciliation;
+`deferredByLimit` includes known backlog and a lower-bound marker for unvisited
+sessions. `stages` exposes pending/failed/succeeded counts and exhausted retries
+for the cohort/date range, before person filters. `retry-failed` only resets failed
+work; successful stages remain cached. Source freshness is checked before activation.
+
+Review tasks distinguish concrete delivery shortfalls from high-intensity human
+experience complaints. Stable task keys include exchange, scoped human and issue
+family. Decisions survive rescoring; stale source evidence and superseded findings
+are labeled separately. Review status/provenance never changes the raw judgments.
+Tasks and change annotations are operator-only and stay out of memory/whisperer
+prompts. `--reviewer` records human/agent provenance, not authentication or a new
+permission grant. Task lists disclose their 1,000-item cap. There are no automatic
+dossier updates: review the evidence and approve any concrete preference separately.
+Old cohorts remain stored; the first staged-cohort run does not silently import
+unverified older rubric judgments. Audit-history retention is not automatic.
+
+Two separate TypeSafe requests prevent human feedback from influencing the original
+fulfillment/deliverable-fit grade. The feedback pass distinguishes acceptance,
+correction, continuation, unrelated replies, expressed sentiment, repeated constraints
+and avoidable rework. Current-index memory investigation runs only for a strong
+memory-gap signal: lexical retrieval selects up to three whole short documents from
+approved collections. This is an investigation lead, **not proof of historical
+availability, factual truth, or agent fault**. Tool-call counts do not establish what
+the model saw or whether it should have searched. Unseen artifacts are unassessable.
+
+Deliverable kind/format/scope has its own assessability gate, independent of whether
+execution or external facts can be verified. Feedback attribution distinguishes the
+current answer, earlier behavior, delivery, missing proactive action, external events,
+new work and mixed/unclear targets. A reported forgotten instruction does not prove
+searchable memory existed. A third, separate request examines the original exchange,
+human feedback and available next assistant block for specific reported shortfalls,
+acknowledgment, explicit factual corrections, delivery failures and regressions. These are
+retrospective signals, not independently verified facts and never inputs to the
+original grade. Clean text preceding a synthetic error/delivery notice can be assessed
+as **partial** evidence; the notice itself is excluded and no successful completion
+is inferred. Later evidence is capped at six messages/12K characters; incomplete,
+unsafe or oversized blocks stay explicitly pending/unavailable/oversized. New later
+evidence changes the input hash; only changed assessment stages are re-evaluated,
+within normal audit budgets. Successful stages survive failures in later stages.
+When the next block is unavailable, the third pass uses only the original exchange
+and feedback; it cannot infer a missing delivery from missing later evidence.
+
+Code combines narrow, confident evidence into an **observed outcome**, preserving
+its basis and reason. A concrete original-answer shortfall or later admission takes
+precedence over praise. Broad reported failures are used only when they do not
+depend on a newly introduced requirement. Accurate explanations of earlier mistakes,
+ordinary follow-ups, necessary clarification and unseen work are not automatically
+failures. Sentiment and earlier-workflow complaints remain separate review signals.
+Sentiment includes independent annoyance and frustration yes-probabilities (both
+can apply), plus an expressed-dissatisfaction intensity score from 0 to 3. Intensity
+means no expressed displeasure / restrained displeasure / pointed complaint /
+explicit rejection or loss of trust. It is **not confidence or failure severity**.
+External frustration, brevity and factual corrections alone do not establish
+annoyance or frustration; mixed praise and complaints can still carry both signals.
+Weekly reports show dissatisfaction, annoyance and frustration rates, intensity
+means, unknown counts and their own assessment denominators. Unassessed results
+are never counted as neutral. Sentiment deltas require 20 samples in both periods
+and matching assessment coverage; they remain descriptive, not causal evidence.
+Outcome, evidence basis and failure reasons remain distinct: a correction does not
+automatically mean `incorrect_claim`. Confident reason judgments and direct
+delivery/regression admissions supply reasons; otherwise `reasonStatus` is
+`uncertain`. `reasonDetails` retain each label's source and strength, distinguishing
+Choice confidence from Noul yes-probability. Multiple supported reasons can coexist.
+`reportVersion` identifies composition/reporting semantics independently of the
+judge rubric, allowing cached judgments to be re-reported without re-inference.
+
+Results live in the agent's private `unblock-memory/response-audit.sqlite`, outside
+the memory index. It stores judgments and source event references/hashes, not copies
+of conversations. Identical successful inputs are cached; source rewrites invalidate
+in-scope results on the next scan. Reports partition by fixed judge/rubric/context
+configuration, UTC week, task type and agent model. They expose eligible/assessed
+counts, excluded cases, confidence-qualified score means with per-dimension denominators, rework rates with Wilson
+intervals, and evidence IDs. Small groups (<20) are marked explicitly. Confidence
+thresholds are provisional, not calibrated guarantees. Human-reviewed evaluation
+data is still needed before drawing performance conclusions.
+Reports include dated clear-underdelivery examples and reason counts. Descriptive
+score deltas compare successive available UTC weeks within the same task type,
+agent model and rubric/configuration, with at least 20 confident scores per dimension
+in each period and unchanged scored coverage; changed coverage withholds the score
+delta. Outcome trends show acknowledgment, reported-shortfall and unknown rates
+against **all evaluated exchanges**, with at least 20 evaluated exchanges per period.
+Read the three rates together: fewer acknowledgments can mean more unknowns, not
+more failures. Every delta includes before/after values, sample counts, denominator
+and coverage-change flags. Unknown task types/models cannot produce deltas. These
+are not statistical change-point detections or proof of causality; model/version
+changes remain visible as separate groups rather than silently mixing cohorts.
+The legacy `observedSuccessRate` group field remains acknowledgment / known outcomes
+for compatibility, but is not used for trends. Unknowns are never successes.
+Coverage changes and threshold variability can move rates; acknowledgment is not
+factual verification. Week buckets
+may be partial, and several exchanges in one session are not independent. Wilson
+intervals are descriptive, not calibrated confidence about overall agent ability.
+
+Each run selects at most 100 recent sessions for inference, each at most 2,000 active events/2M
+characters; episodes must fit 24K characters and six feedback messages without
+truncating the answer. Coverage counts describe the scanned sessions; only episodes
+within `lookbackDays` are judged. Caps, failures and no-feedback cases remain visible.
+Saved sessions in the report window are also reconciled independently of that
+selection, so removing an entire active branch retires its scores. Oversized saved
+sessions defer reconciliation rather than being treated as deleted; the report
+exposes `reconciledSessions` and `reconciliationDeferred`. All reconciliation shares
+the run deadline. Freshness checks compare the assessed episode, not unrelated
+later session activity. Actual snapshot races do not exhaust provider retries.
+The whole run has a two-minute deadline, at most three provider attempts per input (ten-minute
+backoff), and a cross-process lease. Scheduling never starts inference on the agent
+turn path or boots a QMD manager. No model downloads or source re-indexing occur.
+The report is observational: different task mixes, selective human replies and judge
+changes can produce apparent trends. It does not automatically declare regressions,
+rewrite prompts, or treat silence as success.
+
+## 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 +278,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

@@ -1,3 +1,4 @@
+import { type ResponseAuditConfig } from "./response-config.js";
 export type FileCorpusConfig = {
     name: string;
     kind: "files";
@@ -36,6 +37,11 @@ export type UnblockMemoryConfig = {
         corpora: readonly string[];
         minNoise: number;
     };
+    evidenceReview: {
+        enabled: boolean;
+        corpora: readonly string[];
+    };
+    responseAudit: ResponseAuditConfig;
     people: {
         enabled: boolean;
         whisperer: {
@@ -54,6 +60,7 @@ export type UnblockMemoryConfig = {
     };
     memoryWhisperer: {
         enabled: boolean;
+        complementaryHints: boolean;
         corpora: readonly string[];
         historyMessages: number;
         minUsefulness: number;

package/dist/src/config.js

@@ -1,4 +1,5 @@
 import { isAbsolute } from "node:path";
+import { resolveResponseAudit } from "./response-config.js";
 const DEFAULT_PATHS = ["MEMORY.md", "USER.md", "memory/**/*.md"];
 const DEFAULT_SESSION_MAX_EXPANDED_TOKENS = 500;
 const MAX_SESSION_MAX_EXPANDED_TOKENS = 10_000;
@@ -79,7 +80,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 +94,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 +116,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 +262,8 @@ export function resolveConfig(value) {
             analysis: {},
             typesafe: { ...DEFAULT_TYPESAFE_CONFIG },
             qualityAudit: { ...DEFAULT_QUALITY_AUDIT },
+            evidenceReview: { enabled: false, corpora: [] },
+            responseAudit: resolveResponseAudit(undefined, DEFAULT_CORPORA),
             people: DEFAULT_PEOPLE_CONFIG,
             skillWhisperer: DEFAULT_SKILL_WHISPERER,
             memoryWhisperer: { ...DEFAULT_MEMORY_WHISPERER },
@@ -267,9 +273,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", "responseAudit"], "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 +348,7 @@ export function resolveConfig(value) {
     }
     return { corpora, keepEmbeddingModelWarm, analysis: analysisConfig, people, skillWhisperer,
         qualityAudit: resolveQualityAudit(config.qualityAudit, corpora),
+        evidenceReview,
+        responseAudit: resolveResponseAudit(config.responseAudit, corpora),
         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";
+}>;