akm-cli 0.9.0-beta.3 → 0.9.0-beta.31

package/dist/commands/read/show.js

@@ -22,18 +22,22 @@ import { parseAssetRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { META_DIR, parseMetaRef, resolveMetaFilePath } from "../../core/asset/stash-meta.js";
 import { asNonEmptyString } from "../../core/common.js";
-import { loadConfig } from "../../core/config/config.js";
+import { getIndexPassConfig, loadConfig } from "../../core/config/config.js";
 import { NotFoundError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
-import { findEntryIdByRef } from "../../indexer/db/db.js";
+import { closeDatabase, computeBodyHash, findEntryIdByRef, openExistingDatabase } from "../../indexer/db/db.js";
+import { hasGraphData } from "../../indexer/db/graph-db.js";
 import { ensureIndex } from "../../indexer/ensure-index.js";
 import { listRelatedPathsForFile } from "../../indexer/graph/graph-boost.js";
+import { extractGraphForSingleFile } from "../../indexer/graph/graph-extraction.js";
 import { lookup } from "../../indexer/indexer.js";
 import { buildEditHint, findSourceForPath, isEditable, resolveSourceEntries } from "../../indexer/search/search-source.js";
 import { insertUsageEvent } from "../../indexer/usage/usage-events.js";
 import { buildFileContext, buildRenderContext, getRenderer, runMatchers } from "../../indexer/walk/file-context.js";
 import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
+import { resolveIndexPassLLM } from "../../llm/index-passes.js";
 import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
+import { resolveStorageLocations } from "../../storage/locations.js";
 import { withIndexDb } from "../../storage/repositories/index-db.js";
 // Eagerly import source providers to trigger self-registration.
 import "../../sources/providers/index.js";
@@ -383,6 +387,15 @@ export async function showLocal(input) {
     if (activeRun) {
         fullResponse.activeRun = activeRun;
     }
+    // #624-P3: opt-in inline graph extraction. Default OFF — when the flag is
+    // unset this whole block is skipped (no hasGraphData check, no LLM call), so
+    // behavior is byte-identical to today. When ON, it extracts graph data for an
+    // ungraphed asset, but ONLY when a model is configured (model-available
+    // guard) and ALWAYS bounded by a 30s timeout so `show` can never hang. Any
+    // timeout/model-unavailable/error path returns the response unchanged.
+    if (getIndexPassConfig(config.index, "graph")?.lazyGraphExtraction === true) {
+        await maybeExtractGraphInline(config, sourceStashDir, assetPath);
+    }
     if (input.detail === "brief") {
         return buildBriefResponse(fullResponse, assetPath);
     }
@@ -391,6 +404,58 @@ export async function showLocal(input) {
     }
     return fullResponse;
 }
+/**
+ * #624-P3 — opt-in inline graph extraction for `akm show`. Best-effort and
+ * timeout-bounded: never throws, never hangs, never mutates the response.
+ *
+ * Preconditions (caller already checked the flag): a model must be configured
+ * (model-available guard via {@link resolveIndexPassLLM}) and the asset must be
+ * ungraphed ({@link hasGraphData}). Extraction races a 30s timeout so `show`
+ * cannot block on a slow provider; any timeout/error/missing-model path is
+ * swallowed and `show` returns its already-assembled response unchanged.
+ */
+async function maybeExtractGraphInline(config, sourceStashDir, assetPath) {
+    try {
+        // Model-available guard — no provider configured ⇒ silent skip, no LLM call.
+        if (!resolveIndexPassLLM("graph", config))
+            return;
+        let alreadyGraphed = false;
+        let bodyHash;
+        try {
+            const raw = fs.readFileSync(assetPath, "utf8");
+            bodyHash = computeBodyHash(parseFrontmatter(raw).content.trim());
+        }
+        catch {
+            return; // file gone/unreadable ⇒ nothing to extract
+        }
+        withIndexDb((db) => {
+            alreadyGraphed = hasGraphData(db, sourceStashDir, assetPath);
+        });
+        if (alreadyGraphed)
+            return;
+        // Open the db for the async extraction ourselves: `withIndexDb` is
+        // synchronous and would close the connection the instant the async fn
+        // returns its Promise (before extraction completes). Close it explicitly
+        // after the race settles instead.
+        const db = openExistingDatabase(resolveStorageLocations().indexDb);
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(resolve, 30_000);
+        });
+        try {
+            await Promise.race([extractGraphForSingleFile(db, sourceStashDir, assetPath, bodyHash, { config }), timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+            closeDatabase(db);
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        // Any other failure: silently return the unchanged show response.
+    }
+}
 /**
  * Minimal `show`: ref → indexer lookup → file contents. Used by callers that
  * just need the raw file (e.g. clone, write-source) and don't want the full

package/dist/commands/sources/installed-stashes.js

@@ -205,7 +205,11 @@ async function updateRegistryEntry(entry, force) {
     const synced = await syncFromRef(entry.ref, { force });
     const installedEntry = {
         id: synced.id,
-        source: synced.source,
+        // Preserve the original source classification. syncFromRef() re-derives the
+        // source type from the ref scheme (e.g. "github:" → source: "github"), but
+        // an update should not reclassify an existing entry. A writable entry stored
+        // as source: "git" would fail config validation if rewritten to "github".
+        source: entry.source,
         ref: synced.ref,
         artifactUrl: synced.artifactUrl,
         resolvedVersion: synced.resolvedVersion,

package/dist/commands/sources/stash-cli.js

@@ -71,6 +71,11 @@ export const indexCommand = defineCommand({
             description: "When combined with --clean, report stale entries without deleting them.",
             default: false,
         },
+        background: {
+            type: "boolean",
+            description: "Run as a background process (suppresses interactive output, manages PID file).",
+            default: false,
+        },
     },
     async run({ args }) {
         await runWithJsonErrors(async () => {
@@ -80,6 +85,7 @@ export const indexCommand = defineCommand({
             if (getHyphenatedBoolean(args, "re-enrich") || parseFlagValue(process.argv, "--re-enrich") !== undefined) {
                 throw new UsageError("`akm index --re-enrich` has been removed. Re-enrichment of index-time LLM passes is not exposed in this slice.");
             }
+            const isBackground = args.background === true;
             const outputMode = getOutputMode();
             const controller = new AbortController();
             const abort = () => controller.abort(new Error("index interrupted"));
@@ -88,7 +94,7 @@ export const indexCommand = defineCommand({
             const indexLogFile = path.join(getCacheDir(), "logs", "index", `${new Date().toISOString().replace(/[:.]/g, "-")}.log`);
             setLogFile(indexLogFile);
             const verbose = isVerbose();
-            const spin = !verbose && outputMode.format === "text" ? p.spinner() : null;
+            const spin = !verbose && !isBackground && outputMode.format === "text" ? p.spinner() : null;
             if (spin) {
                 spin.start(`Building search index${args.full ? " (full rebuild)" : ""}...`);
             }
@@ -114,7 +120,9 @@ export const indexCommand = defineCommand({
                 if (spin) {
                     spin.stop(`Indexed ${result.totalEntries} assets.`);
                 }
-                output("index", result);
+                if (!isBackground) {
+                    output("index", result);
+                }
             }
             catch (error) {
                 if (spin) {

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

@@ -29,6 +29,7 @@ export const TYPE_TO_RENDERER = {
     wiki: "wiki-md",
     task: "task-yaml",
     session: "session-md",
+    fact: "fact-md",
 };
 /** Map asset types to action builder functions for search results. */
 export const ACTION_BUILDERS = {
@@ -45,6 +46,7 @@ export const ACTION_BUILDERS = {
     wiki: (ref) => `akm show ${ref} -> read the wiki page`,
     task: (ref) => `akm tasks show ${ref.replace(/^task:/, "")} -> inspect; akm tasks run <id> -> run now; akm tasks remove <id> -> unschedule`,
     session: (ref) => `akm show ${ref} -> read the session summary; follow the \`access\` frontmatter to open the raw log at \`log_path\``,
+    fact: (ref) => `akm show ${ref} -> read the stash fact and apply it as durable context`,
 };
 /**
  * Register a type-to-renderer mapping.

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

@@ -154,6 +154,20 @@ const ASSET_SPECS_INTERNAL = {
         rendererName: "session-md",
         actionBuilder: (ref) => `akm show ${ref} -> read the session summary; follow the \`access\` frontmatter to open the raw log at \`log_path\``,
     },
+    // Durable stash-level semantic knowledge — facts about the user, team, or
+    // project (personal details, team tool stacks, coding conventions /
+    // "constitution", and stash-meta like naming conventions or the active
+    // projects list). Unlike `memory` (episodic, recency-decayed) these are
+    // mostly-static declarations meant to be reliably surfaced as context. A
+    // plain markdown spec; `category` frontmatter scopes the fact and
+    // `pinned: true` marks the small always-injected core. See
+    // docs/design/fact-asset-type.md.
+    fact: {
+        stashDir: "facts",
+        ...markdownSpec,
+        rendererName: "fact-md",
+        actionBuilder: (ref) => `akm show ${ref} -> read the stash fact and apply it as durable context`,
+    },
 };
 export const ASSET_SPECS = ASSET_SPECS_INTERNAL;
 /**

package/dist/core/asset/frontmatter.js

@@ -4,170 +4,43 @@
 /**
  * Shared frontmatter parsing utilities.
  *
- * Provides a single, canonical YAML-subset frontmatter parser used by both
- * the stash open logic and the metadata generator.
+ * Uses the `yaml` library for all YAML parsing so that the full YAML spec
+ * (block scalars, multi-line strings, nested objects, flow sequences, escape
+ * sequences) is handled correctly without a brittle hand-rolled state machine.
  */
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 /**
- * Parse YAML-subset frontmatter from a Markdown (or similar) string.
+ * Parse YAML frontmatter from a Markdown (or similar) string.
  *
  * Returns the parsed key-value data and the remaining body content.
- *
- * **Limitations**: This is a hand-rolled YAML-subset parser with intentional
- * constraints for simplicity and safety:
- * - **Top-level values**: string, boolean, and number scalars are supported,
- *   as well as top-level list-valued keys using YAML block sequences
- *   (`- item`) or flow arrays (`[a, b, c]`).
- * - **List item types**: list items must be scalar values and may be strings,
- *   booleans, or numbers.
- * - **No nested objects beyond one level**: Only a single level of indented
- *   key-value pairs is supported.
- * - **Block scalars**: `|` (literal), `|-` (strip), and `|+` (keep) block
- *   scalars are supported for multi-line string values as emitted by the
- *   `yaml` library's `stringify`.
+ * Delegates all YAML parsing to the `yaml` library; the only responsibility
+ * of this function is extracting the `---…---` block and normalizing the
+ * parsed result (e.g. converting YAML timestamp values to ISO date strings).
  */
 export function parseFrontmatter(raw) {
     const parsedBlock = parseFrontmatterBlock(raw);
     if (!parsedBlock) {
         return { data: {}, content: raw, frontmatter: null, bodyStartLine: 1 };
     }
-    const data = {};
-    let currentKey = null;
-    /**
-     * "scalar" | "list" | "object" | "pending" | "block" —
-     * "pending" means empty value, mode determined by next line.
-     * "block" means we are accumulating lines for a `|`-block scalar.
-     */
-    let mode = "scalar";
-    let nested = null;
-    let currentList = null;
-    /** Lines collected while in "block" mode. */
-    let blockLines = null;
-    /** Block scalar chomping: "clip" (|), "strip" (|-), "keep" (|+). */
-    let blockChomping = "clip";
-    const flushPending = () => {
-        // Called when we start a new top-level key and the previous key was still "pending".
-        // An empty-value key followed by another top-level key means it was an empty scalar.
-        if (mode === "pending" && currentKey !== null) {
-            data[currentKey] = "";
-        }
-    };
-    const flushBlock = () => {
-        // Commit the accumulated block-scalar lines to `data[currentKey]`.
-        if (mode !== "block" || currentKey === null || blockLines === null)
-            return;
-        // De-indent: strip the common 2-space prefix `yaml.stringify` emits.
-        const deindented = blockLines.map((l) => (l.startsWith("  ") ? l.slice(2) : l));
-        // Chomping: apply trailing-newline policy.
-        // "clip" (|): single trailing newline.
-        // "strip" (|-): no trailing newline.
-        // "keep" (|+): keep all trailing newlines as-is.
-        if (blockChomping === "keep") {
-            data[currentKey] = deindented.join("\n");
-        }
-        else if (blockChomping === "strip") {
-            data[currentKey] = deindented.join("\n").replace(/\n+$/, "");
-        }
-        else {
-            // "clip": exactly one trailing newline
-            data[currentKey] = `${deindented.join("\n").replace(/\n+$/, "")}\n`;
-        }
-    };
-    for (const line of parsedBlock.frontmatter.split(/\r?\n/)) {
-        // If we are in block-scalar mode, collect indented lines or end the block.
-        if (mode === "block") {
-            if (line.startsWith("  ") || line === "") {
-                // Continuation of the block scalar (indented content or blank line).
-                blockLines.push(line);
-                continue;
+    let data = {};
+    if (parsedBlock.frontmatter.trim()) {
+        try {
+            const parsed = yamlParse(parsedBlock.frontmatter);
+            if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+                // Normalize Date objects: the yaml "core" schema parses YYYY-MM-DD
+                // literals as JS Date instances. Convert them back to ISO date strings
+                // to preserve the string type that callers (and yaml.stringify on write)
+                // expect.
+                data = normalizeYamlValues(parsed);
             }
-            // Non-indented line ends the block scalar — flush and fall through to
-            // parse the new line as a top-level key.
-            flushBlock();
-            mode = "scalar";
-            blockLines = null;
         }
-        // Block-sequence item: "- value" or "  - value" (optional 2-space indent)
-        // Only match when the current key is in list or pending mode.
-        const seqItem = line.match(/^(?: {2})?- (.*)$/);
-        if (seqItem && currentKey !== null && (mode === "list" || mode === "pending")) {
-            if (mode === "pending") {
-                // First block-sequence item after an empty-value key — switch to list mode
-                currentList = [];
-                data[currentKey] = currentList;
-                mode = "list";
-            }
-            currentList.push(parseYamlScalar(seqItem[1].trim()));
-            continue;
-        }
-        // Plain-style multi-line scalar continuation: a 2-space-indented line that
-        // is not a sequence item or nested key. YAML plain scalars fold newlines
-        // into a single space, so we append with a space. This handles LLM-emitted
-        // descriptions like:
-        //   description: Use 4-colon outer containers when mixing
-        //     nesting depths in markdown-it-container plugins.
-        // Without this, only the first line is captured and the truncation
-        // heuristic wrongly flags it as cut off mid-sentence.
-        if (mode === "scalar" && currentKey !== null && /^ {2}\S/.test(line)) {
-            data[currentKey] = `${String(data[currentKey])} ${line.trim()}`;
-            continue;
-        }
-        // Indented nested key-value (object under a key with empty value)
-        const indented = line.match(/^ {2}(\w[\w-]*):\s*(.+)$/);
-        if (indented && currentKey !== null && (mode === "object" || mode === "pending")) {
-            if (mode === "pending") {
-                // First indented k-v after an empty-value key — switch to object mode
-                nested = {};
-                data[currentKey] = nested;
-                mode = "object";
-            }
-            nested[indented[1]] = parseYamlScalar(indented[2].trim());
-            continue;
+        catch {
+            // Malformed YAML (e.g. unterminated quotes from LLM output corruption).
+            // Fall back to line-by-line best-effort extraction so callers still get
+            // whatever scalar values they can rather than a completely empty record.
+            data = parseFrontmatterLenient(parsedBlock.frontmatter);
         }
-        // Top-level key (possibly with inline value)
-        const top = line.match(/^(\w[\w-]*):\s*(.*)$/);
-        if (!top) {
-            continue;
-        }
-        // Starting a new top-level key — flush any pending empty-value key
-        flushPending();
-        currentKey = top[1];
-        const value = top[2].trim();
-        if (value === "|" || value === "|-" || value === "|+") {
-            // Block scalar header — collect subsequent indented lines.
-            mode = "block";
-            blockLines = [];
-            blockChomping = value === "|-" ? "strip" : value === "|+" ? "keep" : "clip";
-            nested = null;
-            currentList = null;
-        }
-        else if (value === "") {
-            // Defer mode decision until we see the next line
-            mode = "pending";
-            nested = null;
-            currentList = null;
-            // Don't store anything yet — flushPending will set "" if no continuation
-        }
-        else if (value.startsWith("[") && value.endsWith("]")) {
-            // Inline flow array: tags: [ops, networking]
-            mode = "list";
-            nested = null;
-            currentList = null;
-            currentList = parseFlowArray(value);
-            data[currentKey] = currentList;
-        }
-        else {
-            mode = "scalar";
-            nested = null;
-            currentList = null;
-            data[currentKey] = parseYamlScalar(value);
-        }
-    }
-    // Flush any in-progress block scalar at end of frontmatter.
-    if (mode === "block") {
-        flushBlock();
     }
-    // Flush the last key if it was still pending (empty value, no continuation)
-    flushPending();
     return {
         data,
         content: parsedBlock.content,
@@ -176,29 +49,89 @@ export function parseFrontmatter(raw) {
     };
 }
 /**
- * Parse a YAML flow array string like `[a, b, c]` into an array of scalars.
+ * Normalize YAML-parsed values to match expected AKM frontmatter types.
+ *
+ * Two conversions:
+ * 1. `Date` → YYYY-MM-DD string: the yaml "core" schema parses bare date
+ *    scalars like `2026-06-18` as JS Date instances. AKM frontmatter treats
+ *    `updated:` and similar fields as plain strings.
+ * 2. `null` → `""`: the yaml library parses empty-value keys (`key:` with no
+ *    value) as `null`, but AKM callers historically received `""` from the
+ *    hand-rolled parser. Convert to preserve backward compatibility.
  */
-function parseFlowArray(value) {
-    const inner = value.slice(1, -1).trim();
-    if (!inner)
-        return [];
-    return inner.split(",").map((item) => parseYamlScalar(item.trim()));
+function normalizeYamlValues(value) {
+    if (value instanceof Date) {
+        const y = value.getUTCFullYear();
+        const m = String(value.getUTCMonth() + 1).padStart(2, "0");
+        const d = String(value.getUTCDate()).padStart(2, "0");
+        return `${y}-${m}-${d}`;
+    }
+    if (value === null)
+        return "";
+    if (Array.isArray(value))
+        return value.map(normalizeYamlValues);
+    if (typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, normalizeYamlValues(v)]));
+    }
+    return value;
+}
+/**
+ * Best-effort line-by-line frontmatter extraction for malformed YAML.
+ *
+ * Used as a fallback when yaml.parse throws (e.g. unterminated quotes from LLM
+ * output corruption). Extracts simple `key: value` scalar pairs only — nested
+ * objects and sequences are skipped. Values that are individually parseable by
+ * yaml are normalized; otherwise stored as raw strings.
+ */
+function parseFrontmatterLenient(frontmatter) {
+    const data = {};
+    for (const line of frontmatter.split(/\r?\n/)) {
+        const m = line.match(/^([\w][\w-]*):\s*(.*)$/);
+        if (!m)
+            continue;
+        const key = m[1];
+        const rawValue = (m[2] ?? "").trim();
+        try {
+            const singleEntry = yamlParse(`k: ${rawValue}`);
+            if (singleEntry !== null && typeof singleEntry === "object" && !Array.isArray(singleEntry)) {
+                const v = singleEntry.k;
+                data[key] = v === null || v === undefined ? "" : v;
+            }
+            else {
+                data[key] = rawValue;
+            }
+        }
+        catch {
+            data[key] = rawValue;
+        }
+    }
+    return data;
 }
 export function parseFrontmatterBlock(raw) {
     // Handle both LF and CRLF line endings throughout.
     // The closing --- may be preceded by \r\n; capture and strip trailing \r
     // from the frontmatter block so key parsing sees clean LF-terminated lines.
     const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r\n|\r|\n|$)([\s\S]*)$/);
-    if (!match)
-        return null;
-    // Strip any \r characters from the frontmatter block to normalise CRLF → LF
-    const frontmatter = match[1].replace(/\r/g, "");
-    const content = match[2];
-    return {
-        frontmatter,
-        content,
-        bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1,
-    };
+    if (match) {
+        // Strip any \r characters from the frontmatter block to normalise CRLF → LF
+        const frontmatter = match[1].replace(/\r/g, "");
+        const content = match[2];
+        return {
+            frontmatter,
+            content,
+            bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1,
+        };
+    }
+    // Empty frontmatter (---\n---): the content-bearing regex above requires at
+    // least one character between the fences. Handle the degenerate case so
+    // callers can reconstruct `---\nkey: val\n---\n\nbody` from a previously
+    // empty-frontmatter file without corrupting it by wrapping the entire raw
+    // string as body content.
+    const emptyMatch = raw.match(/^---\r?\n---(?:\r\n|\r|\n)([\s\S]*)$/);
+    if (emptyMatch) {
+        return { frontmatter: "", content: emptyMatch[1], bodyStartLine: 3 };
+    }
+    return null;
 }
 function countLines(text) {
     if (text.length === 0)
@@ -206,7 +139,13 @@ function countLines(text) {
     return text.split(/\r?\n/).length - 1;
 }
 /**
- * Parse a simple YAML scalar value (string, boolean, or number).
+ * Parse a YAML scalar value (string, boolean, or number).
+ *
+ * For quoted strings (single or double), delegates to the `yaml` library so
+ * escape sequences are handled correctly per spec. The previous hand-rolled
+ * `slice(1, -1)` only stripped one layer of quoting and left inner quotes and
+ * escape sequences as literal characters in the stored value, causing visible
+ * corruption when `yaml.stringify` re-quoted them on the next write.
  */
 export function parseYamlScalar(value) {
     if (value === "")
@@ -219,7 +158,67 @@ export function parseYamlScalar(value) {
     if (!Number.isNaN(asNumber))
         return asNumber;
     if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        try {
+            const parsed = yamlParse(value);
+            if (typeof parsed === "string")
+                return parsed;
+        }
+        catch {
+            // Fall through to raw slice on malformed YAML — better than throwing.
+        }
         return value.slice(1, -1);
     }
     return value;
 }
+// ── Minimum score delta to trigger a frontmatter salience rewrite ─────────────
+const SALIENCE_WRITE_DELTA_THRESHOLD = 0.05;
+/**
+ * Idempotently write `salience` and `salienceInputs` fields into the YAML
+ * frontmatter of a raw asset string.
+ *
+ * Skips the write when the existing `salience` field differs from `score` by
+ * less than {@link SALIENCE_WRITE_DELTA_THRESHOLD}, to avoid churn for minor
+ * floating-point drift. Returns the raw string unchanged when no write is needed
+ * or when no frontmatter block is present.
+ *
+ * The `salienceInputs` field is written for auditability only; no pipeline code
+ * reads it back. `state.db :: asset_salience` is the canonical store.
+ */
+export function writeSalienceToFrontmatter(raw, score, inputs) {
+    const parsed = parseFrontmatterBlock(raw);
+    if (!parsed)
+        return raw;
+    const existingData = parseFrontmatter(raw).data;
+    const existingSalience = typeof existingData.salience === "number" ? existingData.salience : undefined;
+    if (existingSalience !== undefined && Math.abs(existingSalience - score) < SALIENCE_WRITE_DELTA_THRESHOLD) {
+        return raw;
+    }
+    // Parse existing frontmatter into an object, then set/overwrite salience fields.
+    let fm = {};
+    if (parsed.frontmatter.trim()) {
+        try {
+            const p = yamlParse(parsed.frontmatter);
+            if (p !== null && typeof p === "object" && !Array.isArray(p)) {
+                fm = p;
+            }
+        }
+        catch {
+            // Malformed YAML — rebuild from best-effort parse
+            fm = parseFrontmatterLenient(parsed.frontmatter);
+        }
+    }
+    fm.salience = roundTo2dp(score);
+    fm.salienceInputs = {
+        novelty: roundTo2dp(inputs.novelty),
+        magnitude: roundTo2dp(inputs.magnitude),
+        predictionError: roundTo2dp(inputs.predictionError),
+    };
+    const newFrontmatter = yamlStringify(fm).trimEnd();
+    const body = parsed.content;
+    // Preserve original line ending style between frontmatter and body
+    const separator = body.startsWith("\n") ? "" : "\n";
+    return `---\n${newFrontmatter}\n---\n${separator}${body}`;
+}
+function roundTo2dp(n) {
+    return Math.round(n * 100) / 100;
+}

package/dist/core/asset/markdown.js

@@ -8,7 +8,15 @@ export function parseMarkdownToc(content) {
     const headings = [];
     const parsed = parseFrontmatter(content);
     const start = parsed.frontmatter ? parsed.bodyStartLine - 1 : 0;
+    let inFence = false;
     for (let i = start; i < lines.length; i++) {
+        // Track fenced code blocks (``` or ~~~) so headings inside them are skipped.
+        if (/^\s*(`{3,}|~{3,})/.test(lines[i])) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence)
+            continue;
         const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
         if (match) {
             headings.push({