akm-cli 0.9.6 → 0.9.7

package/dist/commands/lint/base-linter.js

@@ -34,10 +34,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isScalar, parseDocument } from "yaml";
-import { assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
+import { assetPathCandidatesForName, assetPathForName, stashDirFor } from "../../core/asset/asset-placement.js";
 import { BUNDLE_REF_RE } from "../../core/asset/asset-ref.js";
-import { spliceFrontmatterLine } from "../../core/asset/frontmatter.js";
+import { removeFrontmatterListValues, spliceFrontmatterLine } from "../../core/asset/frontmatter.js";
 import { checkUnquotedDescriptionColon } from "../../core/asset/frontmatter-lint.js";
+import { isArchivedRelPath } from "../../core/asset/memory-archive.js";
 import { typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { localDateStamp } from "../../core/common.js";
 import { findFenceRegions } from "./markdown-insertion.js";
@@ -191,6 +192,37 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
         if (resolveRefPathInStash(relPath, refType, refName, root) !== null)
             return true;
     }
+    // #884: a memory pruned by `analyzeMemoryCleanup` was ARCHIVED, not deleted —
+    // its bytes and identity live on under `.akm/memory-cleanup/archive`. Inbound
+    // belief edges to it are satisfied, not dangling, so resolve the tombstone
+    // rather than reporting `missing-ref`. Checked only after every live location
+    // misses: a tombstone must never shadow a real file, and the scan then costs
+    // one directory read per root instead of one per ref.
+    //
+    // Existence ONLY. `resolveRefPathInStash` deliberately does NOT consult the
+    // archive: it hands back a path callers MUTATE (SPEC-5 `--supersedes`
+    // demotion), and writing into an archived tombstone would corrupt the audit
+    // record while leaving the live stash untouched.
+    return memoryArchiveHasRef(refType, refName, stashRoots);
+}
+/**
+ * True when `(refType, refName)` names a memory that prune archived in any
+ * root. Mirrors `resolveRefPathInStash`'s candidate set so a ref that resolved
+ * through the `.derived.md` twin (#882) still resolves once archived.
+ */
+function memoryArchiveHasRef(refType, refName, stashRoots) {
+    if (refType !== "memory")
+        return false; // only memories are ever archived
+    const typeDir = stashDirFor(refType);
+    if (typeDir === undefined)
+        return false;
+    const candidates = assetPathCandidatesForName(refType, typeDir, refName);
+    for (const root of stashRoots) {
+        for (const candidate of candidates) {
+            if (isArchivedRelPath(candidate, root))
+                return true;
+        }
+    }
     return false;
 }
 /**
@@ -198,8 +230,9 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
  * the same reachability rules (in the same order) as
  * {@link refExistsInAnyStash}, which delegates here. Returns the absolute path
  * of the file that makes the ref "exist" — for a multi-file skill directory
- * that is its `SKILL.md` primary — or `null` when the ref does not resolve in
- * this root.
+ * that is its `SKILL.md` primary, for a `memory` ref its `.derived.md` twin
+ * when the plain `.md` is absent (#882, see `assetPathCandidatesForName`) —
+ * or `null` when the ref does not resolve in this root.
  *
  * Extracted for SPEC-5 (`--supersedes` demotion): write commands need the
  * superseded asset's actual file to mutate, and forking a second resolver
@@ -207,10 +240,14 @@ export function refExistsInAnyStash(relPath, refType, refName, stashRoots) {
  * (the contract pins `refToRelPath` + `refExistsInAnyStash`; this is the
  * shared internal both build on).
  */
