akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/indexer/installations.js

@@ -53,114 +53,49 @@
  * the loose `akm` stash-shape probe.
  *
  * When NO adapter's probe fires (an empty or not-yet-materialized root), the
- * fallback is **`akm`** (see {@link FALLBACK_ADAPTER_ID}) — a RECORDED DEVIATION
- * from spec §1.2(3), which specifies an `okf` fallback. See that constant's
- * comment for the rationale (workspace-root discipline in the pre-config-adapter
- * transitional model).
+ * fallback is **`akm`** (see {@link FALLBACK_ADAPTER_ID}), preserving workspace
+ * root behavior. Explicit configured ownership always wins over probing.
  */
-import crypto from "node:crypto";
-import path from "node:path";
 import { isSourceWriteActivated } from "../core/activation-policy.js";
-import { getAdapters } from "../core/adapter/registry.js";
+import { detectAdapterId } from "../core/adapter/detect-adapter.js";
 import { stashDirFor } from "../core/asset/asset-placement.js";
-import { isBundleSlug } from "../core/asset/asset-ref.js";
+import { deriveBundleId, deriveBundleIds, slugForPath } from "../core/bundle-id.js";
+export { deriveBundleId, deriveBundleIds, slugForPath };
 /**
  * The no-probe-match fallback adapter id.
  *
- * RECORDED DEVIATION from spec §1.2(3) (which specifies an `okf` fallback),
- * kept as the status-quo-preserving choice pending 0.9.1:
+ * The status-quo-preserving default from spec §1.2(3):
  *
  *  - Behavior discipline (spec line 267): the AKM workspace root's own indexing
  *    MUST stay classified `akm`. In this transitional model there is no
- *    config-driven adapter plumbing yet (§1.4) — `deriveInstallations` derives
- *    the adapter SOLELY from this probe, so the workspace-root classification
- *    depends on either `akm.looksLikeRoot` firing (type dirs / `.stash` present)
- *    OR this fallback. A genuinely empty / not-yet-materialized workspace root
- *    (no type dirs) fires no probe; an `okf` fallback would misclassify it as
- *    `okf`, violating that discipline. `akm` keeps it correct.
+ *    depends on either explicit adapter configuration, `akm.looksLikeRoot`
+ *    firing (type dirs / `.stash` present), or this fallback. A genuinely empty
+ *    root fires no probe; `akm` keeps the implicit workspace root correct.
  *  - Status quo: before the registry was wired, `getAdapters()` was empty in
  *    production so EVERY source fell back here — this preserves that exact
  *    fallback value while the probe now genuinely classifies the non-akm shapes.
- *
- * 0.9.1 should flip this to `okf` once the config-default adapter for the
- * workspace root is plumbed from config (§1.4 / spec line 267), which frees this
- * fallback to be the spec §1.2(3) `okf`.
  */
 const FALLBACK_ADAPTER_ID = "akm";
