akm-cli 0.9.0-beta.56 → 0.9.0-beta.58

package/dist/commands/improve/consolidate.js

@@ -10,12 +10,13 @@ import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { assembleAssetFromString, serializeFrontmatter } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { resolveStashDir, timestampForFilename } from "../../core/common.js";
-import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
+import { getDefaultLlmConfig, getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { ConfigError } from "../../core/errors.js";
 // Note: appendEvent import removed (WS-3a: archive TTL machinery retired)
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
 import { detectTruncatedDescription } from "../../core/text-truncation.js";
+import { DURATION_UNITS, parseDuration } from "../../core/time.js";
 import { createProposal, isProposalSkipped, listProposals } from "../proposal/repository.js";
 import { hasSupersededStatus, MERGE_ABSOLUTE_FLOOR_CHARS, MERGE_SHRINK_RATIO_MIN, validateProposalFrontmatter, } from "../proposal/validators/proposal-quality-validators.js";
 import { checkGenerationGuard, checkLexicalDiversity, checkMergeInformationFloor, computeMergedGeneration, readAssetGeneration, } from "./anti-collapse.js";
@@ -507,8 +508,8 @@ function archiveMemory(filePath, stashDir, ref, reason, opIndex, supersededBy, w
  * silent 400s from LM Studio). The investigation lives at
  * `/tmp/akm-health-investigations/consolidation-no-op.md`.
  */
-function resolveConsolidateLlmConfig(config) {
-    const consolidateProcess = config.profiles?.improve?.default?.processes?.consolidate;
+function resolveConsolidateLlmConfig(config, activeProfile) {
+    const consolidateProcess = getImproveProcessConfig(config, "consolidate", activeProfile);
     const runnerSpec = resolveImproveProcessRunnerFromProfile(consolidateProcess, config);
     if (runnerSpec && runnerIsLlm(runnerSpec)) {
         return runnerSpec.connection;
@@ -605,9 +606,49 @@ export async function akmConsolidate(opts = {}) {
         sharedStateDb?.close();
     }
 }
-// Inner implementation — all early-return paths are here; sharedStateDb is
-// closed by the outer finally in `akmConsolidate`.
-async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, warnings, sharedStateDb) {
+/** Fresh, zeroed accounting accumulators for one consolidate run. */
+function createConsolidateAccounting() {
+    const acc = {
+        judgedNoAction: 0,
+        failedChunkMemories: 0,
+        totalChunksFailed: 0,
+        skipReasons: [],
+        skipReasonByRef: new Map(),
+        judgedNoActionRefs: new Set(),
+        pushSkipReason: () => { },
+    };
+    acc.pushSkipReason = (op, ref, reason) => {
+        // 2026-05-27 cross-chunk double-count fix: if `ref` already contributed
+        // to judgedNoAction in its own chunk (a different chunk proposed an op
+        // for it that is now being rejected here), promote it from the
+        // judgedNoAction bucket into the more specific skipReason bucket.
+        // Preserves the invariant: processed == actioned + judgedNoAction +
+        // Σ(skipReasons) + failedChunkMemories.
+        if (acc.judgedNoActionRefs.delete(ref))
+            acc.judgedNoAction--;
+        const existing = acc.skipReasonByRef.get(ref);
+        if (existing) {
+            // Already counted once for accounting. Append the extra skip to the
+            // ref's grouped entry for observability without adding a new array
+            // entry (which would break the accounting invariant).
+            existing.skips.push({ op, reason });
+            return;
+        }
+        const entry = { ref, skips: [{ op, reason }] };
+        acc.skipReasonByRef.set(ref, entry);
+        acc.skipReasons.push(entry);
+    };
+    return acc;
+}
+/**
+ * Pass 1 — narrow the memory pool before any LLM work: drop stale DB entries,
+ * partition hot-probation assets, run the deterministic dedup pre-pass, apply
+ * incremental-since and judged-state-cache 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.
+ */
+async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings, sharedStateDb) {
     let memories = loadMemoriesForSource(opts.target, stashDir, warnings);
     // Pre-flight: filter out stale DB entries whose files no longer exist on
     // disk. Without this, memories deleted by a prior run (but not yet
@@ -632,7 +673,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
     // (the flag that causes extract to tag new extractions as hot-probation).
     // Without that flag no assets will ever carry the hot-probation marker, so
     // running the filter loop would be pure unnecessary I/O over the full corpus.
-    const hotProbationEnabled = config.profiles?.improve?.default?.processes?.extract?.hotProbation
+    const hotProbationEnabled = getImproveProcessConfig(config, "extract", opts.improveProfile)?.hotProbation
         ?.enabled === true;
     let hotProbationCount = 0;
     if (hotProbationEnabled) {
@@ -685,26 +726,32 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         }
     }
     if (memories.length === 0) {
-        return makeConsolidateResult({
-            dryRun: opts.dryRun ?? false,
-            target: opts.target ?? stashDir,
-            // #617: the deterministic dedup pre-pass may have emptied the pool by
-            // collapsing every remaining memory into a canonical. Surface those
-            // collapses in `deleted` so the run reports the work it actually did.
-            deleted: dedupCollapsed,
-            warnings,
-            durationMs: Date.now() - startMs,
-        });
-    }
-    if (opts.incrementalSince) {
-        memories = narrowToIncrementalCandidates(memories, opts.incrementalSince, warnings, opts.neighborsPerChanged);
-        if (memories.length === 0) {
-            return makeConsolidateResult({
+        return {
+            done: true,
+            result: makeConsolidateResult({
                 dryRun: opts.dryRun ?? false,
                 target: opts.target ?? stashDir,
+                // #617: the deterministic dedup pre-pass may have emptied the pool by
+                // collapsing every remaining memory into a canonical. Surface those
+                // collapses in `deleted` so the run reports the work it actually did.
+                deleted: dedupCollapsed,
                 warnings,
                 durationMs: Date.now() - startMs,
-            });
+            }),
+        };
+    }
+    if (opts.incrementalSince) {
+        memories = narrowToIncrementalCandidates(memories, opts.incrementalSince, warnings, opts.neighborsPerChanged);
+        if (memories.length === 0) {
+            return {
+                done: true,
+                result: makeConsolidateResult({
+                    dryRun: opts.dryRun ?? false,
+                    target: opts.target ?? stashDir,
+                    warnings,
+                    durationMs: Date.now() - startMs,
+                }),
+            };
         }
     }
     // WS-5 perf telemetry accumulators. These are collected throughout the run and
@@ -769,13 +816,16 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
             warnings.push(`Judged-state cache: skipped ${skipped} memor${skipped === 1 ? "y" : "ies"} judged-unchanged (no LLM); ${memories.length} remain for judging.`);
         }
         if (memories.length === 0) {
-            return makeConsolidateResult({
-                dryRun: opts.dryRun ?? false,
-                target: opts.target ?? stashDir,
-                deleted: dedupCollapsed,
-                warnings,
-                durationMs: Date.now() - startMs,
-            });
+            return {
+                done: true,
+                result: makeConsolidateResult({
+                    dryRun: opts.dryRun ?? false,
+                    target: opts.target ?? stashDir,
+                    deleted: dedupCollapsed,
+                    warnings,
+                    durationMs: Date.now() - startMs,
+                }),
+            };
         }
     }
     if (opts.limit === undefined && memories.length > 150) {
@@ -802,13 +852,25 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         warnings.push(`Consolidation: pool capped at ${opts.limit} of ${memories.length} memories (limit option, oldest-modified first).`);
         memories = memories.slice(0, opts.limit);
     }
+    return { done: false, memories, dedupCollapsed, perfMs, judgedCacheEnabled, currentHashByName };
+}
+/**
+ * Pass 2 — turn the narrowed pool into an executable plan. Sizes chunks to the
+ * model context window, clusters by embedding similarity, injects the
+ * anti-collapse random fraction, applies the cold-start budget cap, runs the
+ * per-chunk LLM calls (with retry + failure-rate abort), records judged-state
+ * cache outcomes, and reconciles the per-chunk op arrays via {@link mergePlans}.
+ * Populates `accounting` in place. Behavior-identical to the former inlined
+ * plan-generation block.
+ */
+async function planConsolidation(opts, config, stashDir, startMs, memories, warnings, sharedStateDb, judgedCacheEnabled, currentHashByName, accounting) {
     // Consolidation always uses the HTTP LLM client directly — never the agent
     // CLI. The agent CLI is for interactive agent sessions (reflect, propose);
     // structured JSON generation works better and faster via HTTP.
     //
     // Honor `profiles.improve.default.processes.consolidate.profile` first; fall
     // back to the default LLM. See {@link resolveConsolidateLlmConfig}.
-    const llmConfig = resolveConsolidateLlmConfig(config);
+    const llmConfig = resolveConsolidateLlmConfig(config, opts.improveProfile);
     const isHttpPath = !!llmConfig;
     // Chunk sizing: derive a safe chunk size from the configured model context
     // window so that the full prompt (system prompt + chunk user prompt) never
@@ -841,7 +903,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
     // DEFAULT ON since R5 — opt out via antiCollapse.enabled: false.
     let finalClusteredMemories = clusteredMemories;
     {
-        const antiCollapseForCluster = config.profiles?.improve?.default?.processes?.consolidate?.antiCollapse ?? {};
+        const antiCollapseForCluster = getImproveProcessConfig(config, "consolidate", opts.improveProfile)?.antiCollapse ?? {};
         if (antiCollapseForCluster.enabled !== false && clusteredMemories.length > 2) {
             const fraction = antiCollapseForCluster.randomClusterFraction ?? 0.05;
             const randomCount = Math.max(1, Math.floor(clusteredMemories.length * fraction));
@@ -932,41 +994,13 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
     // per chunk).
     const standardsContext = resolveStashStandards(stashDir);
     const chunkOpsArrays = [];
-    // Structured skip-reason histogram (2026-05-26): every deterministic
-    // post-LLM op rejection site below also calls `pushSkipReason` so the
-    // health rollup can aggregate without regex-parsing English warning
-    // strings. See `/tmp/akm-health-investigations/tuning-reasons-investigation.md` §Q2.
-    const skipReasons = [];
-    // Per-ref grouping of skipReasons entries. A ref occupies exactly one
-    // accounting bucket and therefore exactly one skipReasons array entry;
-    // subsequent skip ops for the same ref append to that entry's `skips[]`
-    // rather than pushing a second array entry (that would inflate
-    // Σ(skipReasons) and break the invariant by +1 per duplicate).
-    const skipReasonByRef = new Map();
-    const pushSkipReason = (op, ref, reason) => {
-        // 2026-05-27 cross-chunk double-count fix: if `ref` already contributed
-        // to judgedNoAction in its own chunk (a different chunk proposed an op
-        // for it that is now being rejected here), promote it from the
-        // judgedNoAction bucket into the more specific skipReason bucket.
-        // Preserves the invariant: processed == actioned + judgedNoAction +
-        // Σ(skipReasons) + failedChunkMemories.
-        if (judgedNoActionRefs.delete(ref))
-            judgedNoAction--;
-        const existing = skipReasonByRef.get(ref);
-        if (existing) {
-            // Already counted once for accounting. Append the extra skip to the
-            // ref's grouped entry for observability without adding a new array
-            // entry (which would break the accounting invariant).
-            existing.skips.push({ op, reason });
-            return;
-        }
-        const entry = { ref, skips: [{ op, reason }] };
-        skipReasonByRef.set(ref, entry);
-        skipReasons.push(entry);
-    };
     // judgedNoAction tracks memories the LLM saw inside a chunk but proposed
     // no op for. Computed per chunk as `chunk.length − unique(targetRefs in ops)`.
-    let judgedNoAction = 0;
+    // The structured skip-reason histogram (2026-05-26) plus the cross-chunk
+    // double-count fixes now live on `accounting`; every deterministic post-LLM
+    // op rejection site calls `accounting.pushSkipReason`. See
+    // `/tmp/akm-health-investigations/tuning-reasons-investigation.md` §Q2.
+    //
     // Judged-state cache (#581): coarse outcome per memory NAME the LLM actually
     // judged in a successfully-parsed chunk this run. "actioned" = an op targeted
     // it; "no_action" = the LLM saw it and proposed nothing. Populated only when
@@ -974,24 +1008,12 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
     // step is a no-op). Memories in failed/aborted chunks are NOT recorded, so a
     // transient LLM failure never poisons the cache into skipping them next run.
     const judgedOutcomeByName = new Map();
-    // 2026-05-27 cross-chunk double-count fix: refs that contributed to
-    // judgedNoAction in their own chunk. When a different chunk's op references
-    // one of these as a secondary and that op later fails, the ref would land
-    // in BOTH judgedNoAction and skipReasons (delta +1 per occurrence). Track
-    // the set so the merge-failure path can decrement and re-bucket.
-    const judgedNoActionRefs = new Set();
-    // 2026-05-26 accounting-leak fix: memories that belong to a chunk whose
-    // LLM call failed before any per-chunk noAction calculation runs. They
-    // would otherwise vanish from the envelope's accounting (no judgedNoAction
-    // bump, no skipReasons entry, no actioned counter).
-    let failedChunkMemories = 0;
     // C-6 / #392: Replace two-consecutive-failures abort with failure-rate threshold.
     // Consecutive-count policies are brittle against transient LM Studio reloads:
     // two transient failures abort the run even though the next chunk would succeed.
     // Rate-based abort (≥50% failure over ≥4 chunks) is more robust.
     // Tanenbaum, Distributed Systems §8 — rate-based policies with minimum sample sizes.
     let totalChunksProcessed = 0;
-    let totalChunksFailed = 0;
     const ABORT_MIN_CHUNKS = 4;
     const ABORT_FAILURE_RATE = 0.5;
     for (let chunkIdx = 0; chunkIdx < chunks.length; chunkIdx++) {
@@ -1004,13 +1026,13 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
             warnings.push(msg);
             // Account for memories in unprocessed chunks.
             for (let i = chunkIdx; i < chunks.length; i++) {
-                failedChunkMemories += chunks[i].length;
+                accounting.failedChunkMemories += chunks[i].length;
             }
             break;
         }
         // Abort if failure rate >= 50% over at least 4 processed chunks.
         if (totalChunksProcessed >= ABORT_MIN_CHUNKS) {
-            const failureRate = totalChunksFailed / totalChunksProcessed;
+            const failureRate = accounting.totalChunksFailed / totalChunksProcessed;
             if (failureRate >= ABORT_FAILURE_RATE) {
                 const skipped = chunks.length - chunkIdx;
                 const abortMsg = `Consolidation aborted — failure rate ${(failureRate * 100).toFixed(0)}% over ${totalChunksProcessed} chunks (>= ${ABORT_FAILURE_RATE * 100}% threshold). LLM may be unavailable. ${skipped} chunk(s) skipped.`;
@@ -1021,7 +1043,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
                 // rejected). Without this, the accounting invariant fails by
                 // `Σ(unattempted_chunk.length)` whenever the abort fires.
                 for (let i = chunkIdx; i < chunks.length; i++) {
-                    failedChunkMemories += chunks[i].length;
+                    accounting.failedChunkMemories += chunks[i].length;
                 }
                 break;
             }
@@ -1039,8 +1061,8 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         // LLM-failure-rate abort policy — no request was attempted.
         if (chunk.length > 0 && chunk.every((m) => isHotCapturedMemory(m.filePath))) {
             for (const m of chunk)
-                judgedNoActionRefs.add(`memory:${m.name}`);
-            judgedNoAction += chunk.length;
+                accounting.judgedNoActionRefs.add(`memory:${m.name}`);
+            accounting.judgedNoAction += chunk.length;
             warn(`[consolidate] chunk ${chunkIdx + 1}/${chunks.length}: all ${chunk.length} memories are captureMode: hot — skipping LLM (judged no-action).`);
             continue;
         }
@@ -1077,12 +1099,12 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
                 warn(retry.error ?? `chunk ${chunkIdx + 1} failed after retry`);
                 warnings.push(retry.error ?? `chunk ${chunkIdx + 1} failed after retry`);
                 totalChunksProcessed++;
-                totalChunksFailed++;
+                accounting.totalChunksFailed++;
                 // Account for the chunk's memories under the failed-chunk bucket.
                 // judgedNoAction does NOT run on this path (it's after the success
                 // guards) so without this the accounting invariant breaks on every
                 // chunk-level transport/parse failure.
-                failedChunkMemories += chunk.length;
+                accounting.failedChunkMemories += chunk.length;
                 continue;
             }
             raw = retry;
@@ -1099,8 +1121,8 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
             warn(`Chunk ${chunkIdx + 1}: invalid plan from AI — skipping.${hint}`);
             warnings.push(`Chunk ${chunkIdx + 1}: invalid plan from AI — skipping.${hint}`);
             totalChunksProcessed++;
-            totalChunksFailed++;
-            failedChunkMemories += chunk.length;
+            accounting.totalChunksFailed++;
+            accounting.failedChunkMemories += chunk.length;
             continue;
         }
         totalChunksProcessed++; // success
@@ -1140,7 +1162,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
             const memRef = `memory:${m.name}`;
             if (!targetRefs.has(memRef)) {
                 chunkNoAction++;
-                judgedNoActionRefs.add(memRef);
+                accounting.judgedNoActionRefs.add(memRef);
                 // Judged-state cache (#581): the LLM saw this memory and proposed
                 // nothing → record judged-unchanged so the next run can skip it.
                 if (judgedCacheEnabled)
@@ -1151,7 +1173,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
                 judgedOutcomeByName.set(m.name, "actioned");
             }
         }
-        judgedNoAction += chunkNoAction;
+        accounting.judgedNoAction += chunkNoAction;
         chunkOpsArrays.push(ops);
     }
     // ── Judged-state cache recording (#581) ─────────────────────────────────────
