@unblocklabs/unblock-memory 0.3.13 → 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
@@ -8,6 +54,53 @@ search without query expansion or a reranker, so only the embedding model loads.
 Optional memory analysis uses those same stored vectors in the same SQLite
 index. It does not re-embed memory, copy vectors, or create another database.
 
+### Loggie meeting interoperability
+
+Loggie v0.1.12+ persists versioned, speaker-attributed meeting Markdown separately
+from its workflow prompt. Session projection recognizes that format and also
+normalizes complete legacy Loggie JSON envelopes. Unrecognized, malformed or
+truncated legacy payloads keep their original text; source sessions are never
+rewritten. Summaries remain labeled as generated material, distinct from speech.
+
+QMD groups adjacent speaker blocks rather than forcing one chunk per speaker.
+Search expands around the matching exchange within its existing budget. Long
+monologue excerpts regain the source speaker label while citations still point
+to the exact original source lines. No identity or timestamp is invented.
+
+Within a session, identical replayed transcripts are suppressed; distinct
+complete revisions with ordered source sequence numbers retain their history
+and assistant follow-ups, with older versions marked superseded. Account,
+workspace, meeting and external transcript identifiers scope the comparison.
+Ambiguous/partial revisions are preserved. Separate session windows are not
+globally deduplicated.
+
+Use the session projection as the searchable meeting copy. Loggie raw archives
+remain opt-in and should stay outside file-corpus globs (new default:
+`transcripts/loggie-archive`). Memory never follows archive paths embedded in
+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/loggie-projection.d.ts

@@ -0,0 +1,24 @@
+/** Loggie's v1 Markdown is persisted source data, never instructions. */
+type Meeting = {
+    text: string;
+    key?: string;
+    hash?: string;
+    sequence?: number;
+    complete: boolean;
+};
+export declare function projectLoggieMessage(text: string, accountId?: string): Meeting | undefined;
+export declare function meetingRevisionAnnotation(content: string, position: number): string | undefined;
+/** Spans stay in source coordinates; headings and assistant replies stop expansion. */
+export declare function meetingSpeakerSpans(content: string, position: number, end?: number): {
+    header: string;
+    start: number;
+    message: {
+        start: number;
+        end: number;
+    };
+    turn: {
+        start: number;
+        end: number;
+    };
+} | undefined;
+export {};

package/dist/src/loggie-projection.js