-export function resolveRefPathInStash(relPath, _refType, _refName, root) {
-    const absPath = path.join(root, relPath);
-    if (fs.existsSync(absPath))
-        return absPath;
+export function resolveRefPathInStash(relPath, refType, refName, root) {
+    const typeDir = stashDirFor(refType);
+    const candidates = typeDir === undefined ? [relPath] : assetPathCandidatesForName(refType, typeDir, refName);
+    for (const candidate of candidates) {
+        const absPath = path.join(root, candidate);
+        if (fs.existsSync(absPath))
+            return absPath;
+    }
     return null;
 }
 /**
@@ -281,11 +318,31 @@ function scanBundleRefs(scanBody, allRoots) {
  */
 function classifyConceptRef(rawConceptId, allRoots) {
     const conceptId = rawConceptId.split("#", 1)[0];
-    const parts = typeNameFromConceptId(conceptId);
+    const parts = typeNameFromConceptId(conceptId) ?? legacyTypeSlugParts(conceptId);
     if (parts === undefined)
         return null; // foreign type / not a local asset ref
     return localRefMissingRelPath(parts.type, parts.name, allRoots);
 }
+/**
+ * Read-only fallback for the retired `type:slug` xref grammar (see
+ * resolve-ref.ts Q-02 — the write boundary no longer emits or accepts it).
+ * Stash content written before that retirement still carries it in frontmatter
+ * `xrefs:` lists, and `typeNameFromConceptId` (conceptId-only) returns
+ * `undefined` for it, so without this it was silently skipped rather than
+ * validated (#882). `refToRelPath`/`refExistsInAnyStash` already key off a bare
+ * `(type, slug)` pair — the same shape `type:slug` already is — so this only
+ * needs to split the token; no new resolution logic.
+ */
+function legacyTypeSlugParts(rawConceptId) {
+    const colon = rawConceptId.indexOf(":");
+    if (colon <= 0)
+        return undefined;
+    const type = rawConceptId.slice(0, colon);
+    const name = rawConceptId.slice(colon + 1);
+    if (!name || name.includes("/") || name.includes(":"))
+        return undefined;
+    return stashDirFor(type) === undefined ? undefined : { type, name };
+}
 /**
  * Returns an array of {ref, resolvedRelPath} for every local AKM ref in the
  * PROSE body that does not resolve to a real file under any of the provided
@@ -364,6 +421,12 @@ function dedupeMissing(rows) {
  * excluded because it can point at merged-away or pruned assets.
  */
 const XREF_FRONTMATTER_KEYS = ["xrefs", "supersededBy", "contradictedBy"];
+/**
+ * The belief-graph subset of {@link XREF_FRONTMATTER_KEYS} — the only channels
+ * `--prune-dangling-edges` will repair (#884). Typed as `readonly string[]` so
+ * `.includes` accepts any xref key without a cast.
+ */
+const BELIEF_EDGE_KEYS = ["supersededBy", "contradictedBy"];
 /**
  * Return the `refs:` array from frontmatter when it is present and is an
  * array of strings; otherwise return `null` to signal the caller should
@@ -597,12 +660,22 @@ export function runBaseChecks(ctx) {
             });
         }
     }
-    if (modified) {
-        // Mirrors the two stub-delete call sites in `commands/lint/index.ts`
-        // (`appendMemoryStubIssue`/`appendWorkflowStubIssue`), which already report
-        // a failed mutation as `fixed: "failed"` instead of throwing. Without this
-        // the sweep aborted mid-run on the first unwritable file and the caller got
-        // an exception instead of a result naming the fixes that HAD landed.
+    /**
+     * Flush accumulated mutations to disk. Called after the fixable checks above
+     * AND again at the very end, because the `missing-ref` section below can also
+     * mutate (`--prune-dangling-edges`, #884) and used to run PAST this point —
+     * its edits were computed and then silently dropped.
+     *
+     * Mirrors the two stub-delete call sites in `commands/lint/index.ts`
+     * (`appendMemoryStubIssue`/`appendWorkflowStubIssue`), which already report
+     * a failed mutation as `fixed: "failed"` instead of throwing. Without this
+     * the sweep aborted mid-run on the first unwritable file and the caller got
+     * an exception instead of a result naming the fixes that HAD landed.
+     */
+    const flushIfModified = () => {
+        if (!modified)
+            return;
+        modified = false;
         try {
             fs.writeFileSync(ctx.filePath, currentRaw, "utf8");
             // Propagate the mutated raw back so subclasses can re-parse if needed
@@ -615,7 +688,8 @@ export function runBaseChecks(ctx) {
                 issue.detail = `${issue.detail} — could not write fix: ${reason}`;
             }
         }
-    }
+    };
+    flushIfModified();
     // ── 3. stale-path ──────────────────────────────────────────────────────
     // M3: checkStalePath returns all stale matches; push one issue per path.
     // M4: Also scan ctx.frontmatter for stale paths (absolute paths in frontmatter).
@@ -636,6 +710,26 @@ export function runBaseChecks(ctx) {
         }
     }
     // ── 4. missing-ref ─────────────────────────────────────────────────────