@@ -1199,63 +1221,16 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
     const knownRefs = new Set(memories.map((m) => `memory:${m.name}`));
     const { ops: allOps, warnings: mergeWarnings } = mergePlans(chunkOpsArrays, knownRefs);
     warnings.push(...mergeWarnings);
-    // -- Dry-run: show AI plan without executing any writes --------------------
-    if (opts.dryRun) {
-        return makeConsolidateResult({
-            dryRun: true,
-            previewOnly: true,
-            target: sourceName,
-            processed: memories.length,
-            failedChunks: totalChunksFailed,
-            totalChunks: chunks.length,
-            judgedNoAction,
-            skipReasons,
-            // No merge has executed on the preview path — the per-secondary tally is
-            // provably still 0 here (it only increments in the op-execution loop).
-            mergedSecondaries: 0,
-            failedChunkMemories,
-            planned: allOps,
-            warnings,
-            durationMs: Date.now() - startMs,
-        });
-    }
-    warn(`[consolidate] plan: ${allOps.length} operation(s)`);
-    // -- HTTP path: warn about quality and confirm unless auto-accepted --------
-    if (isHttpPath) {
-        warnings.push("Running on HTTP path — plan generated from truncated memory excerpts; quality may vary.");
-        // Per-proposal confidence gating is handled by the caller (improve.ts)
-        // via runAutoAcceptGate after this function returns. The gate reads
-        // proposal.confidence (forwarded from op.confidence above) and applies
-        // a minimumThreshold floor of 95 for consolidate's destructive ops.
-        // Here we only gate the interactive-confirm path for manual/HTTP invocations.
-        if (opts.autoAccept === undefined && allOps.length > 0) {
-            const n = allOps.length;
-            // Non-interactive contexts (CI / test runners / piped stdin) must not
-            // block on an unanswerable prompt. Default to a non-destructive "no"
-            // so callers in those contexts get the same "aborted, preview only"
-            // shape they'd get from explicit user dismissal. AKM_NON_INTERACTIVE
-            // lets callers force this path even when stdin happens to be a TTY.
-            const nonInteractive = process.stdin.isTTY === false || process.env.AKM_NON_INTERACTIVE === "1";
-            const answer = nonInteractive ? false : await promptConfirm(`Apply ${n} operations? [y/N] `);
-            if (!answer) {
-                return makeConsolidateResult({
-                    previewOnly: true,
-                    target: sourceName,
-                    processed: memories.length,
-                    failedChunks: totalChunksFailed,
-                    totalChunks: chunks.length,
-                    judgedNoAction,
-                    skipReasons,
-                    // No merge executed on the abort path — mergedSecondaries is still 0.
-                    mergedSecondaries: 0,
-                    failedChunkMemories,
-                    planned: allOps,
-                    warnings: [...warnings, nonInteractive ? "Non-interactive context: skipped apply." : "Aborted by user."],
-                    durationMs: Date.now() - startMs,
-                });
-            }
-        }
-    }
+    return { allOps, totalChunks: chunks.length, llmPoolSize, embedTelemetry, isHttpPath, sourceName };
+}
+/**
+ * Pass 3 — execute the reconciled plan against the filesystem: resolve the
+ * write target, journal the batch, dispatch each op to its handler, then commit
+ * the batch at the boundary and clean up the journal. Mutates `accounting` via
+ * the op-handlers' `pushSkipReason`. Behavior-identical to the former inlined
+ * write block. Never invoked on the dry-run or aborted-confirm paths.
+ */
+async function applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, activeProfile) {
     // -- Phase B + writes -------------------------------------------------------
     const target = resolveWriteTarget(config);
     const timestamp = timestampForFilename();
@@ -1282,6 +1257,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
     }
     const opCtx = {
         config,
+        improveProfile: activeProfile,
         stashDir,
         sourceRun,
         target,
@@ -1291,7 +1267,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         promotedSourceRefs,
         warnings,
         counts,
-        pushSkipReason,
+        pushSkipReason: accounting.pushSkipReason,
     };
     // Thin dispatch over the op discriminator — each branch is now an isolated,
     // independently-testable handler that mutates `opCtx`.
