@goondocks/myco 0.6.1 → 0.6.2

package/dist/{chunk-24DOZEUJ.js → chunk-ALBVNGCF.js}

@@ -1,10 +1,19 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
 import {
-  external_exports
-} from "./chunk-MQSYSQ6T.js";
+  generateEmbedding
+} from "./chunk-RGVBGTD6.js";
 import {
-  CANDIDATE_CONTENT_PREVIEW
-} from "./chunk-6BSDCZ5Q.js";
+  external_exports,
+  require_dist
+} from "./chunk-JSK7L46L.js";
+import {
+  CANDIDATE_CONTENT_PREVIEW,
+  EMBEDDING_INPUT_LIMIT,
+  LLM_REASONING_MODE,
+  SUPERSESSION_CANDIDATE_LIMIT,
+  SUPERSESSION_MAX_TOKENS,
+  SUPERSESSION_VECTOR_FETCH_LIMIT
+} from "./chunk-WBLTISAK.js";
 import {
   __commonJS,
   __require,
@@ -3383,7 +3392,7 @@ var require_parse = __commonJS({
 var require_gray_matter = __commonJS({
   "node_modules/gray-matter/index.js"(exports2, module2) {
     "use strict";
-    var fs3 = __require("fs");
+    var fs5 = __require("fs");
     var sections = require_section_matter();
     var defaults = require_defaults();
     var stringify = require_stringify();
@@ -3467,7 +3476,7 @@ var require_gray_matter = __commonJS({
       return stringify(file, data, options2);
     };
     matter2.read = function(filepath, options2) {
-      const str2 = fs3.readFileSync(filepath, "utf8");
+      const str2 = fs5.readFileSync(filepath, "utf8");
       const file = matter2(str2, options2);
       file.path = filepath;
       return file;
@@ -3495,10 +3504,427 @@ var require_gray_matter = __commonJS({
   }
 });
 
-// src/vault/reader.ts
-var import_gray_matter = __toESM(require_gray_matter(), 1);
+// src/vault/session-id.ts
+var SESSION_PREFIX = "session-";
+function sessionNoteId(bareId) {
+  if (bareId.startsWith(SESSION_PREFIX)) return bareId;
+  return `${SESSION_PREFIX}${bareId}`;
+}
+function bareSessionId(noteId) {
+  if (noteId.startsWith(SESSION_PREFIX)) return noteId.slice(SESSION_PREFIX.length);
+  return noteId;
+}
+function sessionWikilink(bareId) {
+  return `[[${sessionNoteId(bareId)}]]`;
+}
+function sessionRelativePath(bareId, date) {
+  return `sessions/${date}/${sessionNoteId(bareId)}.md`;
+}
+
+// src/obsidian/formatter.ts
+var CONVERSATION_HEADING = "## Conversation";
+var CALLOUT_MAP = {
+  gotcha: "warning",
+  bug_fix: "bug",
+  decision: "info",
+  discovery: "tip",
+  trade_off: "question"
+};
+function observationCalloutType(observationType) {
+  return CALLOUT_MAP[observationType] ?? "note";
+}
+function escapeHtmlTags(text) {
+  return text.replace(/<(?=[a-zA-Z/!])/g, "\\<");
+}
+function callout(type, title, content) {
+  const safe = escapeHtmlTags(content);
+  const indented = safe.split("\n").map((line) => `> ${line}`).join("\n");
+  return `> [!${type}] ${title}
+${indented}`;
+}
+function inlineField(key, value) {
+  return `${key}:: ${value}`;
+}
+function wikilink(target, display) {
+  return display ? `[[${target}|${display}]]` : `[[${target}]]`;
+}
+function tagNormalize(s) {
+  return s.replace(/_/g, "-");
+}
+function sanitizeTag(raw) {
+  const stripped = raw.startsWith("#") ? raw.slice(1) : raw;
+  return stripped.replace(/\s+/g, "/");
+}
+function buildTags(type, subtype, extraTags = []) {
+  const tags = [`type/${type}`];
+  if (subtype) {
+    tags.push(`${type}/${tagNormalize(subtype)}`);
+  }
+  for (const tag of extraTags) {
+    const normalized = sanitizeTag(tag);
+    if (normalized && !tags.includes(normalized)) {
+      tags.push(normalized);
+    }
+  }
+  return tags;
+}
+function footerTags(tags) {
+  return tags.map((t) => t.startsWith("#") ? t : `#${t}`).join(" ");
+}
+function formatSessionBody(input) {
+  const sections = [];
+  sections.push(`# ${input.title}`);
+  if (input.narrative) {
+    sections.push(callout("abstract", "Summary", input.narrative));
+  }
+  const fields = [];
+  fields.push(inlineField("Session", wikilink(sessionNoteId(input.sessionId))));
+  if (input.user) fields.push(inlineField("User", input.user));
+  if (input.started && input.ended) {
+    const duration = formatDuration(input.started, input.ended);
+    if (duration) fields.push(inlineField("Duration", duration));
+  }
+  if (input.branch) fields.push(inlineField("Branch", `\`${input.branch}\``));
+  sections.push(fields.join("\n"));
+  if (input.relatedMemories?.length) {
+    const links = input.relatedMemories.map((m) => `- ${wikilink(m.id, m.title)}`);
+    sections.push(`## Related Spores
+${links.join("\n")}`);
+  }
+  if (input.turns.length > 0) {
+    const turnLines = [];
+    for (let i = 0; i < input.turns.length; i++) {
+      const turn = input.turns[i];
+      const turnNum = i + 1;
+      turnLines.push(`### Turn ${turnNum}`);
+      if (turn.prompt || turn.images?.length) {
+        const parts = [];
+        if (turn.prompt) parts.push(turn.prompt);
+        if (turn.images?.length) {
+          parts.push(turn.images.map((f) => `![[${f}]]`).join("\n"));
+        }
+        if (turn.toolCount > 0) parts.push(`*${turn.toolCount} tool calls*`);
+        turnLines.push(callout("user", "Prompt", parts.join("\n\n")));
+      } else if (turn.toolCount > 0) {
+        turnLines.push(callout("user", "Prompt", `*${turn.toolCount} tool calls*`));
+      }
+      if (turn.aiResponse) {
+        turnLines.push(callout("assistant", "Response", turn.aiResponse));
+      }
+    }
+    sections.push(`${CONVERSATION_HEADING}
+
+${turnLines.join("\n\n")}`);
+  }
+  const allTags = buildTags("session", "ended", [
+    ...input.user ? [`user/${input.user}`] : [],
+    ...input.tags ?? []
+  ]);
+  sections.push(footerTags(allTags));
+  return sections.join("\n\n");
+}
+function formatSporeBody(input) {
+  const sections = [];
+  const calloutType = observationCalloutType(input.observationType);
+  const calloutTitle = capitalize(tagNormalize(input.observationType));
+  sections.push(`# ${input.title}`);
+  sections.push(callout(calloutType, calloutTitle, input.content));
+  const fields = [];
+  if (input.sessionId) {
+    fields.push(inlineField("Session", wikilink(sessionNoteId(input.sessionId))));
+  }
+  fields.push(inlineField("Observation", input.observationType));
+  if (fields.length > 0) sections.push(fields.join("\n"));
+  if (input.root_cause) sections.push(`## Root Cause
+${input.root_cause}`);
+  if (input.fix) sections.push(`## Fix
+${input.fix}`);
+  if (input.rationale) sections.push(`## Rationale
+${input.rationale}`);
+  if (input.alternatives_rejected) sections.push(`## Alternatives Rejected
+${input.alternatives_rejected}`);
+  if (input.gained) sections.push(`## Gained
+${input.gained}`);
+  if (input.sacrificed) sections.push(`## Sacrificed
+${input.sacrificed}`);
+  const allTags = buildTags("spore", input.observationType, input.tags ?? []);
+  sections.push(footerTags(allTags));
+  return sections.join("\n\n");
+}
+function formatPlanBody(input) {
+  const sections = [];
+  const fields = [];
+  fields.push(inlineField("Plan", wikilink(input.id)));
+  fields.push(inlineField("Status", input.status));
+  if (input.author) fields.push(inlineField("Author", input.author));
+  if (input.created) fields.push(inlineField("Created", input.created));
+  sections.push(fields.join("\n"));
+  sections.push(input.content);
+  if (input.sessions?.length) {
+    const links = input.sessions.map((s) => `- ${wikilink(sessionNoteId(s.id), s.title)}`);
+    sections.push(`## Sessions
+${links.join("\n")}`);
+  }
+  const statusTag = tagNormalize(input.status);
+  const allTags = buildTags("plan", statusTag, input.tags ?? []);
+  sections.push(footerTags(allTags));
+  return sections.join("\n\n");
+}
+function formatArtifactBody(input) {
+  const sections = [];
+  const fields = [];
+  fields.push(inlineField("Artifact", wikilink(input.id)));
+  fields.push(inlineField("Source", `\`${input.source_path}\``));
+  fields.push(inlineField("Type", input.artifact_type));
+  fields.push(inlineField("Session", wikilink(sessionNoteId(input.sessionId))));
+  sections.push(fields.join("\n"));
+  sections.push(input.content);
+  const allTags = buildTags("artifact", input.artifact_type, input.tags ?? []);
+  sections.push(footerTags(allTags));
+  return sections.join("\n\n");
+}
+function formatTeamBody(input) {
+  const sections = [];
+  sections.push(`# ${input.user}`);
+  sections.push(callout("info", "Team Member", input.role ?? "Contributor"));
+  const fields = [];
+  fields.push(inlineField("User", input.user));
+  if (input.role) fields.push(inlineField("Role", input.role));
+  sections.push(fields.join("\n"));
+  if (input.recentSessions?.length) {
+    const links = input.recentSessions.map((s) => `- ${wikilink(sessionNoteId(s.id), s.title)}`);
+    sections.push(`## Recent Sessions
+${links.join("\n")}`);
+  }
+  const allTags = buildTags("team", "", [`user/${input.user}`]);
+  sections.push(footerTags(allTags));
+  return sections.join("\n\n");
+}
+var FOOTER_TAG_PREFIX = "\n#type/";
+function extractSection(body, heading) {
+  const start = body.indexOf(heading);
+  if (start === -1) return "";
+  const section = body.slice(start + heading.length);
+  const footerIdx = section.lastIndexOf(FOOTER_TAG_PREFIX);
+  if (footerIdx !== -1) return section.slice(0, footerIdx).trim();
+  return section.trim();
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function formatDuration(started, ended) {
+  const ms = new Date(ended).getTime() - new Date(started).getTime();
+  if (isNaN(ms) || ms < 0) return "";
+  const totalMinutes = Math.floor(ms / 6e4);
+  if (totalMinutes < 1) return "<1m";
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours === 0) return `${minutes}m`;
+  if (minutes === 0) return `${hours}h`;
+  return `${hours}h ${minutes}m`;
+}
+
+// src/vault/writer.ts
+var import_yaml = __toESM(require_dist(), 1);
 import fs from "fs";
 import path from "path";
+var VaultWriter = class {
+  constructor(vaultDir) {
+    this.vaultDir = vaultDir;
+  }
+  writeSession(input) {
+    const date = input.started.slice(0, 10);
+    const relativePath = sessionRelativePath(input.id, date);
+    const frontmatter = {
+      type: "session",
+      id: input.id,
+      agent: input.agent ?? "claude-code",
+      user: input.user ?? "",
+      started: input.started
+    };
+    if (input.ended) frontmatter.ended = input.ended;
+    if (input.parent) frontmatter.parent = input.parent;
+    if (input.parent_reason) frontmatter.parent_reason = input.parent_reason;
+    if (input.plans?.length) frontmatter.plans = input.plans;
+    if (input.branch) frontmatter.branch = input.branch;
+    frontmatter.tags = buildTags("session", "ended", [
+      ...input.user ? [`user/${input.user}`] : [],
+      ...input.tags ?? []
+    ]);
+    if (input.tools_used != null) frontmatter.tools_used = input.tools_used;
+    if (input.files_changed != null) frontmatter.files_changed = input.files_changed;
+    this.writeMarkdown(relativePath, frontmatter, input.summary);
+    return relativePath;
+  }
+  writePlan(input) {
+    const relativePath = `plans/${input.id}.md`;
+    const fullPath = path.join(this.vaultDir, relativePath);
+    const status = input.status ?? "active";
+    let created = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const existing = fs.readFileSync(fullPath, "utf-8");
+      const fmMatch = existing.match(/^---\n([\s\S]*?)\n---/);
+      if (fmMatch) {
+        const parsed = import_yaml.default.parse(fmMatch[1]);
+        if (typeof parsed.created === "string") created = parsed.created;
+      }
+    } catch {
+    }
+    const frontmatter = {
+      type: "plan",
+      id: input.id,
+      status,
+      created
+    };
+    if (input.author) frontmatter.author = input.author;
+    frontmatter.tags = buildTags("plan", status, input.tags ?? []);
+    const body = formatPlanBody({
+      id: input.id,
+      status,
+      author: input.author,
+      created,
+      content: input.content,
+      tags: input.tags
+    });
+    this.writeMarkdown(relativePath, frontmatter, body);
+    return relativePath;
+  }
+  writeSpore(input) {
+    const normalizedType = input.observation_type.replace(/_/g, "-");
+    const relativePath = `spores/${normalizedType}/${input.id}.md`;
+    const fullPath = path.join(this.vaultDir, relativePath);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let created = now;
+    try {
+      const existing = fs.readFileSync(fullPath, "utf-8");
+      const fmMatch = existing.match(/^---\n([\s\S]*?)\n---/);
+      if (fmMatch) {
+        const parsed = import_yaml.default.parse(fmMatch[1]);
+        if (typeof parsed.created === "string") created = parsed.created;
+      }
+    } catch {
+    }
+    const frontmatter = {
+      type: "spore",
+      id: input.id,
+      observation_type: input.observation_type,
+      created
+    };
+    if (input.session) frontmatter.session = input.session;
+    if (input.plan) frontmatter.plan = input.plan;
+    frontmatter.tags = buildTags("spore", input.observation_type, input.tags ?? []);
+    this.writeMarkdown(relativePath, frontmatter, input.content);
+    return relativePath;
+  }
+  writeArtifact(input) {
+    const relativePath = `artifacts/${input.id}.md`;
+    const fullPath = path.join(this.vaultDir, relativePath);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let created = now;
+    try {
+      const existing = fs.readFileSync(fullPath, "utf-8");
+      const fmMatch = existing.match(/^---\n([\s\S]*?)\n---/);
+      if (fmMatch) {
+        const parsed = import_yaml.default.parse(fmMatch[1]);
+        if (typeof parsed.created === "string") created = parsed.created;
+      }
+    } catch {
+    }
+    const frontmatter = {
+      type: "artifact",
+      id: input.id,
+      artifact_type: input.artifact_type,
+      source_path: input.source_path,
+      title: input.title,
+      last_captured_by: sessionNoteId(input.session),
+      created,
+      updated: now,
+      tags: buildTags("artifact", input.artifact_type, input.tags ?? [])
+    };
+    const body = formatArtifactBody({
+      id: input.id,
+      title: input.title,
+      artifact_type: input.artifact_type,
+      source_path: input.source_path,
+      sessionId: input.session,
+      content: input.content,
+      tags: input.tags
+    });
+    this.writeMarkdown(relativePath, frontmatter, body);
+    return relativePath;
+  }
+  writeTeamMember(input) {
+    const relativePath = `team/${input.user}.md`;
+    const frontmatter = {
+      type: "team-member",
+      user: input.user,
+      joined: (/* @__PURE__ */ new Date()).toISOString(),
+      tags: buildTags("team", "", [`user/${input.user}`])
+    };
+    if (input.role) frontmatter.role = input.role;
+    const body = formatTeamBody({
+      user: input.user,
+      role: input.role
+    });
+    this.writeMarkdown(relativePath, frontmatter, body);
+    return relativePath;
+  }
+  /**
+   * Update frontmatter fields on an existing note without touching the body.
+   * By default only adds fields that don't exist. Set overwrite=true to replace existing values.
+   * Returns true if the update was applied, false if the file doesn't exist.
+   */
+  updateNoteFrontmatter(relativePath, fields, overwrite = false) {
+    const fullPath = path.join(this.vaultDir, relativePath);
+    let fileContent;
+    try {
+      fileContent = fs.readFileSync(fullPath, "utf-8");
+    } catch {
+      return false;
+    }
+    const fmMatch = fileContent.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return false;
+    const parsed = import_yaml.default.parse(fmMatch[1]);
+    for (const [key, value] of Object.entries(fields)) {
+      if (overwrite || parsed[key] === void 0) {
+        parsed[key] = value;
+      }
+    }
+    const body = fileContent.slice(fmMatch[0].length);
+    const fmYaml = import_yaml.default.stringify(parsed, { defaultStringType: "QUOTE_DOUBLE", defaultKeyType: "PLAIN" }).trim();
+    this.atomicWrite(fullPath, `---
+${fmYaml}
+---${body}`);
+    return true;
+  }
+  /** @deprecated Use updateNoteFrontmatter instead */
+  updateSessionFrontmatter(relativePath, fields) {
+    return this.updateNoteFrontmatter(relativePath, fields);
+  }
+  writeMarkdown(relativePath, frontmatter, content) {
+    const fullPath = path.join(this.vaultDir, relativePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    const fmYaml = import_yaml.default.stringify(frontmatter, { defaultStringType: "QUOTE_DOUBLE", defaultKeyType: "PLAIN" }).trim();
+    const file = `---
+${fmYaml}
+---
+
+${content}
+`;
+    this.atomicWrite(fullPath, file);
+  }
+  /** Write to a temp file then rename — prevents Obsidian from seeing a truncated file mid-write. */
+  atomicWrite(fullPath, content) {
+    const tmp = `${fullPath}.tmp`;
+    fs.writeFileSync(tmp, content, "utf-8");
+    fs.renameSync(tmp, fullPath);
+  }
+};
+
+// src/vault/reader.ts
+var import_gray_matter = __toESM(require_gray_matter(), 1);
+import fs2 from "fs";
+import path2 from "path";
 
 // src/vault/types.ts
 var SessionFrontmatterSchema = external_exports.object({
@@ -3600,18 +4026,18 @@ var VaultReader = class {
     this.vaultDir = vaultDir;
   }
   readNote(relativePath) {
-    const fullPath = path.join(this.vaultDir, relativePath);
-    const raw = fs.readFileSync(fullPath, "utf-8");
+    const fullPath = path2.join(this.vaultDir, relativePath);
+    const raw = fs2.readFileSync(fullPath, "utf-8");
     const { data, content } = (0, import_gray_matter.default)(raw);
     const frontmatter = parseNoteFrontmatter(data);
     return { path: relativePath, frontmatter, content: content.trim() };
   }
   listNotes(subdir) {
-    const dirPath = path.join(this.vaultDir, subdir);
-    if (!fs.existsSync(dirPath)) return [];
+    const dirPath = path2.join(this.vaultDir, subdir);
+    if (!fs2.existsSync(dirPath)) return [];
     const files = this.walkMarkdownFiles(dirPath);
     return files.map((filePath) => {
-      const relativePath = path.relative(this.vaultDir, filePath);
+      const relativePath = path2.relative(this.vaultDir, filePath);
       return this.readNote(relativePath);
     });
   }
@@ -3619,11 +4045,11 @@ var VaultReader = class {
     return VAULT_SUBDIRS.flatMap((subdir) => this.listNotes(subdir));
   }
   walkMarkdownFiles(dir) {
-    if (!fs.existsSync(dir)) return [];
+    if (!fs2.existsSync(dir)) return [];
     const results = [];
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...this.walkMarkdownFiles(fullPath));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -3716,28 +4142,28 @@ function extractNumber(text) {
 }
 
 // src/prompts/index.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
 function resolvePromptsDir() {
-  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 5; i++) {
-    if (fs2.existsSync(path2.join(dir, "package.json"))) {
-      return path2.join(dir, "dist", "src", "prompts");
+    if (fs3.existsSync(path3.join(dir, "package.json"))) {
+      return path3.join(dir, "dist", "src", "prompts");
     }
-    if (fs2.existsSync(path2.join(dir, "extraction.md"))) {
+    if (fs3.existsSync(path3.join(dir, "extraction.md"))) {
       return dir;
     }
-    dir = path2.dirname(dir);
+    dir = path3.dirname(dir);
   }
-  return path2.dirname(fileURLToPath(import.meta.url));
+  return path3.dirname(fileURLToPath(import.meta.url));
 }
 var PROMPTS_DIR = resolvePromptsDir();
 var promptCache = /* @__PURE__ */ new Map();
 function loadPrompt(name) {
   let cached = promptCache.get(name);
   if (!cached) {
-    cached = fs2.readFileSync(path2.join(PROMPTS_DIR, `${name}.md`), "utf-8").trim();
+    cached = fs3.readFileSync(path3.join(PROMPTS_DIR, `${name}.md`), "utf-8").trim();
     promptCache.set(name, cached);
   }
   return cached;
@@ -3808,7 +4234,141 @@ ${truncated}
   });
 }
 
+// src/vault/curation.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import fs4 from "fs";
+import path4 from "path";
+var supersededIdsSchema = external_exports.array(external_exports.string());
+var SUPERSESSION_NOTICE_MARKER = "Superseded by::";
+function isActiveSpore(frontmatter) {
+  const status = frontmatter.status;
+  return !status || status === "active";
+}
+function supersedeSpore(targetId, newSporeId, targetPath, deps) {
+  const fullPath = path4.join(deps.vaultDir, targetPath);
+  let fileContent;
+  try {
+    fileContent = fs4.readFileSync(fullPath, "utf-8");
+  } catch {
+    return false;
+  }
+  const fmMatch = fileContent.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return false;
+  const parsed = import_yaml2.default.parse(fmMatch[1]);
+  parsed.status = "superseded";
+  parsed.superseded_by = newSporeId;
+  const fmYaml = import_yaml2.default.stringify(parsed, { defaultStringType: "QUOTE_DOUBLE", defaultKeyType: "PLAIN" }).trim();
+  let body = fileContent.slice(fmMatch[0].length);
+  if (!body.includes(SUPERSESSION_NOTICE_MARKER)) {
+    const notice = `
+
+> [!warning] Superseded
+> This observation has been superseded.
+
+${SUPERSESSION_NOTICE_MARKER} [[${newSporeId}]]`;
+    body = body.trimEnd() + notice + "\n";
+  }
+  const tmp = `${fullPath}.tmp`;
+  fs4.writeFileSync(tmp, `---
+${fmYaml}
+---${body}`, "utf-8");
+  fs4.renameSync(tmp, fullPath);
+  indexNote(deps.index, deps.vaultDir, targetPath);
+  deps.vectorIndex?.delete(targetId);
+  return true;
+}
+async function checkSupersession(newSporeId, deps) {
+  const { index, vectorIndex, embeddingProvider, llmProvider, vaultDir, log } = deps;
+  if (!vectorIndex || !llmProvider) {
+    log?.("debug", "checkSupersession: skipped \u2014 vectorIndex or llmProvider unavailable", { newSporeId });
+    return [];
+  }
+  const newSporeResults = index.queryByIds([newSporeId]);
+  if (newSporeResults.length === 0) {
+    log?.("warn", "checkSupersession: new spore not found in index", { newSporeId });
+    return [];
+  }
+  const newSpore = newSporeResults[0];
+  const observationType = newSpore.frontmatter["observation_type"];
+  const embeddingText = newSpore.content.slice(0, EMBEDDING_INPUT_LIMIT);
+  const embeddingResult = await generateEmbedding(embeddingProvider, embeddingText);
+  const vectorResults = vectorIndex.search(embeddingResult.embedding, {
+    type: "spore",
+    limit: SUPERSESSION_VECTOR_FETCH_LIMIT
+  });
+  if (vectorResults.length === 0) {
+    log?.("debug", "checkSupersession: no vector results", { newSporeId });
+    return [];
+  }
+  const candidateIds = vectorResults.map((r) => r.id);
+  const candidateNotes = index.queryByIds(candidateIds);
+  const filtered = candidateNotes.filter((note) => {
+    if (note.id === newSporeId) return false;
+    if (!isActiveSpore(note.frontmatter)) return false;
+    if (observationType && note.frontmatter["observation_type"] !== observationType) return false;
+    return true;
+  }).slice(0, SUPERSESSION_CANDIDATE_LIMIT);
+  if (filtered.length === 0) {
+    log?.("debug", "checkSupersession: no candidates after filtering", { newSporeId, observationType });
+    return [];
+  }
+  const template = loadPrompt("supersession");
+  const newSporeText = formatNoteForPrompt(newSpore);
+  const candidatesText = formatNotesForPrompt(filtered);
+  const prompt = template.replace("{{new_spore}}", newSporeText).replace("{{candidates}}", candidatesText);
+  let responseText;
+  try {
+    const response = await llmProvider.summarize(prompt, {
+      maxTokens: SUPERSESSION_MAX_TOKENS,
+      reasoning: LLM_REASONING_MODE
+    });
+    responseText = stripReasoningTokens(response.text);
+  } catch (err) {
+    log?.("warn", "checkSupersession: LLM call failed", { newSporeId, error: String(err) });
+    return [];
+  }
+  let rawIds;
+  try {
+    rawIds = extractJson(responseText);
+  } catch {
+    log?.("warn", "checkSupersession: failed to parse LLM response", { newSporeId, responseText });
+    return [];
+  }
+  const parsed = supersededIdsSchema.safeParse(rawIds);
+  if (!parsed.success) {
+    log?.("warn", "checkSupersession: LLM response failed schema validation", { newSporeId });
+    return [];
+  }
+  const candidateMap = new Map(filtered.map((c) => [c.id, c]));
+  const validIds = parsed.data.filter((id) => candidateMap.has(id));
+  if (validIds.length === 0) {
+    return [];
+  }
+  const supersededIds = [];
+  for (const id of validIds) {
+    const candidate = candidateMap.get(id);
+    const wrote = supersedeSpore(id, newSporeId, candidate.path, { index, vectorIndex, vaultDir });
+    if (!wrote) {
+      log?.("warn", "checkSupersession: file not found for candidate, skipping", { id, path: candidate.path });
+      continue;
+    }
+    supersededIds.push(id);
+    log?.("info", "checkSupersession: marked superseded", { supersededId: id, newSporeId });
+  }
+  return supersededIds;
+}
+
 export {
+  sessionNoteId,
+  bareSessionId,
+  sessionWikilink,
+  sessionRelativePath,
+  CONVERSATION_HEADING,
+  callout,
+  formatSessionBody,
+  formatSporeBody,
+  extractSection,
+  VaultWriter,
   require_gray_matter,
   PLAN_STATUSES,
   OBSERVATION_TYPES,
@@ -3825,7 +4385,11 @@ export {
   buildSummaryPrompt,
   buildTitlePrompt,
   buildSimilarityPrompt,
-  buildClassificationPrompt
+  buildClassificationPrompt,
+  supersededIdsSchema,
+  isActiveSpore,
+  supersedeSpore,
+  checkSupersession
 };
 /*! Bundled license information:
 
@@ -3845,4 +4409,4 @@ strip-bom-string/index.js:
    * Released under the MIT License.
    *)
 */
-//# sourceMappingURL=chunk-24DOZEUJ.js.map
+//# sourceMappingURL=chunk-ALBVNGCF.js.map