-/**
- * Deterministic, filesystem-safe bundle slug from a source path. Sanitizes the
- * path's basename to the ref bundle-slug charset (spec §1.3: no `/`, `:`, `.`,
- * `#`); an empty result (e.g. a root path) falls back to a short path hash.
- * Pure function of the resolved path — the same path always slugs the same.
- */
-export function slugForPath(sourcePath) {
-    const resolved = path.resolve(sourcePath);
-    const base = path
-        .basename(resolved)
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    if (base.length > 0)
-        return base;
-    return `bundle-${shortHash(resolved)}`;
-}
-/** First 8 hex chars of the sha256 of the input — a stable disambiguator. */
-function shortHash(input) {
-    return crypto.createHash("sha256").update(input).digest("hex").slice(0, 8);
-}
-/**
- * Derive the batch-unique bundle id for a source (D-R5, ref-grammar decision):
- *
- *   1. `registryId` — WHEN it is a legal bundle slug (spec §11.1 charset). A
- *      non-slug-legal registry id (`github:owner/repo`, `npm:@scope/pkg` — they
- *      carry `:` / `/`) CANNOT be a bundle prefix (it would break the
- *      `bundle//conceptId` grammar), so it falls through to (2).
- *   2. `slugForPath(sourcePath)` — the basename slug fallback.
- *
- * The result is made unique WITHIN a derivation batch by `ensureUniqueId`, and
- * the chosen id is added to `usedIds`. This is the ONE derivation the Chunk-8
- * config migrator ({@link import("../migrate/legacy/config-source-migration.js")})
- * and {@link deriveInstallations} share, so a migrated `bundles` key equals the
- * runtime installation id by construction (D-R5 no-identity-shift proof).
- */
-export function deriveBundleId(registryId, sourcePath, usedIds) {
-    const preferred = registryId && registryId.length > 0 && isBundleSlug(registryId) ? registryId : slugForPath(sourcePath);
-    const id = ensureUniqueId(preferred, sourcePath, usedIds);
-    usedIds.add(id);
-    return id;
-}
 /**
  * Resolve the adapter id for a component root via the ordered `looksLikeRoot`
  * probe (spec §1.2), first match wins; falls back to `akm` when no probe fires.
  */
