akm-cli 0.10.261007-beta → 0.10.261009-beta

package/dist/commands/read/curate.js

@@ -24,7 +24,7 @@ import { appendEvent } from "../../core/events.js";
 import { nonTaskInput } from "../../core/non-task-input.js";
 import { redactCredentialPatterns } from "../../core/redaction.js";
 import { withStateDbTelemetry } from "../../core/state-db.js";
-import { searchHitContent } from "../../indexer/search/db-search.js";
+import { matchBeliefFilter, searchHitContent } from "../../indexer/search/db-search.js";
 import { copySearchHitAttribution, getSearchHitAttribution, usageEventAttributionMetadata, } from "../../indexer/search/search-attribution.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { estimateTokenCount } from "../../llm/embedders/remote.js";
@@ -32,9 +32,11 @@ import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
 import { rerankDocuments } from "../../llm/rerank-client.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";
-import { akmSearch, parseSearchSource } from "./search.js";
+import { findEntryIdByRef, getEntryIdByFilePath, getItemRefById, } from "../../storage/repositories/index-entries-repository.js";
+import { akmSearch, normalizeScopeFilters, parseBeliefFilterMode, parseSearchSource } from "./search.js";
 import { akmShowUnified } from "./show.js";
+// Keep the effective policy with the result through packing without changing JSON.
+const recallPolicies = new WeakMap();
 const DEFAULT_CURATE_LIMIT = 4;
 const MAX_CURATE_SUPPORT_REFS = 2;
 /** Fused candidates the reranker reorders when `search.curateRerank.topN` is unset. */
@@ -103,6 +105,12 @@ export async function akmCurate(options) {
     if (!trimmedQuery) {
         throw new UsageError('A curation query is required. Usage: akm curate "<task or prompt>" [--type <type>] [--limit <n>]', "MISSING_REQUIRED_ARGUMENT");
     }
+    const recall = {
+        type: options.type,
+        source: options.source ?? "local",
+        filters: normalizeScopeFilters(options.filters),
+        belief: parseBeliefFilterMode(options.belief ?? "current"),
+    };
     const nonTask = nonTaskInput(trimmedQuery);
     if (nonTask) {
         const abstained = {
@@ -125,15 +133,18 @@ export async function akmCurate(options) {
             // An enabled reranker reorders the top fused candidates, not just the final `limit`.
             limit: Math.max(limit, rerankTopN(loadConfig())),
             source,
+            filters: recall.filters,
+            belief: recall.belief,
             skipLogging: true,
         }));
-    const result = await curateSearchResults(options.query, searchResponse, limit, options.type, options.eventSource);
+    const result = await curateSearchResults(options.query, searchResponse, limit, options.type, options.eventSource, options.searchResponse ? undefined : recall);
+    recallPolicies.set(result, recall);
     if (!options.skipLogging) {
         logCurateEvent(options.query, result, options.eventSource, options.attributionProjection);
     }
     return result;
 }
