akm-cli 0.9.16-alpha.2 → 0.9.17-alpha.1

package/dist/commands/health/checks.js

@@ -13,6 +13,7 @@ import { isLlmCredentialAvailable, resolveEngine, } from "../../integrations/age
 import { executionEngineDefinitionsFromConfig } from "../../integrations/agent/execution-definitions.js";
 import { loadModelMap, mergeModelMapLayers, parseModelMapLayer, readInstalledModelMapText, resolveModelMapAlias, userModelMapPath, } from "../../integrations/agent/model-map.js";
 import { probeEndpointOnce } from "../../llm/client.js";
+import { STATE_DB_FREELIST_WARN_RATIO, } from "../../storage/state-db-integrity.js";
 import { listKeys } from "../env/env.js";
 import { resolveImprovePlan } from "../improve/improve-strategies.js";
 import { ENGINE_LAST_USED_LOOKBACK_DAYS } from "./engine-usage.js";
@@ -868,6 +869,59 @@ export const HEALTH_CHECKS = [
             evidence: { path: ctx.stateDbPath, durationMs: ctx.probe.durationMs },
         }),
     },
+    {
+        // R0: nothing looked at state.db's own SQLite-level integrity before
+        // this — the round-trip probe above only proves one row can be appended
+        // and read back, which stays true on a database that fails
+        // `PRAGMA quick_check` elsewhere (corrupt indexes, out-of-order rowids).
+        // Also reports the freelist ratio (fraction of pages VACUUM could
+        // reclaim) so a bloated-but-uncorrupted file is visible as a warning
+        // rather than silence.
+        name: "state-db-integrity",
+        channel: "hard",
+        run: (ctx) => {
+            const { ok, lines, error } = ctx.stateDbIntegrity;
+            const { ratio: freelistRatio, error: freelistError } = ctx.stateDbFreelist;
+            if (!ok) {
+                const detail = error ?? lines.join("; ");
+                return {
+                    name: "state-db-integrity",
+                    kind: "deterministic",
+                    status: "fail",
+                    confidence: "high",
+                    message: `state.db failed PRAGMA quick_check: ${detail}. Repair: back up state.db, then run ` +
+                        `sqlite3 state.db ".dump" | sqlite3 state.new.db, verify state.new.db passes quick_check, and swap it in.`,
+                    evidence: { path: ctx.stateDbPath, lines, freelistRatio },
+                };
+            }
+            if (freelistError) {
+                return {
+                    name: "state-db-integrity",
+                    kind: "deterministic",
+                    status: "fail",
+                    confidence: "high",
+                    message: `state.db passed PRAGMA quick_check, but reading its freelist/page-count failed: ${freelistError}.`,
+                    evidence: { path: ctx.stateDbPath, lines, freelistError },
+                };
+            }
+            const freelistWarn = freelistRatio > STATE_DB_FREELIST_WARN_RATIO;
+            return {
+                name: "state-db-integrity",
+                kind: "deterministic",
+                status: freelistWarn ? "warn" : "pass",
+                confidence: "high",
+                message: freelistWarn
+                    ? `state.db passed PRAGMA quick_check, but ${(freelistRatio * 100).toFixed(1)}% of its pages are free (reclaimable by VACUUM).`
+                    : "state.db passed PRAGMA quick_check.",
+                evidence: {
+                    path: ctx.stateDbPath,
+                    freelistCount: ctx.stateDbFreelist.freelistCount,
+                    pageCount: ctx.stateDbFreelist.pageCount,
+                    freelistRatio,
+                },
+            };
+        },
+    },
     {
         name: "state-db-migrations",
         channel: "hard",

package/dist/commands/health/improve-metrics.js

@@ -92,7 +92,6 @@ function createUnknownImproveMetrics() {
         autoAccept: { promoted: 0, validationFailed: 0 },
         reflectsWithErrorContext: 0,
         coverageGapCount: 0,
-        evalCasesWritten: 0,
         deadUrlCount: 0,
         deadUrlsChecked: 0,
         deadUrlsTotal: 0,
@@ -344,14 +343,13 @@ function applyDistillSkippedAggregate(metrics, result) {
         }
     }
 }