@@ -0,0 +1,126 @@
+const HEADER = /^<!-- loggie:meeting:v1 (\{[^\n]*\}) -->\n/u;
+const SPEAKER = /^\*\*Speaker: ("(?:[^"\\\r\n]|\\.)*")\*\*\n/gmu;
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+export function projectLoggieMessage(text, accountId) {
+    const header = HEADER.exec(text);
+    if (header) {
+        let value;
+        try {
+            value = JSON.parse(header[1]);
+        }
+        catch {
+            return undefined;
+        }
+        const meta = record(value);
+        if (!meta || typeof meta.accountId !== "string" || typeof meta.workspaceId !== "string" ||
+            typeof meta.meetingId !== "string" || typeof meta.contentHash !== "string" ||
+            !["complete", "truncated", "unavailable"].includes(String(meta.completeness)) ||
+            (accountId !== undefined && meta.accountId !== accountId))
+            return undefined;
+        return {
+            text: text.slice(header[0].length),
+            key: JSON.stringify([meta.accountId, meta.workspaceId, meta.meetingId, meta.externalId ?? null]),
+            hash: meta.contentHash,
+            sequence: typeof meta.sequence === "number" && Number.isSafeInteger(meta.sequence) && meta.sequence >= 0 ? meta.sequence : undefined,
+            complete: meta.completeness === "complete",
+        };
+    }
+    // Only accept the old producer's exact envelope and a complete JSON payload.
+    if (!text.startsWith("Loggie meeting transcript ready: "))
+        return undefined;
+    const delimiter = "\nTranscript Detail:\n";
+    const at = text.indexOf(delimiter);
+    if (at < 0)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(text.slice(at + delimiter.length));
+    }
+    catch {
+        return undefined;
+    }
+    const transcript = record(record(value)?.transcript);
+    if (!transcript || typeof transcript.text !== "string")
+        return undefined;
+    const names = Array.isArray(transcript.participants) ? transcript.participants.flatMap(item => {
+        const name = record(item)?.name;
+        return typeof name === "string" && name.trim() ? [name.trim()] : [];
+    }) : [];
+    const raw = transcript.text.trim();
+    const speech = raw === "[No transcript provided]" ? "" : raw;
+    const blocks = [];
+    let speaker = "Unattributed";
+    let lines = [];
+    const flush = () => {
+        const content = lines.join("\n").trim();
+        if (content)
+            blocks.push(`**Speaker: ${JSON.stringify(speaker)}**\n` + content.split("\n").map(line => `> ${line}`).join("\n"));
+        lines = [];
+    };
+    for (const line of speech.replace(/\r\n?/gu, "\n").split("\n")) {
+        const match = /^([^:\n]{1,160}):[ \t]+(.*)$/u.exec(line);
+        const label = match?.[1]?.trim();
+        const recognized = label && (names.some(name => label === name || label.startsWith(`${name} [`)) ||
+            /^(?:Speaker|Person)\s+[\p{L}\d]+(?:\s|$)/u.test(label) ||
+            /^[\p{Lu}\p{Lt}][\p{L}'’.-]+(?:\s+[\p{Lu}\p{Lt}][\p{L}'’.-]+)+(?:\s*\[.*\])?$/u.test(label));
+        if (match && recognized) {
+            flush();
+            speaker = label;
+            lines.push(match[2]);
+        }
+        else
+            lines.push(line);
+    }
+    flush();
+    const sections = [speech ? `## Transcript\n\n${blocks.join("\n\n")}` : "Transcript status: unavailable. No verbatim speech was supplied."];
+    for (const [key, title] of [["summary", "Summary (generated)"], ["outline", "Outline (generated)"]]) {
+        const content = transcript[key];
+        if (typeof content === "string" && content.trim())
+            sections.push(`## ${title}\n\n${content.trim().split(/\r?\n/u).map(line => `> ${line}`).join("\n")}`);
+    }
+    const title = text.split("\n")[0].slice("Loggie meeting transcript ready: ".length);
+    const date = /^Meeting Date: (.*)$/mu.exec(text.slice(0, at))?.[1];
+    return { text: `# Meeting: ${title}\n\n${date ? `Meeting date: ${date}\n\n` : ""}${sections.join("\n\n")}`, complete: false };
+}
+export function meetingRevisionAnnotation(content, position) {
+    const enclosingMessage = content.lastIndexOf("\n## User — ", position);
+    return /^Transcript revision \d+ \(superseded by revision \d+\)\.$/mu.exec(content.slice(Math.max(0, enclosingMessage), position))?.[0];
+}
+/** Spans stay in source coordinates; headings and assistant replies stop expansion. */
+export function meetingSpeakerSpans(content, position, end = position) {
+    const markers = [...content.matchAll(SPEAKER)].flatMap(match => {
+        try {
+            const speaker = JSON.parse(match[1]);
+            return typeof speaker === "string" ? [{ start: match.index, header: match[0].trimEnd() }] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    const ranges = markers.map(marker => {
+        const rest = content.slice(marker.start + marker.header.length + 1);
+        const quoted = /^(?:>[^\n]*(?:\n|$))+/u.exec(rest)?.[0];
+        return { ...marker, end: marker.start + marker.header.length + 1 + (quoted?.length ?? 0) };
+    });
+    const first = ranges.findIndex(range => range.start <= position && range.end > position);
+    if (first < 0)
+        return undefined;
+    let last = first;
+    while (ranges[last].end < end && ranges[last + 1] && !content.slice(ranges[last].end, ranges[last + 1].start).trim())
+        last++;
+    if (ranges[last].end < end && content.slice(ranges[last].end, end).trim())
+        return undefined;
+    const prev = ranges[first - 1];
+    const next = ranges[last + 1];
+    return {
+        header: ranges[first].header,
+        start: ranges[first].start,
+        message: { start: ranges[first].start, end: Math.max(end, ranges[last].end) },
+        turn: {
+            start: prev && !content.slice(prev.end, ranges[first].start).trim() ? prev.start : ranges[first].start,
+            end: next && !content.slice(ranges[last].end, next.start).trim() ? next.end : Math.max(end, ranges[last].end),
+        },
+    };
+}