@@ -1335,6 +1311,76 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         const totalChanged = merged + deleted + dedupCollapsed;
         warnings.push(`Changed ${totalChanged} file(s) this run. Recover any via git if needed (git history is the backstop).`);
     }
+    return { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted };
+}
+async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, warnings, sharedStateDb) {
+    // -- Pass 1: narrow the memory pool (may early-return an envelope) ----------
+    const narrowed = await narrowConsolidationPool(opts, config, stashDir, startMs, warnings, sharedStateDb);
+    if (narrowed.done)
+        return narrowed.result;
+    const { memories, dedupCollapsed, perfMs, judgedCacheEnabled, currentHashByName } = narrowed;
+    // -- Pass 2: build the LLM plan (populates the shared accounting counters) ---
+    const accounting = createConsolidateAccounting();
+    const { allOps, totalChunks, llmPoolSize, embedTelemetry, isHttpPath, sourceName } = await planConsolidation(opts, config, stashDir, startMs, memories, warnings, sharedStateDb, judgedCacheEnabled, currentHashByName, accounting);
+    // -- Dry-run: show AI plan without executing any writes --------------------
+    if (opts.dryRun) {
+        return makeConsolidateResult({
+            dryRun: true,
+            previewOnly: true,
+            target: sourceName,
+            processed: memories.length,
+            failedChunks: accounting.totalChunksFailed,
+            totalChunks,
+            judgedNoAction: accounting.judgedNoAction,
+            skipReasons: accounting.skipReasons,
+            // No merge has executed on the preview path — the per-secondary tally is
+            // provably still 0 here (it only increments in the op-execution loop).
+            mergedSecondaries: 0,
+            failedChunkMemories: accounting.failedChunkMemories,
+            planned: allOps,
+            warnings,
+            durationMs: Date.now() - startMs,
+        });
+    }
+    warn(`[consolidate] plan: ${allOps.length} operation(s)`);
+    // -- HTTP path: warn about quality and confirm unless auto-accepted --------
+    if (isHttpPath) {
+        warnings.push("Running on HTTP path — plan generated from truncated memory excerpts; quality may vary.");
+        // Per-proposal confidence gating is handled by the caller (improve.ts)
+        // via runAutoAcceptGate after this function returns. The gate reads
+        // proposal.confidence (forwarded from op.confidence above) and applies
+        // a minimumThreshold floor of 95 for consolidate's destructive ops.
+        // Here we only gate the interactive-confirm path for manual/HTTP invocations.
+        if (opts.autoAccept === undefined && allOps.length > 0) {
+            const n = allOps.length;
+            // Non-interactive contexts (CI / test runners / piped stdin) must not
+            // block on an unanswerable prompt. Default to a non-destructive "no"
+            // so callers in those contexts get the same "aborted, preview only"
+            // shape they'd get from explicit user dismissal. AKM_NON_INTERACTIVE
+            // lets callers force this path even when stdin happens to be a TTY.
+            const nonInteractive = process.stdin.isTTY === false || process.env.AKM_NON_INTERACTIVE === "1";
+            const answer = nonInteractive ? false : await promptConfirm(`Apply ${n} operations? [y/N] `);
+            if (!answer) {
+                return makeConsolidateResult({
+                    previewOnly: true,
+                    target: sourceName,
+                    processed: memories.length,
+                    failedChunks: accounting.totalChunksFailed,
+                    totalChunks,
+                    judgedNoAction: accounting.judgedNoAction,
+                    skipReasons: accounting.skipReasons,
+                    // No merge executed on the abort path — mergedSecondaries is still 0.
+                    mergedSecondaries: 0,
+                    failedChunkMemories: accounting.failedChunkMemories,
+                    planned: allOps,
+                    warnings: [...warnings, nonInteractive ? "Non-interactive context: skipped apply." : "Aborted by user."],
+                    durationMs: Date.now() - startMs,
+                });
+            }
+        }
+    }
+    // -- Pass 3: execute the plan against the filesystem ------------------------
+    const { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted } = await applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, opts.improveProfile);
     const runDurationMs = Date.now() - startMs;
     const budgetFraction = opts.runBudgetMs !== undefined && opts.runBudgetMs > 0 ? runDurationMs / opts.runBudgetMs : undefined;
     return {
@@ -1353,12 +1399,12 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         promoted,
         contradicted,
         mergeFloorViolations,
-        failedChunks: totalChunksFailed,
-        totalChunks: chunks.length,
-        judgedNoAction,
-        skipReasons,
+        failedChunks: accounting.totalChunksFailed,
+        totalChunks,
+        judgedNoAction: accounting.judgedNoAction,
+        skipReasons: accounting.skipReasons,
         mergedSecondaries,
-        failedChunkMemories,
+        failedChunkMemories: accounting.failedChunkMemories,
         warnings,
         durationMs: runDurationMs,
         perfTelemetry: {
@@ -1456,7 +1502,7 @@ export async function handleMergeOp(op, opIndex, ctx) {
         emitMergeFailureSkips("merge_read_failed");
         return;
     }
-    const mergeResult = await generateMergedContent(config, op.primary, primaryBody, op.secondaries, memoryByRef);
+    const mergeResult = await generateMergedContent(config, op.primary, primaryBody, op.secondaries, memoryByRef, ctx.improveProfile);
     if ("error" in mergeResult) {
         warnings.push(`Merge: ${mergeResult.error} for ${mergeResult.detail}.`);
         emitMergeFailureSkips(mergeResult.error);
@@ -1521,7 +1567,7 @@ export async function handleMergeOp(op, opIndex, ctx) {
     // to merge two assets both above generation N (default 2) — prevents the
     // pipeline from building ever-deeper LLM-merged trees that lose the
     // source fidelity of the original episodes.
-    const antiCollapseConfig = config.profiles?.improve?.default?.processes?.consolidate?.antiCollapse ?? {};
+    const antiCollapseConfig = getImproveProcessConfig(config, "consolidate", ctx.improveProfile)?.antiCollapse ?? {};
     if (antiCollapseConfig.enabled !== false) {
         const allParticipants = [op.primary, ...op.secondaries];
         // One read per participant: generation counter, stripped body (for the
@@ -1989,11 +2035,13 @@ async function checkPreEmitDedup(opts) {
  * doesn't match the pattern (assumed to already be an ISO timestamp).
  */
 function parseSinceToIso(since) {
-    const m = since.match(/^(\d+)(m|h|d)$/);
-    if (!m)
+    // Canonical CLI unit grammar: `m` = minutes, `M` = months (see core/time.ts
+    // DURATION_UNITS). Non-matching input is returned unchanged (assumed to
+    // already be an ISO timestamp).
+    const ms = parseDuration(since, DURATION_UNITS);
+    if (ms === null)
         return since;
-    const multiplier = { m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2]];
-    return new Date(Date.now() - parseInt(m[1], 10) * multiplier).toISOString();
+    return new Date(Date.now() - ms).toISOString();
 }
 export function narrowToIncrementalCandidates(memories, since, warnings, neighborsPerChanged = 5) {
     const sinceIso = parseSinceToIso(since);
@@ -2105,7 +2153,7 @@ function loadMemoriesForSource(source, stashDir, warnings) {
     }
     return memories;
 }
-async function generateMergedContent(config, primaryRef, primaryBody, secondaryRefs, memoryByRef) {
+async function generateMergedContent(config, primaryRef, primaryBody, secondaryRefs, memoryByRef, activeProfile) {
     // Only handle single-secondary merges per design (one call per merge op)
     const secRef = secondaryRefs[0];
     const secEntry = memoryByRef.get(secRef);
@@ -2149,7 +2197,7 @@ async function generateMergedContent(config, primaryRef, primaryBody, secondaryR
         .join("\n");
     // Use the same per-process profile resolution as the chunk-plan call above
     // so the merge generation step doesn't silently revert to the default LLM.
-    const llmConfig = resolveConsolidateLlmConfig(config);
+    const llmConfig = resolveConsolidateLlmConfig(config, activeProfile);
     const result = await tryLlmFeature("memory_consolidation", config, async () => {
         if (!llmConfig)
             return { ok: false, error: "No LLM configured for consolidation" };

package/dist/commands/improve/distill/promote-memory.js

@@ -152,9 +152,10 @@ export async function promoteMemoryToKnowledge(ctx) {
             }
             return writeQualityRejection(stash, inputRef, promotion.knowledgeRef, resolvedPromotionContent, judgeResult.score, judgeResult.reason, {}, ctx.eligibilitySource);
         }
-        // Normalize 1-5 judge score to [0, 1]. Score of -1 means pass-through
-        // (no LLM / timeout / parse failure) — leave confidence undefined so
-        // the auto-accept gate treats the proposal as unscored and skips it.
+        // Normalize 1-5 judge score to [0, 1]. Only a real passing verdict reaches
+        // here (07 P0-2: the judge now fails CLOSED on no-LLM / timeout / parse
+        // failure, so those return pass:false and early-return above). The score>0
+        // guard defensively leaves confidence undefined for any non-positive score.
         if (judgeResult.score > 0)
             knowledgeJudgeConfidence = judgeResult.score / 5;
     }

package/dist/commands/improve/distill/quality-gate.js

@@ -107,14 +107,17 @@ export function buildJudgePrompt(lessonContent, sourceContent, similarLessons) {
  * `profiles.improve.default.processes.distill.qualityGate.enabled` (and the
  * corresponding `.reflect.qualityGate.enabled` for proposals).
  *
- * Fail-open: returns `pass: true` on timeout, parse failure, or missing LLM.
+ * Fail-CLOSED (07 P0-2): returns `pass: false` (score -1) on timeout, parse
+ * failure, or missing LLM. Minted content that cannot be judged is rejected,
+ * not passed through — an unverifiable judge must never wave content into the
+ * stash. The rejection is `quality_rejected`, not `review_needed`.
  */
 export async function runLessonQualityJudge(config, lessonContent, sourceContent, chat, 
 /** D-4 / #390: top-3 similar existing lessons for dedup check. */
 similarLessons) {
     const llmConfig = getDefaultLlmConfig(config);
     if (!llmConfig) {
-        return { pass: true, score: -1, reason: "no LLM configured — passing through" };
+        return { pass: false, score: -1, reason: "no LLM configured — cannot judge, failing closed" };
     }
     const judgeLlmConfig = llmConfig.judgeModel ? { ...llmConfig, model: llmConfig.judgeModel } : llmConfig;
     const JUDGE_TIMEOUT_MS = 8_000;
@@ -128,7 +131,7 @@ similarLessons) {
         ]);
         const parsed = parseEmbeddedJsonResponse(raw);
         if (!parsed || typeof parsed.score !== "number") {
-            return { pass: true, score: -1, reason: "judge parse failed — passing through" };
+            return { pass: false, score: -1, reason: "judge parse failed — cannot judge, failing closed" };
         }
         // D-5 / #388: Three-band system (MT-Bench arXiv:2306.05685 — ~±0.5 judge variance).
         //   >= 3.5: auto-queue as pending (pass: true)
@@ -146,7 +149,7 @@ similarLessons) {
         return { pass: false, score, reason };
     }
     catch {
-        return { pass: true, score: -1, reason: "judge failed — passing through" };
+        return { pass: false, score: -1, reason: "judge timeout/error — cannot judge, failing closed" };
     }
 }
 // ── Quality-rejection helper ─────────────────────────────────────────────────