-/** autoAccept + the small envelope-level counters (reflectsWithErrorContext, coverageGaps, evalCasesWritten, deadUrls). */
+/** autoAccept + the small envelope-level counters (reflectsWithErrorContext, coverageGaps, deadUrls). */
 function applyMiscCounters(metrics, result) {
     metrics.autoAccept.promoted += toFiniteNumber(result.gateAutoAcceptedCount);
     metrics.autoAccept.validationFailed += toFiniteNumber(result.gateAutoAcceptFailedCount);
     metrics.reflectsWithErrorContext += toFiniteNumber(result.reflectsWithErrorContext);
     if (Array.isArray(result.coverageGaps))
         metrics.coverageGapCount += result.coverageGaps.length;
-    metrics.evalCasesWritten += toFiniteNumber(result.evalCasesWritten);
     if (Array.isArray(result.deadUrls))
         metrics.deadUrlCount += result.deadUrls.length;
     const deadUrlCoverage = result.deadUrlCoverage;
@@ -593,7 +591,6 @@ function mergeImproveMetrics(dst, src) {
     dst.autoAccept.validationFailed += src.autoAccept.validationFailed;
     dst.reflectsWithErrorContext += src.reflectsWithErrorContext;
     dst.coverageGapCount += src.coverageGapCount;
-    dst.evalCasesWritten += src.evalCasesWritten;
     dst.deadUrlCount += src.deadUrlCount;
     dst.deadUrlsChecked += src.deadUrlsChecked;
     dst.deadUrlsTotal += src.deadUrlsTotal;
@@ -801,7 +798,6 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
         memoryInference: perRow.memoryInference,
         graphExtraction: perRow.graphExtraction,
         reflectsWithErrorContext: perRow.reflectsWithErrorContext,
-        evalCasesWritten: perRow.evalCasesWritten,
         orphansPurged,
         lintFixed,
         lintFlagged,

package/dist/commands/health/report-view-model.js

@@ -113,7 +113,6 @@ function reshapeRun(r) {
         lintFixed: r.lintFixed,
         reflectsWithErrorContext: r.reflectsWithErrorContext,
         orphansPurged: r.orphansPurged,
-        evalCasesWritten: r.evalCasesWritten,
     };
 }
 function compareRuns(a, b) {

package/dist/commands/health.js

@@ -18,6 +18,7 @@ import { countImproveRunsSince } from "../storage/repositories/improve-runs-repo
 import { closeDatabase, openReadonlyExistingDatabase } from "../storage/repositories/index-connection.js";
 import { getAllEntries } from "../storage/repositories/index-entries-repository.js";
 import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
+import { getStateDbFreelistInfo, runStateDbQuickCheck } from "../storage/state-db-integrity.js";
 import { pkgVersion } from "../version.js";
 import { collectImproveAdvisories } from "./health/advisories.js";
 import { HEALTH_CHECKS, probeActiveImproveStrategy, runHealthEngineProbes, runPendingStateMigrationsCheck, SESSION_EXTRACTION_LEDGER_WINDOW_DAYS, } from "./health/checks.js";
@@ -124,6 +125,11 @@ function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
     const requiredTables = ["events", "proposals", "schema_migrations", "task_history"];
     const missingTables = requiredTables.filter((name) => !tableNames.includes(name));
     const probe = probeStateDbRoundTrip(stateDbPath);
+    // R0: read-only, independent of the round-trip probe above — quick_check
+    // catches corruption a successful append/read cannot (out-of-order rowids,
+    // bad index entry counts), and the freelist reading is purely informational.
+    const stateDbIntegrity = runStateDbQuickCheck(stateDbPath);
+    const stateDbFreelist = getStateDbFreelistInfo(stateDbPath);
     const taskRows = queryTaskHistory(db, { since });
     const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
@@ -145,6 +151,8 @@ function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
         tableNames,
         missingTables,
         probe,
+        stateDbIntegrity,
+        stateDbFreelist,
         taskRowCount: taskRows.length,
         taskRowsWithLogsCount: taskRowsWithLogs.length,
         existingLogRowsCount: existingLogRows.length,
@@ -580,6 +588,8 @@ export async function akmHealth(options = {}) {
             tableNames,
             missingTables,
             probe,
+            stateDbIntegrity: taskHistory.stateDbIntegrity,
+            stateDbFreelist: taskHistory.stateDbFreelist,
             taskRowCount: taskHistory.taskRowCount,
             taskFailRate: taskHistory.taskFailRate,
             taskRowsWithLogsCount: taskHistory.taskRowsWithLogsCount,

package/dist/commands/improve/consolidate/chunking.js

@@ -6,7 +6,7 @@
 // no orchestrator coupling.
 import fs from "node:fs";
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
-import { cacheHash } from "../content-hash.js";
+import { cacheHash, stripFrontmatterBody } from "../content-hash.js";
 /**
  * Conservative chars-per-token estimate used when computing prompt budgets.
  * English text averages roughly 4 chars/token for most LLM tokenizers. We use
@@ -66,25 +66,19 @@ export function computeSafeChunkSize(contextLength, bodyTruncation, maxChunkSize
 /**
  * Build the per-chunk user prompt fed to the consolidate LLM.
  *
- * Each memory is annotated with two flags that drive the system-prompt
- * rules at lines 181-186:
- *   - `(captureMode: hot)` — user-explicit memory; system prompt rule 2
- *     forbids proposing delete. ~60 wasted LLM verdicts/4h on this user's
- *     stack before this annotation.
+ * Each memory is annotated with two flags:
+ *   - `(captureMode: hot)` — user-explicit memory, surfaced to the model as
+ *     provenance context.
  *   - `(already queued)` — the memory's body hash matches a pending
- *     consolidate proposal; system prompt rule 3 forbids proposing
- *     promote/merge/contradict. ~107/4h before this annotation.
+ *     consolidate proposal; the system prompt's PROMOTE rule forbids
+ *     proposing promote for these. ~107/4h before this annotation.
  *
  * Both annotations are visible to the LLM. `pendingProposalBodyHashes`
  * is precomputed once per run by `loadPendingConsolidateProposalHashes`
  * so the cost stays O(memories) inside the chunk loop.
  */
-export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks, bodyTruncation, pendingProposalBodyHashes = new Set(), standardsContext = "") {
-    const start = memories[0] ? `memories/${memories[0].name}` : "";
-    const lastMemory = memories[memories.length - 1];
-    const end = lastMemory ? `memories/${lastMemory.name}` : "";
+export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks, bodyTruncation, pendingProposalBodyHashes = new Set()) {
     const annotationsByIndex = [];
-    const hotRefs = [];
     for (const m of memories) {
         let body = "";
         try {
@@ -93,41 +87,31 @@ export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks,
         catch {
             body = "(unreadable)";
         }
+        // Hot/queued detection stays on the raw body — frontmatter is exactly
+        // what parseFrontmatter and the pending-proposal hash domain need.
         const parsed = parseFrontmatter(body);
         const isHot = parsed.data.captureMode === "hot";
         // Use cacheHash (case-preserving stripped body) to match the domain used
         // by loadPendingConsolidateProposalHashes and the body-embedding cache.
         const bodyHash = cacheHash(body);
         const isAlreadyQueued = pendingProposalBodyHashes.has(bodyHash);
-        annotationsByIndex.push({ isHot, isAlreadyQueued, body });
-        if (isHot)
-            hotRefs.push(`memories/${m.name}`);
+        // The excerpt shown to the LLM is the body ONLY — frontmatter can run
+        // longer than bodyTruncation (~21% of memories), which used to leave the
+        // model judging metadata instead of content. stripFrontmatterBody falls
+        // back to raw.trim() on unparseable/absent frontmatter, so this is a
+        // no-op for the "(unreadable)" placeholder.
+        const excerpt = stripFrontmatterBody(body);
+        annotationsByIndex.push({ isHot, isAlreadyQueued, excerpt });
     }
     const lines = [
         `Source: ${sourceName}`,
-        `Chunk ${chunkIndex + 1} of ${totalChunks}, memories ${start}–${end}:`,
+        `Chunk ${chunkIndex + 1} of ${totalChunks} (${memories.length} memories):`,
         "",
     ];
-    if (standardsContext.trim()) {
-        lines.push("Standards to follow (the rulebook for this target):");
-        lines.push(standardsContext.trim());
-        lines.push("");
-    }
-    // Top-of-prompt protection block for hot refs. Neutral phrasing — avoid
-    // op-words like "promote", "merge", "contradict" so the model doesn't
-    // accidentally treat the warning as a hint to use that op elsewhere
-    // (variant B leaked the word "contradict" into the control sample
-    // during the diagnostic).
-    if (hotRefs.length > 0) {
-        lines.push("⛔ DO NOT propose any `delete` operation for these refs — they are user-explicit (captureMode: hot) and the downstream guard refuses them regardless. Proposing delete for any of these only wastes tokens.");
-        for (const ref of hotRefs)
-            lines.push(`  - ${ref}`);
-        lines.push("");
-    }
     for (let i = 0; i < memories.length; i++) {
         const m = memories[i];
         // `annotationsByIndex` has exactly one entry per memory (built in the loop above).
-        const { isHot, isAlreadyQueued, body } = annotationsByIndex[i];
+        const { isHot, isAlreadyQueued, excerpt } = annotationsByIndex[i];
         const annotations = [];
         if (isHot)
             annotations.push("captureMode: hot");
@@ -138,7 +122,7 @@ export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks,
         lines.push(`Description: ${m.description || "(none)"}`);
         lines.push(`Tags: ${m.tags.length > 0 ? m.tags.join(", ") : "(none)"}`);
         lines.push("---");
-        lines.push(body.slice(0, bodyTruncation));
+        lines.push(excerpt.slice(0, bodyTruncation));
         lines.push("");
     }
     return lines.join("\n");

package/dist/commands/improve/consolidate/merge.js

@@ -1,22 +1,19 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+// R12a: merge/delete/contradict are no longer requested (see
+// CONSOLIDATE_PLAN_JSON_SCHEMA / consolidate-system.md) — only promote is
+// ever executed. An op of one of those retired shapes — e.g. from a model
+// that ignores the schema — is rejected here so it degrades to the generic
+// "skipping invalid operation" warning in the chunk-judge loop rather than
+// being treated as an actionable (if advisory) plan entry.
 export function isValidOp(op) {
     if (typeof op !== "object" || op === null)
         return false;
     const o = op;
-    if (o.op === "merge") {
-        return typeof o.primary === "string" && Array.isArray(o.secondaries);
-    }
-    if (o.op === "delete") {
-        return typeof o.ref === "string";
-    }
     if (o.op === "promote") {
         return typeof o.ref === "string" && typeof o.knowledgeRef === "string";
     }
-    if (o.op === "contradict") {
-        return typeof o.ref === "string" && typeof o.contradictedByRef === "string";
-    }
     return false;
 }
 export function mergePlans(chunks, knownRefs) {

package/dist/commands/improve/consolidate.js

@@ -11,7 +11,6 @@ import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { conceptIdFromTypeName, displayRef, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
-import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { openStateDatabase } from "../../core/state-db.js";
 import { parseSinceToIsoLenient } from "../../core/time.js";
 import { warn, warnVerbose } from "../../core/warn.js";
@@ -48,15 +47,18 @@ const CONSOLIDATE_SYSTEM_PROMPT = consolidateSystemPrompt;
 /**
  * JSON Schema for structured consolidate plans (PR 1 of the asset-writers
  * decision — see knowledge/projects/akm/asset-writers-investigation/00-synthesis).
- * Mirrors the {ops[], warnings?[]} shape currently described in
- * CONSOLIDATE_SYSTEM_PROMPT. Providers with `supportsJsonSchema: true` enforce
- * the shape upstream so the chunk-level "invalid plan from AI — skipping"
- * branch in `runConsolidate` becomes unreachable on schema-honouring providers.
+ * Mirrors the {ops[]} shape currently described in CONSOLIDATE_SYSTEM_PROMPT.
+ * Providers with `supportsJsonSchema: true` enforce the shape upstream so the
+ * chunk-level "invalid plan from AI — skipping" branch in `runConsolidate`
+ * becomes unreachable on schema-honouring providers.
  *
- * The four operation variants (merge / delete / promote / contradict) are
- * modeled as a oneOf so a structured-output provider can still tell them apart
- * by the required `op` discriminator. `parseEmbeddedJsonResponse` keeps
- * working as a fallback parser for providers that ignore the schema.
+ * Promote-only (R12a): `merge`/`delete`/`contradict` were advisory-only — the
+ * apply loop only ever executed `promote` — and cost 21-30k completion tokens
+ * per run for output nothing acted on. `warnings` is dropped for the same
+ * reason. `parseEmbeddedJsonResponse` keeps working as a fallback parser for
+ * providers that ignore the schema; `isValidOp` rejects any op shape other
+ * than `promote` so a non-compliant response degrades to a skipped-op warning
+ * rather than being treated as an actionable plan.
  */
 export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
     type: "object",
@@ -65,70 +67,21 @@ export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
     properties: {
         operations: {
             type: "array",
-            description: "Ordered list of consolidate operations the planner proposes.",
+            description: "Ordered list of promote operations the planner proposes.",
             items: {
-                oneOf: [
-                    {
-                        type: "object",
-                        required: ["op", "primary", "secondaries", "mergeStrategy"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["merge"] },
-                            primary: { type: "string", minLength: 1 },
-                            secondaries: {
-                                type: "array",
-                                minItems: 1,
-                                maxItems: 1,
-                                items: { type: "string", minLength: 1 },
-                            },
-                            mergeStrategy: { type: "string", minLength: 1 },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                    {
-                        type: "object",
-                        required: ["op", "ref", "reason"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["delete"] },
-                            ref: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                    {
-                        type: "object",
-                        required: ["op", "ref", "knowledgeRef", "reason"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["promote"] },
-                            ref: { type: "string", minLength: 1 },
-                            knowledgeRef: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                            description: { type: "string" },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                    {
-                        type: "object",
-                        required: ["op", "ref", "contradictedByRef", "reason"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["contradict"] },
-                            ref: { type: "string", minLength: 1 },
-                            contradictedByRef: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                ],
+                type: "object",
+                required: ["op", "ref", "knowledgeRef", "reason"],
+                additionalProperties: false,
+                properties: {
+                    op: { type: "string", enum: ["promote"] },
+                    ref: { type: "string", minLength: 1 },
+                    knowledgeRef: { type: "string", minLength: 1 },
+                    reason: { type: "string", minLength: 1, maxLength: 200 },
+                    description: { type: "string" },
+                    confidence: { type: "number", minimum: 0, maximum: 1 },
+                },
             },
         },
-        warnings: {
-            type: "array",
-            description: "Optional list of human-readable concerns the planner wants to surface.",
-            items: { type: "string" },
-        },
     },
 };
 async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
@@ -574,7 +527,7 @@ function resolveConsolidationSourceOwner(opts, stashDir) {
  * Read and narrow the exact pool the live pass consumes, without embedding,
  * LLM, proposal, event, or asset writes. Used by both preview and execution.
  */
-export function inspectConsolidationPool(opts, stashDir, warnings, access) {
+export function inspectConsolidationPool(opts, stashDir, warnings, existingKnowledgeBodyHashes = new Set(), access) {
     const readOnly = access?.readOnly === true;
     const sourceOwner = resolveConsolidationSourceOwner(opts, stashDir);
     let memories = loadMemoriesForSource(sourceOwner, warnings, readOnly);
@@ -591,6 +544,13 @@ export function inspectConsolidationPool(opts, stashDir, warnings, access) {
     if (opts.limit === undefined && memories.length > 150) {
         warnings.push(`Consolidation: pool has ${memories.length} memories and no limit is set. Consider adding a limit to your consolidate config to prevent timeouts on slow LLM endpoints.`);
     }
+    // Drop already-promoted memories before the limit cap selects its window,
+    // so the cap picks from memories the run can actually act on (R2-1: with
+    // the pre-filter applied afterward, the cap's oldest-modified-first window
+    // was drawn from the unfiltered pool, re-selecting and re-dropping the same
+    // permanently-undeletable duplicates on every run).
+    const { memories: prefiltered, prefilteredAlreadyPromoted } = prefilterAlreadyPromotedMemories(memories, existingKnowledgeBodyHashes);
+    memories = prefiltered;
     if (opts.limit !== undefined && memories.length > opts.limit) {
         const mtimeOf = (memory) => {
             try {
@@ -605,18 +565,60 @@ export function inspectConsolidationPool(opts, stashDir, warnings, access) {
         warnings.push(`Consolidation: pool capped at ${opts.limit} of ${memories.length} memories (limit option, oldest-modified first).`);
         memories = memories.slice(0, opts.limit);
     }
-    return { poolSize, candidatePoolSize: memories.length, dedupPoolSize, memories };
+    return { poolSize, candidatePoolSize: memories.length, dedupPoolSize, memories, prefilteredAlreadyPromoted };
+}
+/**
+ * Drop memories whose body already exists verbatim in `knowledge/` before any
+ * chunking or LLM work. Hashes the raw file with `cacheHash` (case-preserving
+ * stripped body), the same way `loadExistingKnowledgeBodyHashes` built
+ * `existingKnowledgeBodyHashes` — so the two sides of the comparison are
+ * computed identically. (H1: the post-LLM check, `shouldSkipPromotionBody-
+ * Duplicate`, used to hash `cacheHash(parseFrontmatter(memoryContent).content
+ * .trim())` — double-stripping frontmatter and diverging from this pre-filter
+ * for a memory body starting with its own `---` block. It now hashes
+ * `cacheHash(memoryContent)` directly, matching this single-strip domain.)
+ * An unreadable memory is kept (fail-safe: let the later passes surface the
+ * read error).
+ */
+function prefilterAlreadyPromotedMemories(memories, existingKnowledgeBodyHashes) {
+    if (existingKnowledgeBodyHashes.size === 0)
+        return { memories, prefilteredAlreadyPromoted: 0 };
+    const kept = [];
+    let prefilteredAlreadyPromoted = 0;
+    for (const memory of memories) {
+        let raw;
+        try {
+            raw = fs.readFileSync(memory.filePath, "utf8");
+        }
+        catch {
+            kept.push(memory);
+            continue;
+        }
+        if (existingKnowledgeBodyHashes.has(cacheHash(raw))) {
+            prefilteredAlreadyPromoted++;
+        }
+        else {
+            kept.push(memory);
+        }
+    }
+    return { memories: kept, prefilteredAlreadyPromoted };
 }
 /**
  * Pass 1 — narrow the memory pool before any LLM work: drop stale DB entries,
- * apply incremental-since narrowing, and cap to `opts.limit` (oldest-modified
- * first). Returns an early envelope when the pool empties at any stage;
- * otherwise returns the narrowed pool and the state the plan/apply passes
- * consume. Behavior-identical to the former inlined narrowing block.
+ * apply incremental-since narrowing, pre-filter memories already promoted
+ * verbatim into `knowledge/` (R5 (b) — discovered previously only after the
+ * LLM chunk call, paying for the judgement on ~84% of the pool just to skip
+ * it), and cap to `opts.limit` (oldest-modified first, drawn from the
+ * pre-filtered pool — R2-1). Returns an early envelope when the pool empties
+ * at any stage; otherwise returns the narrowed pool and the state the
+ * plan/apply passes consume.
  */
-async function narrowConsolidationPool(opts, stashDir, startMs, warnings) {
-    const snapshot = inspectConsolidationPool(opts, stashDir, warnings);
-    const memories = snapshot.memories;
+async function narrowConsolidationPool(opts, stashDir, startMs, warnings, existingKnowledgeBodyHashes) {
+    const snapshot = inspectConsolidationPool(opts, stashDir, warnings, existingKnowledgeBodyHashes);
+    const { memories, prefilteredAlreadyPromoted } = snapshot;
+    if (prefilteredAlreadyPromoted > 0) {
+        warnings.push(`Consolidation: pre-filtered ${prefilteredAlreadyPromoted} memor${prefilteredAlreadyPromoted === 1 ? "y" : "ies"} whose body already exists verbatim in knowledge/ before chunking.`);
+    }
     // (The former WS-3b Step 0a homeostatic demotion pass was removed — R4:
     // it was default-off and self-undoing (the next salience recompute
     // unconditionally overwrote the demoted values). Continuous decay now lives
@@ -629,10 +631,11 @@ async function narrowConsolidationPool(opts, stashDir, startMs, warnings) {
                 target: opts.target ?? stashDir,
                 warnings,
                 durationMs: Date.now() - startMs,
+                prefilteredAlreadyPromoted,
             }),
         };
     }
-    return { done: false, memories, dedupPoolSize: snapshot.dedupPoolSize };
+    return { done: false, memories, dedupPoolSize: snapshot.dedupPoolSize, prefilteredAlreadyPromoted };
 }
 /**
  * Pass 2 — turn the narrowed pool into an executable plan. Sizes chunks to the
@@ -681,7 +684,7 @@ function recordChunkJudgedNoAction(chunk, ops, accounting) {
  * are byte-identical, and every counter-increment point is unmoved.
  */
 async function judgeConsolidationChunks(args) {
-    const { chunks, opts, config, llmRunner, lease, sourceName, bodyTruncation, pendingProposalBodyHashes, standardsContext, warnings, accounting, } = args;
+    const { chunks, opts, config, llmRunner, lease, sourceName, bodyTruncation, pendingProposalBodyHashes, warnings, accounting, } = args;
     const chunkOpsArrays = [];
     // judgedNoAction tracks memories the LLM saw inside a chunk but proposed
     // no op for. Computed per chunk as `chunk.length − unique(targetRefs in ops)`.
@@ -748,7 +751,7 @@ async function judgeConsolidationChunks(args) {
             continue;
         }
         warn(`[consolidate] chunk ${chunkIdx + 1}/${chunks.length} (${chunk.length} memories) …`);
-        const userPrompt = buildChunkPrompt(sourceName, chunk, chunkIdx, chunks.length, bodyTruncation, pendingProposalBodyHashes, standardsContext);
+        const userPrompt = buildChunkPrompt(sourceName, chunk, chunkIdx, chunks.length, bodyTruncation, pendingProposalBodyHashes);
         // Single chunk LLM call, wrapped in the feature gate. Deduplicated across
         // the first attempt and the retry below (the two blocks were byte-identical
         // apart from their fallback error string). responseSchema lift (PR 1,
@@ -971,10 +974,6 @@ async function planConsolidation(opts, config, stashDir, _startMs, memories, war
         const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir);
         warn(`[consolidate] ${budgetedMemories.length} memories / ${chunks.length} chunk(s) / chunk_size=${chunkSize}` +
             ` / pending-proposal hashes: ${pendingProposalBodyHashes.size}`);
-        // Consolidate output merges memories (non-wiki) → stash authoring standards.
-        // Resolved ONCE per run and passed to each chunk prompt (facts not re-read
-        // per chunk).
-        const standardsContext = resolveStandardsContext("memories/_consolidated", stashDir);
         const chunkOpsArrays = await judgeConsolidationChunks({
             chunks,
             opts,
@@ -984,7 +983,6 @@ async function planConsolidation(opts, config, stashDir, _startMs, memories, war
             sourceName,
             bodyTruncation,
             pendingProposalBodyHashes,
-            standardsContext,
             warnings,
             accounting,
         });
@@ -1008,11 +1006,18 @@ async function planConsolidation(opts, config, stashDir, _startMs, memories, war
     }
 }
 async function akmConsolidateInner(opts, config, stashDir, startMs, warnings, sharedStateDb) {
+    // Loaded once and shared with the pre-filter (narrowConsolidationPool) and
+    // the post-LLM promote-dedup check (shouldSkipPromotionBodyDuplicate) below
+    // — knowledge/ can hold thousands of files, so walking it twice per run
+    // would double that cost for no benefit. When the caller already walked
+    // knowledge/ for the pool preview (runConsolidationPass, R2-1/R3-1), reuse
+    // that set instead of walking it again here.
+    const existingKnowledgeBodyHashes = opts.existingKnowledgeBodyHashes ?? loadExistingKnowledgeBodyHashes(stashDir);
     // -- Pass 1: narrow the memory pool (may early-return an envelope) ----------
-    const narrowed = await narrowConsolidationPool(opts, stashDir, startMs, warnings);
+    const narrowed = await narrowConsolidationPool(opts, stashDir, startMs, warnings, existingKnowledgeBodyHashes);
     if (narrowed.done)
         return narrowed.result;
-    const { memories, dedupPoolSize } = narrowed;
+    const { memories, dedupPoolSize, prefilteredAlreadyPromoted } = narrowed;
     // -- Pass 2: build the LLM plan (populates the shared accounting counters) ---
     const accounting = createConsolidateAccounting();
     const { allOps, totalChunks, llmPoolSize, deferredMemories, embedTelemetry, sourceName } = await planConsolidation(opts, config, stashDir, startMs, memories, warnings, sharedStateDb, accounting);
@@ -1035,6 +1040,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, warnings, sh
             planned: allOps,
             warnings,
             durationMs: Date.now() - startMs,
+            prefilteredAlreadyPromoted,
         });
     }
     warn(`[consolidate] plan: ${allOps.length} operation(s)`);
@@ -1052,7 +1058,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, warnings, sh
         memoryByRef,
         promoted,
         promotedSourceRefs: new Set(),
-        existingKnowledgeBodyHashes: loadExistingKnowledgeBodyHashes(opts.writeTarget.source.path),
+        existingKnowledgeBodyHashes,
         promotionFailures,
         warnings,
         pushSkipReason: accounting.pushSkipReason,
@@ -1077,6 +1083,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, warnings, sh
         planned: allOps,
         warnings,
         durationMs: Date.now() - startMs,
+        prefilteredAlreadyPromoted,
         perfTelemetry: {
             dedupPoolSize,
             llmPoolSize,
@@ -1203,7 +1210,13 @@ export async function emitPromotionProposal(op, ctx) {
     //       different knowledgeRef slug.
     // Use cacheHash (case-preserving stripped body) to match the canonical
     // hash domain used by the body-embedding cache and pending-proposal set.
-    const bodyHash = cacheHash(sourceBody);
+    // H1: hash `memoryContent` (one frontmatter strip, inside cacheHash)
+    // rather than the already-stripped `sourceBody` — hashing sourceBody here
+    // double-stripped (parseFrontmatter ran once above to produce sourceBody,
+    // then cacheHash's internal stripFrontmatterBody ran again), diverging from
+    // the single-strip domain `loadExistingKnowledgeBodyHashes` and the
+    // pre-filter use whenever a body starts with its own `---` block.
+    const bodyHash = cacheHash(memoryContent);
     if (shouldSkipPromotionBodyDuplicate({ bodyHash, op, knowledgeRef, ctx }))
         return;
     try {