akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/commands/improve/loop-stages.js

@@ -23,6 +23,9 @@ import { purgeOldCycleMetrics } from "../../storage/repositories/canaries-reposi
 import { purgeOldEvents } from "../../storage/repositories/events-repository.js";
 import { purgeOldImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
 import { closeDatabase, openIndexDatabase } from "../../storage/repositories/index-connection.js";
+import { getEntryByRef } from "../../storage/repositories/index-entries-repository.js";
+import { clearAssetOutcomeMissing, countAssetOutcomeMissing, deleteAssetOutcomeMissingBefore, listAssetOutcomeMissingState, stampAssetOutcomeMissing, } from "../../storage/repositories/outcome-repository.js";
+import { clearAssetSalienceMissing, countAssetSalienceMissing, deleteAssetSalienceMissingBefore, listAssetSalienceMissingState, stampAssetSalienceMissing, } from "../../storage/repositories/salience-repository.js";
 import { expireStaleProposals, listProposals, purgeOrphanProposals } from "../proposal/repository.js";
 import { checkDeadUrls } from "../url-checker.js";
 import { DEFAULT_RETENTION_DAYS as CYCLE_METRICS_RETENTION_DAYS, runCollapseDetector } from "./collapse-detector.js";
@@ -34,7 +37,7 @@ import { writeEvalCase } from "./eval-cases.js";
 import { shouldSkipRef } from "./improve-strategies.js";
 import { recordNoOp, resetConsecutiveNoOps } from "./salience.js";
 import { errMessage, refSlug } from "./shared.js";
-import { durableImproveRef } from "./source-identity.js";
+import { bareImproveRef, durableImproveRef } from "./source-identity.js";
 // ── improve loop / post-loop / maintenance stages ───────────────────
 // The cycle stages run by akmImprove, extracted from improve.ts.
 /** O-5 / #378: rolling per-originator error-window cap. */
@@ -180,17 +183,17 @@ async function runLoopReflectPass(planned, isDistillOnly, env, tally) {
             const reflectProfileRunner = resolvedPlan.processes.reflect.runner;
             const reflectCallArgs = {
                 ref: planned.ref,
-                ...(options.sourceName ? { sourceName: options.sourceName } : {}),
-                ...(options.legacyBareState ? { legacyBareState: true } : {}),
-                // Chunk-5 flip F5f — carry the resolved item_ref so reflect keys its
-                // reflect_invoked event + source/distill_invoked reads on it (dormant
-                // until item_ref populates through the improve path).
+                // Carry the resolved item_ref so reflect uses the same durable key for
+                // events and state reads.
                 ...(planned.itemRef ? { itemRef: planned.itemRef } : {}),
                 task: options.task,
                 // Active strategy supplies non-engine process tuning.
                 ...(improveProfile ? { improveProfile } : {}),
                 config: options.config,
                 ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
+                ...(options.sourceName && primaryStashDir
+                    ? { target: { source: options.sourceName, root: primaryStashDir } }
+                    : {}),
                 ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
                 eventSource: "improve",
                 // #639 — resolve the low-value filter from the ACTIVE improve profile
@@ -271,11 +274,8 @@ async function runLoopReflectPass(planned, isDistillOnly, env, tally) {
             // A no_change reflect means the LLM was invoked but found nothing to
             // improve — the asset is stable. Track it. A successful reflect means
             // the asset changed; reset the counter so the dampener lifts.
-            // Chunk-5 flip F5e — key the plasticity counter by the SAME durable
-            // salience write key the preparation/distill salience writers use:
-            // item_ref when the planner resolved one, else the source-qualified
-            // `type:name`. A split key would strand consecutive_no_ops on a second row.
-            const plasticityKey = planned.itemRef ?? durableImproveRef(planned.ref, options.sourceName);
+            // Use the same item_ref-or-conceptId salience key as preparation/distill.
+            const plasticityKey = planned.itemRef ?? durableImproveRef(planned.ref);
             if (isNoChange && eventsCtx?.db) {
                 try {
                     recordNoOp(eventsCtx.db, plasticityKey);
@@ -430,11 +430,8 @@ async function invokeDistillAndRecord(planned, parsedPlannedRef, env, tally) {
     const { options, primaryStashDir, distillFn, eventsCtx, improveProfile, resolvedPlan, budgetSignal } = env;
     const distillResult = await withLlmStage("distill", () => distillFn({
         ref: planned.ref,
-        // Chunk-5 flip F5e — the resolved item_ref so distill keys its salience
-        // write by it (matching preparation), when the planner supplied one.
+        // Carry the resolved item_ref so distill matches preparation's state key.
         ...(planned.itemRef ? { itemRef: planned.itemRef } : {}),
-        ...(options.sourceName ? { sourceName: options.sourceName } : {}),
-        ...(options.legacyBareState ? { legacyBareState: true } : {}),
         ...(parsedPlannedRef.type === "memory" ? { proposalKind: "auto" } : {}),
         ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
         // Active profile so distill's per-process reads honor `--profile`.
@@ -461,9 +458,8 @@ async function invokeDistillAndRecord(planned, parsedPlannedRef, env, tally) {
     // quality gate — the asset is not yielding useful distill output.
     // queued: a proposal was produced; reset the no-op counter.
     if (eventsCtx?.db) {
-        // Chunk-5 flip F5e — same durable salience write key as the distill/
-        // preparation salience writers (item_ref, else source-qualified type:name).
-        const plasticityKey = planned.itemRef ?? durableImproveRef(planned.ref, options.sourceName);
+        // Use the same item_ref-or-conceptId key as the distill/preparation writers.
+        const plasticityKey = planned.itemRef ?? durableImproveRef(planned.ref);
         try {
             if (distillResult.outcome === "quality_rejected" || distillResult.outcome === "skipped") {
                 recordNoOp(eventsCtx.db, plasticityKey);
@@ -624,7 +620,6 @@ export async function runImprovePostLoopStage(args) {
             runId: options.runId ?? "improve-adhoc",
             ...(improveProfile ? { improveProfile } : {}),
             pass: "consolidate",
-            acceptedActions: args.acceptedActions ?? 0,
             mergeFloorViolations: args.consolidationMergeFloorViolations ?? 0,
             config: options.config ?? loadConfig(),
             ...(eventsCtx ? { eventsCtx } : {}),
@@ -744,6 +739,12 @@ async function runMaintenancePassesUnderLease(ctx, dbCell, args) {
         allWarnings.push(...graph.warnings);
         const orphan = runOrphanProposalPurgePass(ctx);
         allWarnings.push(...orphan.warnings);
+        // #733: orphan-state GC — stamps/clears/(optionally) collects
+        // asset_salience/asset_outcome rows whose ref no longer resolves in
+        // index.db. Needs the SAME already-open index.db handle (dbCell.current)
+        // the passes above share.
+        const stateGc = runOrphanStateGcPass(ctx, dbCell);
+        allWarnings.push(...stateGc.warnings);
         const expiration = runProposalExpirationPass(ctx);
         allWarnings.push(...expiration.warnings);
         allWarnings.push(...runRetentionPurgePass(ctx).warnings);
@@ -764,7 +765,7 @@ async function runMaintenancePassesUnderLease(ctx, dbCell, args) {
 }
 /**
  * Memory inference candidate-discovery (post-Item 9 fix from
- * memory:akm-improve-critical-review-2026-05-20). Previously this pass
+ * memories/akm-improve-critical-review-2026-05-20). Previously this pass
  * was gated on memoryRefsForInference.size > 0 AND passed those refs as a
  * candidateRefs filter. But memoryRefsForInference is populated from refs
  * distilled THIS RUN — by the time that happens, those parents are
@@ -1123,3 +1124,164 @@ export function runRetentionPurgePass(ctx) {
     }
     return { warnings };
 }
+// ── #733 — orphan-state GC pass (Workstream C) ──────────────────────────────
+//
+// Deliberately lean: one maintenance pass, one additive migration (021), one
+// event type (asset_state_gc), one config gate (improve.stateGc.collect,
+// default false). See docs/architecture/specs/0.9.0-close-out-plan.md
+// Workstream C for the full design rationale. No quarantine archive, no
+// circuit breaker, no health-advisory plumbing, no new tables.
+/**
+ * Grace window (ms) before an unresolved `asset_salience` / `asset_outcome`
+ * row becomes delete-eligible — only when `improve.stateGc.collect` is true.
+ * A named constant, not a config knob (owner ruling — see the close-out
+ * plan's Workstream C). Mirrors `TXN_SWEEP_GRACE_MS` (src/core/fs-txn.ts:298).
+ */
+export const STATE_GC_GRACE_MS = daysToMs(7);
+/**
+ * Resolve one state-table's stored `asset_ref` against the live index.
+ *
+ * "ref not present in entries.item_ref" is the authoritative-deletion
+ * predicate (see the pass doc comment below), so this is a thin wrapper
+ * around the same single-ref probe the rest of improve uses
+ * (`getEntryByRef`, index-entries-repository.ts) — which already resolves
+ * both storage spellings a write can produce (`salienceWriteKey`/
+ * `outcomeWriteKey` = `itemRef ?? ref`): an exact bundle-qualified item_ref,
+ * or a bare conceptId matched by suffix across all bundles.
+ *
+ * On top of that, falls back to the BARE conceptId form (`bareImproveRef` —
+ * the same primitive `preparation.ts`'s `normalizeStoredKey` map is built
+ * from via `improveStateReadRefs`) when the stored ref carries a bundle
+ * prefix that no longer matches exactly. This is the legacy-spelling
+ * normalization trap: a naive `asset_ref NOT IN (SELECT item_ref FROM
+ * entries)` would treat a live asset whose row predates bundle-qualification
+ * (or whose bundle prefix is stale) as an orphan and delete it. Preferring
+ * "never delete a live row" over "never miss a genuinely dead one" mirrors
+ * `getEntryByRef`'s own bare-conceptId suffix-match trade-off.
+ */
+function isStateRefLive(indexDb, storedRef) {
+    if (getEntryByRef(indexDb, storedRef) !== null)
+        return true;
+    const bare = bareImproveRef(storedRef);
+    return bare !== storedRef && getEntryByRef(indexDb, bare) !== null;
+}
+/**
+ * Sweep ONE state table: stamp refs that just went unresolved, clear refs
+ * that resolved again, and — only when `collect` is true — delete rows whose
+ * `missing_since` is older than {@link STATE_GC_GRACE_MS}. `pending` is a
+ * point-in-time snapshot taken AFTER stamp/clear/delete (re-queried, not
+ * accumulated), so it reflects the current backlog rather than this run's
+ * delta — "every run emits the counts either way, so live data accumulates
+ * proof" (close-out plan, Workstream C).
+ */
+function gcOneStateTable(args) {
+    const { refRows, indexDb, now, collect, stamp, clear, deleteOlderThan, countPending } = args;
+    const toStamp = [];
+    const toClear = [];
+    for (const row of refRows) {
+        const live = isStateRefLive(indexDb, row.asset_ref);
+        if (!live && row.missing_since == null)
+            toStamp.push(row.asset_ref);
+        else if (live && row.missing_since != null)
+            toClear.push(row.asset_ref);
+    }
+    if (toStamp.length > 0)
+        stamp(toStamp, now);
+    if (toClear.length > 0)
+        clear(toClear);
+    const collected = collect ? deleteOlderThan(now - STATE_GC_GRACE_MS) : 0;
+    const pending = countPending();
+    return { pending, collected };
+}
+/**
+ * Orphan-state GC — #733 (Workstream C). For each of the two per-asset state
+ * tables (`asset_salience`, `asset_outcome`), stamps `missing_since` on refs
+ * that no longer resolve against `entries.item_ref` in index.db, clears the
+ * stamp on refs that resolve again, and — only when `improve.stateGc.collect`
+ * is true — deletes rows whose stamp is older than {@link STATE_GC_GRACE_MS}.
+ *
+ * "ref not present in entries.item_ref" IS the authoritative-deletion
+ * predicate: "absent ≠ deleted" is inherited from the indexer, not
+ * re-implemented here — an incomplete or failed source scan preserves that
+ * source's last-known-good `entries` rows (indexer.ts ~1195-1199), and
+ * mass-wipe is already gated upstream (`preserveExistingIndex` +
+ * `fullDelete && scanComplete`). A temporarily unreachable source therefore
+ * never surfaces candidates; no separate scan-status tracking is needed.
+ *
+ * Runs under the SAME index-writer lease / borrowed-state.db-connection
+ * discipline as the neighboring maintenance passes: `dbCell.current` supplies
+ * the already-open index.db handle (#584), and state.db access goes through
+ * `withStateDb(..., { borrowed: eventsCtx?.db })` so this never opens a
+ * second live writer alongside a long-lived `eventsCtx.db` connection — see
+ * the #585 comment on {@link runRetentionPurgePass}'s events-purge call for
+ * why that matters ("database is locked").
+ *
+ * Exported for direct test coverage (tests/integration/commands/improve/
+ * state-gc.test.ts), mirroring the `runMemoryInferenceMaintenancePass` /
+ * `runGraphExtractionMaintenancePass` / `runRetentionPurgePass` precedent;
+ * production callers reach it only through `runMaintenancePassesUnderLease`.
+ */
+export function runOrphanStateGcPass(ctx, dbCell) {
+    const { eventsCtx, config } = ctx;
+    const warnings = [];
+    const indexDb = dbCell.current;
+    if (!indexDb) {
+        warnings.push("orphan state GC skipped: no index.db handle available");
+        return { pending: 0, collected: 0, warnings };
+    }
+    const collect = config.improve?.stateGc?.collect === true;
+    const now = Date.now();
+    let pending = 0;
+    let collected = 0;
+    try {
+        withStateDb((stateDb) => {
+            const salienceResult = gcOneStateTable({
+                refRows: listAssetSalienceMissingState(stateDb),
+                indexDb,
+                now,
+                collect,
+                stamp: (refs, ts) => stampAssetSalienceMissing(stateDb, refs, ts),
+                clear: (refs) => clearAssetSalienceMissing(stateDb, refs),
+                deleteOlderThan: (cutoffMs) => deleteAssetSalienceMissingBefore(stateDb, cutoffMs),
+                countPending: () => countAssetSalienceMissing(stateDb),
+            });
+            const outcomeResult = gcOneStateTable({
+                refRows: listAssetOutcomeMissingState(stateDb),
+                indexDb,
+                now,
+                collect,
+                stamp: (refs, ts) => stampAssetOutcomeMissing(stateDb, refs, ts),
+                clear: (refs) => clearAssetOutcomeMissing(stateDb, refs),
+                deleteOlderThan: (cutoffMs) => deleteAssetOutcomeMissingBefore(stateDb, cutoffMs),
+                countPending: () => countAssetOutcomeMissing(stateDb),
+            });
+            // Table-name-shaped keys ("salience"/"outcome", not the guarded
+            // "asset_salience"/"asset_outcome" table names) — this file sits
+            // outside src/storage/repositories/**, where the state-table-sql
+            // lint rule (#672) forbids naming those tables even in a log string
+            // or an object key, not just in raw SQL.
+            const byTable = { salience: salienceResult, outcome: outcomeResult };
+            pending = salienceResult.pending + outcomeResult.pending;
+            collected = salienceResult.collected + outcomeResult.collected;
+            if (pending > 0 || collected > 0) {
+                info(`[improve] orphan state GC: ${pending} pending, ${collected} collected ` +
+                    `(salience ${salienceResult.pending}/${salienceResult.collected}, ` +
+                    `outcome ${outcomeResult.pending}/${outcomeResult.collected})`);
+                // #733 — asset_state_gc reports the current per-table backlog
+                // snapshot (`pending`) plus this run's deletions (`collected`);
+                // emitted only when there is something to report (mirrors the
+                // rekey script's no-op-stays-silent precedent) so a perpetually
+                // clean stash never accumulates events.
+                appendEvent({
+                    eventType: "asset_state_gc",
+                    ref: "asset_state/_gc",
+                    metadata: { pending, collected, byTable },
+                }, eventsCtx);
+            }
+        }, { path: eventsCtx?.dbPath, borrowed: eventsCtx?.db });
+    }
+    catch (err) {
+        warnings.push(`orphan state GC failed: ${errMessage(err)}`);
+    }
+    return { pending, collected, warnings };
+}

package/dist/commands/improve/memory/derived-ref.js

@@ -9,10 +9,9 @@
  * (`memory-improve.ts`, keyed on the memory name) and the PRODUCER
  * (`memory-contradiction-detect.ts`, keyed on the file path). The producer's
  * copy was strictly narrower: it ignored `derivedFrom` entirely and matched
- * `source:` only via a raw `startsWith("memory:")` (so a whitespace- or
- * origin-prefixed `source:` fell through to the filename heuristic). That let
- * the producer and consumer disagree on a memory's parent — the exact defect
- * plan §6 calls out ("producer/consumer cannot disagree").
+ * `source:` through a separate parser. That let the producer and consumer
+ * disagree on a memory's parent — the exact defect plan §6 calls out
+ * ("producer/consumer cannot disagree").
  *
  * Both sides now share this one impl, keyed on the memory NAME (the stash-
  * relative path without the `.md` extension, e.g. `nested/foo.derived`). The
@@ -21,9 +20,8 @@
  * `tests/commands/improve/derived-ref.test.ts`:
  *   - `derivedFrom`-keyed families now resolve a parent (and so participate in
  *     contradiction detection); and
- *   - `source:` is normalised through `parseRefInput` (trim + origin) so a
- *     `source: " team//memory:parent "` resolves to `memory:parent` instead of
- *     silently degrading to the filename.
+ *   - `source:` is parsed through `parseRefInput` so current bundle-qualified
+ *     refs resolve consistently.
  *
  * Resolution order (source → derivedFrom → `.derived` suffix) matches the
  * consumer's prior behaviour exactly, so the consumer side is a pure move.
@@ -32,62 +30,66 @@ import { conceptIdFromTypeName, parseRefInput } from "../../../core/asset/resolv
 import { asNonEmptyString } from "../../../core/common.js";
 import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
 /**
- * Parse an arbitrary `source:`/edge string to the BARE memory name (no type
- * prefix), or `undefined` when it is empty, unparseable, or not a memory ref.
- * Trims whitespace and drops any origin/bundle prefix.
+ * Parse a belief edge (`supersededBy` / `contradictedBy` / `currentBeliefRefs`)
+ * to the bare memory name the identity channel keys on.
  *
- * READ tolerance is intentionally dual-grammar: the value may carry the legacy
- * `[origin//]memory:<name>` spelling (un-migrated stash content in the wild) OR
- * the 0.9.0 `[bundle//]memories/<name>` conceptId. Callers format the bare name
- * into whichever CHANNEL grammar they compare against:
- *   - the `derived_from` channel → `memories/<name>` conceptId (see
- *     {@link parseMemoryRef} / {@link resolveParentRef});
- *   - the belief-edge / identity channel → `memory:<name>` (memory-improve's
- *     `refArray`, compared against a derived memory's own `memory:<name>` ref,
- *     a separate legacy remnant Group-C item 2 does NOT touch).
+ * Accepts BOTH spellings, because both reach this function:
+ *   - `memory:<name>` — the internal identity spelling, and what belief edges
+ *     written before 0.9.0 carry on disk;
+ *   - `memories/<name>` / `<bundle>//memories/<name>` — the conceptId grammar
+ *     the current writers emit (`akm remember --supersedes` and `akm import
+ *     --supersedes` go through `writeSupersededEdge` with the write result's
+ *     `ref`, which is fully qualified).
+ *
+ * Accepting only the first spelling silently reduced every edge written by the
+ * current code path to nothing, so a superseded memory read back as active.
+ * Both normalize to the bare name; the caller re-mints the internal
+ * `memory:<name>` form via {@link memoryIdentityRef}, so there is still exactly
+ * one identity spelling downstream.
  */
 export function parseMemoryName(value) {
     if (!value)
         return undefined;
     const trimmed = value.trim();
+    const MEMORY_PREFIX = "memory:";
+    if (trimmed.startsWith(MEMORY_PREFIX)) {
+        const name = trimmed.slice(MEMORY_PREFIX.length);
+        return name.length > 0 ? name : undefined;
+    }
     try {
         const parsed = parseRefInput(trimmed);
-        return parsed.type === "memory" ? parsed.name : undefined;
+        return parsed.type === "memory" && parsed.name.length > 0 ? parsed.name : undefined;
     }
     catch {
-        // Legacy `[origin//]memory:<name>` — strip the origin, keep memory refs only.
-        const boundary = trimmed.indexOf("//");
-        const body = boundary >= 0 ? trimmed.slice(boundary + 2) : trimmed;
-        const MEMORY_PREFIX = "memory:";
-        return body.startsWith(MEMORY_PREFIX) ? body.slice(MEMORY_PREFIX.length) : undefined;
+        return undefined;
     }
 }
 /**
- * Normalise an arbitrary `source:` derived_from backref to the canonical 0.9.0
- * `memories/<name>` conceptId, or `undefined` when it is not a memory ref
- * (Group-C item 2 flip). Tolerant of BOTH grammars on input (see
- * {@link parseMemoryName}), but the NORMALISED OUTPUT is always the conceptId —
- * so every consumer that compares against the `derived_from` channel (the
- * parentRef filter, inference dedup, eligibility) speaks one grammar. The
- * content-migration folds the on-disk legacy spelling forward; this reader keeps
- * tolerating it until the 0.10.0 grammar removal.
+ * Parse a current `source:` backref and return its canonical memory conceptId,
+ * or `undefined` when it is empty, invalid, or not a memory ref.
  */
 export function parseMemoryRef(value) {
-    const name = parseMemoryName(value);
-    return name === undefined ? undefined : conceptIdFromTypeName("memory", name);
+    if (!value)
+        return undefined;
+    try {
+        const parsed = parseRefInput(value.trim());
+        return parsed.type === "memory" ? conceptIdFromTypeName("memory", parsed.name) : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 /**
  * Format a bare memory name into the belief-edge IDENTITY channel ref
  * `memory:<name>` — the ONE implementation of that spelling.
  *
- * DOCUMENTED EXCEPTION (ref-grammar decision D-R3): the belief-edge / identity
+ * Belief-edge / identity
  * channel (`contradictedBy` / `supersededBy` / `currentBeliefRefs`, and a derived
- * memory's own `record.ref`) deliberately stays in `memory:<name>` grammar — it
- * is compared against a derived memory's own identity ref, a channel DECOUPLED
- * from the `derived_from` record refs that Group-C item 2 flipped to
- * `memories/<name>`. Both `memory-improve.ts` (`refArray`) and
+ * memory's own `record.ref`) uses `memory:<name>` and is compared against a
+ * derived memory's identity ref. This channel is separate from `source:` asset
+ * refs, which use `memories/<name>`. Both `memory-improve.ts` (`refArray`) and
  * `memory-contradiction-detect.ts` (`toMemoryRef`) emit through here so the
- * exception has exactly one home instead of three hand-rolled copies.
+ * identity spelling has one implementation.
  */
 export function memoryIdentityRef(name) {
     return `memory:${name}`;
@@ -101,8 +103,8 @@ export function isDerivedMemory(name, frontmatter) {
     return frontmatter.inferred === true || name.endsWith(DERIVED_SUFFIX);
 }
 /**
- * Resolve the parent (source) memory ref for a derived memory as the canonical
- * `memories/<name>` conceptId (Group-C item 2 flip), or `undefined` when none
+ * Resolve the parent (source) memory ref for a derived memory as a canonical
+ * `memories/<name>` conceptId, or `undefined` when none
  * can be determined. Precedence:
  *   1. `frontmatter.source` (normalised through {@link parseMemoryRef});
  *   2. `frontmatter.derivedFrom` (a bare memory name → `memories/<name>`);

package/dist/commands/improve/memory/memory-belief.js

@@ -63,7 +63,7 @@ function readEdgeList(value) {
  * present WITHOUT the demotion (e.g. a hand-written `contradictedBy:` line,
  * or a beliefState lost to a partial edit) is repaired, not skipped — an
  * edge-only guard would make such a file a permanent no-op while
- * consolidate's handleContradictOp reports the contradiction as applied.
+ * contradiction writers report the contradiction as applied.
  *
  * Never weakens a stronger demotion: `archived` ranks BELOW `contradicted`
  * (see `BELIEF_STATE_SCORE_CEILINGS` in

package/dist/commands/improve/memory/memory-contradiction-detect.js

@@ -37,9 +37,10 @@ import fs from "node:fs";
 import path from "node:path";
 import contradictionJudgeTemplate from "../../../assets/prompts/contradiction-judge.md" with { type: "text" };
 import { mutateFrontmatter, parseFrontmatter } from "../../../core/asset/frontmatter.js";
+import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
 import { getDefaultLlmConfig } from "../../../integrations/agent/engine-resolution.js";
 import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../../integrations/agent/runner.js";
-import { chatCompletion, parseEmbeddedJsonResponse } from "../../../llm/client.js";
+import { chatCompletion } from "../../../llm/client.js";
 import { callStructured } from "../../../llm/structured-call.js";
 import { isDerivedMemory, memoryIdentityRef, resolveParentRef } from "./derived-ref.js";
 // ── Constants ────────────────────────────────────────────────────────────────
@@ -56,8 +57,7 @@ const MAX_PAIRS_PER_RUN = 20;
 /**
  * Minimum confidence required to write a contradiction edge. Below this
  * threshold the LLM may be flagging topic-overlap rather than genuine logical
- * exclusivity (investigation 2026-06-18). Absent confidence fields default to
- * 1.0 for backward compatibility with older judge responses.
+ * exclusivity (investigation 2026-06-18).
  */
 const CONTRADICT_CONFIDENCE_THRESHOLD = 0.92;
 /**
@@ -230,11 +230,6 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
                 // edge already exists (no new information; avoids re-judging resolved
                 // pairs across runs).
                 //
-                // Legacy mutual A↔B edges written by the pre-fix pass self-heal: the
-                // skip fires this run, but the SCC resolver treats the 2-cycle as a sink
-                // and refreshes both to active — DELETING both `contradictedBy` arrays
-                // (memory-improve.ts persistBeliefStateTransition). The next detection
-                // run then sees no edge, re-judges, and writes the single canonical edge.
                 const aParsed = parseFrontmatter(fs.readFileSync(a.filePath, "utf8"));
                 const bParsed = parseFrontmatter(fs.readFileSync(b.filePath, "utf8"));
                 const { loser, winnerRef } = pickContradictionLoser(a, b);
@@ -274,10 +269,7 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
                 }
                 if (!parsed?.contradicts)
                     continue;
-                // Confidence gate: absent field defaults to 1.0 (backward compat with
-                // pre-confidence responses). Do NOT default to 0 — that would silently
-                // disable all detection during the rollout period.
-                const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 1.0;
+                const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
                 if (confidence < CONTRADICT_CONFIDENCE_THRESHOLD) {
                     result.warnings.push(`Pair ${a.ref} / ${b.ref}: confidence ${confidence.toFixed(2)} below ${CONTRADICT_CONFIDENCE_THRESHOLD} threshold — skipped.`);
                     continue;

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

@@ -657,11 +657,12 @@ function resolveBeliefState(frontmatter) {
 // Belief-edge refs (contradictedBy / supersededBy / currentBeliefRefs) are the
 // IDENTITY channel: they are compared against a derived memory's own
 // `memory:<name>` ref (resolveFamilyContradictions' familyRefSet,
-// firstExistingRef's byRef map), so they stay in `memory:<name>` grammar. This
-// is deliberately NOT the `memories/<name>` derived_from conceptId — Group-C
-// item 2 flipped only that channel. We parse the tolerant bare name and format
-// it back into identity grammar so both grammars on disk resolve to the ref
-// record.ref carries.
+// firstExistingRef's byRef map), so they are NORMALIZED to `memory:<name>` here.
+// On disk they arrive in either spelling — `memory:<name>` from pre-0.9.0
+// writes, or the `[<bundle>//]memories/<name>` conceptId that
+// `writeSupersededEdge`/`writeContradictEdge` persist today — and
+// `parseMemoryName` accepts both. Reading only the first spelling silently
+// dropped every edge the current write path produces.
 function refArray(value) {
     if (typeof value === "string") {
         const name = parseMemoryName(value);

package/dist/commands/improve/outcome-loop.js

@@ -1,6 +1,7 @@
 // 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/.
+import { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef, upsertAssetOutcome, } from "../../storage/repositories/outcome-repository.js";
 // ── Constants ─────────────────────────────────────────────────────────────────
 /**
  * EMA decay factor for the expected-retrieval rolling mean (α).
@@ -94,76 +95,32 @@ export function updateAssetOutcome(db, inputs) {
         const newScore = OUTCOME_EMA_ALPHA * rawUpdate + (1 - OUTCOME_EMA_ALPHA) * existing.outcome_score;
         // Clip to [OUTCOME_SCORE_MIN, OUTCOME_SCORE_MAX] — the ceiling is the RPE
         // saturation analog (G2): without it, long-lived popular assets accumulate
-        // unbounded positive mass (live max was 3.13) and would dominate rank_score
-        // the moment the outcome weight is enabled. Stored legacy scores above the
-        // ceiling converge back under it on their next differential update.
+        // unbounded positive mass and would dominate rank_score when outcome weight
+        // is enabled.
         outcomeScore = Math.min(OUTCOME_SCORE_MAX, Math.max(OUTCOME_SCORE_MIN, newScore));
     }
-    // Upsert the row. `review_pressure` is intentionally omitted from both the
-    // INSERT column list and the ON CONFLICT SET clause: the column's DEFAULT 0
-    // seeds fresh rows, and omitting it from SET leaves an existing row's value
-    // untouched on update (never written going forward). The column itself is
-    // dropped in migration 018.
-    db.prepare(`INSERT INTO asset_outcome
-       (asset_ref, last_retrieved_at, retrieval_count, expected_retrieval_rate,
-        negative_feedback_count, accepted_change_count,
-        outcome_score, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-     ON CONFLICT(asset_ref) DO UPDATE SET
-       last_retrieved_at      = excluded.last_retrieved_at,
-       retrieval_count        = excluded.retrieval_count,
-       expected_retrieval_rate= excluded.expected_retrieval_rate,
-       negative_feedback_count= excluded.negative_feedback_count,
-       accepted_change_count  = excluded.accepted_change_count,
-       outcome_score          = excluded.outcome_score,
-       updated_at             = excluded.updated_at`).run(inputs.ref, inputs.lastRetrievedAt, inputs.currentRetrievalCount, expectedRetrievalRate, inputs.negativeFeedbackCount, inputs.acceptedChangeCount, outcomeScore, now);
+    // Upsert the row. See `upsertAssetOutcome` in
+    // storage/repositories/outcome-repository.ts (#672 part 2) for the SQL text
+    // and the `review_pressure` omission rationale — this call site is
+    // unchanged in intent, just no longer inline.
+    upsertAssetOutcome(db, {
+        ref: inputs.ref,
+        lastRetrievedAt: inputs.lastRetrievedAt,
+        retrievalCount: inputs.currentRetrievalCount,
+        expectedRetrievalRate,
+        negativeFeedbackCount: inputs.negativeFeedbackCount,
+        acceptedChangeCount: inputs.acceptedChangeCount,
+        outcomeScore,
+        updatedAt: now,
+    });
     return { outcomeScore, isNewRow };
 }
 // ── Reader ────────────────────────────────────────────────────────────────────
-/**
- * Load the outcome row for one asset, or `undefined` if not yet written.
- */
-export function getAssetOutcome(db, ref) {
-    const row = db
-        .prepare(`SELECT asset_ref, last_retrieved_at, retrieval_count, expected_retrieval_rate,
-              negative_feedback_count, accepted_change_count,
-              outcome_score, updated_at
-       FROM asset_outcome WHERE asset_ref = ?`)
-        .get(ref);
-    return row == null ? undefined : row;
-}
-/**
- * Load ALL asset_outcome rows. Used for the proxy-adequacy tripwire computation.
- */
-export function getAllAssetOutcomes(db) {
-    return db
-        .prepare(`SELECT asset_ref, last_retrieved_at, retrieval_count, expected_retrieval_rate,
-              negative_feedback_count, accepted_change_count,
-              outcome_score, updated_at
-       FROM asset_outcome ORDER BY asset_ref`)
-        .all();
-}
-/**
- * Build a Map<ref, outcome_score> for a set of refs in one query.
- * Used by `salience.ts` to populate `outcomeSalience`.
- */
-export function getOutcomeScoresByRef(db, refs) {
-    const result = new Map();
-    if (refs.length === 0)
-        return result;
-    const CHUNK = 500;
-    for (let i = 0; i < refs.length; i += CHUNK) {
-        const chunk = refs.slice(i, i + CHUNK);
-        const placeholders = chunk.map(() => "?").join(",");
-        const rows = db
-            .prepare(`SELECT asset_ref, outcome_score FROM asset_outcome WHERE asset_ref IN (${placeholders})`)
-            .all(...chunk);
-        for (const row of rows) {
-            result.set(row.asset_ref, row.outcome_score);
-        }
-    }
-    return result;
-}
+//
+// getAssetOutcome / getAllAssetOutcomes / getOutcomeScoresByRef moved verbatim
+// to storage/repositories/outcome-repository.ts (#672 part 2) — re-exported
+// here so existing importers of this module resolve unchanged.
+export { getAllAssetOutcomes, getAssetOutcome, getOutcomeScoresByRef };
 // ── outcomeSalience projection ────────────────────────────────────────────────
 /**
  * Convert a raw `outcome_score` (differential, may be negative) to a