+    const missingRefPass = runMissingRefChecks(ctx, currentRaw, shouldRun, pendingFixes);
+    issues.push(...missingRefPass.issues);
+    if (missingRefPass.modified) {
+        currentRaw = missingRefPass.raw;
+        modified = true;
+    }
+    flushIfModified();
+    return issues;
+}
+/**
+ * The `missing-ref` pass, extracted from {@link runBaseChecks} so that function
+ * stays under the src fn-size ratchet after #884 gave this pass its own
+ * (opt-in) mutation path. Pure move plus the explicit state hand-off: `raw` in,
+ * `{raw, modified}` out, `issues`/`pendingFixes` appended in place.
+ */
+function runMissingRefChecks(ctx, raw, shouldRun, pendingFixes) {
+    const issues = [];
+    let currentRaw = raw;
+    let modified = false;
+    // ── 4. missing-ref ─────────────────────────────────────────────────────
     // Carve-out for assets that declare an explicit `refs:` array in
     // frontmatter (e.g. session-checkpoint memories captured by the
     // claude-code hook). The frontmatter array is the *authoritative*
@@ -650,7 +744,9 @@ export function runBaseChecks(ctx) {
     // still run `checkMissingRefs` against the array itself to catch
     // refs that were valid at capture time but later removed from the
     // stash.
-    if (shouldRun("missing-ref")) {
+    if (!shouldRun("missing-ref"))
+        return { issues, raw, modified };
+    {
         const explicitRefs = extractFrontmatterRefs(ctx.data, ctx.body);
         // An explicit `refs:` array is a REF LIST (each value is a whole ref —
         // short conceptIds included); a bare body is PROSE (anchored refs only).
@@ -691,6 +787,33 @@ export function runBaseChecks(ctx) {
                 if (values === null)
                     continue;
                 const missingXrefs = checkMissingRefsInList(values, ctx.stashRoot, ctx.extraStashRoots);
+                // #884 opt-in repair. Scoped to the BELIEF channels only: an edge whose
+                // target has neither a file nor a prune tombstone asserts a
+                // relationship to a memory that no longer exists in any form, and
+                // carrying it forward corrupts every belief-graph read. `xrefs` is
+                // excluded — a stale xref is an ordinary broken link (the 3 skill refs
+                // in #884), and repairing it by DELETION would throw away a pointer the
+                // author may simply need to re-target.
+                const repairable = ctx.pruneDanglingEdges === true && BELIEF_EDGE_KEYS.includes(key) && missingXrefs.length > 0;
+                if (repairable) {
+                    const dropped = missingXrefs.map(({ ref }) => ref);
+                    const rewritten = removeFrontmatterListValues(currentRaw, key, dropped);
+                    if (rewritten !== null) {
+                        currentRaw = rewritten;
+                        modified = true;
+                        for (const { ref, resolvedRelPath } of missingXrefs) {
+                            const issue = {
+                                file: ctx.relPath,
+                                issue: "missing-ref",
+                                detail: `dangling ${key} edge dropped: ${ref} (no file and no prune tombstone at ${resolvedRelPath})`,
+                                fixed: true,
+                            };
+                            issues.push(issue);
+                            pendingFixes.push(issue);
+                        }
+                        continue;
+                    }
+                }
                 for (const { ref, resolvedRelPath } of missingXrefs) {
                     issues.push({
                         file: ctx.relPath,
@@ -702,5 +825,5 @@ export function runBaseChecks(ctx) {
             }
         }
     }
-    return issues;
+    return { issues, raw: currentRaw, modified };
 }

package/dist/commands/lint/index.js

@@ -385,8 +385,8 @@ function assertFixTargetWritable(stashRoot, sources) {
         return;
     // Same error kind and code `write-source.ts#ensureWritable` raises for the
     // identical refusal, so a scripted caller classifies both the same way.
-    throw new UsageError(`lint --fix: bundle "${stashRoot}" is configured \`writable: false\`; refusing to modify it. ` +
-        "Run `akm lint` without --fix to report findings, or set `writable: true` on the bundle.", "INVALID_FLAG_VALUE");
+    throw new UsageError(`lint: bundle "${stashRoot}" is configured \`writable: false\`; refusing to modify it. ` +
+        "Run `akm lint` without --fix / --prune-dangling-edges to report findings, or set `writable: true` on the bundle.", "INVALID_FLAG_VALUE");
 }
 /** True when the issue represents a file deletion that was successfully applied. */
 function isFileDeletion(issue) {
@@ -523,7 +523,9 @@ export function lintAssetFile(ctx, subdir) {
  */
 function lintAkmSweep(stashRoot, extraStashRoots, cfg, sources, options) {
     const fix = options.fix === true;
-    if (fix)
+    // #884: the dangling-edge repair writes too, so it clears the same
+    // read-only gate `--fix` does.
+    if (fix || options.pruneDanglingEdges === true)
         assertFixTargetWritable(stashRoot, sources);
     const fixed = [];
     const flagged = [];
@@ -627,7 +629,18 @@ function lintAkmSweep(stashRoot, extraStashRoots, cfg, sources, options) {
             try {
                 issues = [
                     ...fileIssues,
-                    ...lintAssetFile({ filePath, relPath, raw, data, body, frontmatter, fix, stashRoot, extraStashRoots }, subdir),
+                    ...lintAssetFile({
+                        filePath,
+                        relPath,
+                        raw,
+                        data,
+                        body,
+                        frontmatter,
+                        fix,
+                        pruneDanglingEdges: options.pruneDanglingEdges === true,
+                        stashRoot,
+                        extraStashRoots,
+                    }, subdir),
                 ];
             }
             catch (e) {

package/dist/commands/read/curate.js

@@ -24,6 +24,7 @@ import { enqueueGraphExtraction, hasGraphData } from "../../indexer/db/graph-db.
 import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
 import { findSourceForPath, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
+import { estimateTokenCount } from "../../llm/embedders/remote.js";
 import { truncateDescription } from "../../output/shapes/helpers.js";
 import { TELEMETRY_BUSY_TIMEOUT_MS, withIndexDb } from "../../storage/repositories/index-db.js";
 import { findEntryIdByRef, getItemRefById } from "../../storage/repositories/index-entries-repository.js";
@@ -163,6 +164,52 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
         ...(result.tip ? { tip: result.tip } : {}),
     };
 }
+/**
+ * Pack a curate result's stash hits into a single token-budgeted blob:
+ * resolve each hit's content via the SAME path `akm show` uses
+ * (`akmShowUnified` — this also means a `ref#fragment` hit packs just the
+ * matched section), then greedily accumulate hits, in the ranking order
+ * `curateSearchResults` already produced, until the next hit would exceed
+ * `budgetTokens`.
+ *
+ * Registry hits are never packed — only `CuratedStashItem`s (locked
+ * contract, AGENTS.md: registry results stay separate/opt-in).
+ *
+ * Truncation policy: drop whole hits from the tail of the ranked list first.
+ * The only exception is a single high-rank hit that alone exceeds the
+ * budget — that one hit is truncated to fit rather than dropping everything.
+ */
+export async function packCuratedHits(result, budgetTokens) {
+    const stashItems = result.items.filter((item) => item.source === "local");
+    const packed = [];
+    let used = 0;
+    for (const item of stashItems) {
+        let shown;
+        try {
+            shown = await akmShowUnified({ ref: item.ref, skipLogging: true });
+        }
+        catch {
+            continue;
+        }
+        const content = shown.content ?? shown.template ?? shown.prompt ?? "";
+        const tokens = estimateTokenCount(content);
+        if (used + tokens <= budgetTokens) {
+            packed.push({ ref: item.ref, tokens, content });
+            used += tokens;
+            continue;
+        }
+        if (packed.length === 0) {
+            const remaining = budgetTokens - used;
+            if (remaining > 0) {
+                const truncated = content.slice(0, remaining * 4);
+                packed.push({ ref: item.ref, tokens: estimateTokenCount(truncated), content: truncated });
+                used += estimateTokenCount(truncated);
+            }
+        }
+        break;
+    }
+    return { query: result.query, budget: budgetTokens, tokens: used, items: packed };
+}
 async function enrichCuratedStashHit(query, hit, supportRefs, selectedRefs, eventSource) {
     let shown;
     try {

package/dist/commands/read/search-cli.js

@@ -20,7 +20,8 @@ import { parseMetaRef } from "../../core/asset/stash-meta.js";
 import { UsageError } from "../../core/errors.js";
 import { resolveUsageEventSource } from "../../indexer/usage/usage-events.js";
 import { getOutputMode } from "../../output/context.js";
-import { akmCurate } from "./curate.js";
+import { deliverRendered } from "../../output/html-render.js";
+import { akmCurate, packCuratedHits } from "./curate.js";
 import { akmSearch, parseBeliefFilterMode, parseScopeFilterFlags, parseSearchSource } from "./search.js";
 import { akmShowUnified } from "./show.js";
 /**
@@ -153,6 +154,15 @@ export const curateCommand = defineJsonCommand({
         },
         limit: { type: "string", description: "Maximum number of curated results", default: "4" },
         from: { type: "string", description: "Search source (local|registry|all)", default: "local" },
+        pack: {
+            type: "string",
+            description: "Pack the ranked stash hits' full content into a single token-budgeted blob instead of returning refs " +
+                "to follow up on individually — value is the max token budget, e.g. --pack 4000 (~4 chars/token, same " +
+                "estimator as embedding). Content is resolved the same way `akm show` resolves it, so a ref#fragment " +
+                "hit packs just that section. Registry hits (--from registry|all) are never packed. Not to be confused " +
+                "with a workflow asset's own `budget` field (a run-cost cap) — this is a context-size target for this " +
+                "one curate call.",
+        },
         // Declared as the POSITIVE name with `default: true` — see the
         // `project-context` comment on `searchCommand` above for why a flag NAME
         // must never start with `no-`.
@@ -175,6 +185,7 @@ export const curateCommand = defineJsonCommand({
         const source = parseSearchSource(args.from ?? "local");
         const skipLogging = args["track-usage"] === false;
         const outputMode = getOutputMode();
+        const packBudget = parsePositiveIntFlag(args.pack ?? undefined, "--pack");
         const curated = await akmCurate({
             query: args.query,
             type,
@@ -184,9 +195,21 @@ export const curateCommand = defineJsonCommand({
             eventSource: resolveUsageEventSource(),
             attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
         });
+        if (packBudget !== undefined) {
+            const packed = await packCuratedHits(curated, packBudget);
+            deliverRendered(outputMode.format === "text" ? formatCuratePackText(packed) : JSON.stringify(packed.items, null, 2), outputMode.outputPath);
+            return;
+        }
         output("curate", curated);
     },
 });
+/** Human-readable rendering for `akm curate --pack`: concatenated content per hit under a `## <ref>` header. */
+function formatCuratePackText(packed) {
+    if (packed.items.length === 0) {
+        return `No packed content for "${packed.query}" (budget ${packed.budget} tokens).`;
+    }
+    return packed.items.map((item) => `## ${item.ref}\n\n${item.content}`).join("\n\n");
+}
 /**
  * Reject `--scope` (either spelling) on `akm show` (E-3). `--scope` was
  * removed in favor of `--filter` (R-047, guardrail 6 — no alias, must keep

package/dist/core/asset/asset-placement.js

@@ -25,7 +25,7 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { SCRIPT_EXTENSIONS, WORKFLOW_EXTENSIONS } from "../recognition-util.js";
+import { DERIVED_SUFFIX, SCRIPT_EXTENSIONS, WORKFLOW_EXTENSIONS } from "../recognition-util.js";
 function toPosix(input) {
     return input.replace(/\\/g, "/");
 }
@@ -247,10 +247,21 @@ export function assetPathForName(assetType, typeRoot, name) {
  * "default" alias is genuinely dual-owned: both `<dir>/.env` and
  * `<dir>/default.env` derive the same canonical name (`toCanonicalName`
  * above), so a physical-owner lookup must consider both without reading
- * either file. Every other placement type has exactly one inverse spelling.
+ * either file. `memory` has a second, analogous duality (#882): a ref to
+ * `<name>` may own either `<name>.md` or the LLM-inferred `<name>.derived.md`
+ * twin — `.derived` is a provenance marker on the SAME identity, not part of
+ * the name (see `resolveParentRef`/`isDerivedMemory` in
+ * `commands/improve/memory/derived-ref.ts`, and the belief-edge identity
+ * channel's own `memory:<name>.derived` refs). The plain `.md` file wins when
+ * both exist, so it stays `primary` — first in the returned list — and every
+ * caller here already prefers the first candidate that exists on disk. Every
+ * other placement type has exactly one inverse spelling.
  */
 export function assetPathCandidatesForName(assetType, typeRoot, name) {
     const primary = assetPathForName(assetType, typeRoot, name);
+    if (assetType === "memory" && !name.endsWith(DERIVED_SUFFIX)) {
+        return [primary, assetPathForName(assetType, typeRoot, `${name}${DERIVED_SUFFIX}`)];
+    }
     if (assetType !== "env")
         return [primary];
     const base = name === "default" ? "" : name.endsWith("/default") ? name.slice(0, -"default".length) : undefined;

package/dist/core/asset/frontmatter.js

@@ -207,6 +207,122 @@ export function spliceFrontmatterLine(raw, line) {
     lines.splice(closeIdx, 0, line);
     return lines.join("\n");
 }
+/**
+ * Strip one layer of matching quotes — frontmatter list items are often quoted
+ * refs. Written as an explicit char compare rather than a backreference regex
+ * on purpose: `scripts/lint-repository-sql.ts`'s comment/string stripper has no
+ * regex-literal awareness, so a literal holding an ODD number of quote
+ * characters desyncs its state machine and corrupts every match after it.
+ */
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed[0];
+    if ((first === '"' || first === "'") && trimmed[trimmed.length - 1] === first)
+        return trimmed.slice(1, -1);
+    return trimmed;
+}
+/**
+ * Remove specific VALUES from one frontmatter list key, preserving every other
+ * byte — the counterpart to {@link spliceFrontmatterLine} for the
+ * `akm lint --prune-dangling-edges` repair (#884).
+ *
+ * Handles the three spellings a belief channel appears in: a block sequence
+ * (`contradictedBy:\n  - a`), an inline flow (`contradictedBy: [a, b]`), and a
+ * bare scalar (`contradictedBy: a`). When every value under the key is removed
+ * the key itself goes too — an empty `contradictedBy: []` is not the same
+ * assertion as no edge at all.
+ *
+ * Returns the rewritten source, or `null` when `raw` has no well-formed
+ * frontmatter block or nothing matched, so the caller can leave the file
+ * untouched and report the finding unfixed. Deliberately source-preserving:
+ * these are user-authored memories, and a repair must not silently reformat
+ * the frontmatter it was not asked to touch.
+ */
+export function removeFrontmatterListValues(raw, key, values) {
+    const remove = new Set(values.map((v) => unquote(v)));
+    if (remove.size === 0)
+        return null;
+    const lines = raw.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return null;
+    const closeIdx = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+    if (closeIdx === -1)
+        return null;
+    const out = [];
+    let changed = false;
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (index === 0 || index >= closeIdx) {
+            out.push(line);
+            index += 1;
+            continue;
+        }
+        const kv = line.match(/^(\w[\w-]*):\s*(.*)$/);
+        if (kv === null || kv[1] !== key) {
+            out.push(line);
+            index += 1;
+            continue;
+        }
+        const rest = kv[2].trim();
+        // Inline flow: contradictedBy: [a, b]
+        const flow = rest.match(/^\[(.*)\]$/);
+        if (flow !== null) {
+            const kept = flow[1]
+                .split(",")
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .filter((item) => !remove.has(unquote(item)));
+            const original = flow[1].split(",").filter((s) => s.trim().length > 0).length;
+            if (kept.length !== original) {
+                changed = true;
+                if (kept.length > 0)
+                    out.push(`${key}: [${kept.join(", ")}]`);
+            }
+            else {
+                out.push(line);
+            }
+            index += 1;
+            continue;
+        }
+        // Bare scalar: contradictedBy: a
+        if (rest !== "") {
+            if (remove.has(unquote(rest)))
+                changed = true;
+            else
+                out.push(line);
+            index += 1;
+            continue;
+        }
+        // Block sequence: the key line, then `  - value` items.
+        const header = line;
+        const items = [];
+        let cursor = index + 1;
+        while (cursor < closeIdx) {
+            const itemMatch = lines[cursor].match(/^\s+-\s*(.*)$/);
+            if (itemMatch === null)
+                break;
+            items.push(lines[cursor]);
+            cursor += 1;
+        }
+        const kept = items.filter((item) => !remove.has(unquote(item.replace(/^\s*-\s*/, ""))));
+        if (kept.length !== items.length) {
+            changed = true;
+            if (kept.length > 0) {
+                out.push(header);
+                out.push(...kept);
+            }
+        }
+        else {
+            out.push(header);
+            out.push(...items);
+        }
+        index = cursor;
+    }
+    return changed ? out.join("\n") : null;
+}
 /**
  * Parse a YAML scalar value (string, boolean, or number).
  *

package/dist/core/asset/memory-archive.js

@@ -0,0 +1,97 @@
+// 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/.
+/**
+ * The memory-cleanup archive as a REF-RESOLUTION surface (#884).
+ *
+ * `analyzeMemoryCleanup`'s prune (`commands/improve/memory/memory-improve.ts`
+ * `#archiveMemory`) does not delete a memory: it `rename`s the file under
+ * `.akm/memory-cleanup/archive/<stamp>-<ref>/<originalPath>` and writes a
+ * sibling `cleanup.md` audit asset carrying `ref` / `originalPath` /
+ * `archivedPath`. The bytes and the identity both survive — but the ref stops
+ * resolving at its ORIGINAL location, so every inbound belief edge
+ * (`contradictedBy` / `supersededBy`) pointing at the pruned memory becomes a
+ * `missing-ref` the moment #882 made those channels validatable.
+ *
+ * That is the #884 defect, and the archive already holds everything needed to
+ * fix it: the audit record IS a tombstone. This module reads those tombstones
+ * so ref resolution can answer "archived" instead of "missing". Resolution
+ * stays non-destructive — pruning never rewrites an unrelated memory's
+ * frontmatter, and the contradiction an edge records is preserved rather than
+ * erased (the concern #884 raised against a bare edge-scrub).
+ *
+ * A ref whose target has NO tombstone and no file is genuinely dangling — it
+ * was removed by something other than prune (a hand `git rm`, an older
+ * release). Those stay reported; clearing them mutates user data and so is
+ * gated behind `akm lint --prune-dangling-edges`.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { parseFrontmatter } from "./frontmatter.js";
+/** Stash-relative root the prune path archives into. Must match `memory-improve.ts#createArchiveDir`. */
+export const MEMORY_ARCHIVE_REL = ".akm/memory-cleanup/archive";
+/** Filename of the per-archive audit asset written alongside the archived memory. */
+const AUDIT_FILENAME = "cleanup.md";
+/**
+ * Cache keyed by stash root. A lint sweep resolves thousands of refs against a
+ * directory that only the prune path ever writes, so the scan runs once per
+ * root instead of once per missing ref.
+ */
+const cache = new Map();
+/** @internal Drop the memoized scans — process-global state needs a reset seam for tests (#785). */
+export function resetMemoryArchiveCache() {
+    cache.clear();
+}
+/**
+ * Every stash-relative `originalPath` archived under `root`, i.e. the set of
+ * paths that USED to hold a memory and now hold a tombstone instead.
+ *
+ * Unreadable or malformed audit records are skipped rather than thrown: a
+ * corrupt tombstone must degrade to "this ref is missing" (the pre-#884
+ * answer), never break the whole lint sweep.
+ */
+export function archivedOriginalPaths(root) {
+    const cached = cache.get(root);
+    if (cached !== undefined)
+        return cached;
+    const paths = new Set();
+    const archiveRoot = path.join(root, MEMORY_ARCHIVE_REL);
+    let entries;
+    try {
+        entries = fs.readdirSync(archiveRoot, { withFileTypes: true });
+    }
+    catch {
+        cache.set(root, paths); // no archive dir — nothing was ever pruned here
+        return paths;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        let raw;
+        try {
+            raw = fs.readFileSync(path.join(archiveRoot, entry.name, AUDIT_FILENAME), "utf8");
+        }
+        catch {
+            continue;
+        }
+        let originalPath;
+        try {
+            originalPath = parseFrontmatter(raw).data.originalPath;
+        }
+        catch {
+            continue;
+        }
+        if (typeof originalPath === "string" && originalPath.trim().length > 0) {
+            paths.add(originalPath.trim().replace(/\\/g, "/"));
+        }
+    }
+    cache.set(root, paths);
+    return paths;
+}
+/**
+ * True when `relPath` (stash-relative, POSIX) names a memory that prune
+ * archived — the ref resolves to a tombstone rather than to nothing.
+ */
+export function isArchivedRelPath(relPath, root) {
+    return archivedOriginalPaths(root).has(relPath.replace(/\\/g, "/"));
+}

package/dist/core/config/engine-semantics.js

@@ -6,9 +6,7 @@ export const BUILTIN_IMPROVE_STRATEGY_NAMES = [
     "default",
     "quick",
     "thorough",
-    "memory-focus",
     "graph-refresh",
-    "frequent",
     "consolidate",
     "catchup",
     "reflect-distill",