@goondocks/myco 0.6.4 → 0.9.0

package/dist/{server-6UDN35QN.js → server-6KMBJCHZ.js}

@@ -1,45 +1,6 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
-import {
-  queryLogs
-} from "./chunk-H7PRCVGQ.js";
-import {
-  consolidateSpores,
-  handleMycoContext
-} from "./chunk-2ZIBCEYO.js";
-import "./chunk-QLUE3BUL.js";
-import {
-  VectorIndex
-} from "./chunk-4RMSHZE4.js";
-import {
-  OBSERVATION_TYPES,
-  PLAN_STATUSES,
-  VaultWriter,
-  checkSupersession,
-  indexNote
-} from "./chunk-UP4P4OAA.js";
-import {
-  generateEmbedding
-} from "./chunk-RGVBGTD6.js";
-import {
-  createEmbeddingProvider,
-  createLlmProvider
-} from "./chunk-NLUE6CYG.js";
-import {
-  planFm,
-  sessionFm,
-  sporeFm
-} from "./chunk-GENQ5QGP.js";
-import {
-  initFts,
-  searchFts
-} from "./chunk-6FQISQNA.js";
-import {
-  MycoIndex
-} from "./chunk-TWSTAVLO.js";
-import "./chunk-7WHF2OIZ.js";
-import {
-  loadConfig
-} from "./chunk-HYVT345Y.js";
+import "./chunk-IB76KGBY.js";
+import "./chunk-E4VLWIJC.js";
 import {
   _enum,
   _null,
@@ -47,6 +8,7 @@ import {
   boolean,
   custom,
   discriminatedUnion,
+  external_exports,
   intersection,
   iso_exports,
   literal,
@@ -60,26 +22,23 @@ import {
   string,
   union,
   unknown
-} from "./chunk-ERG2IEWX.js";
+} from "./chunk-KH64DHOY.js";
 import {
-  resolveSessionFromBuffer
-} from "./chunk-HIN3UVOG.js";
+  DaemonClient
+} from "./chunk-TRUJLI6K.js";
+import {
+  DAEMON_CLIENT_TIMEOUT_MS,
+  MCP_SEARCH_DEFAULT_LIMIT,
+  MCP_SESSIONS_DEFAULT_LIMIT
+} from "./chunk-5VZ52A4T.js";
+import "./chunk-WGTCA2NU.js";
 import {
   getPluginVersion
-} from "./chunk-QN4W3JUA.js";
+} from "./chunk-PB6TOLRQ.js";
+import "./chunk-LPUQPDC2.js";
 import {
   resolveVaultDir
-} from "./chunk-N33KUCFP.js";
-import "./chunk-Z74SDEKE.js";
-import {
-  CONTENT_SNIPPET_CHARS,
-  EMBEDDING_INPUT_LIMIT,
-  MCP_LOGS_DEFAULT_LIMIT,
-  MCP_SEARCH_DEFAULT_LIMIT,
-  MCP_SESSIONS_DEFAULT_LIMIT,
-  RECALL_SUMMARY_PREVIEW_CHARS,
-  SESSION_SUMMARY_PREVIEW_CHARS
-} from "./chunk-J4D4CROB.js";
+} from "./chunk-JTYZRPX5.js";
 import {
   __commonJS,
   __toESM
@@ -3278,8 +3237,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path5) {
-      let input = path5;
+    function removeDotSegments(path2) {
+      let input = path2;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3478,8 +3437,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path5, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
+        const [path2, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6841,12 +6800,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs2, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs2[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -7213,8 +7172,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7329,11 +7288,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -14065,379 +14024,238 @@ var StdioServerTransport = class {
 };
 
 // src/mcp/server.ts
-import fs2 from "fs";
-import path4 from "path";
+import fs from "fs";
+import path from "path";
+
+// src/mcp/tools/shared.ts
+function buildEndpoint(base, params) {
+  const qs = new URLSearchParams();
+  for (const [key, val] of Object.entries(params)) {
+    if (val !== void 0) qs.set(key, String(val));
+  }
+  const str = qs.toString();
+  return str ? `${base}?${str}` : base;
+}
 
 // src/mcp/tools/search.ts
-async function handleMycoSearch(index, input, vectorIndex, backend) {
-  const type = input.type === "all" ? void 0 : input.type;
-  const limit = input.limit ?? 10;
-  if (vectorIndex && backend) {
-    try {
-      const emb = await generateEmbedding(backend, input.query);
-      const results = vectorIndex.search(emb.embedding, {
-        limit,
-        type
-      });
-      if (results.length > 0) {
-        const noteMap = new Map(
-          index.queryByIds(results.map((r) => r.id)).map((n) => [n.id, n])
-        );
-        return results.map((r) => {
-          const note = noteMap.get(r.id);
-          return {
-            note_path: note?.path ?? r.id,
-            type: r.metadata.type || note?.type || "unknown",
-            title: note?.title ?? r.id,
-            snippet: note?.content?.slice(0, CONTENT_SNIPPET_CHARS) ?? "",
-            score: r.similarity,
-            frontmatter: note?.frontmatter ?? {}
-          };
-        }).filter((r) => r.snippet).filter((r) => {
-          const status = r.frontmatter.status;
-          return status !== "superseded" && status !== "archived";
-        });
-      }
-    } catch {
-    }
-  }
-  const ftsResults = searchFts(index, input.query, { type, limit });
-  return ftsResults.map((r) => {
-    const note = index.getNoteByPath(r.path);
-    return {
-      note_path: r.path,
-      type: r.type,
-      title: r.title,
-      snippet: r.snippet,
-      score: Math.abs(r.rank),
-      frontmatter: note?.frontmatter ?? {}
-    };
-  }).filter((r) => {
-    const status = r.frontmatter.status;
-    return status !== "superseded" && status !== "archived";
+async function handleMycoSearch(input, client) {
+  const limit = input.limit ?? MCP_SEARCH_DEFAULT_LIMIT;
+  const endpoint = buildEndpoint("/api/search", {
+    q: input.query,
+    limit,
+    type: input.type
   });
+  const result = await client.get(endpoint);
+  if (!result.ok || !result.data?.results) return [];
+  return result.data.results;
 }
 
 // src/mcp/tools/recall.ts
-async function handleMycoRecall(index, input) {
-  const allPlans = index.query({ type: "plan" });
-  const activePlans = allPlans.filter((p) => {
-    const status = planFm(p).status;
-    return status === "active" || status === "in_progress";
-  });
-  let sessions = index.query({ type: "session", limit: 10 });
-  if (input.branch) {
-    sessions = sessions.filter((s) => sessionFm(s).branch === input.branch);
-  }
-  const spores = index.query({ type: "spore", limit: 5 }).filter((m) => sporeFm(m).status !== "superseded" && sporeFm(m).status !== "archived");
-  return {
-    active_plans: activePlans.map((p) => ({
-      id: p.id,
-      title: p.title,
-      status: planFm(p).status ?? "active"
-    })),
-    recent_sessions: sessions.slice(0, 5).map((s) => ({
-      id: s.id,
-      title: s.title,
-      summary: s.content.slice(0, RECALL_SUMMARY_PREVIEW_CHARS)
-    })),
-    relevant_spores: spores.map((m) => ({
-      id: m.id,
-      title: m.title,
-      type: sporeFm(m).observation_type ?? "discovery"
-    })),
-    team_activity: []
-  };
+async function handleMycoRecall(input, client) {
+  const id = input.note_id;
+  const [sessionResult, sporeResult] = await Promise.all([
+    client.get(`/api/sessions/${encodeURIComponent(id)}`),
+    client.get(`/api/spores/${encodeURIComponent(id)}`)
+  ]);
+  if (sessionResult.ok && sessionResult.data) {
+    return { type: "session", ...sessionResult.data };
+  }
+  if (sporeResult.ok && sporeResult.data) {
+    return { type: "spore", ...sporeResult.data };
+  }
+  return { error: `Note not found: ${id}` };
 }
 
 // src/mcp/tools/remember.ts
-import { randomBytes } from "crypto";
-import path from "path";
-async function handleMycoRemember(vaultDir, index, input) {
-  const writer = new VaultWriter(vaultDir);
-  const id = `${input.type}-${randomBytes(4).toString("hex")}`;
-  const session = input.session ?? resolveSessionFromBuffer(path.join(vaultDir, "buffer"));
-  const notePath = writer.writeSpore({
-    id,
-    observation_type: input.type,
-    session,
-    plan: input.related_plan ?? void 0,
-    tags: input.tags,
-    content: input.content
+async function handleMycoRemember(input, client) {
+  const result = await client.post("/api/mcp/remember", {
+    content: input.content,
+    type: input.type,
+    tags: input.tags
   });
-  indexNote(index, vaultDir, notePath);
-  return { note_path: notePath, id, session };
-}
-
-// src/mcp/tools/plans.ts
-async function handleMycoPlans(index, input) {
-  if (input.id) {
-    return getPlanDetail(index, input.id);
-  }
-  const allPlans = index.query({ type: "plan" });
-  let plans = allPlans;
-  if (input.status && input.status !== "all") {
-    plans = allPlans.filter((p) => planFm(p).status === input.status);
-  }
-  return plans.map((p) => {
-    const f = planFm(p);
+  if (!result.ok || !result.data) {
     return {
-      id: p.id,
-      title: p.title,
-      status: f.status ?? "active",
-      progress: extractProgress(p.content),
-      tags: f.tags ?? []
+      id: "",
+      observation_type: input.type ?? "discovery",
+      status: "error",
+      created_at: 0
     };
-  });
+  }
+  return result.data;
 }
-function getPlanDetail(index, planId) {
-  const plans = index.query({ type: "plan", id: planId });
-  if (plans.length === 0) {
-    throw new Error(`Plan not found: ${planId}`);
-  }
-  const plan = plans[0];
-  const f = planFm(plan);
-  const allSessions = index.query({ type: "session", limit: 100 });
-  const linkedSessions = allSessions.filter((s) => {
-    const sf = sessionFm(s);
-    const planRef = sf.plan;
-    const plansArr = sf.plans;
-    return planRef === `[[${planId}]]` || planRef === planId || plansArr?.includes(planId) || plansArr?.includes(`[[${planId}]]`);
+
+// src/mcp/tools/plans.ts
+async function handleMycoPlans(input, client) {
+  const endpoint = buildEndpoint("/api/mcp/plans", {
+    status: input.status,
+    limit: input.limit
   });
-  return {
-    id: plan.id,
-    title: plan.title,
-    status: f.status ?? "active",
-    progress: extractProgress(plan.content),
-    tags: f.tags ?? [],
-    content: plan.content,
-    sessions: linkedSessions.map((s) => {
-      const sf = sessionFm(s);
-      return {
-        id: s.id,
-        title: s.title,
-        started: sf.started ?? s.created
-      };
-    })
-  };
-}
-function extractProgress(content) {
-  const checked = (content.match(/- \[x\]/gi) ?? []).length;
-  const unchecked = (content.match(/- \[ \]/g) ?? []).length;
-  const total = checked + unchecked;
-  if (total === 0) return "N/A";
-  return `${checked}/${total}`;
+  const result = await client.get(endpoint);
+  if (!result.ok || !result.data?.plans) return [];
+  return result.data.plans;
 }
 
 // src/mcp/tools/sessions.ts
-async function handleMycoSessions(index, input) {
-  const frontmatter = {};
-  if (input.branch) frontmatter.branch = input.branch;
-  if (input.user) frontmatter.user = input.user;
-  let sessions = index.query({
-    type: "session",
-    since: input.since,
-    limit: input.limit ?? 20,
-    frontmatter
-  });
-  if (input.plan) {
-    sessions = sessions.filter((s) => {
-      const planRef = sessionFm(s).plan;
-      return planRef === `[[${input.plan}]]` || planRef === input.plan;
-    });
-  }
-  return sessions.map((s) => {
-    const f = sessionFm(s);
-    return {
-      id: s.id,
-      summary: s.content.slice(0, SESSION_SUMMARY_PREVIEW_CHARS),
-      user: f.user ?? "",
-      agent: f.agent ?? "",
-      started: f.started ?? s.created,
-      parent: f.parent ?? null,
-      plan: f.plan ?? null,
-      tags: f.tags ?? []
-    };
+async function handleMycoSessions(input, client) {
+  const endpoint = buildEndpoint("/api/mcp/sessions", {
+    limit: input.limit,
+    status: input.status
   });
+  const result = await client.get(endpoint);
+  if (!result.ok || !result.data?.sessions) return [];
+  return result.data.sessions;
 }
 
 // src/mcp/tools/team.ts
-async function handleMycoTeam(index, input, currentUser) {
-  const sessions = index.query({
-    type: "session",
-    since: input.since,
-    limit: 50
-  });
-  const filtered = sessions.filter((s) => {
-    const f = sessionFm(s);
-    if (!f.user || f.user === currentUser) return false;
-    if (input.plan) {
-      const planRef = f.plan;
-      if (planRef !== `[[${input.plan}]]` && planRef !== input.plan) return false;
-    }
-    return true;
-  });
-  return filtered.map((s) => {
-    const f = sessionFm(s);
-    return {
-      user: f.user ?? "",
-      session_id: s.id,
-      summary: s.content.slice(0, RECALL_SUMMARY_PREVIEW_CHARS),
-      files_changed: [],
-      decisions: []
-    };
-  });
+async function handleMycoTeam(_input, client) {
+  const result = await client.get("/api/mcp/team");
+  if (!result.ok || !result.data?.members) return [];
+  return result.data.members;
 }
 
 // src/mcp/tools/graph.ts
-var WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
-function extractWikilinks(content) {
-  const links = [];
-  let match;
-  while ((match = WIKILINK_RE.exec(content)) !== null) {
-    links.push(match[1]);
-  }
-  return links;
-}
-function findNoteById(index, noteId) {
-  const results = index.query({ id: noteId, limit: 1 });
-  return results[0] ?? null;
-}
-async function handleMycoGraph(index, input) {
-  const direction = input.direction ?? "both";
-  const depth = Math.min(input.depth ?? 1, 3);
-  const visited = /* @__PURE__ */ new Set();
-  const allLinks = [];
-  function traverse(noteId, currentDepth) {
-    if (currentDepth > depth || visited.has(noteId)) return;
-    visited.add(noteId);
-    const note = findNoteById(index, noteId);
-    if (direction === "outgoing" || direction === "both") {
-      if (note) {
-        const targets = extractWikilinks(note.content);
-        for (const target of targets) {
-          const targetNote = findNoteById(index, target);
-          allLinks.push({
-            source: noteId,
-            target,
-            source_type: note.type,
-            target_type: targetNote?.type ?? "unknown",
-            source_title: note.title,
-            target_title: targetNote?.title ?? target
-          });
-          if (currentDepth < depth) traverse(target, currentDepth + 1);
-        }
-      }
-    }
-    if (direction === "incoming" || direction === "both") {
-      const allNotes = index.query({ limit: 500 });
-      for (const n of allNotes) {
-        if (n.id === noteId) continue;
-        const links = extractWikilinks(n.content);
-        if (links.includes(noteId)) {
-          allLinks.push({
-            source: n.id,
-            target: noteId,
-            source_type: n.type,
-            target_type: note?.type ?? "unknown",
-            source_title: n.title,
-            target_title: note?.title ?? noteId
-          });
-          if (currentDepth < depth) traverse(n.id, currentDepth + 1);
-        }
-      }
-    }
-  }
-  traverse(input.note_id, 1);
-  const seen = /* @__PURE__ */ new Set();
-  const unique = allLinks.filter((link) => {
-    const key = `${link.source}->${link.target}`;
-    if (seen.has(key)) return false;
-    seen.add(key);
-    return true;
+async function handleMycoGraph(input, client) {
+  const endpoint = buildEndpoint(`/api/graph/${encodeURIComponent(input.note_id)}`, {
+    direction: input.direction,
+    depth: input.depth
   });
-  return { note_id: input.note_id, links: unique };
-}
-async function handleMycoOrphans(index) {
-  const allNotes = index.query({ limit: 1e3 });
-  const hasOutgoing = /* @__PURE__ */ new Set();
-  const isLinkedTo = /* @__PURE__ */ new Set();
-  for (const note of allNotes) {
-    const links = extractWikilinks(note.content);
-    if (links.length > 0) hasOutgoing.add(note.id);
-    for (const target of links) {
-      isLinkedTo.add(target);
-    }
-    const fm = note.frontmatter;
-    if (fm.session && typeof fm.session === "string") {
-      isLinkedTo.add(fm.session);
-    }
-    if (fm.plan && typeof fm.plan === "string") {
-      isLinkedTo.add(fm.plan);
-    }
-  }
-  const orphans = allNotes.filter(
-    (note) => !hasOutgoing.has(note.id) && !isLinkedTo.has(note.id)
-  ).map((note) => ({
-    id: note.id,
-    type: note.type,
-    title: note.title,
-    path: note.path
-  }));
-  return { orphans };
-}
-
-// src/mcp/tools/logs.ts
-import path2 from "path";
-async function handleMycoLogs(vaultDir, input) {
-  const logDir = path2.join(vaultDir, "logs");
-  return queryLogs(logDir, input);
+  const result = await client.get(endpoint);
+  if (!result.ok || !result.data) {
+    return { note_id: input.note_id, edges: [], entities: [] };
+  }
+  const data = result.data;
+  return {
+    note_id: input.note_id,
+    edges: data.edges ?? [],
+    entities: data.nodes ?? []
+  };
 }
 
 // src/mcp/tools/supersede.ts
-import fs from "fs";
-import path3 from "path";
-async function handleMycoSupersede(vaultDir, index, input) {
-  const writer = new VaultWriter(vaultDir);
-  const oldNotes = index.queryByIds([input.old_spore_id]);
-  if (oldNotes.length === 0) {
-    return { old_spore: input.old_spore_id, new_spore: input.new_spore_id, status: "not_found" };
-  }
-  const oldNote = oldNotes[0];
-  writer.updateNoteFrontmatter(oldNote.path, {
-    status: "superseded",
-    superseded_by: input.new_spore_id
-  }, true);
-  const fullPath = path3.join(vaultDir, oldNote.path);
-  const content = fs.readFileSync(fullPath, "utf-8");
-  if (!content.includes("Superseded by::")) {
-    const notice = `
-
-> [!warning] Superseded
-> This observation has been superseded.
-
-Superseded by:: [[${input.new_spore_id}]]`;
-    const reasonLine = input.reason ? `
-Reason:: ${input.reason}` : "";
-    fs.writeFileSync(fullPath, content.trimEnd() + notice + reasonLine + "\n", "utf-8");
+async function handleMycoSupersede(input, client) {
+  const result = await client.post("/api/mcp/supersede", {
+    old_spore_id: input.old_spore_id,
+    new_spore_id: input.new_spore_id,
+    reason: input.reason
+  });
+  if (!result.ok || !result.data) {
+    throw new Error(`Failed to supersede spore: daemon request failed`);
   }
-  indexNote(index, vaultDir, oldNote.path);
-  return { old_spore: input.old_spore_id, new_spore: input.new_spore_id, status: "superseded" };
+  return result.data;
 }
 
 // src/mcp/tools/consolidate.ts
-async function handleMycoConsolidate(vaultDir, index, input, vectorIndex = null, embeddingProvider = null) {
-  return consolidateSpores(
-    {
-      sourceSporeIds: input.source_spore_ids,
-      consolidatedContent: input.consolidated_content,
-      observationType: input.observation_type,
-      tags: input.tags
-    },
-    { vaultDir, index, vectorIndex, embeddingProvider }
-  );
+async function handleMycoConsolidate(_input) {
+  return {
+    status: "unavailable",
+    message: "Consolidation requires intelligence configuration (Phase 2). Use myco_supersede to manually mark outdated spores."
+  };
 }
 
+// src/mcp/tools/context.ts
+var DEFAULT_CONTEXT_TIER = 5e3;
+var NO_DIGEST_MESSAGE = "Digest context is not yet available. The first digest cycle has not completed.";
+async function handleMycoContext(input, client) {
+  const requestedTier = input.tier ?? DEFAULT_CONTEXT_TIER;
+  const result = await client.get("/api/digest");
+  if (!result.ok || !result.data?.tiers) {
+    return {
+      content: NO_DIGEST_MESSAGE,
+      tier: requestedTier,
+      fallback: false
+    };
+  }
+  const tiers = result.data.tiers;
+  const exact = tiers.find((t) => t.tier === requestedTier);
+  if (exact) {
+    return {
+      content: exact.content,
+      tier: exact.tier,
+      fallback: false,
+      generated_at: exact.generated_at
+    };
+  }
+  if (tiers.length > 0) {
+    const sorted = [...tiers].sort(
+      (a, b) => Math.abs(a.tier - requestedTier) - Math.abs(b.tier - requestedTier)
+    );
+    const nearest = sorted[0];
+    return {
+      content: nearest.content,
+      tier: nearest.tier,
+      fallback: true,
+      generated_at: nearest.generated_at
+    };
+  }
+  return {
+    content: NO_DIGEST_MESSAGE,
+    tier: requestedTier,
+    fallback: false
+  };
+}
+
+// src/vault/types.ts
+var SessionFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("session"),
+  id: external_exports.string(),
+  agent: external_exports.string(),
+  user: external_exports.string(),
+  started: external_exports.string(),
+  ended: external_exports.string().optional(),
+  parent: external_exports.string().optional(),
+  parent_reason: external_exports.string().optional(),
+  plan: external_exports.string().optional(),
+  // backward compat read path
+  plans: external_exports.array(external_exports.string()).optional(),
+  // new: multiple plans
+  branch: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([]),
+  tools_used: external_exports.number().int().optional(),
+  files_changed: external_exports.number().int().optional()
+});
+var PLAN_STATUSES = ["active", "in_progress", "completed", "abandoned"];
+var PlanFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("plan"),
+  id: external_exports.string(),
+  status: external_exports.enum(PLAN_STATUSES).default("active"),
+  created: external_exports.string(),
+  author: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var OBSERVATION_TYPES = ["gotcha", "bug_fix", "decision", "discovery", "trade_off", "cross-cutting"];
+var SPORE_STATUSES = ["active", "superseded", "archived"];
+var SporeFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("spore"),
+  id: external_exports.string(),
+  observation_type: external_exports.string(),
+  status: external_exports.enum(SPORE_STATUSES).default("active"),
+  session: external_exports.string().optional(),
+  plan: external_exports.string().optional(),
+  superseded_by: external_exports.string().optional(),
+  consolidated_from: external_exports.array(external_exports.string()).optional(),
+  created: external_exports.string(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var ARTIFACT_TYPES = ["spec", "plan", "rfc", "doc", "other"];
+var ArtifactFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("artifact"),
+  id: external_exports.string(),
+  artifact_type: external_exports.enum(ARTIFACT_TYPES).default("other"),
+  source_path: external_exports.string(),
+  title: external_exports.string(),
+  last_captured_by: external_exports.string(),
+  created: external_exports.string(),
+  updated: external_exports.string(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+var TeamMemberFrontmatterSchema = external_exports.object({
+  type: external_exports.literal("team-member"),
+  user: external_exports.string(),
+  joined: external_exports.string(),
+  role: external_exports.string().optional(),
+  tags: external_exports.array(external_exports.string()).default([])
+});
+
 // src/mcp/tool-definitions.ts
 var PLAN_STATUS_FILTER = [...PLAN_STATUSES, "all"];
 var TOOL_SEARCH = "myco_search";
@@ -14447,8 +14265,6 @@ var TOOL_PLANS = "myco_plans";
 var TOOL_SESSIONS = "myco_sessions";
 var TOOL_TEAM = "myco_team";
 var TOOL_GRAPH = "myco_graph";
-var TOOL_ORPHANS = "myco_orphans";
-var TOOL_LOGS = "myco_logs";
 var TOOL_SUPERSEDE = "myco_supersede";
 var TOOL_CONSOLIDATE = "myco_consolidate";
 var TOOL_CONTEXT = "myco_context";
@@ -14471,13 +14287,13 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: TOOL_RECALL,
-    description: "Get context relevant to your current work \u2014 spores, sessions, and plans related to the branch and files you are working on. Use at the start of a task or when you need background on a component.",
+    description: "Look up a specific vault note by ID \u2014 returns the full content of a session, spore, or plan. Use when you have a note ID from search results or graph traversal and need the complete details.",
     inputSchema: {
       type: "object",
       properties: {
-        branch: { type: "string", description: PROP_BRANCH },
-        files: { type: "array", items: { type: "string" }, description: "File paths you are working on \u2014 finds spores tagged with these files" }
-      }
+        note_id: { type: "string", description: 'Note ID to look up (e.g., "session-abc123", "decision-xyz789", "plan-feature-x")' }
+      },
+      required: ["note_id"]
     }
   },
   {
@@ -14534,7 +14350,7 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: TOOL_GRAPH,
-    description: "Traverse connections between vault notes via wikilinks \u2014 explore how sessions, spores, and plans relate to each other.",
+    description: "Traverse connections between records via graph edges \u2014 explore how sessions, spores, and plans relate to each other.",
     inputSchema: {
       type: "object",
       properties: {
@@ -14545,28 +14361,6 @@ var TOOL_DEFINITIONS = [
       required: ["note_id"]
     }
   },
-  {
-    name: TOOL_ORPHANS,
-    description: "Find vault notes with no connections \u2014 potentially stale or unlinked knowledge that may need review or cleanup.",
-    inputSchema: {
-      type: "object",
-      properties: {}
-    }
-  },
-  {
-    name: TOOL_LOGS,
-    description: "View daemon logs for debugging when sessions are not being captured, observations are missing, or embeddings fail. Filter by level, component, or time range.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        limit: { type: "number", description: `Max entries to return (default: ${MCP_LOGS_DEFAULT_LIMIT})` },
-        level: { type: "string", enum: ["debug", "info", "warn", "error"], description: "Minimum log level filter" },
-        component: { type: "string", description: "Component filter: daemon, processor, hooks, lifecycle, embeddings, mcp, lineage, watcher" },
-        since: { type: "string", description: PROP_SINCE },
-        until: { type: "string", description: "ISO timestamp \u2014 entries before this time" }
-      }
-    }
-  },
   {
     name: TOOL_SUPERSEDE,
     description: "Mark a spore as outdated and replaced by a newer one. Use when a decision was reversed, a gotcha was fixed, a discovery was wrong, or the codebase changed and an observation no longer applies. The old spore is preserved but marked superseded.",
@@ -14596,14 +14390,14 @@ var TOOL_DEFINITIONS = [
   },
   {
     name: TOOL_CONTEXT,
-    description: "Retrieve Myco's synthesized understanding of this project. Returns a pre-computed context extract at the requested token tier. Available tiers: 1500 (executive briefing), 3000 (team standup), 5000 (deep onboarding), 10000 (institutional knowledge). This is a rich, always-current synthesis of project history, decisions, patterns, and active work \u2014 not a search result.",
+    description: "Retrieve Myco's synthesized understanding of this project. Returns a pre-computed context extract at the requested token tier. Available tiers: 1500 (executive briefing), 5000 (deep onboarding), 10000 (institutional knowledge). This is a rich, always-current synthesis of project history, decisions, patterns, and active work \u2014 not a search result.",
     inputSchema: {
       type: "object",
       properties: {
         tier: {
           type: "number",
-          enum: [1500, 3e3, 5e3, 7500, 1e4],
-          description: "Token budget tier. Larger tiers include more detail. Default: 3000."
+          enum: [1500, 5e3, 1e4],
+          description: "Token budget tier. Larger tiers include more detail. Default: 5000."
         }
       }
     }
@@ -14611,89 +14405,107 @@ var TOOL_DEFINITIONS = [
 ];
 
 // src/mcp/server.ts
-function createMycoServer(config2) {
+function createMycoServer(vaultDir, client) {
   const server = new Server(
     { name: "myco", version: getPluginVersion() },
     { capabilities: { tools: {} } }
   );
-  const dbPath = path4.join(config2.vaultDir, "index.db");
-  let index = null;
-  function getIndex() {
-    if (!index) {
-      index = new MycoIndex(dbPath);
-      initFts(index);
-    }
-    return index;
-  }
-  function embedNote(noteId, text, metadata) {
-    if (!config2.embeddingProvider || !config2.vectorIndex || !text) return;
-    generateEmbedding(config2.embeddingProvider, text.slice(0, EMBEDDING_INPUT_LIMIT)).then((emb) => config2.vectorIndex.upsert(noteId, emb.embedding, metadata)).catch(() => {
-    });
-  }
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: TOOL_DEFINITIONS
   }));
   function logActivity(tool, detail) {
-    const logDir = path4.join(config2.vaultDir, "logs");
+    const logDir = path.join(vaultDir, "logs");
     try {
-      fs2.mkdirSync(logDir, { recursive: true });
+      fs.mkdirSync(logDir, { recursive: true });
       const entry = JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), component: "mcp", level: "info", tool, ...detail }) + "\n";
-      fs2.appendFileSync(path4.join(logDir, "mcp.jsonl"), entry);
+      fs.appendFileSync(path.join(logDir, "mcp.jsonl"), entry);
     } catch {
     }
+    postToDaemon("info", "mcp", `Tool call: ${tool}`, { tool, ...detail });
+  }
+  let cachedDaemonPort = null;
+  function postToDaemon(level, component, message, data) {
+    try {
+      if (cachedDaemonPort === null) {
+        const daemonJsonPath = path.join(vaultDir, "daemon.json");
+        const raw = fs.readFileSync(daemonJsonPath, "utf-8");
+        cachedDaemonPort = JSON.parse(raw).port;
+      }
+      fetch(`http://127.0.0.1:${cachedDaemonPort}/api/log`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ level, component, message, data }),
+        signal: AbortSignal.timeout(DAEMON_CLIENT_TIMEOUT_MS)
+      }).catch(() => {
+        cachedDaemonPort = null;
+      });
+    } catch {
+      cachedDaemonPort = null;
+    }
   }
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args = {} } = request.params;
-    const idx = getIndex();
     const input = args;
+    const start = Date.now();
     switch (name) {
-      case TOOL_SEARCH:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoSearch(idx, input, config2.vectorIndex, config2.embeddingProvider)) }] };
-      case TOOL_RECALL:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoRecall(idx, input)) }] };
+      case TOOL_SEARCH: {
+        const searchInput = input;
+        const result = await handleMycoSearch(searchInput, client);
+        logActivity(TOOL_SEARCH, { query: searchInput.query, matches: result.length, duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_RECALL: {
+        const recallInput = input;
+        const result = await handleMycoRecall(recallInput, client);
+        logActivity(TOOL_RECALL, { note_id: recallInput.note_id, duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
       case TOOL_REMEMBER: {
-        const result = await handleMycoRemember(config2.vaultDir, idx, input);
-        embedNote(result.id, String(input.content), { type: "spore", observation_type: String(input.type ?? ""), importance: "high" });
-        if (config2.vectorIndex && config2.embeddingProvider && config2.llmProvider) {
-          checkSupersession(result.id, {
-            index: idx,
-            vectorIndex: config2.vectorIndex,
-            embeddingProvider: config2.embeddingProvider,
-            llmProvider: config2.llmProvider,
-            vaultDir: config2.vaultDir
-          }).catch(() => {
-          });
-        }
-        logActivity(TOOL_REMEMBER, { id: result.id, observation_type: input.type, path: result.note_path });
+        const rememberInput = input;
+        const result = await handleMycoRemember(rememberInput, client);
+        logActivity(TOOL_REMEMBER, { id: result.id, observation_type: result.observation_type, duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_PLANS: {
+        const plansInput = input;
+        const result = await handleMycoPlans(plansInput, client);
+        logActivity(TOOL_PLANS, { count: result.length, duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_SESSIONS: {
+        const sessionsInput = input;
+        const result = await handleMycoSessions(sessionsInput, client);
+        logActivity(TOOL_SESSIONS, { count: result.length, duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_TEAM: {
+        const teamInput = input;
+        const result = await handleMycoTeam(teamInput, client);
+        logActivity(TOOL_TEAM, { count: result.length, duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_GRAPH: {
+        const graphInput = input;
+        const result = await handleMycoGraph(graphInput, client);
+        logActivity(TOOL_GRAPH, { note_id: graphInput.note_id, duration_ms: Date.now() - start });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       }
-      case TOOL_PLANS:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoPlans(idx, input)) }] };
-      case TOOL_SESSIONS:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoSessions(idx, input)) }] };
-      case TOOL_TEAM:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoTeam(idx, input, config2.teamUser)) }] };
-      case TOOL_GRAPH:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoGraph(idx, input)) }] };
-      case TOOL_ORPHANS:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoOrphans(idx)) }] };
-      case TOOL_LOGS:
-        return { content: [{ type: "text", text: JSON.stringify(await handleMycoLogs(config2.vaultDir, input)) }] };
       case TOOL_SUPERSEDE: {
-        const result = await handleMycoSupersede(config2.vaultDir, idx, input);
-        if (result.status === "superseded" && config2.vectorIndex) {
-          config2.vectorIndex.delete(result.old_spore);
-        }
-        logActivity(TOOL_SUPERSEDE, { old: result.old_spore, new: result.new_spore, status: result.status });
+        const supersedeInput = input;
+        const result = await handleMycoSupersede(supersedeInput, client);
+        logActivity(TOOL_SUPERSEDE, { old: result.old_spore, new: result.new_spore, status: result.status, duration_ms: Date.now() - start });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       }
       case TOOL_CONSOLIDATE: {
-        const result = await handleMycoConsolidate(config2.vaultDir, idx, input, config2.vectorIndex ?? null, config2.embeddingProvider ?? null);
-        logActivity(TOOL_CONSOLIDATE, { wisdom_id: result.wisdom_id, sources: input.source_spore_ids, archived: result.sources_archived });
+        const consolidateInput = input;
+        const result = await handleMycoConsolidate(consolidateInput);
+        logActivity(TOOL_CONSOLIDATE, { status: result.status, duration_ms: Date.now() - start });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       }
       case TOOL_CONTEXT: {
-        const result = handleMycoContext(config2.vaultDir, args);
+        const contextInput = input;
+        const result = await handleMycoContext(contextInput, client);
+        logActivity(TOOL_CONTEXT, { tier: contextInput.tier, duration_ms: Date.now() - start });
         return { content: [{ type: "text", text: result.content }] };
       }
       default:
@@ -14713,33 +14525,12 @@ function createMycoServer(config2) {
 }
 async function main() {
   const vaultDir = resolveVaultDir();
-  const config2 = fs2.existsSync(path4.join(vaultDir, "myco.yaml")) ? loadConfig(vaultDir) : void 0;
-  let embeddingProvider;
-  let vectorIndex;
-  let llmProvider;
-  if (config2) {
-    try {
-      embeddingProvider = createEmbeddingProvider(config2.intelligence.embedding);
-      const testEmbed = await embeddingProvider.embed("test");
-      vectorIndex = new VectorIndex(path4.join(vaultDir, "vectors.db"), testEmbed.dimensions);
-    } catch {
-    }
-    try {
-      llmProvider = createLlmProvider(config2.intelligence.llm);
-    } catch {
-    }
-  }
-  const server = createMycoServer({
-    vaultDir,
-    teamUser: config2?.team?.user,
-    embeddingProvider,
-    vectorIndex,
-    llmProvider
-  });
+  const client = new DaemonClient(vaultDir);
+  const server = createMycoServer(vaultDir, client);
   await server.start();
 }
 export {
   createMycoServer,
   main
 };
-//# sourceMappingURL=server-6UDN35QN.js.map
+//# sourceMappingURL=server-6KMBJCHZ.js.map