opencode-orchestrator 1.2.70 → 1.3.3

package/dist/index.js

@@ -1903,10 +1903,14 @@ var init_plugin_hooks = __esm({
     PLUGIN_HOOKS = {
       /** Intercepts user messages before sending to LLM */
       CHAT_MESSAGE: "chat.message",
-      /** Runs after LLM finishes responding */
-      ASSISTANT_DONE: "assistant.done",
+      /** Runs before any tool call */
+      TOOL_EXECUTE_BEFORE: "tool.execute.before",
       /** Runs after any tool call completes */
-      TOOL_EXECUTE_AFTER: "tool.execute.after"
+      TOOL_EXECUTE_AFTER: "tool.execute.after",
+      /** Preserves custom compaction context */
+      EXPERIMENTAL_SESSION_COMPACTING: "experimental.session.compacting",
+      /** Injects dynamic system prompt additions */
+      EXPERIMENTAL_CHAT_SYSTEM_TRANSFORM: "experimental.chat.system.transform"
     };
   }
 });
@@ -7966,10 +7970,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path10) {
-  if (!path10)
+function getElementAtPath(obj, path11) {
+  if (!path11)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -8378,11 +8382,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path10, issues) {
+function prefixIssues(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -8529,16 +8533,16 @@ function flattenError(error95, mapper = (issue3) => issue3.message) {
 }
 function formatError(error95, mapper = (issue3) => issue3.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error96, path10 = []) => {
+  const processError = (error96, path11 = []) => {
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path10, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path11, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path11, ...issue3.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue3));
         } else {
@@ -8565,17 +8569,17 @@ function formatError(error95, mapper = (issue3) => issue3.message) {
 }
 function treeifyError(error95, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error96, path10 = []) => {
+  const processError = (error96, path11 = []) => {
     var _a3, _b;
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
-        issue3.errors.map((issues) => processError({ issues }, [...path10, ...issue3.path]));
+        issue3.errors.map((issues) => processError({ issues }, [...path11, ...issue3.path]));
       } else if (issue3.code === "invalid_key") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else if (issue3.code === "invalid_element") {
-        processError({ issues: issue3.issues }, [...path10, ...issue3.path]);
+        processError({ issues: issue3.issues }, [...path11, ...issue3.path]);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path11, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -8607,8 +8611,8 @@ function treeifyError(error95, mapper = (issue3) => issue3.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -21300,13 +21304,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path10 = ref.slice(1).split("/").filter(Boolean);
-  if (path10.length === 0) {
+  const path11 = ref.slice(1).split("/").filter(Boolean);
+  if (path11.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path10[0] === defsKey) {
-    const key = path10[1];
+  if (path11[0] === defsKey) {
+    const key = path11[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -23909,10 +23913,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema) {
   return mergeDefs2(schema._zod.def);
 }
-function getElementAtPath2(obj, path10) {
-  if (!path10)
+function getElementAtPath2(obj, path11) {
+  if (!path11)
     return obj;
-  return path10.reduce((acc, key) => acc?.[key], obj);
+  return path11.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -24273,11 +24277,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path10, issues) {
+function prefixIssues2(path11, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path10);
+    iss.path.unshift(path11);
     return iss;
   });
 }
@@ -24445,7 +24449,7 @@ function treeifyError2(error95, _mapper) {
     return issue3.message;
   };
   const result = { errors: [] };
-  const processError = (error96, path10 = []) => {
+  const processError = (error96, path11 = []) => {
     var _a3, _b;
     for (const issue3 of error96.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -24455,7 +24459,7 @@ function treeifyError2(error95, _mapper) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path10, ...issue3.path];
+        const fullpath = [...path11, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -24487,8 +24491,8 @@ function treeifyError2(error95, _mapper) {
 }
 function toDotPath2(_path) {
   const segs = [];
-  const path10 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path10) {
+  const path11 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path11) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -36638,6 +36642,7 @@ function ensureSessionInitialized(sessions, sessionID, directory) {
       timestamp: now,
       startTime: now,
       lastStepTime: now,
+      lastCompletedMessageID: void 0,
       tokens: { totalInput: 0, totalOutput: 0, estimatedCost: 0 }
     };
     if (directory) {
@@ -37284,10 +37289,10 @@ async function resolveCommandPath(key, commandName) {
   const currentPending = pending.get(key);
   if (currentPending) return currentPending;
   const promise3 = (async () => {
-    const path10 = await findCommand(commandName);
-    cache[key] = path10;
+    const path11 = await findCommand(commandName);
+    cache[key] = path11;
     pending.delete(key);
-    return path10;
+    return path11;
   })();
   pending.set(key, promise3);
   return promise3;
@@ -37296,14 +37301,14 @@ async function resolveCommandPath(key, commandName) {
 // src/core/notification/os-notify/notifier.ts
 var execAsync2 = promisify2(exec2);
 async function notifyDarwin(title, message) {
-  const path10 = await resolveCommandPath(
+  const path11 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.OSASCRIPT,
     NOTIFICATION_COMMANDS.OSASCRIPT
   );
-  if (!path10) return;
+  if (!path11) return;
   const escT = title.replace(/"/g, '\\"');
   const escM = message.replace(/"/g, '\\"');
-  await execAsync2(`${path10} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"' >/dev/null 2>/dev/null`);
+  await execAsync2(`${path11} -e 'display notification "${escM}" with title "${escT}" sound name "Glass"' >/dev/null 2>/dev/null`);
 }
 function isWSL() {
   try {
@@ -37316,11 +37321,11 @@ function isWSL() {
 }
 async function notifyLinux(title, message) {
   if (isWSL()) return;
-  const path10 = await resolveCommandPath(
+  const path11 = await resolveCommandPath(
     NOTIFICATION_COMMAND_KEYS.NOTIFY_SEND,
     NOTIFICATION_COMMANDS.NOTIFY_SEND
   );
-  if (path10) await execAsync2(`${path10} "${title}" "${message}" >/dev/null 2>/dev/null`);
+  if (path11) await execAsync2(`${path11} "${title}" "${message}" >/dev/null 2>/dev/null`);
 }
 async function notifyWindows(title, message) {
   const ps = await resolveCommandPath(
@@ -37368,11 +37373,11 @@ init_os();
 async function playDarwin(soundPath) {
   if (!soundPath) return;
   try {
-    const path10 = await resolveCommandPath(
+    const path11 = await resolveCommandPath(
       NOTIFICATION_COMMAND_KEYS.AFPLAY,
       NOTIFICATION_COMMANDS.AFPLAY
     );
-    if (path10) exec3(`"${path10}" "${soundPath}" >/dev/null 2>/dev/null`);
+    if (path11) exec3(`"${path11}" "${soundPath}" >/dev/null 2>/dev/null`);
   } catch (err) {
     log(`[session-notify] Error playing sound (Darwin): ${err}`);
   }
@@ -41541,6 +41546,55 @@ function handleSessionCompacted(sessionID) {
 
 // src/plugin-handlers/event-handler.ts
 init_shared();
+
+// src/plugin-handlers/assistant-done-handler.ts
+init_logger();
+init_shared();
+async function handleCompletedAssistantMessage(ctx, sessionID, messageID) {
+  const { client, directory, sessions } = ctx;
+  const hooks = HookRegistry.getInstance();
+  const session = sessions.get(sessionID);
+  if (!session?.active || session.lastCompletedMessageID === messageID) {
+    return;
+  }
+  const textContent = await readAssistantText(client, sessionID, messageID);
+  session.lastCompletedMessageID = messageID;
+  const result = await hooks.executeDone(
+    { sessionID, directory, sessions },
+    textContent
+  );
+  if (result.action !== "inject" || result.prompts.length === 0) {
+    return;
+  }
+  const now = Date.now();
+  session.step++;
+  session.timestamp = now;
+  session.lastStepTime = now;
+  try {
+    const parts = result.prompts.map((text) => ({ type: PART_TYPES.TEXT, text }));
+    client.session.prompt({
+      path: { id: sessionID },
+      body: { parts }
+    }).catch((error95) => {
+      log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
+    });
+  } catch (error95) {
+    log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
+  }
+}
+async function readAssistantText(client, sessionID, messageID) {
+  try {
+    const response = await client.session.message({
+      path: { id: sessionID, messageID }
+    });
+    return (response.parts ?? []).filter((part) => part.type === PART_TYPES.TEXT || part.type === PART_TYPES.REASONING).map((part) => part.text ?? "").join("\n");
+  } catch (error95) {
+    log("[assistant-done-handler] Failed to read assistant message", { sessionID, messageID, error: error95 });
+    return "";
+  }
+}
+
+// src/plugin-handlers/event-handler.ts
 function createEventHandler(ctx) {
   const { client, directory, sessions, state: state2 } = ctx;
   return async (input) => {
@@ -41591,7 +41645,7 @@ function createEventHandler(ctx) {
     if (event.type === MESSAGE_EVENTS.UPDATED) {
       const messageProperties = event.properties;
       const messageInfo = messageProperties?.info;
-      const sessionID = messageInfo?.sessionID;
+      const sessionID = messageProperties.sessionID || messageInfo?.sessionID;
       const role = messageInfo?.role;
       if (sessionID && messageProperties?.usage) {
         const totalTokens = messageProperties.usage.totalTokens ?? (messageProperties.usage.inputTokens ?? 0) + (messageProperties.usage.outputTokens ?? 0);
@@ -41601,6 +41655,9 @@ function createEventHandler(ctx) {
       }
       if (sessionID && role === MESSAGE_ROLES.ASSISTANT) {
         markRecoveryComplete(sessionID);
+        if (messageInfo?.id && messageInfo.time?.completed) {
+          await handleCompletedAssistantMessage(ctx, sessionID, messageInfo.id);
+        }
       }
       if (sessionID && role === MESSAGE_ROLES.USER) {
         handleUserMessage(sessionID);
@@ -41682,53 +41739,6 @@ function createToolExecuteAfterHandler(ctx) {
   };
 }
 
-// src/plugin-handlers/assistant-done-handler.ts
-init_logger();
-init_shared();
-function createAssistantDoneHandler(ctx) {
-  const { client, directory, sessions } = ctx;
-  const hooks = HookRegistry.getInstance();
-  return async (assistantInput, assistantOutput) => {
-    const sessionID = assistantInput.sessionID;
-    const session = sessions.get(sessionID);
-    if (!session?.active) return;
-    const parts = assistantOutput.parts;
-    const textContent = parts?.filter((p) => p.type === PART_TYPES.TEXT || p.type === PART_TYPES.REASONING).map((p) => p.text || "").join("\n") || "";
-    const hookContext = {
-      sessionID,
-      directory,
-      sessions
-      // Cast because types might slightly differ in strict mode, but it's the same object
-    };
-    const result = await hooks.executeDone(hookContext, textContent);
-    if (result.action === "stop") {
-      return;
-    }
-    if (result.action === "inject" && result.prompts) {
-      const now = Date.now();
-      session.step++;
-      session.timestamp = now;
-      session.lastStepTime = now;
-      try {
-        if (client?.session?.prompt) {
-          const parts2 = result.prompts.map((p) => ({
-            type: PART_TYPES.TEXT,
-            text: p
-          }));
-          client.session.prompt({
-            path: { id: sessionID },
-            body: { parts: parts2 }
-          }).catch((error95) => {
-            log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
-          });
-        }
-      } catch (error95) {
-        log("[assistant-done-handler] Failed to inject continuation prompts", { sessionID, error: error95 });
-      }
-    }
-  };
-}
-
 // src/plugin-handlers/session-compacting-handler.ts
 init_shared();
 function createSessionCompactingHandler(ctx) {
@@ -41805,6 +41815,564 @@ Wait for these tasks to complete before concluding the mission.
 
 // src/plugin-handlers/system-transform-handler.ts
 init_shared();
+
+// src/core/knowledge/context-provider.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5, readdirSync } from "node:fs";
+import path10 from "node:path";
+
+// src/core/knowledge/graph-parser.ts
+var GraphParser = class _GraphParser {
+  /** Heading marker used for the auto-generated backlinks section */
+  static BACKLINKS_HEADING = "## \u{1F517} Backlinks";
+  // Maps note name -> set of target note names it links to
+  forwardLinks = /* @__PURE__ */ new Map();
+  // Maps note name -> set of source note names that link to it
+  backlinks = /* @__PURE__ */ new Map();
+  // Maps note name -> file path
+  noteToPath = /* @__PURE__ */ new Map();
+  // Maps file path -> note name
+  pathToNote = /* @__PURE__ */ new Map();
+  /**
+   * Resolve file path or relative link to a note name (basename without extension).
+   */
+  getNoteName(filePath) {
+    const basename = filePath.split(/[/\\]/).pop() || "";
+    const dotIdx = basename.lastIndexOf(".");
+    return dotIdx !== -1 ? basename.slice(0, dotIdx) : basename;
+  }
+  /**
+   * Parse content and extract all unique referenced target note names.
+   */
+  parseLinks(content) {
+    const targets = [];
+    const wikiRegex = /\[\[([^[\]|#]+)(?:\|[^[\]]+)?(?:#[^[\]]+)?\]\]/g;
+    let match;
+    while ((match = wikiRegex.exec(content)) !== null) {
+      const target = match[1].trim();
+      if (target && !targets.includes(target)) {
+        targets.push(target);
+      }
+    }
+    const mdLinkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
+    while ((match = mdLinkRegex.exec(content)) !== null) {
+      const url3 = match[2].trim();
+      if (!url3.includes("://") && (url3.endsWith(".md") || url3.startsWith(".") || url3.startsWith("/"))) {
+        const targetName = this.getNoteName(url3);
+        if (targetName && !targets.includes(targetName)) {
+          targets.push(targetName);
+        }
+      }
+    }
+    return targets;
+  }
+  /**
+   * Index file and register its bi-directional links.
+   */
+  indexFile(filePath, content) {
+    const sourceNote = this.getNoteName(filePath);
+    this.noteToPath.set(sourceNote, filePath);
+    this.pathToNote.set(filePath, sourceNote);
+    this.clearIndexForNote(sourceNote);
+    const targets = this.parseLinks(content);
+    if (targets.length > 0) {
+      const forwardSet = new Set(targets);
+      this.forwardLinks.set(sourceNote, forwardSet);
+      for (const target of targets) {
+        let backSet = this.backlinks.get(target);
+        if (!backSet) {
+          backSet = /* @__PURE__ */ new Set();
+          this.backlinks.set(target, backSet);
+        }
+        backSet.add(sourceNote);
+      }
+    }
+  }
+  /**
+   * Retrieve backlinks for a note name or file path.
+   */
+  getBacklinks(noteOrPath) {
+    const note = noteOrPath.includes("/") || noteOrPath.endsWith(".md") ? this.getNoteName(noteOrPath) : noteOrPath;
+    const sources = this.backlinks.get(note);
+    return sources ? Array.from(sources).sort() : [];
+  }
+  /**
+   * Retrieve forward links for a note name or file path.
+   */
+  getForwardLinks(noteOrPath) {
+    const note = noteOrPath.includes("/") || noteOrPath.endsWith(".md") ? this.getNoteName(noteOrPath) : noteOrPath;
+    const targets = this.forwardLinks.get(note);
+    return targets ? Array.from(targets).sort() : [];
+  }
+  /**
+   * Synchronize the ## 🔗 Backlinks section in a file's content.
+   */
+  syncBacklinksSection(content, backlinksList) {
+    const backlinksHeading = _GraphParser.BACKLINKS_HEADING;
+    const headingRegex = new RegExp(`(?:\\r?\\n|^)${backlinksHeading}\\b[\\s\\S]*$`);
+    let backlinksSectionContent = `
+
+${backlinksHeading}
+
+`;
+    if (backlinksList.length > 0) {
+      backlinksSectionContent += backlinksList.map((b) => `- [[${b}]]`).join("\n");
+    } else {
+      backlinksSectionContent += "*(No backlinks found)*";
+    }
+    if (content.includes(backlinksHeading)) {
+      return content.replace(headingRegex, backlinksSectionContent);
+    } else {
+      return content.trimEnd() + backlinksSectionContent;
+    }
+  }
+  /**
+   * Clear all indexes for a note.
+   */
+  clearIndexForNote(sourceNote) {
+    const targets = this.forwardLinks.get(sourceNote);
+    if (targets) {
+      for (const target of targets) {
+        const backSet = this.backlinks.get(target);
+        if (backSet) {
+          backSet.delete(sourceNote);
+          if (backSet.size === 0) {
+            this.backlinks.delete(target);
+          }
+        }
+      }
+      this.forwardLinks.delete(sourceNote);
+    }
+  }
+};
+
+// src/core/knowledge/hybrid-search.ts
+var RRF_K = 60;
+var DEFAULT_MAX_RESULTS = 20;
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+var GRAPH_HOP_DEPTH = 2;
+var HybridSearch = class {
+  tagIndexer;
+  graphParser;
+  /** Stores indexed note content keyed by note name. */
+  contentMap = /* @__PURE__ */ new Map();
+  constructor(tagIndexer, graphParser) {
+    this.tagIndexer = tagIndexer;
+    this.graphParser = graphParser;
+  }
+  /**
+   * Register note content for lexical search.
+   * Must be called after TagIndexer.indexFile / GraphParser.indexFile.
+   */
+  indexContent(noteName, content) {
+    this.contentMap.set(noteName, content.toLowerCase());
+  }
+  /**
+   * Fuse lexical, tag, and graph rankings via RRF to produce a single list.
+   */
+  search(query, maxResults) {
+    const limit = maxResults ?? DEFAULT_MAX_RESULTS;
+    const terms = this.tokenize(query);
+    if (terms.length === 0) return [];
+    const lexicalRanked = this.lexicalSearch(terms);
+    const tagRanked = this.tagSearch(terms);
+    const graphRanked = this.graphSearch(terms);
+    return this.fuseResults(lexicalRanked, tagRanked, graphRanked, limit);
+  }
+  /**
+   * BM25-inspired term-frequency scoring across all indexed documents.
+   * Approximates IDF via corpus size and document frequency.
+   */
+  lexicalSearch(terms) {
+    const scores = /* @__PURE__ */ new Map();
+    const corpusSize = this.contentMap.size;
+    if (corpusSize === 0) return [];
+    const avgLen = this.computeAverageLength();
+    for (const term of terms) {
+      const df = this.documentFrequency(term);
+      const idf = Math.log((corpusSize - df + 0.5) / (df + 0.5) + 1);
+      for (const [name, content] of this.contentMap) {
+        const tf = this.countOccurrences(content, term);
+        if (tf === 0) continue;
+        const docLen = content.length;
+        const tfNorm = tf * (BM25_K1 + 1) / (tf + BM25_K1 * (1 - BM25_B + BM25_B * (docLen / avgLen)));
+        const prev = scores.get(name) ?? 0;
+        scores.set(name, prev + idf * tfNorm);
+      }
+    }
+    return this.sortByScore(scores);
+  }
+  /**
+   * Match query terms against the tag index to find tagged notes.
+   */
+  tagSearch(terms) {
+    const scores = /* @__PURE__ */ new Map();
+    for (const term of terms) {
+      const files = this.tagIndexer.getFilesWithTag(term);
+      for (const file3 of files) {
+        const noteName = this.graphParser.getNoteName(file3);
+        const prev = scores.get(noteName) ?? 0;
+        scores.set(noteName, prev + 1);
+      }
+    }
+    return this.sortByScore(scores);
+  }
+  /**
+   * 2-hop graph traversal from tag-matched seed notes to discover related notes.
+   */
+  graphSearch(terms) {
+    const seeds = new Set(this.tagSearch(terms));
+    const visited = /* @__PURE__ */ new Set();
+    const scores = /* @__PURE__ */ new Map();
+    for (const seed of seeds) {
+      this.traverseGraph(seed, GRAPH_HOP_DEPTH, visited, scores);
+    }
+    return this.sortByScore(scores);
+  }
+  /**
+   * Depth-limited BFS from a seed note, scoring neighbors by proximity.
+   */
+  traverseGraph(note, depth, visited, scores) {
+    if (depth <= 0 || visited.has(note)) return;
+    visited.add(note);
+    const neighbors = [
+      ...this.graphParser.getForwardLinks(note),
+      ...this.graphParser.getBacklinks(note)
+    ];
+    for (const neighbor of neighbors) {
+      const prev = scores.get(neighbor) ?? 0;
+      scores.set(neighbor, prev + depth);
+      this.traverseGraph(neighbor, depth - 1, visited, scores);
+    }
+  }
+  /**
+   * Reciprocal Rank Fusion: combine three ranked lists into a single ranking.
+   * Formula: score(d) = Σ 1/(k + rank_i) for each list where d appears.
+   */
+  fuseResults(lexical, tags, graph, limit) {
+    const fused = /* @__PURE__ */ new Map();
+    this.addRrfScores(fused, lexical, "lexical");
+    this.addRrfScores(fused, tags, "tag");
+    this.addRrfScores(fused, graph, "graph");
+    return Array.from(fused.entries()).map(([noteName, { score, matchType }]) => ({ noteName, score, matchType })).sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  /**
+   * Accumulate RRF scores from a single ranked list into the fused map.
+   * The matchType is set to the source with the highest individual contribution.
+   */
+  addRrfScores(fused, ranked, matchType) {
+    for (let i = 0; i < ranked.length; i++) {
+      const rrfScore = 1 / (RRF_K + i + 1);
+      const existing = fused.get(ranked[i]);
+      if (existing) {
+        existing.score += rrfScore;
+        if (rrfScore > 1 / (RRF_K + 1)) {
+          existing.matchType = matchType;
+        }
+      } else {
+        fused.set(ranked[i], { score: rrfScore, matchType });
+      }
+    }
+  }
+  /** Split query into lowercase tokens for matching. */
+  tokenize(query) {
+    return query.toLowerCase().split(/\s+/).filter(Boolean);
+  }
+  /** Count non-overlapping occurrences of a term in text. */
+  countOccurrences(text, term) {
+    let count = 0;
+    let pos = 0;
+    while ((pos = text.indexOf(term, pos)) !== -1) {
+      count++;
+      pos += term.length;
+    }
+    return count;
+  }
+  /** Average document length across the corpus (character-based). */
+  computeAverageLength() {
+    let total = 0;
+    for (const content of this.contentMap.values()) {
+      total += content.length;
+    }
+    return total / Math.max(this.contentMap.size, 1);
+  }
+  /** Number of documents containing the given term. */
+  documentFrequency(term) {
+    let count = 0;
+    for (const content of this.contentMap.values()) {
+      if (content.includes(term)) count++;
+    }
+    return count;
+  }
+  /** Sort entries by descending score and return the keys in order. */
+  sortByScore(scores) {
+    return Array.from(scores.entries()).sort((a, b) => b[1] - a[1]).map(([name]) => name);
+  }
+};
+
+// src/core/knowledge/tag-indexer.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+var TagIndexer = class {
+  tagMap = /* @__PURE__ */ new Map();
+  fileCache = /* @__PURE__ */ new Map();
+  /**
+   * Parse frontmatter using regular expressions as a primary safe parser.
+   * This avoids library dependencies and provides deterministic error recovery.
+   */
+  parseFrontmatter(content) {
+    const data = {};
+    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { data, body: content };
+    }
+    const rawYaml = match[1];
+    const body = content.replace(frontmatterRegex, "").trim();
+    const lines = rawYaml.split(/\r?\n/);
+    let activeKey = null;
+    for (const line of lines) {
+      activeKey = this.parseYamlLine(line, data, activeKey);
+    }
+    return { data, body };
+  }
+  /**
+   * Parse a single YAML line and update data object in-place.
+   * Returns the currently active key for block list continuation.
+   */
+  parseYamlLine(line, data, activeKey) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) return activeKey;
+    const colonIdx = trimmed.indexOf(":");
+    if (colonIdx !== -1) {
+      const key = trimmed.slice(0, colonIdx).trim();
+      const val = trimmed.slice(colonIdx + 1).trim();
+      if (val.startsWith("[") && val.endsWith("]")) {
+        data[key] = val.slice(1, -1).split(",").map((s) => s.trim()).filter(Boolean);
+      } else if (val) {
+        data[key] = this.parseScalar(val);
+      } else {
+        data[key] = [];
+      }
+      return key;
+    }
+    if (trimmed.startsWith("-") && activeKey) {
+      const listVal = trimmed.slice(1).trim();
+      if (listVal) {
+        const currentList = Array.isArray(data[activeKey]) ? data[activeKey] : [];
+        currentList.push(listVal);
+        data[activeKey] = currentList;
+      }
+    }
+    return activeKey;
+  }
+  /**
+   * Index a single markdown file content dynamically.
+   */
+  indexFile(filePath, fileContent) {
+    this.clearIndexForFile(filePath);
+    const { data } = this.parseFrontmatter(fileContent);
+    this.fileCache.set(filePath, data);
+    if (data.tags && Array.isArray(data.tags)) {
+      for (const tag of data.tags) {
+        if (typeof tag === "string") {
+          this.addTagEntry(tag.toLowerCase(), filePath);
+        }
+      }
+    }
+  }
+  /**
+   * Index a file directly from the filesystem.
+   */
+  indexFileFromDisk(filePath) {
+    try {
+      const content = readFileSync4(filePath, "utf8");
+      this.indexFile(filePath, content);
+    } catch {
+      this.clearIndexForFile(filePath);
+    }
+  }
+  /**
+   * Get all files associated with a specific tag O(1).
+   */
+  getFilesWithTag(tag) {
+    return this.tagMap.get(tag.toLowerCase()) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Get intersection of files containing all specified tags.
+   */
+  getFilesWithAllTags(tags) {
+    if (tags.length === 0) return /* @__PURE__ */ new Set();
+    let result = new Set(this.getFilesWithTag(tags[0]));
+    for (let i = 1; i < tags.length; i++) {
+      const currentSet = this.getFilesWithTag(tags[i]);
+      result = new Set([...result].filter((x) => currentSet.has(x)));
+    }
+    return result;
+  }
+  /**
+   * Get union of files containing any of the specified tags.
+   */
+  getFilesWithAnyTags(tags) {
+    const result = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      const files = this.getFilesWithTag(tag);
+      for (const file3 of files) {
+        result.add(file3);
+      }
+    }
+    return result;
+  }
+  /**
+   * Get the cached frontmatter metadata of a file.
+   */
+  getMetadata(filePath) {
+    return this.fileCache.get(filePath);
+  }
+  /**
+   * Return all file paths that have been indexed.
+   */
+  getIndexedFiles() {
+    return Array.from(this.fileCache.keys());
+  }
+  /**
+   * Return all distinct tags currently present across all indexed files.
+   */
+  getAllTags() {
+    return Array.from(this.tagMap.keys());
+  }
+  /**
+   * Remove file references cleanly from tag mappings and metadata cache.
+   */
+  clearIndexForFile(filePath) {
+    this.fileCache.delete(filePath);
+    for (const [tag, files] of this.tagMap.entries()) {
+      if (files.has(filePath)) {
+        files.delete(filePath);
+        if (files.size === 0) {
+          this.tagMap.delete(tag);
+        }
+      }
+    }
+  }
+  /**
+   * Helper to insert tags atomically.
+   */
+  addTagEntry(tag, filePath) {
+    let files = this.tagMap.get(tag);
+    if (!files) {
+      files = /* @__PURE__ */ new Set();
+      this.tagMap.set(tag, files);
+    }
+    files.add(filePath);
+  }
+  /**
+   * Basic scalar value parser for YAML frontmatter fields.
+   */
+  parseScalar(val) {
+    if (val === "true") return true;
+    if (val === "false") return false;
+    const num = Number(val);
+    if (!isNaN(num)) return num;
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      return val.slice(1, -1);
+    }
+    return val;
+  }
+};
+
+// src/core/knowledge/context-provider.ts
+var MAX_RESULTS = 3;
+var MAX_SNIPPET_CHARS = 220;
+var KNOWLEDGE_ROOTS = ["docs", path10.join(".opencode", "docs")];
+var SKIP_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", "bin", ".git", "archive"]);
+var KnowledgeContextProvider = class {
+  buildPrompt(directory, query) {
+    const normalizedQuery = query.trim();
+    if (!normalizedQuery) return null;
+    const markdownFiles = this.collectMarkdownFiles(directory);
+    if (markdownFiles.length === 0) return null;
+    const indexed = this.indexKnowledge(directory, markdownFiles);
+    const results = indexed.search.search(normalizedQuery, MAX_RESULTS);
+    if (results.length === 0) return null;
+    return this.formatPrompt(normalizedQuery, results, indexed);
+  }
+  collectMarkdownFiles(directory) {
+    const files = [];
+    for (const root of KNOWLEDGE_ROOTS) {
+      const fullRoot = path10.join(directory, root);
+      if (!existsSync9(fullRoot)) continue;
+      files.push(...this.walkDirectory(fullRoot));
+    }
+    return files.sort();
+  }
+  walkDirectory(directory) {
+    const files = [];
+    for (const entry of readdirSync(directory, { withFileTypes: true })) {
+      const fullPath = path10.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        if (SKIP_SEGMENTS.has(entry.name)) continue;
+        files.push(...this.walkDirectory(fullPath));
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  indexKnowledge(directory, files) {
+    const tagIndexer = new TagIndexer();
+    const graphParser = new GraphParser();
+    const search = new HybridSearch(tagIndexer, graphParser);
+    const noteToPath = /* @__PURE__ */ new Map();
+    const noteToSnippet = /* @__PURE__ */ new Map();
+    for (const filePath of files) {
+      try {
+        const content = readFileSync5(filePath, "utf8");
+        const noteName = graphParser.getNoteName(filePath);
+        const { body } = tagIndexer.parseFrontmatter(content);
+        const normalizedBody = body.trim();
+        tagIndexer.indexFile(filePath, content);
+        graphParser.indexFile(filePath, content);
+        search.indexContent(noteName, normalizedBody);
+        noteToPath.set(noteName, path10.relative(directory, filePath) || filePath);
+        noteToSnippet.set(noteName, this.buildSnippet(normalizedBody));
+      } catch {
+        continue;
+      }
+    }
+    return { search, noteToPath, noteToSnippet };
+  }
+  buildSnippet(content) {
+    const normalized = content.replace(/\s+/g, " ").trim();
+    if (normalized.length <= MAX_SNIPPET_CHARS) return normalized;
+    return `${normalized.slice(0, MAX_SNIPPET_CHARS)}...`;
+  }
+  formatPrompt(query, results, indexed) {
+    const lines = [
+      "<knowledge_rag_context>",
+      `Query: ${query}`,
+      "Repository knowledge matches:",
+      ""
+    ];
+    for (const [index, result] of results.entries()) {
+      const filePath = indexed.noteToPath.get(result.noteName) ?? result.noteName;
+      const snippet = indexed.noteToSnippet.get(result.noteName) ?? "";
+      lines.push(`${index + 1}. ${result.noteName} [${result.matchType}]`);
+      lines.push(`   Source: ${filePath}`);
+      if (snippet) {
+        lines.push(`   Snippet: ${snippet}`);
+      }
+    }
+    lines.push("");
+    lines.push("Use this as supplemental repository memory. Verify against source files before making claims.");
+    lines.push("</knowledge_rag_context>");
+    return lines.join("\n");
+  }
+};
+
+// src/plugin-handlers/system-transform-handler.ts
+var knowledgeContextProvider = new KnowledgeContextProvider();
 function createSystemTransformHandler(ctx) {
   const { directory, sessions, state: state2 } = ctx;
   return async (input, output) => {
@@ -41825,6 +42393,14 @@ function createSystemTransformHandler(ctx) {
     if (session?.active) {
       systemAdditions.push(buildActiveSessionPrompt(session.step));
     }
+    const knowledgePrompt = buildKnowledgeContextPrompt(
+      directory,
+      loopState?.prompt,
+      state2.sessions.get(sessionID)?.currentTask
+    );
+    if (knowledgePrompt) {
+      systemAdditions.push(knowledgePrompt);
+    }
     try {
       const manager = ParallelAgentManager.getInstance();
       const tasks = manager.getTasksByParent(sessionID);
@@ -41840,6 +42416,10 @@ function createSystemTransformHandler(ctx) {
     }
   };
 }
+function buildKnowledgeContextPrompt(directory, missionPrompt, currentTask) {
+  const queryParts = [missionPrompt ?? "", currentTask ?? ""].filter(Boolean);
+  return knowledgeContextProvider.buildPrompt(directory, queryParts.join(" ").trim());
+}
 function buildMissionLoopSystemPrompt(iteration, maxIterations) {
   return `<orchestrator_mission_loop>
 \u{1F3AF} MISSION LOOP ACTIVE: Iteration ${iteration}/${maxIterations}
@@ -41945,23 +42525,19 @@ var OrchestratorPlugin = async (input) => {
     // -----------------------------------------------------------------
     // tool.execute.before hook - runs before any tool call
     // -----------------------------------------------------------------
-    "tool.execute.before": createToolExecuteBeforeHandler(handlerContext),
+    [PLUGIN_HOOKS.TOOL_EXECUTE_BEFORE]: createToolExecuteBeforeHandler(handlerContext),
     // -----------------------------------------------------------------
     // tool.execute.after hook - runs after any tool call completes
     // -----------------------------------------------------------------
     [PLUGIN_HOOKS.TOOL_EXECUTE_AFTER]: createToolExecuteAfterHandler(handlerContext),
     // -----------------------------------------------------------------
-    // assistant.done hook - runs when the LLM finishes responding
-    // -----------------------------------------------------------------
-    [PLUGIN_HOOKS.ASSISTANT_DONE]: createAssistantDoneHandler(handlerContext),
-    // -----------------------------------------------------------------
     // experimental.session.compacting hook - preserves mission context during compaction
     // -----------------------------------------------------------------
-    "experimental.session.compacting": createSessionCompactingHandler(handlerContext),
+    [PLUGIN_HOOKS.EXPERIMENTAL_SESSION_COMPACTING]: createSessionCompactingHandler(handlerContext),
     // -----------------------------------------------------------------
     // experimental.chat.system.transform hook - dynamic system prompt injection
     // -----------------------------------------------------------------
-    "experimental.chat.system.transform": createSystemTransformHandler(handlerContext),
+    [PLUGIN_HOOKS.EXPERIMENTAL_CHAT_SYSTEM_TRANSFORM]: createSystemTransformHandler(handlerContext),
     // -----------------------------------------------------------------
     // shutdown hook - cleanup resources on plugin unload
     // -----------------------------------------------------------------