akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/indexer/passes/metadata.js

@@ -6,7 +6,6 @@ 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 { isVerbose, warn } from "../../core/warn.js";
 export const SCOPE_KEYS = ["user", "agent", "run", "channel"];
 // ── Quality semantics (v1 spec §4.2) ────────────────────────────────────────
@@ -180,10 +179,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 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;
+    if (typeof e.content === "string" && e.content.trim().length > 0) {
+        result.content = e.content;
     }
     if (typeof e.scope === "object" && e.scope !== null && !Array.isArray(e.scope)) {
         const scope = normalizeScopeObject(e.scope);
@@ -835,36 +832,13 @@ export function isEnrichmentComplete(entry) {
     const hasSearchHints = Array.isArray(entry.searchHints) && entry.searchHints.length > 0;
     return hasDescription && hasTags && hasSearchHints;
 }
-// ── Body-opening extraction (stash-conventions SPEC-8) ──────────────────────
+// ── Native Markdown search projection ──────────────────────────────────────
 /**
- * Maximum length of a captured self-situating body opening. Bounds index-size
- * growth and keeps a single verbose opening from dominating the low-weight
- * `content` FTS column.
+ * Maximum native Markdown prose carried by the low-weight `content` field.
+ * Structured fields remain separate and higher-weighted; this bound prevents
+ * large documents from dominating index size or embedding inputs.
  */
-export const BODY_OPENING_MAX_CHARS = 280;
-/**
- * Minimum characters retained when the cap truncates at a word boundary. A
- * boundary cut that would retain less than this falls back to a hard cut, so
- * one pathological long token cannot gut the capture.
- */
-const BODY_OPENING_MIN_RETAINED_CHARS = 250;
-/**
- * True when `index.indexBodyOpening` is enabled in the user config.
- *
- * The gate is the GLOBAL user config, read directly by the metadata pass so
- * every indexing entry point (stash walk, flat walk, write-path indexing)
- * honors the flag without parameter plumbing. Fail-open: an unreadable or
- * invalid config must never break indexing (CLI entry points surface config
- * errors loudly on their own), so any load failure reads as "off".
- */
-function isBodyOpeningIndexingEnabled() {
-    try {
-        return loadUserConfig().index?.indexBodyOpening === true;
-    }
-    catch {
-        return false;
-    }
-}
+export const MARKDOWN_CONTENT_MAX_CHARS = 16_384;
 /**
  * Locate a leading nested frontmatter block in a body: up to three blank
  * lines, then a `---` line, closed by a later `---` line. Mirrors the
@@ -892,7 +866,7 @@ function findInnerFrontmatterBlock(lines) {
  * marker — in the outer frontmatter data OR in a nested inner block at the
  * top of the body (both producer layouts exist; see base-linter's
  * `extractFrontmatterRefs`). Session bodies are raw transcripts, never a
- * self-situating opening.
+ * searchable content projection.
  */
 function hasSessionMemoryMarker(fmData, body) {
     if (typeof fmData.akm_memory_kind === "string")
@@ -930,96 +904,271 @@ function isFrontmatterShaped(lines, block) {
     }
     return true;
 }
+function truncateUnicodeSafe(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    let cut = text.slice(0, maxChars);
+    const lastCode = cut.charCodeAt(cut.length - 1);
+    if (lastCode >= 0xd800 && lastCode <= 0xdbff)
+        cut = cut.slice(0, -1);
+    const boundary = cut.lastIndexOf(" ");
+    if (boundary >= Math.floor(maxChars * 0.9))
+        cut = cut.slice(0, boundary);
+    return cut.trimEnd();
+}
+function parseMarkdownFenceOpening(line) {
+    const match = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    const run = match?.[1];
+    if (!run)
+        return undefined;
+    const marker = run[0];
+    // CommonMark forbids backticks in the info string of a backtick fence.
+    if (marker === "`" && match?.[2]?.includes("`"))
+        return undefined;
+    return { marker, length: run.length };
+}
+function isMarkdownFenceClosing(line, fence) {
+    let cursor = 0;
+    while (cursor < line.length && cursor < 3 && line[cursor] === " ")
+        cursor += 1;
+    const runStart = cursor;
+    while (cursor < line.length && line[cursor] === fence.marker)
+        cursor += 1;
+    if (cursor - runStart < fence.length)
+        return false;
+    return /^[\t ]*$/.test(line.slice(cursor));
+}
+function stripMarkdownHtmlComments(line, state) {
+    let cursor = 0;
+    let visible = "";
+    while (cursor < line.length) {
+        if (state.inComment) {
+            const close = line.indexOf("-->", cursor);
+            if (close < 0)
+                return visible;
+            state.inComment = false;
+            cursor = close + 3;
+            continue;
+        }
+        const open = line.indexOf("<!--", cursor);
+        if (open < 0)
+            return `${visible}${line.slice(cursor)}`;
+        visible += line.slice(cursor, open);
+        state.inComment = true;
+        cursor = open + 4;
+    }
+    return visible;
+}
+function findBalancedMarkdownClose(text, openAt, open, close) {
+    let depth = 1;
+    for (let cursor = openAt + 1; cursor < text.length; cursor += 1) {
+        const char = text[cursor];
+        if (char === "\\") {
+            cursor += 1;
+            continue;
+        }
+        if (char === open)
+            depth += 1;
+        if (char !== close)
+            continue;
+        depth -= 1;
+        if (depth === 0)
+            return cursor;
+    }
+    return undefined;
+}
 /**
- * Extract the first prose paragraph of a markdown body (frontmatter already
- * stripped by the caller): skip blank lines, ATX headings, setext `=`
- * underlines (discarding the heading text above them), thematic breaks,
- * fenced code blocks (``` or ~~~, including their contents), and a leading
- * nested frontmatter block — skipped only when its interior is actually
- * frontmatter-shaped, so prose wrapped in decorative `---` lines is still
- * captured; then collect consecutive non-blank lines until the paragraph
- * ends. Deliberate asymmetry: a `---` row after captured prose ENDS the
- * paragraph and keeps it (favoring the callout/thematic-break reading over
- * CommonMark's setext-H2), while a `=+` row can only be a setext underline
- * and so discards the pending lines as heading text. The result is capped at
- * {@link BODY_OPENING_MAX_CHARS} chars — truncated at the last word boundary
- * that still retains a substantial prefix, with a trailing ellipsis. Returns
- * `undefined` when the body has no prose (frontmatter-only files,
- * headings/fences-only bodies).
+ * Find the closing parenthesis of an inline link destination. Parentheses in
+ * angle-delimited destinations and quoted titles are data, while unquoted
+ * parentheses remain balanced. Backslash escapes suppress delimiter meaning.
  */
-export function extractBodyOpening(body) {
-    const lines = body.split(/\r?\n/);
-    const innerBlock = findInnerFrontmatterBlock(lines);
-    const start = innerBlock && isFrontmatterShaped(lines, innerBlock) ? innerBlock.close + 1 : 0;
-    const paragraph = [];
-    let inFence = false;
-    let fenceChar = "";
-    let inHtmlComment = false;
-    for (let i = start; i < lines.length; i += 1) {
-        const trimmed = lines[i].trim();
-        const fenceMatch = trimmed.match(/^(`{3,}|~{3,})/);
-        if (inFence) {
-            // Fence interiors are never prose (and may be secrets-adjacent command
-            // text); skip until the matching closing marker.
-            if (fenceMatch && fenceMatch[1].charAt(0) === fenceChar)
-                inFence = false;
+function findMarkdownDestinationClose(text, openAt) {
+    let depth = 1;
+    let phase = "before-destination";
+    let quote;
+    let parenthesizedTitle = false;
+    let titleSeparator = false;
+    for (let cursor = openAt + 1; cursor < text.length; cursor += 1) {
+        const char = text[cursor];
+        if (char === "\\") {
+            cursor += 1;
             continue;
         }
-        if (inHtmlComment) {
-            // Comment interiors are machinery (the skeleton convention facts open
-            // with a <!-- SOFT guidance --> block), never orientation prose.
-            if (trimmed.includes("-->"))
-                inHtmlComment = false;
+        if (phase === "before-destination") {
+            if (/\s/u.test(char ?? ""))
+                continue;
+            if (char === "<") {
+                phase = "angle-destination";
+                continue;
+            }
+            if (char === ")")
+                return cursor;
+            phase = "bare-destination";
+        }
+        if (phase === "angle-destination") {
+            if (char === ">")
+                phase = "after-destination";
             continue;
         }
-        if (fenceMatch) {
-            if (paragraph.length > 0)
-                break; // a fence ends an open paragraph
-            inFence = true;
-            fenceChar = fenceMatch[1].charAt(0);
+        if (phase === "title") {
+            if (quote) {
+                if (char === quote) {
+                    quote = undefined;
+                    phase = "after-destination";
+                    titleSeparator = false;
+                }
+                continue;
+            }
+            if (parenthesizedTitle) {
+                if (char === "(")
+                    depth += 1;
+                if (char !== ")")
+                    continue;
+                depth -= 1;
+                if (depth === 1) {
+                    parenthesizedTitle = false;
+                    phase = "after-destination";
+                    titleSeparator = false;
+                }
+            }
+            continue;
+        }
+        if (phase === "after-destination") {
+            if (/\s/u.test(char ?? "")) {
+                titleSeparator = true;
+                continue;
+            }
+            if (char === ")")
+                return cursor;
+            if (titleSeparator && (char === '"' || char === "'")) {
+                quote = char;
+                phase = "title";
+                continue;
+            }
+            if (titleSeparator && char === "(") {
+                depth += 1;
+                parenthesizedTitle = true;
+                phase = "title";
+                continue;
+            }
+            // Invalid trailing bytes are still consumed conservatively until the
+            // balanced outer close. Quotes here are ordinary bytes, never titles.
+            phase = "bare-destination";
+        }
+        if (phase !== "bare-destination")
+            continue;
+        if (char === "(") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")") {
+            depth -= 1;
+            if (depth === 0)
+                return cursor;
             continue;
         }
-        if (trimmed.startsWith("<!--")) {
-            if (paragraph.length > 0)
-                break; // a comment ends an open paragraph
-            if (!trimmed.includes("-->"))
-                inHtmlComment = true;
+        if (/\s/u.test(char ?? "") && depth === 1) {
+            phase = "after-destination";
+            titleSeparator = true;
+        }
+    }
+    return undefined;
+}
+const MAX_MARKDOWN_LINK_NESTING = 32;
+/** Retain recursively projected link labels while dropping complete destinations. */
+function stripMarkdownLinkDestinations(text, nesting = 0) {
+    let visible = "";
+    let cursor = 0;
+    while (cursor < text.length) {
+        const isImage = text[cursor] === "!" && text[cursor + 1] === "[";
+        const labelOpen = isImage ? cursor + 1 : cursor;
+        if (text[labelOpen] !== "[") {
+            visible += text[cursor];
+            cursor += 1;
             continue;
         }
-        if (/^=+$/.test(trimmed)) {
-            // A row of `=` is a setext H1 underline: the pending lines are heading
-            // text, not prose — discard them and keep searching. (A bare `=` row
-            // with nothing pending is skipped like any other non-prose divider.)
-            paragraph.length = 0;
+        const labelClose = findBalancedMarkdownClose(text, labelOpen, "[", "]");
+        const destinationOpen = labelClose === undefined ? undefined : labelClose + 1;
+        if (destinationOpen === undefined || text[destinationOpen] !== "(") {
+            visible += text[cursor];
+            cursor += 1;
             continue;
         }
-        const isBlank = trimmed === "";
-        const isHeading = /^#{1,6}(\s|$)/.test(trimmed);
-        const isThematicBreak = /^(-{3,}|\*{3,}|_{3,})$/.test(trimmed);
-        if (isBlank || isHeading || isThematicBreak) {
-            if (paragraph.length > 0)
-                break; // paragraph complete
-            continue; // still searching for the first prose line
+        const destinationClose = findMarkdownDestinationClose(text, destinationOpen);
+        if (destinationClose === undefined) {
+            visible += text[cursor];
+            cursor += 1;
+            continue;
         }
-        paragraph.push(trimmed);
+        // Labels may themselves contain images/links. Recursively project them so
+        // an inner destination cannot become visible when its outer link is
+        // removed. At an adversarial nesting depth, omit the label rather than
+        // leaking its unparsed bytes into the search projection.
+        if (nesting < MAX_MARKDOWN_LINK_NESTING) {
+            visible += stripMarkdownLinkDestinations(text.slice(labelOpen + 1, labelClose), nesting + 1);
+        }
+        cursor = destinationClose + 1;
     }
-    const text = paragraph.join("\n");
+    return visible;
+}
+/**
+ * Derive the one low-weight search projection for an AKM-native Markdown body.
+ * Frontmatter is removed by the caller. This projection drops comments,
+ * fenced code, raw link targets, and structural punctuation while retaining
+ * prose, headings, link labels, and inline identifiers. It never receives
+ * secret/env/session bytes; that policy is enforced at the adapter metadata
+ * boundary below.
+ */
+export function projectMarkdownContent(body) {
+    const lines = body.split(/\r?\n/);
+    const innerBlock = findInnerFrontmatterBlock(lines);
+    const start = innerBlock && isFrontmatterShaped(lines, innerBlock) ? innerBlock.close + 1 : 0;
+    const projected = [];
+    let fence;
+    const htmlComment = { inComment: false };
+    for (let i = start; i < lines.length; i += 1) {
+        const rawLine = lines[i];
+        if (fence) {
+            if (isMarkdownFenceClosing(rawLine, fence))
+                fence = undefined;
+            continue;
+        }
+        // A leading fence owns the whole line, including any info string that
+        // resembles HTML. Comment state therefore cannot begin inside a fence.
+        if (!htmlComment.inComment) {
+            const openingFence = parseMarkdownFenceOpening(rawLine);
+            if (openingFence) {
+                fence = openingFence;
+                continue;
+            }
+        }
+        let trimmed = stripMarkdownHtmlComments(rawLine, htmlComment).trim();
+        const openingFence = parseMarkdownFenceOpening(trimmed);
+        if (openingFence) {
+            fence = openingFence;
+            continue;
+        }
+        if (!trimmed || /^(-{3,}|\*{3,}|_{3,}|=+)$/.test(trimmed))
+            continue;
+        if (/^\s*\[[^\]]+\]:\s*\S+/.test(trimmed))
+            continue;
+        if (/^<[^>]+>$/.test(trimmed))
+            continue;
+        // Preserve human-facing labels and inline identifiers, never destinations.
+        trimmed = stripMarkdownLinkDestinations(trimmed);
+        trimmed = trimmed.replace(/`{1,2}([^`]+)`{1,2}/g, "$1");
+        trimmed = trimmed.replace(/^#{1,6}\s+/, "");
+        trimmed = trimmed.replace(/^(?:>|[-+*]|\d+[.)])\s+/, "");
+        trimmed = trimmed.replace(/<[^>]+>/g, " ");
+        trimmed = trimmed.replace(/[|]+/g, " ");
+        trimmed = trimmed.replace(/\s+/g, " ").trim();
+        if (trimmed)
+            projected.push(trimmed);
+    }
+    const text = projected.join(" ").replace(/\s+/g, " ").trim();
     if (!text)
         return undefined;
-    if (text.length <= BODY_OPENING_MAX_CHARS)
-        return text;
-    // Cap: prefer a word-boundary cut (never mid-token), but only when it keeps
-    // a substantial prefix; append a one-char ellipsis inside the budget.
-    const slice = text.slice(0, BODY_OPENING_MAX_CHARS - 1);
-    const lastBoundary = Math.max(slice.lastIndexOf(" "), slice.lastIndexOf("\n"), slice.lastIndexOf("\t"));
-    let cut = lastBoundary >= BODY_OPENING_MIN_RETAINED_CHARS ? slice.slice(0, lastBoundary) : slice;
-    // slice() counts UTF-16 code units, so the no-boundary fallback can end on
-    // the high half of a surrogate pair — a lone surrogate that corrupts the
-    // FTS/embedding text. Drop it rather than emit invalid UTF-16.
-    const lastCode = cut.charCodeAt(cut.length - 1);
-    if (lastCode >= 0xd800 && lastCode <= 0xdbff)
-        cut = cut.slice(0, -1);
-    return `${cut.trimEnd()}…`;
+    return truncateUnicodeSafe(text, MARKDOWN_CONTENT_MAX_CHARS);
 }
 // ── Metadata Generation ─────────────────────────────────────────────────────
 /**
@@ -1060,16 +1209,12 @@ export function applyPreContributorFields(entry, file, ctx, pkgMeta) {
         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
-        // already-embedded entries are NOT regenerated; see docs/reference/configuration.md).
-        // Session-kind memories are raw transcripts and are never captured;
-        // secrets never reach this branch (guard above) and env files are not .md.
-        if (isBodyOpeningIndexingEnabled() && !hasSessionMemoryMarker(parsed.data, parsed.content)) {
-            const bodyOpening = extractBodyOpening(parsed.content);
-            if (bodyOpening)
-                entry.bodyOpening = bodyOpening;
+        // Native Markdown has one bounded low-weight body projection. Sensitive
+        // types and raw session/checkpoint material never cross this boundary.
+        if (entry.type !== "env" && entry.type !== "session" && !hasSessionMemoryMarker(parsed.data, parsed.content)) {
+            const contentProjection = projectMarkdownContent(parsed.content);
+            if (contentProjection)
+                entry.content = contentProjection;
         }
         // Extract parameters from template placeholders ($1, $ARGUMENTS, {{named}})
         if (entry.type === "command") {

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

@@ -6,13 +6,11 @@
  * `indexDocumentFromEntry` (`adapters/akm-adapter.ts`). akm 0.9.0 Chunk 5,
  * milestone F4a (M2 groundwork).
  *
- * The engine swap drains an `IndexDocument` stream (`drainDirDocuments` × the
- * dispatched adapter's `recognize`) in place of the per-dir flat-walk matcher-pass
- * `IndexDocument` stream, then persists it. But the durable `entries.entry_json`
- * column stays a faithful `IndexDocument` — every reader (`rowToIndexedEntry` →
- * `DbIndexedEntry.entry`) consumes it as one, and the byte-for-byte goldens pin
- * it. So the persist path must reconstruct the exact `IndexDocument` the old
- * pipeline stored FROM the `IndexDocument` the new pipeline produces.
+ * The indexer drains a single `IndexDocument` stream (`drainDirDocuments` × the
+ * dispatched adapter's `recognize`) and persists its canonical projection in
+ * `entries.document_json`. Every reader (`rowToIndexedEntry` →
+ * `DbIndexedEntry.entry`) consumes that same projection, and parity tests pin
+ * the boundary.
  *
  * That reconstruction is lossless by construction: the akm adapter's `recognize`
  * assembles a full `IndexDocument` (P1/P2 → fold → P4) and then maps it onto the
@@ -20,8 +18,8 @@
  * onto named members, every other search-surface/provenance field onto
  * `documentJson` (the `DOCUMENT_JSON_CARRIED_FIELDS` set). This function reverses
  * that mapping exactly, so `indexDocumentToStashEntry(recognize(file))` deep-
- * equals the entry the legacy flat-walk pass stored for the same file (the
- * `tests/integration/shadow-scan-parity.test.ts` gate pins the persisted index).
+ * equals the current persisted document for the same file (the
+ * `tests/integration/shadow-scan-parity.test.ts` gate pins this boundary).
  *
  * Two deliberate non-round-trip fields:
  *   - `filename` — dropped by `indexDocumentFromEntry` (no IndexDocument home),
@@ -123,7 +121,6 @@ export function indexDocumentToStashEntry(doc) {
         entry.toc = dj.toc;
     if (dj.parameters !== undefined)
         entry.parameters = dj.parameters;
-    assignString(entry, "bodyOpening", dj.bodyOpening);
     if (dj.source !== undefined)
         entry.source = dj.source;
     assignString(entry, "category", dj.category);

package/dist/indexer/scan/drain-dir.js

@@ -14,26 +14,23 @@
  *  - **Broken-workflow drop (item 3).** The live path dropped a broken workflow
  *    via the renderer contributor's throw → metadata-pass skip-with-warning; the
  *    `akm` adapter's synchronous `foldRecognizedMetadata` SWALLOWS the parse
- *    error, so a broken workflow would otherwise silently index. We re-run
- *    `parseWorkflow` on drained workflow docs and DROP
+ *    error, so a broken workflow would otherwise silently index. We run the
+ *    shared source-IR compiler on drained workflow docs and DROP
  *    the entry with the same `Skipped workflow …` warning
  *    ({@link buildMetadataSkipWarning}), so the workflow-skip summary counts it.
- *  - **Workflow-document side-table (workflow-md only).** The valid parsed
- *    `WorkflowDocument` is handed to the persist layer through the same
- *    `document-cache` side channel the live renderer contributor used, keyed by
- *    the reconstructed entry — so `takeWorkflowDocument(entry)` in the persist
- *    loop writes the `workflow_documents` row exactly as before.
  *
  * `doc.hash` (= sha256 of the file content) is surfaced per recognized file so
  * the persist layer can populate the `content_hash` column (item 2). It is keyed
  * by the file's absolute path rather than by the entry object.
  *
- * Pure of DB/global state beyond the workflow-document side channel; a new leaf
- * (nothing imports it back), so it joins no import cycle.
+ * Pure of DB/global state; a new leaf (nothing imports it back), so it joins no
+ * import cycle.
  */
+import path from "node:path";
 import { akmAdapter } from "../../core/adapter/adapters/akm-adapter.js";
-import { parseWorkflow } from "../../workflows/parser.js";
-import { cacheWorkflowDocument } from "../../workflows/runtime/document-cache.js";
+import { canonicalizeWorkflowName } from "../../core/recognition-util.js";
+import { resolveUniqueWorkflowSource, WorkflowSourceRejectionError, workflowNameForSourcePath, } from "../../workflows/source-files.js";
+import { compileWorkflowSource } from "../../workflows/source-ir/compile.js";
 import { buildMetadataSkipWarning } from "../passes/metadata.js";
 import { buildFileContext } from "../walk/file-context.js";
 import { indexDocumentToStashEntry } from "./doc-to-entry.js";
@@ -53,7 +50,34 @@ export function drainDirDocuments(adapter, component, fileContexts) {
     const warnings = [];
     const hashByFile = new Map();
     const conceptIdByFile = new Map();
+    const rejectedPaths = new Set();
+    const rejectedConceptIds = new Set();
+    const workflowLookups = new Map();
     for (const file of fileContexts) {
+        const workflowName = workflowNameForSourcePath(component.root, adapter.id, file.absPath);
+        if (workflowName !== undefined) {
+            const canonicalName = canonicalizeWorkflowName(workflowName);
+            if (!workflowLookups.has(canonicalName))
+                workflowLookups.set(canonicalName, workflowName);
+        }
+    }
+    for (const [canonicalName, workflowName] of [...workflowLookups].sort(([left], [right]) => comparePaths(left, right))) {
+        try {
+            resolveUniqueWorkflowSource(component.root, adapter.id, workflowName);
+        }
+        catch (error) {
+            if (!(error instanceof WorkflowSourceRejectionError))
+                throw error;
+            rejectedConceptIds.add(adapter.id === "akm" ? `workflows/${canonicalName}` : canonicalName);
+            for (const relativePath of error.sourcePaths) {
+                rejectedPaths.add(path.join(component.root, relativePath));
+            }
+            warnings.push(error.message);
+        }
+    }
+    for (const file of fileContexts) {
+        if (rejectedPaths.has(file.absPath))
+            continue;
         const doc = adapter.recognize(component, file);
         if (doc === null)
             continue;
@@ -62,9 +86,9 @@ export function drainDirDocuments(adapter, component, fileContexts) {
             continue;
         }
         const entry = indexDocumentToStashEntry(doc);
-        // Workflow docs: drop-with-warning if broken; otherwise cache the parsed
-        // markdown document for the persist-time `workflow_documents` write.
-        const dropWarning = handleWorkflowDoc(doc, entry, file);
+        // Workflow docs: drop-with-warning if broken; otherwise cache a lossless
+        // runtime projection when the current executor can represent the source.
+        const dropWarning = handleWorkflowDoc(doc, file, component.root);
         if (dropWarning !== null) {
             warnings.push(dropWarning);
             continue;
@@ -74,7 +98,10 @@ export function drainDirDocuments(adapter, component, fileContexts) {
         conceptIdByFile.set(file.absPath, doc.conceptId);
         entries.push(entry);
     }
-    return { entries, warnings, hashByFile, conceptIdByFile };
+    return { entries, warnings, hashByFile, conceptIdByFile, rejectedPaths, rejectedConceptIds };
+}
+function comparePaths(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
 }
 /**
  * `(stashRoot, files) → StashFile` drop-in for the deleted flat-walk matcher
@@ -98,18 +125,19 @@ export function recognizeStashEntries(stashRoot, files) {
         : { entries: drained.entries };
 }
 /**
- * If `doc` is a workflow, re-parse it: return a `Skipped workflow …` drop
- * warning when it is broken, or cache the parsed markdown `WorkflowDocument`
- * (workflow-md only) and return `null` when valid. Non-workflow docs return
- * `null` immediately.
+ * If `doc` is a workflow, compile it through source IR: return a
+ * `Skipped workflow …` drop warning when it is broken, or return `null` when
+ * it compiles. Non-workflow docs return `null` immediately.
  */
-function handleWorkflowDoc(doc, entry, file) {
-    if (docRenderer(doc) !== WORKFLOW_MD_RENDERER)
+function handleWorkflowDoc(doc, file, workspaceRoot) {
+    if (doc.type !== "workflow" ||
+        (doc.adapterId !== "akm" && doc.adapterId !== "akm-workflow") ||
+        (docRenderer(doc) !== WORKFLOW_MD_RENDERER && doc.adapterId !== "akm-workflow")) {
         return null;
-    const result = parseWorkflow(file.content(), { path: file.relPath });
+    }
+    const result = compileWorkflowSource(file.content(), { path: file.relPath, workspaceRoot });
     if (!result.ok)
         return workflowDropWarning(file, result.errors);
-    cacheWorkflowDocument(entry, result.document);
     return null;
 }
 /** The winning renderer name the `akm` adapter carries on `documentJson.renderer`, or `undefined`. */