akm-cli 0.9.13 → 0.9.14

package/dist/scripts/akm-migrate.js

@@ -9466,6 +9466,53 @@ function projectMarkdownContent(body, truncationInfo) {
     truncationInfo.truncated = text.length > MARKDOWN_CONTENT_MAX_CHARS;
   return truncateUnicodeSafe(text, MARKDOWN_CONTENT_MAX_CHARS);
 }
+function setMarkdownFragmentContent(entry, content) {
+  markdownFragmentProjectionEntries.add(entry);
+  if (content)
+    markdownFragmentContentByEntry.set(entry, content);
+}
+function getMarkdownFragmentContent(entry) {
+  return markdownFragmentContentByEntry.get(entry);
+}
+function hasMarkdownFragmentContent(entry) {
+  return markdownFragmentProjectionEntries.has(entry);
+}
+function projectMarkdownFragmentContent(raw) {
+  const lines = raw.split(/\r?\n/);
+  const parsed = parseFrontmatter(raw);
+  const start = parsed.frontmatter ? parsed.bodyStartLine - 1 : 0;
+  const projected = lines.map(() => "");
+  let fence;
+  const htmlComment = { inComment: false };
+  for (let index = start;index < lines.length; index++) {
+    const rawLine = lines[index];
+    if (fence) {
+      if (isMarkdownFenceClosing(rawLine, fence))
+        fence = undefined;
+      continue;
+    }
+    if (!htmlComment.inComment) {
+      const opening2 = parseMarkdownFenceOpening(rawLine);
+      if (opening2) {
+        fence = opening2;
+        continue;
+      }
+    }
+    let safe = stripMarkdownHtmlComments(rawLine, htmlComment);
+    const opening = parseMarkdownFenceOpening(safe.trim());
+    if (opening) {
+      fence = opening;
+      continue;
+    }
+    if (/^\s*\[[^\]]+\]:\s*\S+/.test(safe) || /^\s*<[^>]+>\s*$/.test(safe))
+      continue;
+    safe = stripMarkdownLinkDestinations(safe).replace(/<[^>]+>/g, " ");
+    projected[index] = safe.replace(/[ \t]+$/g, "");
+  }
+  const text = projected.join(`
+`);
+  return text.trim() ? text : undefined;
+}
 function applyPreContributorFields(entry, file, ctx, pkgMeta) {
   const ext = path19.extname(file).toLowerCase();
   if (pkgMeta) {
@@ -9486,7 +9533,9 @@ function applyPreContributorFields(entry, file, ctx, pkgMeta) {
       entry.parameters = fmParams;
     applyWikiFrontmatter(entry, parsed.data);
     applyProvenanceFrontmatter(entry, parsed.data);
-    if (entry.type !== "env" && entry.type !== "session" && !hasSessionMemoryMarker(parsed.data, parsed.content)) {
+    const safeForFragments = entry.type !== "env" && entry.type !== "session" && !hasSessionMemoryMarker(parsed.data, parsed.content);
+    setMarkdownFragmentContent(entry, safeForFragments ? projectMarkdownFragmentContent(content) : undefined);
+    if (safeForFragments) {
       const truncationInfo = { truncated: false };
       const contentProjection = projectMarkdownContent(parsed.content, truncationInfo);
       if (contentProjection) {
@@ -9604,7 +9653,7 @@ function extractDirTagsFromName(name) {
   }
   return Array.from(tags);
 }
-var SCOPE_KEYS, KNOWN_QUALITY_VALUES, warnedUnknownQualityValues, MARKDOWN_CONTENT_MAX_CHARS = 1e6, MAX_MARKDOWN_LINK_NESTING = 32;
+var SCOPE_KEYS, KNOWN_QUALITY_VALUES, warnedUnknownQualityValues, MARKDOWN_CONTENT_MAX_CHARS = 1e6, MAX_MARKDOWN_LINK_NESTING = 32, markdownFragmentContentByEntry, markdownFragmentProjectionEntries;
 var init_metadata = __esm(() => {
   init_asset_ref();
   init_frontmatter();
@@ -9613,6 +9662,8 @@ var init_metadata = __esm(() => {
   SCOPE_KEYS = ["user", "agent", "run", "channel"];
   KNOWN_QUALITY_VALUES = new Set(["generated", "curated", "enriched", "proposed"]);
   warnedUnknownQualityValues = new Set;
+  markdownFragmentContentByEntry = new WeakMap;
+  markdownFragmentProjectionEntries = new WeakSet;
 });
 
 // src/execution/record.ts
@@ -12186,6 +12237,9 @@ var init_schema2 = __esm(() => {
 });
 
 // src/core/asset/markdown.ts
+function markdownHeadingSlug(heading) {
+  return heading.trim().toLowerCase().replace(/<[^>]*>/g, "").replace(/[^\p{L}\p{N}\s_-]+/gu, "-").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
 function parseMarkdownToc(content) {
   const lines = content.split(/\r?\n/);
   const headings = [];
@@ -35620,7 +35674,7 @@ var require_libvips = __commonJS((exports, module) => {
     SPDX-License-Identifier: Apache-2.0
   */
   var { spawnSync: spawnSync6 } = __require("child_process");
-  var { createHash: createHash9 } = __require("crypto");
+  var { createHash: createHash10 } = __require("crypto");
   var semverCoerce = require_coerce2();
   var semverGreaterThanOrEqualTo = require_gte2();
   var semverSatisfies = require_satisfies2();
@@ -35708,7 +35762,7 @@ var require_libvips = __commonJS((exports, module) => {
     }
     return false;
   };
-  var sha512 = (s) => createHash9("sha512").update(s).digest("hex");
+  var sha512 = (s) => createHash10("sha512").update(s).digest("hex");
   var yarnLocator = () => {
     try {
       const identHash = sha512(`imgsharp-libvips-${buildPlatformArch()}`);
@@ -50000,10 +50054,10 @@ var import_sharp, __dirname = "/home/runner/work/akm/akm/node_modules/@huggingfa
       if (cached) {
         return cached.text();
       }
-      const hash3 = await this._getLfsFileHash(url2);
-      if (hash3) {
-        await hashCache.put(url2, new Response(hash3));
-        return hash3;
+      const hash4 = await this._getLfsFileHash(url2);
+      if (hash4) {
+        await hashCache.put(url2, new Response(hash4));
+        return hash4;
       }
       return null;
     } catch {
@@ -78574,7 +78628,7 @@ function listTxnJournalsTolerant(predicate) {
 }
 
 // src/commands/proposal/repository.ts
-import { createHash as createHash9, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID6 } from "crypto";
 import fs49 from "fs";
 init_dist();
 import path61 from "path";
@@ -79482,20 +79536,41 @@ function buildWorkflowAction(ref) {
   return `Start or resume execution with \`akm workflow run ${shellQuote(ref)}\`.`;
 }
 var TYPE_PRESENTATION = {
-  skill: { label: "Skill", renderer: "skill-md", action: (ref) => `akm show ${ref} -> follow the instructions` },
+  skill: {
+    label: "Skill",
+    renderer: "skill-md",
+    action: (ref) => `akm show ${ref} -> follow the instructions`,
+    fragmentRef: false
+  },
   command: {
     label: "Command",
     renderer: "command-md",
-    action: (ref) => `akm show ${ref} -> fill placeholders and dispatch`
+    action: (ref) => `akm show ${ref} -> fill placeholders and dispatch`,
+    fragmentRef: false
+  },
+  agent: {
+    label: "Agent",
+    renderer: "agent-md",
+    action: (ref) => `akm show ${ref} -> dispatch with full prompt`,
+    fragmentRef: false
   },
-  agent: { label: "Agent", renderer: "agent-md", action: (ref) => `akm show ${ref} -> dispatch with full prompt` },
   knowledge: {
     label: "Knowledge",
     renderer: "knowledge-md",
     action: (ref) => `akm show ${ref} -> read reference material`
   },
-  workflow: { label: "Workflow", renderer: "workflow-md", action: (ref) => buildWorkflowAction(ref) },
-  script: { label: "Script", renderer: "script-source", action: (ref) => `akm show ${ref} -> execute the run command` },
+  workflow: {
+    label: "Workflow",
+    renderer: "workflow-md",
+    action: (ref) => buildWorkflowAction(ref),
+    fragmentRef: false
+  },
+  script: {
+    label: "Script",
+    renderer: "script-source",
+    action: (ref) => `akm show ${ref} -> execute the run command`,
+    fragmentRef: false
+  },
   memory: { label: "Memory", renderer: "memory-md", action: (ref) => `akm show ${ref} -> recall context` },
   env: {
     label: "Env",
@@ -79515,7 +79590,8 @@ var TYPE_PRESENTATION = {
   task: {
     label: "Task",
     renderer: "task-yaml",
-    action: (ref) => `akm show ${ref} -> inspect; akm task run <id> -> run now; edit the file + akm task sync -> unschedule`
+    action: (ref) => `akm show ${ref} -> inspect; akm task run <id> -> run now; edit the file + akm task sync -> unschedule`,
+    fragmentRef: false
   },
   session: {
     label: "Session",
@@ -79530,7 +79606,8 @@ var TYPE_PRESENTATION = {
   instruction: {
     label: "Instruction",
     renderer: "knowledge-md",
-    action: (ref) => `akm show ${ref} -> read the project instructions`
+    action: (ref) => `akm show ${ref} -> read the project instructions`,
+    fragmentRef: false
   }
 };
 var DEFAULT_PRESENTATION = { label: "Asset" };
@@ -82456,6 +82533,8 @@ function indexDocumentFromEntry(entry, base3, rendererName) {
     doc.lessonStrength = entry.lessonStrength;
   if (entry.derivedFrom !== undefined)
     doc.derivedFrom = entry.derivedFrom;
+  if (hasMarkdownFragmentContent(entry))
+    setMarkdownFragmentContent(doc, getMarkdownFragmentContent(entry));
   return doc;
 }
 function conceptIdForRecognizedType(root, filePath, type) {
@@ -92673,7 +92752,7 @@ init_paths();
 init_warn();
 
 // src/storage/repositories/index-entry-schema.ts
-var CANONICAL_INDEX_DB_VERSION = 22;
+var CANONICAL_INDEX_DB_VERSION = 23;
 var CANONICAL_ENTRY_SCHEMA_FINGERPRINT = {
   tableSql: "CREATE TABLE entries ( id INTEGER PRIMARY KEY AUTOINCREMENT, item_ref TEXT NOT NULL UNIQUE, bundle_id TEXT NOT NULL, component_id TEXT NOT NULL, concept_id TEXT NOT NULL, adapter_id TEXT NOT NULL, type TEXT NOT NULL, file_path TEXT NOT NULL, content_hash TEXT, document_json TEXT NOT NULL, search_text TEXT NOT NULL, derived_from TEXT )",
   sqliteSequenceTable: true,
@@ -92823,7 +92902,12 @@ var CANONICAL_ENTRY_SCHEMA_FINGERPRINT = {
         { sequence: 1, cid: -1, name: null, descending: 0, collation: "BINARY", key: 0 }
       ]
     }
-  ]
+  ],
+  searchSurfaces: {
+    entriesFtsSql: "CREATE VIRTUAL TABLE entries_fts USING fts5( entry_id UNINDEXED, name, description, tags, hints, content, tokenize='porter unicode61' )",
+    fragmentSourceSql: "CREATE TABLE entry_fragments ( entry_id INTEGER PRIMARY KEY REFERENCES entries(id) ON DELETE CASCADE, safe_markdown TEXT NOT NULL )",
+    fragmentsFtsSql: "CREATE VIRTUAL TABLE entry_fragments_fts USING fts5( entry_id UNINDEXED, fragment_id UNINDEXED, fragment_ordinal UNINDEXED, content, tokenize='porter unicode61' )"
+  }
 };
 function sqlString(value) {
   return `'${value.replaceAll("'", "''")}'`;
@@ -92833,8 +92917,11 @@ function normalizeSchemaSql(value) {
     return null;
   return value.replace(/\s+/g, " ").trim();
 }
+function readNamedTableSql(db, name) {
+  const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ${sqlString(name)}`).get();
+  return normalizeSchemaSql(row?.sql);
+}
 function readEntrySchemaFingerprint(db) {
-  const tableRow = db.prepare("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'entries'").get();
   const sqliteSequenceTable = db.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'").get() != null;
   const maxId = Number(db.prepare("SELECT COALESCE(MAX(id), 0) AS maxId FROM entries").get().maxId);
   const sequenceRow = sqliteSequenceTable ? db.prepare("SELECT seq FROM sqlite_sequence WHERE name = 'entries'").get() : undefined;
@@ -92863,11 +92950,16 @@ function readEntrySchemaFingerprint(db) {
     }))
   })).sort((left, right) => left.name.localeCompare(right.name));
   return {
-    tableSql: normalizeSchemaSql(tableRow?.sql),
+    tableSql: readNamedTableSql(db, "entries"),
     sqliteSequenceTable,
     sqliteSequenceValid,
     columns,
-    indexes
+    indexes,
+    searchSurfaces: {
+      entriesFtsSql: readNamedTableSql(db, "entries_fts"),
+      fragmentSourceSql: readNamedTableSql(db, "entry_fragments"),
+      fragmentsFtsSql: readNamedTableSql(db, "entry_fragments_fts")
+    }
   };
 }
 function hasCanonicalEntrySchema(db) {
@@ -93070,20 +93162,30 @@ function openExistingDatabase(dbPath) {
   if (classifyPathAccess(resolvedPath).access === "absent") {
     throw new Error(`Index database not found at ${resolvedPath}. Run 'akm index' to build it.`);
   }
-  return openManagedDatabase({
+  const db = openManagedDatabase({
     path: resolvedPath,
-    init: (db) => {
-      loadVecExtension(db);
-      warnIfNonCanonicalIndexGeneration(db, resolvedPath);
+    init: (db2) => {
+      loadVecExtension(db2);
     },
     create: false
   });
+  try {
+    assertCanonicalIndexGeneration(db, resolvedPath);
+    return db;
+  } catch (error2) {
+    db.close();
+    throw error2;
+  }
 }
-function warnIfNonCanonicalIndexGeneration(db, resolvedPath) {
+function assertCanonicalIndexGeneration(db, resolvedPath) {
   if (isCanonicalIndexGeneration(db))
     return;
   const classification = classifyIndexGeneration(db);
-  warnOnce(`index-read-noncanonical:${resolvedPath}`, `Index database at ${resolvedPath} does not match this akm's derived schema (stored generation ` + `${classification.storedVersion ?? "unknown"}; this binary understands ${CANONICAL_INDEX_DB_VERSION}). ` + "Reading it as-is; a query that needs a table or column this generation lacks will fail on its own. " + "Run 'akm index' to rebuild it for this binary.");
+  const stored = classification.storedVersion ?? "unknown";
+  if (classification.status === "newer") {
+    throw new ConfigError(`Index database at ${resolvedPath} was built by a newer akm (stored generation ${stored}; ` + `this binary understands ${CANONICAL_INDEX_DB_VERSION}). Upgrade akm to use this index.`, "INDEX_SCHEMA_INCOMPATIBLE", "Upgrade akm to a version that understands this index generation.");
+  }
+  throw new ConfigError(`Index database at ${resolvedPath} is not usable with this akm's derived schema (stored generation ${stored}; ` + `this binary understands ${CANONICAL_INDEX_DB_VERSION}). Run 'akm index' to rebuild it.`, "INDEX_SCHEMA_INCOMPATIBLE", "Run `akm index` to rebuild the derived index from the currently materialized sources.");
 }
 function assertIndexPathReadable(resolvedPath) {
   const { access, code } = classifyPathAccess(resolvedPath);
@@ -93100,6 +93202,7 @@ import fs40 from "fs";
 init_asset_ref();
 init_resolve_ref();
 init_warn();
+init_metadata();
 
 // src/indexer/search/search-fields.ts
 function buildSearchFields(entry) {
@@ -93163,9 +93266,129 @@ function buildSearchText(entry) {
 // src/storage/repositories/index-entry-mapper.ts
 init_warn();
 
+// src/core/asset/markdown-fragments.ts
+init_markdown();
+import { createHash as createHash9 } from "crypto";
+var MARKDOWN_FRAGMENT_MAX_CHARS = 1600;
+var MARKDOWN_FRAGMENT_PREFIX = "akm-fragment-";
+function hash3(text) {
+  return createHash9("sha256").update(text).digest("hex");
+}
+function uniqueSlugs(body) {
+  const out = new Map;
+  const seen = new Set;
+  for (const heading of parseMarkdownToc(body).headings) {
+    const base3 = markdownHeadingSlug(heading.text);
+    if (!base3)
+      continue;
+    let slug = base3;
+    for (let suffix = 1;seen.has(slug); suffix++)
+      slug = `${base3}-${suffix}`;
+    seen.add(slug);
+    out.set(heading.line, slug);
+  }
+  return out;
+}
+function textOf(lines) {
+  return lines.join(`
+`).trim();
+}
+function splitPiece(piece, maxChars) {
+  if (textOf(piece.lines).length <= maxChars)
+    return [piece];
+  const pieces = [];
+  let start = 0;
+  while (start < piece.lines.length) {
+    let end = start;
+    let chars = 0;
+    while (end < piece.lines.length) {
+      const next2 = piece.lines[end];
+      if (end === start && next2.length > maxChars)
+        break;
+      if (end > start && chars + next2.length + 1 > maxChars)
+        break;
+      chars += next2.length + (end > start ? 1 : 0);
+      end++;
+    }
+    if (end === start) {
+      const line = piece.lines[start];
+      let offset = 0;
+      while (offset < line.length) {
+        let cut = Math.min(offset + maxChars, line.length);
+        if (cut < line.length) {
+          const space = line.lastIndexOf(" ", cut);
+          if (space > offset + Math.floor(maxChars * 0.55))
+            cut = space;
+        }
+        pieces.push({ lines: [line.slice(offset, cut).trim()], startLine: piece.startLine + start });
+        offset = cut;
+        while (line[offset] === " ")
+          offset++;
+      }
+      start++;
+      continue;
+    }
+    let preferred = -1;
+    for (let i = start + 1;i < end; i++)
+      if (!piece.lines[i].trim())
+        preferred = i;
+    if (preferred > start)
+      end = preferred;
+    pieces.push({ lines: piece.lines.slice(start, end), startLine: piece.startLine + start });
+    start = end;
+    while (start < piece.lines.length && !piece.lines[start].trim())
+      start++;
+  }
+  return pieces.filter((candidate) => textOf(candidate.lines));
+}
+function splitMarkdownFragmentStats(body, maxChars = MARKDOWN_FRAGMENT_MAX_CHARS) {
+  const lines = body.split(/\r?\n/);
+  const headings = parseMarkdownToc(body).headings;
+  const boundaries = [1, ...headings.map((heading) => heading.line), lines.length + 1].filter((line, index, all) => index === 0 || line !== all[index - 1]).sort((left, right) => left - right);
+  const slugs = uniqueSlugs(body);
+  const pieces = [];
+  let sectionCount = 0;
+  for (let i = 0;i < boundaries.length - 1; i++) {
+    const startLine = boundaries[i];
+    const end = boundaries[i + 1] - 1;
+    const section = { lines: lines.slice(startLine - 1, end), startLine, headingSlug: slugs.get(startLine) };
+    if (textOf(section.lines)) {
+      sectionCount++;
+      pieces.push(...splitPiece(section, maxChars));
+    }
+  }
+  const piecesPerHeading = new Map;
+  for (const piece of pieces) {
+    if (piece.headingSlug)
+      piecesPerHeading.set(piece.headingSlug, (piecesPerHeading.get(piece.headingSlug) ?? 0) + 1);
+  }
+  const fragments = pieces.map((piece, ordinal) => {
+    const text = textOf(piece.lines);
+    const contentLines = piece.lines.map((line, index) => ({ line, index })).filter(({ line }) => line.trim());
+    const first = contentLines[0]?.index ?? 0;
+    const last = contentLines.at(-1)?.index ?? 0;
+    const digest = hash3(text);
+    const unsplitHeading = piece.headingSlug && piecesPerHeading.get(piece.headingSlug) === 1;
+    return {
+      fragmentId: `${MARKDOWN_FRAGMENT_PREFIX}${ordinal + 1}-${digest.slice(0, 12)}`,
+      ordinal,
+      startLine: piece.startLine + first,
+      endLine: piece.startLine + last,
+      ...unsplitHeading ? { headingSlug: piece.headingSlug } : {},
+      text,
+      hash: digest
+    };
+  });
+  return { fragments, hardSplitCount: Math.max(0, pieces.length - sectionCount) };
+}
+function splitMarkdownFragments(body, maxChars = MARKDOWN_FRAGMENT_MAX_CHARS) {
+  return splitMarkdownFragmentStats(body, maxChars).fragments;
+}
+
 // src/storage/repositories/index-fts-repository.ts
 init_warn();
 var INSERT_FTS_SQL = "INSERT INTO entries_fts (entry_id, name, description, tags, hints, content) VALUES (?, ?, ?, ?, ?, ?)";
+var INSERT_FRAGMENT_SQL = "INSERT INTO entry_fragments_fts (entry_id, fragment_id, fragment_ordinal, content) VALUES (?, ?, ?, ?)";
 var ftsMutationStatementsByDb = new WeakMap;
 function getFtsMutationStatements(db) {
   const existing = ftsMutationStatementsByDb.get(db);
@@ -93173,22 +93396,39 @@ function getFtsMutationStatements(db) {
     return existing;
   const statements = {
     deleteOne: db.prepare("DELETE FROM entries_fts WHERE entry_id = ?"),
-    insert: db.prepare(INSERT_FTS_SQL)
+    insert: db.prepare(INSERT_FTS_SQL),
+    deleteFragments: db.prepare("DELETE FROM entry_fragments_fts WHERE entry_id = ?"),
+    upsertFragmentSource: db.prepare("INSERT INTO entry_fragments (entry_id, safe_markdown) VALUES (?, ?) ON CONFLICT(entry_id) DO UPDATE SET safe_markdown = excluded.safe_markdown"),
+    deleteFragmentSource: db.prepare("DELETE FROM entry_fragments WHERE entry_id = ?"),
+    insertFragment: db.prepare(INSERT_FRAGMENT_SQL)
   };
   ftsMutationStatementsByDb.set(db, statements);
   return statements;
 }
-function replaceFtsEntry(db, entryId, entry) {
+function replaceFtsEntry(db, entryId, entry, fragmentContent) {
   const fields = buildSearchFields(entry);
   const statements = getFtsMutationStatements(db);
   statements.deleteOne.run(entryId);
   statements.insert.run(entryId, fields.name, fields.description, fields.tags, fields.hints, fields.content);
+  if (fragmentContent === undefined) {
+    return;
+  }
+  statements.deleteFragments.run(entryId);
+  statements.deleteFragmentSource.run(entryId);
+  if (!fragmentContent)
+    return;
+  statements.upsertFragmentSource.run(entryId, fragmentContent);
+  for (const fragment of splitMarkdownFragments(fragmentContent)) {
+    statements.insertFragment.run(entryId, fragment.fragmentId, fragment.ordinal, fragment.text.toLowerCase());
+  }
 }
 function deleteFtsEntries(db, entryIds) {
   for (let i = 0;i < entryIds.length; i += SQLITE_CHUNK_SIZE) {
     const chunk = entryIds.slice(i, i + SQLITE_CHUNK_SIZE);
     const placeholders = chunk.map(() => "?").join(",");
     db.prepare(`DELETE FROM entries_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
+    db.prepare(`DELETE FROM entry_fragments_fts WHERE entry_id IN (${placeholders})`).run(...chunk);
+    db.prepare(`DELETE FROM entry_fragments WHERE entry_id IN (${placeholders})`).run(...chunk);
   }
 }
 
@@ -93203,7 +93443,7 @@ function upsertEntry(db, filePath, entry, searchText, provenance, contentHash) {
       throw new Error("upsertEntry: item_ref not found after upsert");
     if (previous?.id === result.id && previous.search_text !== searchText)
       deleteEntryVectors(db, result.id);
-    replaceFtsEntry(db, result.id, entry);
+    replaceFtsEntry(db, result.id, entry, hasMarkdownFragmentContent(entry) ? getMarkdownFragmentContent(entry) ?? null : undefined);
     return result.id;
   };
   return db.transaction(apply)();
@@ -94217,6 +94457,9 @@ function publishTargetedEmbeddingMeta(db, config) {
   setMeta(db, "hasEmbeddings", ready ? "1" : "0");
 }
 
+// src/indexer/index-written-assets.ts
+init_metadata();
+
 // src/indexer/scan/drain-dir.ts
 import path58 from "path";
 init_common();
@@ -94279,52 +94522,56 @@ function workflowNameForSourcePath(sourceRoot, adapterId, sourcePath) {
     return;
   return ownedPath;
 }
-function listWorkflowSourceFiles(sourceRoot, adapterId, name) {
+function resolveWorkflowSourceDomains(sourceRoot, adapterId, sourcePaths) {
   if (adapterId !== "akm" && adapterId !== "akm-workflow")
     return [];
-  const canonicalName = canonicalizeWorkflowName(normalizeName2(name));
-  if (!isSafeRelativeName(canonicalName)) {
-    throw new UsageError("Workflow ref resolves outside the bundle root.", "PATH_ESCAPE_VIOLATION");
-  }
-  let realRoot;
   const authoredRoot = path55.resolve(sourceRoot);
+  let realRoot;
   try {
     realRoot = fs46.realpathSync(authoredRoot);
   } catch {
     return [];
   }
-  const ownershipRoot = adapterId === "akm" ? path55.join(authoredRoot, "workflows") : authoredRoot;
-  const parent = path55.join(ownershipRoot, path55.dirname(canonicalName));
-  if (!isWithinResolved(parent, authoredRoot)) {
-    throw new UsageError("Workflow ref resolves outside the bundle root.", "PATH_ESCAPE_VIOLATION");
-  }
-  let entries;
-  try {
-    entries = fs46.readdirSync(parent, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const basename = path55.basename(canonicalName);
-  const candidates = [];
-  for (const entry of entries) {
-    if (!entry.isFile() && !entry.isSymbolicLink())
+  const candidatesByName = new Map;
+  const seenAuthoredPaths = new Set;
+  for (const sourcePath of sourcePaths) {
+    const normalizedSourcePath = path55.resolve(sourcePath);
+    if (seenAuthoredPaths.has(normalizedSourcePath))
+      continue;
+    seenAuthoredPaths.add(normalizedSourcePath);
+    const authoredName = workflowNameForSourcePath(authoredRoot, adapterId, normalizedSourcePath);
+    if (authoredName === undefined)
       continue;
-    const extension = path55.extname(entry.name);
+    const canonicalName = canonicalizeWorkflowName(authoredName);
+    if (!isSafeRelativeName(canonicalName))
+      continue;
+    const extension = path55.extname(normalizedSourcePath);
     const lowerExtension = extension.toLowerCase();
     if (!WORKFLOW_EXTENSIONS.includes(lowerExtension))
       continue;
-    if (entry.name.slice(0, -extension.length) !== basename)
-      continue;
-    const candidatePath = path55.join(parent, entry.name);
-    candidates.push({
-      path: candidatePath,
-      relativePath: toPosix(path55.relative(authoredRoot, candidatePath)),
+    const candidate = {
+      path: normalizedSourcePath,
+      relativePath: toPosix(path55.relative(authoredRoot, normalizedSourcePath)),
       lowerExtension,
-      extensionlessStem: entry.name.slice(0, -extension.length)
+      extensionlessStem: path55.basename(normalizedSourcePath).slice(0, -extension.length)
+    };
+    const domain = candidatesByName.get(canonicalName) ?? [];
+    domain.push(candidate);
+    candidatesByName.set(canonicalName, domain);
+  }
+  const resolutions = [];
+  for (const canonicalName of [...candidatesByName.keys()].sort(compareCodePoints)) {
+    const candidates = candidatesByName.get(canonicalName) ?? [];
+    candidates.sort((left, right) => compareCodePoints(left.relativePath, right.relativePath));
+    const sources = inspectWorkflowSourceDomain(candidates, canonicalName, realRoot);
+    const sourcePaths2 = candidates.map((candidate) => candidate.relativePath);
+    resolutions.push({
+      canonicalName,
+      sourcePaths: sourcePaths2,
+      source: pickWorkflowSource(adapterId, canonicalName, sources)
     });
   }
-  candidates.sort((left, right) => compareCodePoints(left.relativePath, right.relativePath));
-  return inspectWorkflowSourceDomain(candidates, canonicalName, realRoot);
+  return resolutions;
 }
 function inspectWorkflowSourceDomain(candidates, canonicalName, realRoot) {
   const sources = [];
@@ -94398,14 +94645,6 @@ function inspectWorkflowSourceCandidate(candidate, canonicalName, realRoot) {
     }
   };
 }
-function resolveUniqueWorkflowSource(sourceRoot, adapterId, name) {
-  const sources = listWorkflowSourceFiles(sourceRoot, adapterId, name);
-  const canonicalName = sources[0]?.canonicalName ?? canonicalizeWorkflowName(normalizeName2(name));
-  return pickWorkflowSource(adapterId, canonicalName, sources);
-}
-function normalizeName2(name) {
-  return name.replaceAll("\\", "/");
-}
 function isSafeRelativeName(name) {
   return name.length > 0 && !path55.posix.isAbsolute(name) && name !== ".." && !name.startsWith("../") && path55.posix.normalize(name) === name;
 }
@@ -94420,6 +94659,7 @@ init_metadata();
 init_file_context();
 
 // src/indexer/scan/doc-to-entry.ts
+init_metadata();
 import path57 from "path";
 function indexDocumentToStashEntry(doc) {
   const dj = doc.documentJson ?? {};
@@ -94436,6 +94676,8 @@ function indexDocumentToStashEntry(doc) {
     entry.content = doc.content;
   if (doc.contentTruncated !== undefined)
     entry.contentTruncated = doc.contentTruncated;
+  if (hasMarkdownFragmentContent(doc))
+    setMarkdownFragmentContent(entry, getMarkdownFragmentContent(doc));
   if (doc.ownsPresentation !== undefined)
     entry.ownsPresentation = doc.ownsPresentation;
   if (doc.updated !== undefined)
@@ -94529,31 +94771,28 @@ function drainDirDocuments(adapter, component, fileContexts) {
   const conceptIdByFile = new Map;
   const rejectedPaths = new Set;
   const rejectedConceptIds = new Set;
-  const workflowLookups = new Map;
-  for (const file of fileContexts) {
+  const workflowOwnerPathByCanonicalName = new Map(resolveWorkflowSourceDomains(component.root, adapter.id, fileContexts.map((file) => file.absPath)).filter((resolution) => resolution.source !== undefined).map((resolution) => [resolution.canonicalName, path58.resolve(resolution.source.path)]));
+  const invalidWorkflowOwnerNames = new Set;
+  const orderedFileContexts = [...fileContexts].sort((left, right) => {
+    const leftName = workflowNameForSourcePath(component.root, adapter.id, left.absPath);
+    const rightName = workflowNameForSourcePath(component.root, adapter.id, right.absPath);
+    const leftOwner = leftName !== undefined && workflowOwnerPathByCanonicalName.get(canonicalizeWorkflowName(leftName)) === path58.resolve(left.absPath);
+    const rightOwner = rightName !== undefined && workflowOwnerPathByCanonicalName.get(canonicalizeWorkflowName(rightName)) === path58.resolve(right.absPath);
+    if (leftOwner !== rightOwner)
+      return leftOwner ? -1 : 1;
+    return compareCodePoints(left.absPath, right.absPath);
+  });
+  for (const file of orderedFileContexts) {
+    if (rejectedPaths.has(file.absPath))
+      continue;
     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]) => compareCodePoints(left, right))) {
-    try {
-      resolveUniqueWorkflowSource(component.root, adapter.id, workflowName);
-    } catch (error2) {
-      if (!(error2 instanceof WorkflowSourceRejectionError))
-        throw error2;
-      rejectedConceptIds.add(adapter.id === "akm" ? `workflows/${canonicalName}` : canonicalName);
-      for (const relativePath of error2.sourcePaths) {
-        rejectedPaths.add(path58.join(component.root, relativePath));
+      const ownerPath = workflowOwnerPathByCanonicalName.get(canonicalName);
+      if (ownerPath !== undefined && ownerPath !== path58.resolve(file.absPath) && !invalidWorkflowOwnerNames.has(canonicalName)) {
+        continue;
       }
-      warnings.push(error2.message);
     }
-  }
-  for (const file of fileContexts) {
-    if (rejectedPaths.has(file.absPath))
-      continue;
     const doc = adapter.recognize(component, file);
     if (doc === null)
       continue;
@@ -94565,6 +94804,8 @@ function drainDirDocuments(adapter, component, fileContexts) {
     const dropWarning = handleWorkflowDoc(doc, file, component.root);
     if (dropWarning !== null) {
       warnings.push(dropWarning);
+      if (workflowName !== undefined)
+        invalidWorkflowOwnerNames.add(canonicalizeWorkflowName(workflowName));
       continue;
     }
     if (doc.hash !== undefined)
@@ -94677,6 +94918,9 @@ async function indexWrittenAssets(stashDir, filePaths, options = {}) {
             let entryWithSize = entry;
             try {
               entryWithSize = { ...entry, fileSize: fs48.statSync(file).size };
+              if (hasMarkdownFragmentContent(entry)) {
+                setMarkdownFragmentContent(entryWithSize, getMarkdownFragmentContent(entry));
+              }
             } catch {}
             const provenance = deriveEntryProvenance({ bundleId: component.id, componentId: component.id, adapterId: component.adapter }, entry.type, entry.name, conceptId);
             const supersededIds = db.prepare("SELECT id FROM entries WHERE file_path = ? AND item_ref <> ?").all(file, provenance.itemRef);
@@ -95536,7 +95780,7 @@ var PROPOSAL_TXN_PHASES = [
   "committed"
 ];
 function proposalHash(content) {
-  return createHash9("sha256").update(content).digest("hex");
+  return createHash10("sha256").update(content).digest("hex");
 }
 function proposalFileHash(filePath) {
   return proposalHash(fs49.readFileSync(filePath));