-function detectAdapterId(root) {
-    for (const adapter of getAdapters()) {
-        try {
-            if (adapter.looksLikeRoot?.(root) === true)
-                return adapter.id;
-        }
-        catch {
-            // A probe that throws (unreadable root, race) does not claim the root —
-            // fall through to the next adapter, ultimately to the akm fallback.
-        }
-    }
-    return FALLBACK_ADAPTER_ID;
-}
+export { detectAdapterId } from "../core/adapter/detect-adapter.js";
 /**
  * Derive the durable `BundleInstallation[]` from the transitional
  * `SearchSource[]`. Order is preserved (source priority = installation
  * priority). Bundle ids are unique within the returned batch.
  */
 export function deriveInstallations(sources) {
-    const usedIds = new Set();
+    const ids = deriveBundleIds(sources);
     const installations = [];
-    for (const source of sources) {
+    for (const [index, source] of sources.entries()) {
         // D-R5 rule 1: when the source carries its config bundle key (a slug-legal
         // registryId), that key IS the installation id — equal by construction to
         // this derivation. A non-slug-legal registryId slugs from the path instead.
-        const id = deriveBundleId(source.registryId, source.path, usedIds);
+        const id = ids[index];
         const writable = isSourceWriteActivated(source);
-        const adapter = detectAdapterId(source.path);
+        const adapter = source.adapterId ?? detectAdapterId(source.path, FALLBACK_ADAPTER_ID);
         installations.push({
             id,
             trusted: writable,
@@ -205,20 +140,3 @@ adapterConceptId) {
         adapterId: bundle.adapterId,
     };
 }
-/**
- * Guarantee a batch-unique id. The preferred id (registryId or path slug) is
- * used as-is when free; on collision a short path-hash suffix disambiguates
- * (deterministic in the resolved path), and the unlikely second-order collision
- * appends a numeric counter.
- */
-function ensureUniqueId(preferred, sourcePath, used) {
-    if (!used.has(preferred))
-        return preferred;
-    const suffixed = `${preferred}-${shortHash(path.resolve(sourcePath))}`;
-    if (!used.has(suffixed))
-        return suffixed;
-    let n = 2;
-    while (used.has(`${suffixed}-${n}`))
-        n++;
-    return `${suffixed}-${n}`;
-}

package/dist/indexer/passes/dir-staleness.js

@@ -21,15 +21,22 @@ import fs from "node:fs";
 import path from "node:path";
 import { getEntriesByDir } from "../../storage/repositories/index-entries-repository.js";
 import { getIndexDirState } from "../../storage/repositories/index-meta-repository.js";
-export function getDirIndexState(db, dirPath, files, builtAtMs) {
+export function getDirIndexState(db, dirPath, files, builtAtMs, indexVariant = "") {
     const prevEntries = getEntriesByDir(db, dirPath);
-    const fingerprint = computeDirFingerprint(dirPath, files);
+    const fingerprint = computeDirFingerprint(dirPath, files, indexVariant);
     if (prevEntries.length > 0) {
         const staleReason = getDirStaleReason(dirPath, files, prevEntries, builtAtMs);
-        if (!staleReason) {
-            return { stale: false, reason: { kind: "unchanged" }, persistedRowCount: prevEntries.length };
+        if (staleReason)
+            return { stale: true, reason: staleReason, persistedRowCount: prevEntries.length };
+        const cachedState = getIndexDirState(db, dirPath);
+        if (!cachedState || cachedState.fileSetHash !== fingerprint.fileSetHash) {
+            return {
+                stale: true,
+                reason: { kind: "index-context-changed", detail: indexVariant },
+                persistedRowCount: prevEntries.length,
+            };
         }
-        return { stale: true, reason: staleReason, persistedRowCount: prevEntries.length };
+        return { stale: false, reason: { kind: "unchanged" }, persistedRowCount: prevEntries.length };
     }
     const cachedState = getIndexDirState(db, dirPath);
     if (cachedState &&
@@ -47,8 +54,8 @@ export function getDirIndexState(db, dirPath, files, builtAtMs) {
         persistedRowCount: 0,
     };
 }
-export function getCachedZeroRowDirState(db, dirPath, files, builtAtMs, priorDirsChanged) {
-    const state = getDirIndexState(db, dirPath, files, builtAtMs);
+export function getCachedZeroRowDirState(db, dirPath, files, builtAtMs, priorDirsChanged, indexVariant = "") {
+    const state = getDirIndexState(db, dirPath, files, builtAtMs, indexVariant);
     if (state.stale || state.reason.kind !== "cached-zero-row-state")
         return undefined;
     if (!canUseIncrementalSkip(state, priorDirsChanged))
@@ -60,7 +67,7 @@ export function canUseIncrementalSkip(state, priorDirsChanged) {
         state.reason.kind === "cached-zero-row-state" &&
         state.reason.detail === "deduped-zero-row");
 }
-export function computeDirFingerprint(_dirPath, files) {
+export function computeDirFingerprint(_dirPath, files, indexVariant = "") {
     const normalizedFiles = [...new Set(files.map((file) => path.basename(file)))].sort();
     let fileMtimeMaxMs = 0;
     for (const file of files) {
@@ -73,7 +80,7 @@ export function computeDirFingerprint(_dirPath, files) {
         }
     }
     return {
-        fileSetHash: normalizedFiles.join("\0"),
+        fileSetHash: [indexVariant, ...normalizedFiles].join("\0"),
         fileMtimeMaxMs,
     };
 }

package/dist/indexer/passes/memory-inference.js

@@ -36,9 +36,11 @@
  */
 import fs from "node:fs";
 import path from "node:path";
+import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { assembleAsset } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter, parseFrontmatterBlock } from "../../core/asset/frontmatter.js";
 import { conceptIdFromTypeName, parseRefInput } from "../../core/asset/resolve-ref.js";
+import { todayIso } from "../../core/common.js";
 import { concurrentMap } from "../../core/concurrent.js";
 import { warn } from "../../core/warn.js";
 import { writeAssetToSource } from "../../core/write-source.js";
@@ -107,7 +109,7 @@ export async function runMemoryInferencePass(ctx) {
     // (git, npm, website) are deliberately untouched — writing inferred
     // children there would be clobbered by the next sync().
     const primary = sources[0];
-    if (!primary)
+    if (!primary || (primary.adapterId ?? detectAdapterId(primary.path)) !== "akm")
         return result;
     const pending = collectPendingMemories(primary.path).filter((record) => !options.candidateRefs || options.candidateRefs.has(record.ref));
     result.considered = pending.length;
@@ -179,7 +181,7 @@ export async function runMemoryInferencePass(ctx) {
         const derived = db
             ? await withLlmCache(db, record.filePath, record.body, reEnrich ?? false, () => compressMemoryToDerivedMemory(llmConfig, record.body, signal, featureConfig, (evt) => {
                 warn(`[akm] LLM fallback for ${evt.feature}: ${evt.reason}`);
-            }, inferTelemetry, onRetryAttempt), validate, undefined, "", {
+            }, inferTelemetry, onRetryAttempt), validate, undefined, "memory-inference-v2", {
                 onCacheHit: () => {
                     fromCache = true;
                 },
@@ -221,8 +223,8 @@ export async function runMemoryInferencePass(ctx) {
             precheck: false,
         };
     }, 
-    // Default concurrency of 4 for cloud APIs. Set `llm.concurrency: 1`
-    // in config.json for local model servers (LM Studio, Ollama).
+    // Caller-set connection concurrency or 1: `resolveLlmEngineUse` does
+    // not forward `engines.<name>.concurrency`, so config cannot raise this.
     llmConfig.concurrency ?? 1);
     for (let i = 0; i < perRecordResults.length; i++) {
         const res = perRecordResults[i];
@@ -314,7 +316,7 @@ export function collectPendingMemories(stashRoot) {
         out.push({
             filePath,
             stashRoot,
-            ref: `memory:${relName}`,
+            ref: conceptIdFromTypeName("memory", relName),
             data: parsed.data,
             body: parsed.content,
             name: relName,
@@ -374,6 +376,7 @@ async function writeDerivedMemory(parent, derived) {
         kind: "filesystem",
         name: "stash",
         path: parent.stashRoot,
+        adapterId: "akm",
     };
     const writeConfig = {
         type: "filesystem",
@@ -407,16 +410,15 @@ function renderDerivedMemory(parent, derived) {
     const fm = {
         [FM_INFERRED]: true,
         [FM_CAPTURE_MODE]: "background",
-        // Group-C item 2: the `source:` backref (the `derived_from` channel) is now
-        // written in the 0.9.0 `memories/<name>` conceptId grammar, not the legacy
-        // `memory:<name>`. `parent.ref` stays the legacy identity ref used internally
-        // for candidate/progress bookkeeping; only the on-disk backref is flipped.
+        // The `source:` backref and internal candidate identity use the same current
+        // `memories/<name>` conceptId spelling.
         [FM_SOURCE]: conceptIdFromTypeName("memory", parent.name),
         description: derived.description,
         tags: derived.tags,
         searchHints: derived.searchHints,
         title: derived.title,
         derivedFrom: parent.name,
+        updated: todayIso(),
     };
     return assembleAsset(fm, `# ${derived.title.trim()}\n\n${derived.content.trim()}\n`);
 }

package/dist/indexer/passes/metadata.js

@@ -3,10 +3,10 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
+import { parseBundleRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { asNonEmptyString } from "../../core/common.js";
 import { loadUserConfig } from "../../core/config/config.js";
-import { DEPRECATED_REJECTED_TYPES } from "../../core/recognition-util.js";
 import { isVerbose, warn } from "../../core/warn.js";
 export const SCOPE_KEYS = ["user", "agent", "run", "channel"];
 // ── Quality semantics (v1 spec §4.2) ────────────────────────────────────────
@@ -50,11 +50,9 @@ export function isProposedQuality(quality) {
 /**
  * Validate and normalize a raw object into a `IndexDocument`.
  *
- * Open type token (chunk 1.5, D1.5-1/D1.5-6): `entry.type` accepts any
- * non-empty string — foreign/adapter types are valid `IndexDocument` data, not
- * just AKM's own built-in set — EXCEPT `DEPRECATED_REJECTED_TYPES`
- * (`tool`/`vault`), which stay rejected so a hand-edited legacy sidecar can't
- * silently resurrect a deliberately-retired type.
+ * Open type token: `entry.type` accepts any non-empty string. Type ownership
+ * and capability decisions belong to the adapter; this format-neutral
+ * projection must not reject a value merely because AKM does not own it.
  */
 export function validateStashEntry(entry) {
     if (typeof entry !== "object" || entry === null)
@@ -62,7 +60,7 @@ export function validateStashEntry(entry) {
     const e = entry;
     if (typeof e.name !== "string" || !e.name)
         return null;
-    if (typeof e.type !== "string" || !e.type || DEPRECATED_REJECTED_TYPES.has(e.type))
+    if (typeof e.type !== "string" || !e.type)
         return null;
     const result = {
         name: e.name,
@@ -144,9 +142,8 @@ export function validateStashEntry(entry) {
     const sources = normalizeNonEmptyStringList(e.sources);
     if (sources)
         result.sources = sources;
-    // SPEC-6: `category` must survive the whitelist or legacy-sidecar-declared
-    // facts lose their convention/meta marker on the round-trip. Non-string
-    // values are dropped, not coerced.
+    // SPEC-6: `category` must survive the projection. Non-string values are
+    // dropped, not coerced.
     if (typeof e.category === "string" && e.category.trim().length > 0) {
         result.category = e.category.trim();
     }
@@ -165,9 +162,6 @@ export function validateStashEntry(entry) {
     if (typeof e.generation === "number" && Number.isFinite(e.generation) && e.generation > 0) {
         result.generation = Math.floor(e.generation);
     }
-    const sourceRefs = normalizeNonEmptyStringList(e.sourceRefs);
-    if (sourceRefs)
-        result.sourceRefs = sourceRefs;
     const currentBeliefRefs = normalizeNonEmptyStringList(e.currentBeliefRefs);
     if (currentBeliefRefs)
         result.currentBeliefRefs = currentBeliefRefs;
@@ -186,9 +180,8 @@ export function validateStashEntry(entry) {
     if (typeof e.derivedFrom === "string" && e.derivedFrom.trim().length > 0) {
         result.derivedFrom = e.derivedFrom.trim();
     }
-    // SPEC-8: `bodyOpening` must survive the whitelist so entries round-tripped
-    // through the legacy sidecar keep their captured opening. Preserved verbatim —
-    // the extractor already trimmed and capped it at capture time.
+    // SPEC-8: `bodyOpening` must survive the projection. The extractor already
+    // trimmed and capped it at capture time.
     if (typeof e.bodyOpening === "string" && e.bodyOpening.trim().length > 0) {
         result.bodyOpening = e.bodyOpening;
     }
@@ -283,40 +276,43 @@ function normalizeStringListOrUndefined(value) {
     return normalizeNonEmptyStringList(value);
 }
 /**
- * Normalise one derived-memory parent backref to the 0.9.0 `memories/<name>`
- * conceptId for the `derived_from` column (Group-C item 2 flip), tolerant of
- * BOTH the flipped `[bundle//]memories/<name>` producer output and the legacy
- * `[origin//]memory:<name>` spelling still on disk pre content-migration.
- * Returns `undefined` for a non-memory / bare value so the caller can fall back
- * to the bare `derivedFrom` key. Kept inline (a two-branch pure string op) so
- * the indexer stays self-contained and does not import the commands-layer
- * reader — the two normalisers agree on output by construction.
+ * Normalize a current derived-memory parent ref to its `memories/<name>`
+ * conceptId for the `derived_from` column. Returns `undefined` for a non-memory
+ * or bare value so the caller can inspect the current `derivedFrom` key.
  */
 function normalizeMemoryBackref(value) {
     if (!value)
         return undefined;
-    const trimmed = value.trim();
-    const boundary = trimmed.indexOf("//");
-    const body = boundary >= 0 ? trimmed.slice(boundary + 2) : trimmed;
-    const MEMORY_PREFIX = "memory:";
-    if (body.startsWith(MEMORY_PREFIX))
-        return `memories/${body.slice(MEMORY_PREFIX.length)}`;
-    if (body.startsWith("memories/"))
-        return body;
-    return undefined;
+    try {
+        const parsed = parseBundleRef(value);
+        return parsed.fragment === undefined && parsed.conceptId.startsWith("memories/") ? parsed.conceptId : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 /**
- * Resolve a derived memory's parent conceptId from its `source:` backref (new or
- * legacy grammar) or, failing that, its bare `derivedFrom: <name>` frontmatter
- * key (promoted to `memories/<name>`). `undefined` when neither yields a parent.
+ * Resolve a derived memory's parent conceptId from its current `source:` backref
+ * or, failing that, its bare `derivedFrom: <name>` frontmatter key.
  */
 function derivedFromConceptId(source, derivedFrom) {
     const fromSource = normalizeMemoryBackref(source);
     if (fromSource)
         return fromSource;
-    if (derivedFrom)
-        return normalizeMemoryBackref(derivedFrom) ?? `memories/${derivedFrom}`;
-    return undefined;
+    const rawDerivedFrom = derivedFrom?.trim();
+    if (!rawDerivedFrom)
+        return undefined;
+    const qualified = normalizeMemoryBackref(rawDerivedFrom);
+    if (qualified)
+        return qualified;
+    if (rawDerivedFrom.includes(":") || rawDerivedFrom.includes("//"))
+        return undefined;
+    try {
+        return parseBundleRef(`memories/${rawDerivedFrom}`).conceptId;
+    }
+    catch {
+        return undefined;
+    }
 }
 export function applyCuratedFrontmatter(entry, fmData) {
     const description = asNonEmptyString(fmData.description);
@@ -367,17 +363,12 @@ export function applyCuratedFrontmatter(entry, fmData) {
     const contradictedBy = normalizeStringListOrUndefined(fmData.contradictedBy);
     if (contradictedBy)
         entry.contradictedBy = contradictedBy;
-    // R5 — consolidation provenance. `generation` (merge depth counter) and
-    // `source_refs` (merge/distill provenance pointers) are written by the
-    // improve pipeline; captured into the index so the collapse detector can
-    // count over-generation assets and follow merges without filesystem reads.
+    // R5 — consolidation generation depth is captured so the collapse detector
+    // can count over-generation assets without filesystem reads.
     const generation = fmData.generation;
     if (typeof generation === "number" && Number.isFinite(generation) && generation > 0) {
         entry.generation = Math.floor(generation);
     }
-    const sourceRefs = normalizeStringListOrUndefined(fmData.source_refs);
-    if (sourceRefs)
-        entry.sourceRefs = sourceRefs;
     const currentBeliefRefs = normalizeStringListOrUndefined(fmData.currentBeliefRefs);
     if (currentBeliefRefs)
         entry.currentBeliefRefs = currentBeliefRefs;
@@ -493,6 +484,80 @@ export function applyWikiFrontmatter(entry, fmData) {
             entry.sources = filtered;
     }
 }
+/**
+ * Parse one `verified:` family value into the `IndexDocument.provenance` shape.
+ * Accepts OKF v0.2's list form and its documented single-mapping shorthand
+ * ("consumers MUST treat a bare mapping as a one-element list", SPEC §5.2).
+ * Tolerant: an entry without a usable `by` is dropped individually.
+ */
+function parseVerifiedFamily(value) {
+    const entries = Array.isArray(value) ? value : [value];
+    return entries
+        .filter((v) => v !== null && typeof v === "object" && !Array.isArray(v))
+        .map((v) => {
+        const by = asNonEmptyString(v.by);
+        if (!by)
+            return undefined;
+        const at = asNonEmptyString(v.at);
+        return at ? { by, at } : { by };
+    })
+        .filter((v) => v !== undefined);
+}
+/**
+ * Extract the OKF v0.2 provenance families that `promoteProposal` stamps onto
+ * accepted AKM-native proposals (D2, #730), and apply them to the entry.
+ *
+ * The on-disk shape is deliberately **hybrid** (owner decision, #730 review):
+ * `generated:` and `verified:` are stamped BARE at the top level, exactly as
+ * OKF v0.2 spells them, because neither has any pre-existing AKM consumer — so
+ * a third-party OKF v0.2 reader treating an AKM stash as an OKF bundle sees
+ * spec-conformant trust metadata, which is what `okf-support.md`'s
+ * "AKM Markdown is an OKF-compatible superset" positioning promises. Only
+ * `sources` stays namespaced under `provenance:`, because a bare top-level
+ * `sources:` genuinely collides with {@link applyWikiFrontmatter}'s
+ * pre-existing citation-**string** convention (which silently drops
+ * non-strings).
+ *
+ * The nested `provenance.generatedBy` / `.generatedAt` / `.verified` spellings
+ * are still read as a fallback so assets stamped by an earlier build of this
+ * branch keep resolving. Tolerant throughout: any malformed sub-field is
+ * dropped individually rather than rejecting the whole block.
+ */
+export function applyProvenanceFrontmatter(entry, fmData) {
+    const provenance = fmData.provenance;
+    const nested = provenance !== null && typeof provenance === "object" && !Array.isArray(provenance)
+        ? provenance
+        : {};
+    const result = {};
+    // Bare `generated: {by, at}` (OKF v0.2 §5.3) wins; nested is the fallback.
+    const generatedMapping = fmData.generated !== null && typeof fmData.generated === "object" && !Array.isArray(fmData.generated)
+        ? fmData.generated
+        : undefined;
+    const generatedBy = asNonEmptyString(generatedMapping?.by) ?? asNonEmptyString(nested.generatedBy);
+    if (generatedBy)
+        result.generatedBy = generatedBy;
+    const generatedAt = asNonEmptyString(generatedMapping?.at) ?? asNonEmptyString(nested.generatedAt);
+    if (generatedAt)
+        result.generatedAt = generatedAt;
+    // Bare `verified:` (list or single mapping) wins; nested is the fallback.
+    const verified = fmData.verified !== undefined ? parseVerifiedFamily(fmData.verified) : parseVerifiedFamily(nested.verified);
+    if (verified.length > 0)
+        result.verified = verified;
+    // `sources` is namespaced-only — see the collision note above.
+    if (Array.isArray(nested.sources)) {
+        const sources = nested.sources
+            .filter((s) => s !== null && typeof s === "object" && !Array.isArray(s))
+            .map((s) => {
+            const resource = asNonEmptyString(s.resource);
+            return resource ? { resource } : undefined;
+        })
+            .filter((s) => s !== undefined);
+        if (sources.length > 0)
+            result.sources = sources;
+    }
+    if (Object.keys(result).length > 0)
+        entry.provenance = result;
+}
 // AKM-stash indexing policy (env/vaults/secrets sensitive-marker + wiki-infra
 // exclusions) moved to the `akm` adapter's `recognize` as path/stat-based
 // abstention (owner ruling 2026-07-21 — adapter-owned filtering). See
@@ -763,7 +828,6 @@ function mergeAliases(existing, generated) {
  *
  * This predicate is used by `enhanceDirsWithLlm` to skip the LLM call for
  * entries that were previously enriched and already carry all three fields.
- * Pass `reEnrich = true` in the caller to bypass this check.
  */
 export function isEnrichmentComplete(entry) {
     const hasDescription = typeof entry.description === "string" && entry.description.trim().length > 0;
@@ -994,6 +1058,8 @@ export function applyPreContributorFields(entry, file, ctx, pkgMeta) {
             entry.parameters = fmParams;
         // Pass wiki-pattern frontmatter through onto the entry
         applyWikiFrontmatter(entry, parsed.data);
+        // D2 (#730): reread the namespaced `provenance:` block promoteProposal stamps.
+        applyProvenanceFrontmatter(entry, parsed.data);
         // Stash-organization conventions (SPEC-8): config-gated capture of the
         // self-situating body opening. Default off — enabling it changes indexed
         // text (collapse-detector canary baselines shift, and embeddings for

package/dist/indexer/scan/doc-to-entry.js

@@ -58,10 +58,39 @@ export function indexDocumentToStashEntry(doc) {
         entry.description = doc.description;
     if (doc.tags !== undefined)
         entry.tags = doc.tags;
+    if (doc.content !== undefined)
+        entry.content = doc.content;
+    if (doc.ownsPresentation !== undefined)
+        entry.ownsPresentation = doc.ownsPresentation;
+    if (doc.updated !== undefined)
+        entry.updated = doc.updated;
+    if (doc.links !== undefined)
+        entry.links = doc.links;
+    if (doc.adapterId === "okf") {
+        if (doc.documentJson !== undefined)
+            entry.documentJson = doc.documentJson;
+        // OKF v0.2 trust/provenance/lifecycle family (okf-support.md v0.2 note).
+        // These are first-class IndexDocument members the okf adapter sets
+        // directly (never routed through documentJson), so — unlike the akm
+        // adapter's DOCUMENT_JSON_CARRIED_FIELDS reconstruction below — they need
+        // an explicit carry here too, or persistence silently drops them even
+        // though `recognize()` itself returns them correctly.
+        if (doc.provenance !== undefined)
+            entry.provenance = doc.provenance;
+        if (doc.lifecycleStatus !== undefined)
+            entry.lifecycleStatus = doc.lifecycleStatus;
+        if (doc.staleAfter !== undefined)
+            entry.staleAfter = doc.staleAfter;
+        if (doc.okfVersion !== undefined)
+            entry.okfVersion = doc.okfVersion;
+        return entry;
+    }
     if (doc.aliases !== undefined)
         entry.aliases = doc.aliases;
     if (doc.searchHints !== undefined)
         entry.searchHints = doc.searchHints;
+    if (doc.hints !== undefined)
+        entry.hints = doc.hints;
     if (doc.quality !== undefined)
         entry.quality = doc.quality;
     if (doc.confidence !== undefined)
@@ -78,6 +107,8 @@ export function indexDocumentToStashEntry(doc) {
         entry.lessonStrength = doc.lessonStrength;
     if (doc.derivedFrom !== undefined)
         entry.derivedFrom = doc.derivedFrom;
+    if (doc.pinned !== undefined)
+        entry.pinned = doc.pinned;
     // ── documentJson-carried extras (DOCUMENT_JSON_CARRIED_FIELDS) ──
     // The `renderer` key on documentJson is adapter-internal (WI-C presentation),
     // NOT a IndexDocument field — deliberately not restored.
@@ -106,8 +137,14 @@ export function indexDocumentToStashEntry(doc) {
     assignStringList(entry, "sources", dj.sources);
     if (typeof dj.generation === "number")
         entry.generation = dj.generation;
-    assignStringList(entry, "sourceRefs", dj.sourceRefs);
     assignStringList(entry, "evidenceSources", dj.evidenceSources);
+    // D2 (#730): OKF v0.2 provenance promoteProposal stamps onto AKM-native
+    // writes, carried via DOCUMENT_JSON_CARRIED_FIELDS (akm-adapter.ts) —
+    // unpacked back to a first-class member here exactly like `sources`/
+    // `generation`/`evidenceSources` above, so it round-trips to the top level
+    // of the persisted entry rather than staying nested under `documentJson`.
+    if (dj.provenance !== undefined)
+        entry.provenance = dj.provenance;
     return entry;
 }
 function assignStringList(entry, key, value) {