-export async function curateSearchResults(query, result, limit, selectedType, eventSource) {
+export async function curateSearchResults(query, result, limit, selectedType, eventSource, recall) {
     const allStashHits = result.hits.filter((hit) => hit.type !== "registry");
     const registryHits = result.registryHits ?? [];
     // F3/R-018: `--type` NARROWS the candidate pool. The caller's search
@@ -145,9 +156,18 @@ export async function curateSearchResults(query, result, limit, selectedType, ev
     // F4/R-019: respect `--limit` for registry fill instead of hard-capping it
     // at a bare literal 2 — the remaining slots after stash hits ARE the cap.
     const selectedRegistryHits = selectedStashHits.length >= limit ? [] : registryHits.slice(0, limit - selectedStashHits.length);
-    const selectedRefs = new Set(selectedStashHits.map((hit) => hit.ref));
+    const selectedRefs = new Set(selectedStashHits.flatMap((hit) => {
+        if (!recall)
+            return [hit.ref];
+        try {
+            return [hit.ref, evidenceRef(hit)];
+        }
+        catch {
+            return [hit.ref]; // no longer indexed: enrichCuratedStashHit drops it
+        }
+    }));
     const items = [
-        ...(await Promise.all(selectedStashHits.map((hit) => enrichCuratedStashHit(query, hit, selectedRefs, eventSource)))),
+        ...(await Promise.all(selectedStashHits.map((hit) => enrichCuratedStashHit(query, hit, selectedRefs, eventSource, recall)))).filter((item) => item !== undefined),
         ...selectedRegistryHits.map((hit) => buildCuratedRegistryItem(query, hit)),
     ].slice(0, limit);
     return {
@@ -181,15 +201,24 @@ export async function packCuratedHits(result, budgetTokens) {
     for (const item of stashItems) {
         let shown;
         try {
-            shown = await akmShowUnified({ ref: item.ref, skipLogging: true });
+            shown = await akmShowUnified({
+                ref: evidenceRef(item),
+                skipLogging: true,
+                recall: recallPolicies.get(result) ?? { belief: "current" },
+            });
         }
         catch {
             continue;
         }
+        const historical = matchBeliefFilter(shown.beliefState, "historical");
+        const context = {
+            ...(shown.beliefState ? { beliefState: shown.beliefState } : {}),
+            ...(historical ? { reason: "Historical context; not current supporting authority." } : {}),
+        };
         const content = shown.content ?? shown.template ?? shown.prompt ?? "";
         const tokens = estimateTokenCount(content);
         if (used + tokens <= budgetTokens) {
-            packed.push({ ref: item.ref, tokens, content });
+            packed.push({ ref: item.ref, tokens, content, ...context });
             used += tokens;
             continue;
         }
@@ -197,7 +226,7 @@ export async function packCuratedHits(result, budgetTokens) {
             const remaining = budgetTokens - used;
             if (remaining > 0) {
                 const truncated = content.slice(0, remaining * 4);
-                packed.push({ ref: item.ref, tokens: estimateTokenCount(truncated), content: truncated });
+                packed.push({ ref: item.ref, tokens: estimateTokenCount(truncated), content: truncated, ...context });
                 used += estimateTokenCount(truncated);
             }
         }
@@ -205,22 +234,38 @@ export async function packCuratedHits(result, budgetTokens) {
     }
     return { query: result.query, budget: budgetTokens, tokens: used, items: packed };
 }
-async function enrichCuratedStashHit(query, hit, selectedRefs, eventSource) {
+function evidenceRef(item) {
+    return withIndexDb((db) => {
+        const id = getEntryIdByFilePath(db, item.path);
+        const ref = id === undefined ? undefined : getItemRefById(db, id);
+        if (!ref) {
+            if (item.path)
+                throw new UsageError(`Indexed asset no longer available: ${item.ref}`);
+            return item.ref;
+        }
+        const fragment = parseBundleRef(item.ref).fragment;
+        return fragment ? `${ref}#${fragment}` : ref;
+    });
+}
+async function enrichCuratedStashHit(query, hit, selectedRefs, eventSource, recall) {
     let shown;
     try {
-        shown = await akmShowUnified({ ref: hit.ref, eventSource, skipLogging: true });
+        shown = await akmShowUnified({ ref: recall ? evidenceRef(hit) : hit.ref, eventSource, skipLogging: true, recall });
     }
     catch {
+        if (recall)
+            return undefined;
         shown = undefined;
     }
+    const ref = shown?.selectedRef ?? shown?.ref ?? hit.ref;
     const description = shown?.description ?? hit.description;
     const preview = buildCuratedPreview(shown, hit);
-    const supportRefs = buildCurateSupportRefs(shown?.links, selectedRefs, hit.ref);
+    const supportRefs = await buildCurateSupportRefs(shown?.links, selectedRefs, ref, recall);
     const item = {
         source: "local",
         type: shown?.type ?? hit.type,
         name: shown?.name ?? hit.name,
-        ref: hit.ref,
+        ref,
         path: shown?.path ?? hit.path,
         editable: shown?.editable ?? hit.editable ?? false,
         ...((shown?.editable ?? hit.editable ?? false) === false
@@ -232,8 +277,9 @@ async function enrichCuratedStashHit(query, hit, selectedRefs, eventSource) {
         ...(shown?.parameters?.length ? { parameters: shown.parameters } : {}),
         ...(shown?.run ? { run: shown.run } : {}),
         ...(supportRefs.length > 0 ? { supportRefs } : {}),
-        followUp: `akm show ${hit.ref}`,
-        reason: buildCuratedReason(query, shown?.type ?? hit.type),
+        followUp: `akm show ${ref}`,
+        ...(shown?.beliefState ? { beliefState: shown.beliefState } : {}),
+        reason: `${matchBeliefFilter(shown?.beliefState, "historical") ? "Historical context. " : ""}${buildCuratedReason(query, shown?.type ?? hit.type)}`,
         ...(hit.score !== undefined ? { score: hit.score } : {}),
     };
     copySearchHitAttribution(hit, item, item.description);
@@ -333,7 +379,7 @@ function rerankDocumentTexts(hits) {
  * it, in the order `akm show` lists them. The LLM entity graph's `related`
  * list no longer feeds them.
  */
-function buildCurateSupportRefs(links, selectedRefs, ownerRef) {
+async function buildCurateSupportRefs(links, selectedRefs, ownerRef, recall) {
     const supportRefs = [];
     for (const [part, direction] of [
         ["outgoing", "from"],
@@ -343,11 +389,24 @@ function buildCurateSupportRefs(links, selectedRefs, ownerRef) {
             for (const ref of group.refs) {
                 if (ref === ownerRef || selectedRefs.has(ref) || supportRefs.some((existing) => existing.ref === ref))
                     continue;
+                let shown;
+                if (recall) {
+                    try {
+                        // A support ref is a link, not a hit: `--type` narrows the hits only.
+                        const { type: _type, ...linkRecall } = recall;
+                        shown = await akmShowUnified({ ref, recall: linkRecall, skipLogging: true });
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                const historical = matchBeliefFilter(shown?.beliefState, "historical");
                 const type = supportRefType(ref);
                 supportRefs.push({
                     ref,
                     ...(type ? { type } : {}),
-                    reason: `Declared link (${kind}) ${direction} this asset.`,
+                    ...(shown?.beliefState ? { beliefState: shown.beliefState } : {}),
+                    reason: `${historical ? "Historical context; " : ""}Declared link (${kind}) ${direction} this asset.`,
                 });
                 if (supportRefs.length >= MAX_CURATE_SUPPORT_REFS)
                     return supportRefs;

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

@@ -24,6 +24,14 @@ 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";
+const scopeFilterArg = {
+    type: "string",
+    description: "Scope filter (repeatable): --filter user=<id> --filter agent=<id> --filter run=<id> --filter channel=<name>. Narrows results without changing ranking.",
+};
+const beliefArg = {
+    type: "string",
+    description: "Belief filter on any asset: all|current|historical. current keeps active/asserted and unflagged assets; historical keeps deprecated/contradicted/superseded/archived assets. Labels do not establish factual truth.",
+};
 export const searchCommand = defineJsonCommand({
     meta: { name: "search", description: "Search the bundle" },
     args: {
@@ -44,20 +52,13 @@ export const searchCommand = defineJsonCommand({
             description: "Include asset-level search results (only meaningful with --from registry|all)",
             default: false,
         },
-        filter: {
-            type: "string",
-            description: "Scope filter (repeatable): --filter user=<id> --filter agent=<id> --filter run=<id> --filter channel=<name>. Narrows results without changing ranking.",
-        },
+        filter: scopeFilterArg,
         "include-proposed": {
             type: "boolean",
             description: 'Include entries with quality:"proposed" in the result set. Excluded by default.',
             default: false,
         },
-        belief: {
-            type: "string",
-            description: "Memory belief filter: all|current|historical. current keeps active memory beliefs; historical keeps contradicted/superseded/archived memory beliefs.",
-            default: "all",
-        },
+        belief: { ...beliefArg, default: "current" },
         "include-sessions": {
             type: "boolean",
             description: "Include session assets (excluded from default search results via config.search.defaultExcludeTypes).",
@@ -110,6 +111,8 @@ 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" },
+        filter: scopeFilterArg,
+        belief: { ...beliefArg, default: "current" },
         pack: {
             type: "string",
             description: "Pack the ranked stash hits' full content into a single token-budgeted blob instead of returning refs " +
@@ -123,7 +126,14 @@ export const curateCommand = defineJsonCommand({
     async run({ args }) {
         const packBudget = parsePositiveIntFlag(args.pack ?? undefined, "--pack");
         const outputMode = getOutputMode();
-        const curated = await runCurate({ query: args.query, type: args.type, limit: args.limit, from: args.from }, outputMode);
+        const curated = await runCurate({
+            query: args.query,
+            type: args.type,
+            limit: args.limit,
+            from: args.from,
+            filters: parseAllFlagValues("--filter"),
+            belief: args.belief,
+        }, outputMode);
         if (packBudget !== undefined) {
             const packed = await packCuratedHits(curated, packBudget);
             deliverRendered(outputMode.format === "text" ? formatCuratePackText(packed) : JSON.stringify(packed.items, null, 2), outputMode.outputPath);
@@ -149,6 +159,8 @@ export async function runCurate(args, outputMode) {
         type: args.type,
         limit: limitParsed && limitParsed > 0 ? limitParsed : 4,
         source: parseSearchSource(args.from ?? "local"),
+        filters: parseScopeFilterFlags(args.filters ?? [], "--filter"),
+        belief: parseBeliefFilterMode(args.belief ?? "current"),
         eventSource: resolveUsageEventSource(),
         attributionProjection: outputMode.shape === "agent" ? "agent" : outputMode.detail,
     });
@@ -158,7 +170,9 @@ 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");
+    return packed.items
+        .map((item) => `## ${item.ref}\n\n${item.reason ? `${item.reason}\n\n` : ""}${item.content}`)
+        .join("\n\n");
 }
 /**
  * Reject any positional after the ref: `akm show` takes one ref, and a stray

package/dist/commands/read/search.js

@@ -103,7 +103,7 @@ export async function akmSearch(input) {
     const sources = allSources;
     const filters = normalizeScopeFilters(input.filters);
     const includeProposed = input.includeProposed === true;
-    const belief = input.belief ?? "all";
+    const belief = parseBeliefFilterMode(input.belief ?? "current");
     const localResult = source === "registry"
         ? undefined
         : await searchLocal({
@@ -118,7 +118,7 @@ export async function akmSearch(input) {
             beliefFilter: belief,
             // When `--from <name>` narrowed the source list above, propagate
             // that intent down to the database layer so FTS/vector hits from
-            // sources outside the narrowed set are filtered out post-ranking.
+            // sources outside the narrowed set cannot consume candidate budgets.
             // Without this, the index (which spans every configured source)
             // would leak hits from sources the caller did not request.
             restrictToSources: namedSourceName !== undefined,
@@ -384,7 +384,7 @@ export function parseBeliefFilterMode(value) {
  * `undefined` when nothing meaningful remains, so callers don't pay for an
  * empty-filter post-walk in `searchLocal`.
  */
-function normalizeScopeFilters(raw) {
+export function normalizeScopeFilters(raw) {
     if (!raw)
         return undefined;
     const out = {};

package/dist/commands/read/show.js

@@ -34,13 +34,15 @@ import { SCRIPT_EXTENSIONS } from "../../core/recognition-util.js";
 import { presentationFor } from "../../core/type-presentation.js";
 import { warn, warnOnce } from "../../core/warn.js";
 import { lookupBundleRef, lookupBundleRefWithResolution, lookupBundleRefWithResolutionReadonly, } from "../../indexer/indexer.js";
-import { projectMarkdownFragmentContent } from "../../indexer/passes/metadata.js";
+import { applyCuratedFrontmatter, applyProvenanceFrontmatter, projectMarkdownFragmentContent, } from "../../indexer/passes/metadata.js";
 import { ensurePrimaryIndexForRead, resolveReadSources } from "../../indexer/read-preflight.js";
+import { applyEntryFilters } from "../../indexer/search/db-search.js";
 import { buildEditHint, findSourceForPath, isEditable, resolveSourceEntries, } from "../../indexer/search/search-source.js";
 import { recentShowCount, recordShowUsage } from "../../indexer/usage/show-usage.js";
 import { buildFileContext, buildRenderContext, getRenderer, } from "../../indexer/walk/file-context.js";
 import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
 import { withIndexDb } from "../../storage/repositories/index-db.js";
+import { getEntryById, getEntryIdByFilePath } from "../../storage/repositories/index-entries-repository.js";
 import { getIndexedMarkdownFragment } from "../../storage/repositories/index-fts-repository.js";
 import { readEntryLinks } from "../../storage/repositories/index-links-repository.js";
 import { getCurrentWorkflowScopeKey } from "../../workflows/authoring/scope-key.js";
@@ -258,6 +260,34 @@ export async function showLocal(input) {
             "Run `akm bundle create` to create the stash directory, or check `akm bundle list` for configured paths.");
     }
     const fileCtx = buildFileContext(sourceStashDir, assetPath);
+    let beliefState;
+    if (input.recall) {
+        const policy = input.recall;
+        const sources = policy.source && !["local", "all"].includes(policy.source)
+            ? resolveSourcesForOrigin(policy.source, allSources)
+            : allSources;
+        const eligible = withIndexDb((db) => {
+            const id = getEntryIdByFilePath(db, assetPath);
+            const row = id === undefined ? undefined : getEntryById(db, id);
+            if (!row || id === undefined)
+                return false;
+            // Source-live show must not restore a belief/scope changed after indexing.
+            const entry = { ...row.entry, scope: undefined };
+            applyCuratedFrontmatter(entry, parseFrontmatter(fileCtx.content()).data);
+            const allowed = applyEntryFilters([{ ...row, id, entry }], {
+                db,
+                sources,
+                restrictToSources: true,
+                filters: policy.filters,
+                includeProposed: false,
+                beliefFilter: policy.belief ?? "current",
+            });
+            beliefState = entry.beliefState;
+            return allowed.length > 0 && (!policy.type || policy.type === "any" || entry.type === policy.type);
+        }, { readOnly: input.readOnly === true });
+        if (!eligible)
+            throw new NotFoundError(`Asset not found for recall filters: ${input.ref}`);
+    }
     const presentedName = indexedEntry.name;
     const opaqueFragmentSelector = parsed.fragment?.startsWith("akm-fragment-") === true;
     // Friendly heading selectors retain the source-live exact response contract.
@@ -302,6 +332,8 @@ export async function showLocal(input) {
     catch (error) {
         throwIndexedPathNotFound(error, input.ref);
     }
+    if (beliefState)
+        response.beliefState = beliefState;
     response.type = indexedEntry.type;
     response.name = indexedEntry.name;
     const isPrimaryStash = source?.isDefault === true;
@@ -364,8 +396,22 @@ export async function showLocal(input) {
         delete response.toolPolicy;
     }
     const editable = isEditable(assetPath, config, allSources);
+    // Evidence must describe the same revision as the rendered claim: ordinary
+    // Markdown show is source-live, while indexed fragment show is a snapshot.
+    let evidenceMetadata;
+    if (["memory", "lesson", "knowledge"].includes(response.type)) {
+        evidenceMetadata = indexedFragment ? indexedEntry.document : { name: presentedName, type: response.type };
+        if (!indexedFragment && evidenceMetadata) {
+            const frontmatter = parseFrontmatter(fileCtx.content()).data;
+            applyCuratedFrontmatter(evidenceMetadata, frontmatter);
+            applyProvenanceFrontmatter(evidenceMetadata, frontmatter);
+        }
+    }
     const fullResponse = {
         ...response,
+        ...(evidenceMetadata?.evidence ? { evidence: evidenceMetadata.evidence } : {}),
+        ...(evidenceMetadata?.evidenceSources ? { evidenceSources: evidenceMetadata.evidenceSources } : {}),
+        ...(evidenceMetadata?.evidence && evidenceMetadata.provenance ? { provenance: evidenceMetadata.provenance } : {}),
         ref: canonicalRef,
         origin: source?.registryId ?? null,
         editable,

package/dist/core/adapter/adapters/akm-adapter.js

@@ -192,6 +192,7 @@ const DOCUMENT_JSON_CARRIED_FIELDS = [
     "wikiRole",
     "sources",
     "evidenceSources",
+    "evidence",
     // #935: a workflow's step targets and a task's target, read as declared links.
     "uses",
     // D2 (#730): the OKF v0.2 provenance `promoteProposal` stamps onto AKM-native

package/dist/core/adapter/adapters/llm-wiki-adapter.js

@@ -73,6 +73,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { parseFrontmatter, parseFrontmatterBlock } from "../../asset/frontmatter.js";
+import { markdownLinkTargets } from "../../asset/markdown-link-targets.js";
 import { toPosix } from "../../common.js";
 import { hashContent, nonEmptyString } from "./shared.js";
 /** A wiki is a single-component bundle; its one component is conventionally `main` (recognition golden). */
@@ -169,13 +170,10 @@ function resolveXref(xref, bundleId) {
  */
 function resolveBodyLinks(body, fileRelPath) {
     const dir = path.posix.dirname(toPosix(fileRelPath));
-    const linkRe = /\[[^\]]*\]\(([^)]+)\)/g;
     const out = [];
     const seen = new Set();
-    let match;
-    // biome-ignore lint/suspicious/noAssignInExpressions: idiomatic regex loop
-    while ((match = linkRe.exec(body)) !== null) {
-        let target = match[1].trim();
+    for (const link of markdownLinkTargets(body, false)) {
+        let target = link.trim();
         const wsIdx = target.search(/\s/);
         if (wsIdx >= 0)
             target = target.slice(0, wsIdx);

package/dist/core/adapter/adapters/okf-adapter.js

@@ -31,6 +31,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseFrontmatter } from "../../asset/frontmatter.js";
+import { markdownLinkTargets } from "../../asset/markdown-link-targets.js";
 import { isRecord, toPosix } from "../../common.js";
 import { hashContent, nonEmptyString, RESERVED_FILES, readTags, runBaseValidateChecks } from "./shared.js";
 /** v0.2 frontmatter keys consumed into first-class fields below (§0.1) — excluded from the generic `documentJson` extras fold alongside the v0.1 five, so nothing is duplicated between a first-class field and the opaque extras bag. */
@@ -142,24 +143,10 @@ function isReservedFileName(name) {
  */
 export function resolveOkfLinks(body, fileRelPath) {
     const dir = path.posix.dirname(toPosix(fileRelPath));
-    const definitions = new Map();
-    for (const match of body.matchAll(/^\s*\[([^\]]+)\]:\s*(\S+)/gm)) {
-        definitions.set(match[1].trim().toLowerCase(), match[2]);
-    }
-    const candidates = [];
-    for (const match of body.matchAll(/\[[^\]]*\]\(([^)]+)\)/g)) {
-        candidates.push({ index: match.index, target: match[1] });
-    }
-    for (const match of body.matchAll(/(?<!!)\[[^\]]*\]\[([^\]]+)\]/g)) {
-        const target = definitions.get(match[1].trim().toLowerCase());
-        if (target)
-            candidates.push({ index: match.index, target });
-    }
-    candidates.sort((a, b) => a.index - b.index);
     const out = [];
     const seen = new Set();
-    for (const candidate of candidates) {
-        let target = candidate.target.trim();
+    for (const link of markdownLinkTargets(body, true)) {
+        let target = link.trim();
         // Drop an optional markdown link title: `[x](/a.md "Title")`.
         const wsIdx = target.search(/\s/);
         if (wsIdx >= 0)

package/dist/core/asset/markdown-link-targets.js

@@ -0,0 +1,43 @@
+// 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 { Marked } from "marked";
+// A private instance keeps unrelated consumers' global Marked options out of indexing.
+const markdown = new Marked({ gfm: true });
+/**
+ * Actual document links, in authored order. The tokenizer owns code regions,
+ * escapes and nested containers; the adapter still owns its supported syntax
+ * and path resolution. In particular, shortcut/collapsed references and wiki
+ * links are not new indexed syntax. Inline images retain their existing treatment.
+ */
+export function markdownLinkTargets(body, references) {
+    const tokens = markdown.lexer(body);
+    const definitions = new Map();
+    if (references) {
+        markdown.walkTokens(tokens, (token) => {
+            if (token.type !== "def")
+                return;
+            const definition = /^\s*\[([^\]]+)\]:\s*(\S+)/.exec(token.raw);
+            if (definition)
+                definitions.set(definition[1].trim().toLowerCase(), definition[2]);
+        });
+    }
+    const targets = [];
+    markdown.walkTokens(tokens, (token) => {
+        if (token.type !== "link" && token.type !== "image")
+            return;
+        const inline = /^!?\[[\s\S]*\]\(/.test(token.raw);
+        if (inline) {
+            // Angle-wrapped destinations were outside the adapters' existing subset.
+            const angled = /\]\(\s*<[^>]*>(?:\s+["'(][\s\S]*["')])?\s*\)$/.test(token.raw);
+            if (!angled)
+                targets.push(token.href);
+            return;
+        }
+        const reference = references && token.type === "link" ? /^\[[\s\S]*\]\[([^\]]+)\]$/.exec(token.raw) : null;
+        const target = reference ? definitions.get(reference[1].trim().toLowerCase()) : undefined;
+        if (target)
+            targets.push(target);
+    });
+    return targets;
+}

package/dist/core/common.js

@@ -165,8 +165,15 @@ export function writeFileAtomic(target, content, mode) {
     try {
         fd = fs.openSync(tmp, "wx", fileMode);
         tempOwned = true;
-        if (process.platform !== "win32")
-            fs.fchmodSync(fd, fileMode);
+        if (process.platform !== "win32") {
+            try {
+                fs.fchmodSync(fd, fileMode);
+            }
+            catch (error) {
+                if (!isChmodUnsupported(error))
+                    throw error;
+            }
+        }
         let offset = 0;
         while (offset < data.byteLength) {
             const written = fs.writeSync(fd, data, offset, data.byteLength - offset);
@@ -361,6 +368,14 @@ export function hasErrnoCode(error, code) {
         return false;
     return error.code === code;
 }
+/**
+ * True when a chmod failed because the filesystem has no settable POSIX modes
+ * (CIFS/SMB such as an Azure Files share, some FUSE mounts). The mount options
+ * decide the mode there, so callers keep going with whatever mode the file got.
+ */
+export function isChmodUnsupported(error) {
+    return hasErrnoCode(error, "EPERM") || hasErrnoCode(error, "ENOTSUP") || hasErrnoCode(error, "EINVAL");
+}
 /**
  * True when `value` is a RELATIVE path that cannot leave its base directory:
  * no absolute form (POSIX `/`, Windows `\` or a `C:` drive prefix), no `~`

package/dist/core/config/config-io.js

@@ -15,7 +15,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { sleepSync } from "../../runtime.js";
-import { readTextFile, stripJsonComments, writeFileAtomic } from "../common.js";
+import { isChmodUnsupported, readTextFile, stripJsonComments, writeFileAtomic } from "../common.js";
 import { ConfigError } from "../errors.js";
 import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "../file-lock.js";
 import { getCacheDir, getConfigDir } from "../paths.js";
@@ -88,7 +88,7 @@ export function backupExistingConfig(configPath, now = new Date()) {
     // env.ts/secret.ts convention — so no other local user can traverse in during
     // the copy→chmod window. chmod again to tighten a dir from an older version.
     fs.mkdirSync(backupDir, { recursive: true, mode: 0o700 });
-    fs.chmodSync(backupDir, 0o700);
+    chmodIfSupported(backupDir, 0o700);
     const timestamp = now.toISOString().replace(/[.:]/g, "-");
     let sequence = 0;
     let timestamped;
@@ -109,11 +109,21 @@ export function backupExistingConfig(configPath, now = new Date()) {
     // 08-F4: a config backup carries the same sensitive fields as the live config
     // (endpoints, tokens). `copyFileSync` inherits the source's (often 0644) mode,
     // so tighten the backups to owner-only — mirrors the env-cli 0600 write floor.
-    fs.chmodSync(timestamped, 0o600);
-    fs.chmodSync(latest, 0o600);
+    chmodIfSupported(timestamped, 0o600);
+    chmodIfSupported(latest, 0o600);
     pruneOldBackups(backupDir);
     return { timestamped, latest };
 }
+/** chmod, skipped on a filesystem without POSIX modes (CIFS), where the mount sets them. */
+function chmodIfSupported(target, mode) {
+    try {
+        fs.chmodSync(target, mode);
+    }
+    catch (error) {
+        if (!isChmodUnsupported(error))
+            throw error;
+    }
+}
 function pruneOldBackups(backupDir) {
     pruneToNewest(backupDir, MAX_CONFIG_BACKUPS, (entry) => entry.isFile() && isTimestampedConfigBackup(entry.name));
 }

package/dist/indexer/passes/metadata.js

@@ -165,6 +165,8 @@ export function validateStashEntry(entry) {
     const evidenceSources = normalizeNonEmptyStringList(e.evidenceSources);
     if (evidenceSources)
         result.evidenceSources = evidenceSources;
+    if (typeof e.evidence === "string" && e.evidence.trim().length > 0)
+        result.evidence = e.evidence;
     if (typeof e.derivedFrom === "string" && e.derivedFrom.trim().length > 0) {
         result.derivedFrom = e.derivedFrom.trim();
     }
@@ -242,6 +244,19 @@ export function applyScopeFrontmatter(entry, fmData) {
     if (scope)
         entry.scope = scope;
 }
+/** The same normalized tuple the index projects, including legacy nested scope. */
+export function scopeFromFrontmatter(fm) {
+    const entry = { type: "memory", name: "scope" };
+    if (typeof fm.scope === "object" && fm.scope !== null && !Array.isArray(fm.scope)) {
+        entry.scope = normalizeScopeObject(fm.scope);
+    }
+    applyScopeFrontmatter(entry, fm);
+    return entry.scope ?? {};
+}
+/** Exact maintenance equality: absence is a value, never a wildcard. */
+export function sameScope(a, b) {
+    return SCOPE_KEYS.every((key) => a[key] === b[key]);
+}
 function normalizeIntent(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
@@ -367,6 +382,8 @@ export function applyCuratedFrontmatter(entry, fmData) {
     const evidenceSources = normalizeNonEmptyStringList(fmData.evidenceSources);
     if (evidenceSources)
         entry.evidenceSources = evidenceSources;
+    if (typeof fmData.evidence === "string" && fmData.evidence.trim().length > 0)
+        entry.evidence = fmData.evidence;
     // Phase 5A / Advantage D5: capture parent ref for derived memories.
     // Memory-inference writes `source: "memories/<parent>"` and `inferred: true`
     // (and a derived child name suffix `.derived`). We mirror that source ref into

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

@@ -138,6 +138,7 @@ export function indexDocumentToStashEntry(doc) {
         entry.wikiRole = dj.wikiRole;
     assignStringList(entry, "sources", dj.sources);
     assignStringList(entry, "evidenceSources", dj.evidenceSources);
+    assignString(entry, "evidence", dj.evidence);
     assignStringList(entry, "uses", dj.uses);
     // D2 (#730): OKF v0.2 provenance promoteProposal stamps onto AKM-native
     // writes, carried via DOCUMENT_JSON_CARRIED_FIELDS (akm-adapter.ts) —