@goondocks/myco 0.20.2 → 0.21.1

package/dist/{server-AGVYZVP5.js → server-AZJSTQEK.js}

@@ -1,21 +1,46 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  COLLECTIVE_TOOL_DEFINITIONS,
+  TOOL_COLLECTIVE_PROJECT,
+  TOOL_COLLECTIVE_PROJECTS,
+  TOOL_COLLECTIVE_SEARCH,
+  TOOL_CONSOLIDATE,
+  TOOL_CONTEXT,
+  TOOL_CORTEX,
+  TOOL_DEFINITIONS,
+  TOOL_DIGEST_REVISIONS,
+  TOOL_EVALUATIONS,
+  TOOL_GRAPH,
+  TOOL_PHASE_AUDIT,
+  TOOL_PLANS,
+  TOOL_RECALL,
+  TOOL_REMEMBER,
+  TOOL_RESUME_RUN,
+  TOOL_RUNS,
+  TOOL_SAVE_PLAN,
+  TOOL_SEARCH,
+  TOOL_SESSIONS,
+  TOOL_SKILLS,
+  TOOL_SKILL_CANDIDATES,
+  TOOL_SUPERSEDE,
+  TOOL_TEAM,
+  TOOL_WRITE_INTENTS
+} from "./chunk-EEOJWLMP.js";
 import "./chunk-POEPHBQK.js";
 import {
   resolveVaultDir
-} from "./chunk-CUDIZJY7.js";
+} from "./chunk-TSM6VESW.js";
 import {
   DaemonClient
-} from "./chunk-VVNL26WX.js";
+} from "./chunk-KTTSXYEK.js";
 import {
   getPluginVersion
-} from "./chunk-XG5RRUYF.js";
+} from "./chunk-ENZR5NG7.js";
 import "./chunk-LPUQPDC2.js";
 import {
   DAEMON_CLIENT_TIMEOUT_MS,
-  MCP_SEARCH_DEFAULT_LIMIT,
-  MCP_SESSIONS_DEFAULT_LIMIT,
-  MCP_SKILLS_DEFAULT_LIMIT
-} from "./chunk-FLLBJLHM.js";
+  MCP_SEARCH_DEFAULT_LIMIT
+} from "./chunk-6C6QZ4PM.js";
 import "./chunk-UUHLLQXO.js";
 import "./chunk-ODXLRR4U.js";
 import {
@@ -25,7 +50,6 @@ import {
   boolean,
   custom,
   discriminatedUnion,
-  external_exports,
   intersection,
   iso_exports,
   literal,
@@ -14104,10 +14128,42 @@ async function handleMycoRemember(input, client) {
   return result.data;
 }
 
+// src/mcp/tools/error.ts
+function extractErrorMessage(data, fallback) {
+  if (typeof data === "string") return data;
+  if (typeof data !== "object" || data === null) return fallback;
+  const rawError = data.error;
+  if (typeof rawError === "string") return rawError;
+  if (typeof rawError === "object" && rawError !== null && "message" in rawError && typeof rawError.message === "string") {
+    return rawError.message;
+  }
+  return fallback;
+}
+
 // src/mcp/tools/plans.ts
 async function handleMycoPlans(input, client) {
+  const op = input.op ?? "list";
+  if (op === "delete") {
+    if (!input.id) {
+      return { ok: false, error: "id is required for op: delete" };
+    }
+    const body = input.force_remote ? { force_remote: true } : void 0;
+    const result2 = await client.delete(`/api/plans/${encodeURIComponent(input.id)}`, body);
+    if (!result2.ok) {
+      return { ok: false, error: extractErrorMessage(result2.data, "delete_failed") };
+    }
+    return {
+      ok: Boolean(result2.data?.ok),
+      id: result2.data?.id,
+      session_id: result2.data?.session_id ?? null
+    };
+  }
+  if (input.id && input.session) {
+    return { ok: false, error: "Pass either id or session, not both" };
+  }
   const endpoint = buildEndpoint("/api/mcp/plans", {
     id: input.id,
+    session: input.session,
     status: input.status,
     limit: input.limit
   });
@@ -14116,6 +14172,25 @@ async function handleMycoPlans(input, client) {
   return result.data.plans;
 }
 
+// src/mcp/tools/save-plan.ts
+async function handleMycoSavePlan(input, client) {
+  const result = await client.post("/api/mcp/plans", {
+    session_id: input.session_id,
+    content: input.content,
+    source_path: input.source_path,
+    plan_key: input.plan_key,
+    title: input.title,
+    status: input.status,
+    tags: input.tags
+  });
+  if (!result.ok || !result.data) {
+    const rawError = result.data?.error;
+    const message = typeof rawError === "string" ? rawError : typeof rawError === "object" && rawError !== null && "message" in rawError ? String(rawError.message) : "unknown";
+    return { ok: false, error: message };
+  }
+  return { ok: true, ...result.data };
+}
+
 // src/mcp/tools/sessions.ts
 async function handleMycoSessions(input, client) {
   const endpoint = buildEndpoint("/api/mcp/sessions", {
@@ -14294,276 +14369,206 @@ async function handleCollectiveProject(input, client) {
   return result.data?.project ?? null;
 }
 
-// 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";
-var TOOL_RECALL = "myco_recall";
-var TOOL_REMEMBER = "myco_remember";
-var TOOL_PLANS = "myco_plans";
-var TOOL_SESSIONS = "myco_sessions";
-var TOOL_TEAM = "myco_team";
-var TOOL_GRAPH = "myco_graph";
-var TOOL_SUPERSEDE = "myco_supersede";
-var TOOL_CONSOLIDATE = "myco_consolidate";
-var TOOL_CONTEXT = "myco_context";
-var TOOL_SKILLS = "myco_skills";
-var TOOL_SKILL_CANDIDATES = "myco_skill_candidates";
-var TOOL_COLLECTIVE_SEARCH = "collective_search";
-var TOOL_COLLECTIVE_PROJECTS = "collective_projects";
-var TOOL_COLLECTIVE_PROJECT = "collective_project";
-var PROP_BRANCH = "Git branch name to find related sessions and plans";
-var PROP_SINCE = "ISO timestamp \u2014 entries after this date";
-var PROP_TAGS = "Tags for discoverability \u2014 component names, technologies, concepts";
-var TOOL_DEFINITIONS = [
-  {
-    name: TOOL_SEARCH,
-    description: "Search the vault for prior sessions, spores, plans, and artifacts. Use before making design decisions, when debugging non-obvious issues, or when wondering why code is structured a certain way.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Natural language search query \u2014 describe what you are looking for" },
-        type: { type: "string", enum: ["session", "plan", "spore", "all"], description: "Filter by note type (default: all)" },
-        limit: { type: "number", description: `Max results (default: ${MCP_SEARCH_DEFAULT_LIMIT})` }
-      },
-      required: ["query"]
-    }
-  },
-  {
-    name: TOOL_RECALL,
-    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: {
-        note_id: { type: "string", description: 'Note ID to look up (e.g., "session-abc123", "decision-xyz789", "plan-feature-x")' }
-      },
-      required: ["note_id"]
-    }
-  },
-  {
-    name: TOOL_REMEMBER,
-    description: "Save a decision, gotcha, bug fix, discovery, or trade-off as a permanent spore. Use after making a key decision, fixing a tricky bug, discovering something non-obvious, or encountering a gotcha. Session association is derived by the daemon \u2014 the MCP client does not pass it.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        content: { type: "string", description: "The observation \u2014 include context, reasoning, and what someone encountering this in the future needs to know" },
-        type: { type: "string", enum: OBSERVATION_TYPES, description: `Observation type: ${OBSERVATION_TYPES.join(", ")}` },
-        tags: { type: "array", items: { type: "string" }, description: PROP_TAGS }
-      },
-      required: ["content", "type"]
-    }
-  },
-  {
-    name: TOOL_PLANS,
-    description: "List active implementation plans and their status. Use to check what work is in flight before starting new tasks.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        status: { type: "string", enum: PLAN_STATUS_FILTER, description: "Filter by status (default: all statuses)" },
-        id: { type: "string", description: "Get a specific plan by ID" }
-      }
+// src/mcp/tools/cortex.ts
+async function handleMycoCortex(input, client) {
+  switch (input.op) {
+    case "get": {
+      const result = await client.get("/api/cortex/instructions");
+      if (!result.ok) return { ok: false, op: input.op, error: "fetch_failed" };
+      return { ok: true, op: input.op, data: result.data };
+    }
+    case "refresh": {
+      const result = await client.post("/api/cortex/instructions/refresh", {});
+      if (!result.ok) return { ok: false, op: input.op, error: "refresh_failed" };
+      return { ok: true, op: input.op, data: result.data };
+    }
+    case "build_prompt": {
+      if (!input.goal || input.goal.trim().length === 0) {
+        return { ok: false, op: input.op, error: "goal is required" };
+      }
+      const body = { goal: input.goal };
+      if (input.symbiont) body.symbiont = input.symbiont;
+      const result = await client.post("/api/cortex/prompt-builder", body);
+      if (!result.ok) return { ok: false, op: input.op, error: "build_prompt_failed" };
+      return { ok: true, op: input.op, data: result.data };
+    }
+    case "get_prompt_result": {
+      if (!input.run_id) {
+        return { ok: false, op: input.op, error: "run_id is required" };
+      }
+      const result = await client.get(
+        `/api/cortex/prompt-builder/${encodeURIComponent(input.run_id)}`
+      );
+      if (!result.ok) {
+        return { ok: false, op: input.op, error: "not_ready_or_not_found" };
+      }
+      return { ok: true, op: input.op, data: result.data };
+    }
+    default: {
+      const _exhaustive = input.op;
+      return { ok: false, op: _exhaustive, error: "unknown_op" };
     }
-  },
-  {
-    name: TOOL_SESSIONS,
-    description: "Browse past coding sessions with summaries, tools used, and linked spores. Use to understand what work has been done on a feature or branch.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        plan: { type: "string", description: "Filter to the session linked to this plan id" },
-        branch: { type: "string", description: PROP_BRANCH },
-        user: { type: "string", description: "Filter sessions by user" },
-        since: { type: "string", description: PROP_SINCE },
-        status: { type: "string", description: "Filter by session status (e.g., active, completed)" },
-        limit: { type: "number", description: `Max results (default: ${MCP_SESSIONS_DEFAULT_LIMIT})` }
-      }
-    }
-  },
-  {
-    name: TOOL_TEAM,
-    description: "List team members registered in the vault. Returns id, user, role, joined, and tags per member. Phase-1 scope: no filters.",
-    inputSchema: {
-      type: "object",
-      properties: {}
-    }
-  },
-  {
-    name: TOOL_GRAPH,
-    description: "Traverse connections between records via graph edges \u2014 explore how sessions, spores, and plans relate to each other.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        note_id: { type: "string", description: 'Note ID to start from (e.g., "session-abc123" or "decision-xyz789")' },
-        direction: { type: "string", enum: ["incoming", "outgoing", "both"], description: "Link direction to follow (default: both)" },
-        depth: { type: "number", description: "How many hops to traverse, 1-3 (default: 1)" }
-      },
-      required: ["note_id"]
-    }
-  },
-  {
-    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.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        old_spore_id: { type: "string", description: 'ID of the outdated spore (e.g., "decision-abc123")' },
-        new_spore_id: { type: "string", description: "ID of the replacement spore" },
-        reason: { type: "string", description: "Why the old spore is being superseded" }
-      },
-      required: ["old_spore_id", "new_spore_id"]
-    }
-  },
-  {
-    name: TOOL_CONSOLIDATE,
-    description: "Merge 2+ related spores into a single comprehensive wisdom note. Inserts a new spore with the consolidated content; each source spore is marked superseded with a resolution_events row linking it to the new wisdom spore. Use when multiple observations describe aspects of the same insight, share a root cause, or would be more useful as one reference.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        source_spore_ids: { type: "array", items: { type: "string" }, description: "IDs of the spores to merge (minimum 2)" },
-        consolidated_content: { type: "string", description: "The merged, comprehensive content \u2014 synthesize, do not just concatenate" },
-        observation_type: { type: "string", enum: OBSERVATION_TYPES, description: `Type for the consolidated wisdom note: ${OBSERVATION_TYPES.join(", ")}` },
-        tags: { type: "array", items: { type: "string" }, description: PROP_TAGS },
-        reason: { type: "string", description: "Optional reason recorded on each resolution event" }
-      },
-      required: ["source_spore_ids", "consolidated_content", "observation_type"]
+  }
+}
+
+// src/mcp/tools/runs.ts
+async function handleMycoRuns(input, client) {
+  const op = input.op ?? "list";
+  if (op === "get") {
+    if (!input.id) {
+      return { ok: false, op, error: "id is required for op: get" };
     }
-  },
-  {
-    name: TOOL_CONTEXT,
-    description: "Retrieve Myco's pre-computed project digest \u2014 a rich, always-current synthesis of project history, decisions, patterns, active work, and institutional knowledge. Call this at the start of a new task or session to orient yourself on the project before taking action; call it again after long interruptions or when switching contexts. This is NOT a search \u2014 it's the project's accumulated understanding, served instantly. Available tiers: 1500 (executive briefing, one-screen overview), 5000 (deep onboarding, default), 10000 (comprehensive institutional knowledge). Prefer this over myco_search when you need broad project orientation; use myco_search when you need to find specific prior decisions or bug fixes.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        tier: {
-          type: "number",
-          enum: [1500, 5e3, 1e4],
-          description: "Token budget tier. Larger tiers include more detail. Default: 5000."
-        }
-      }
+    const result2 = await client.get(
+      `/api/agent/runs/${encodeURIComponent(input.id)}`
+    );
+    if (!result2.ok) {
+      return { ok: false, op, error: "not_found" };
     }
-  },
-  {
-    name: TOOL_SKILLS,
-    description: "List and inspect skills generated by Myco. Use to see what skills are active, check skill details, or find skills by status.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Get a specific skill by ID or name" },
-        status: { type: "string", description: "Filter by status: active, stale, retired" },
-        limit: { type: "number", description: `Max results (default: ${MCP_SKILLS_DEFAULT_LIMIT})` }
-      }
+    return { ok: true, op, data: result2.data };
+  }
+  const endpoint = buildEndpoint("/api/agent/runs", {
+    task: input.task,
+    agentId: input.agent_id,
+    limit: input.limit
+  });
+  const result = await client.get(endpoint);
+  if (!result.ok) {
+    return { ok: false, op, error: "fetch_failed" };
+  }
+  return { ok: true, op, data: result.data };
+}
+
+// src/mcp/tools/evaluations.ts
+async function handleMycoEvaluations(input, client) {
+  const op = input.op ?? "list";
+  if (op === "get") {
+    if (!input.id) {
+      return { ok: false, op, error: "id is required for op: get" };
     }
-  },
-  {
-    name: TOOL_SKILL_CANDIDATES,
-    description: "List and manage skill candidates \u2014 observations identified as potential skills. Use to see pending candidates, approve, or dismiss them.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        id: { type: "string", description: "Get a specific candidate by ID" },
-        action: { type: "string", enum: ["list", "approve", "dismiss"], description: "Action to perform (default: 'list')" },
-        status: { type: "string", description: "Filter by status: identified, approved, generated, dismissed" },
-        limit: { type: "number", description: `Max results (default: ${MCP_SKILLS_DEFAULT_LIMIT})` }
-      }
+    const result2 = await client.get(
+      `/api/agent/evaluations/${encodeURIComponent(input.id)}`
+    );
+    if (!result2.ok) {
+      return {
+        ok: false,
+        op,
+        error: extractErrorMessage(result2.data, "not_found")
+      };
     }
+    return { ok: true, op, data: result2.data };
   }
-];
-var COLLECTIVE_TOOL_DEFINITIONS = [
-  {
-    name: TOOL_COLLECTIVE_SEARCH,
-    description: "Search across connected projects in the active Myco Collective. Results include project attribution.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Natural language search query across the connected Collective projects" },
-        project: { type: "string", description: "Optional project id or project name filter" },
-        limit: { type: "number", description: `Max results (default: ${MCP_SEARCH_DEFAULT_LIMIT})` }
-      },
-      required: ["query"]
+  if (op === "create") {
+    if (!input.task_id) {
+      return { ok: false, op, error: "task_id is required for op: create" };
     }
-  },
-  {
-    name: TOOL_COLLECTIVE_PROJECTS,
-    description: "List the projects connected to the active Myco Collective.",
-    inputSchema: {
-      type: "object",
-      properties: {}
+    if (input.matrix === void 0 || input.matrix === null) {
+      return { ok: false, op, error: "matrix is required for op: create" };
     }
-  },
-  {
-    name: TOOL_COLLECTIVE_PROJECT,
-    description: "Get metadata for a single project connected to the active Myco Collective.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project: { type: "string", description: "Project id or project name" },
-        include_digest: { type: "boolean", description: "Request digest information when available" }
-      },
-      required: ["project"]
+    const body = {
+      taskId: input.task_id,
+      matrix: input.matrix
+    };
+    if (input.notes !== void 0) body.notes = input.notes;
+    const result2 = await client.post("/api/agent/evaluations", body);
+    if (!result2.ok) {
+      return {
+        ok: false,
+        op,
+        error: extractErrorMessage(result2.data, "create_failed")
+      };
     }
+    return { ok: true, op, data: result2.data };
+  }
+  const endpoint = buildEndpoint("/api/agent/evaluations", {
+    status: input.status,
+    limit: input.limit
+  });
+  const result = await client.get(endpoint);
+  if (!result.ok) {
+    return {
+      ok: false,
+      op,
+      error: extractErrorMessage(result.data, "fetch_failed")
+    };
+  }
+  return { ok: true, op, data: result.data };
+}
+
+// src/mcp/tools/write-intents.ts
+async function handleMycoWriteIntents(input, client) {
+  if (!input.run_id) {
+    return { ok: false, error: "run_id is required" };
+  }
+  const endpoint = buildEndpoint(
+    `/api/agent/runs/${encodeURIComponent(input.run_id)}/write-intents`,
+    { limit: input.limit, offset: input.offset }
+  );
+  const result = await client.get(endpoint);
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: extractErrorMessage(result.data, "fetch_failed")
+    };
+  }
+  return { ok: true, data: result.data };
+}
+
+// src/mcp/tools/phase-audit.ts
+async function handleMycoPhaseAudit(input, client) {
+  if (!input.run_id) {
+    return { ok: false, error: "run_id is required" };
+  }
+  const result = await client.get(
+    `/api/agent/runs/${encodeURIComponent(input.run_id)}/audit`
+  );
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: extractErrorMessage(result.data, "not_found")
+    };
+  }
+  return { ok: true, data: result.data };
+}
+
+// src/mcp/tools/resume-run.ts
+async function handleMycoResumeRun(input, client) {
+  if (!input.id) {
+    return { ok: false, error: "id is required" };
+  }
+  const body = {};
+  if (input.mode) body.mode = input.mode;
+  const result = await client.post(
+    `/api/agent/runs/${encodeURIComponent(input.id)}/resume`,
+    body
+  );
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: extractErrorMessage(result.data, "resume_failed")
+    };
+  }
+  return { ok: true, data: result.data };
+}
+
+// src/mcp/tools/digest-revisions.ts
+async function handleMycoDigestRevisions(input, client) {
+  if (input.tier === void 0 || input.tier === null) {
+    return { ok: false, error: "tier is required" };
+  }
+  const endpoint = buildEndpoint("/api/digest/revisions", {
+    agentId: input.agent_id,
+    tier: input.tier,
+    limit: input.limit
+  });
+  const result = await client.get(endpoint);
+  if (!result.ok) {
+    return {
+      ok: false,
+      error: extractErrorMessage(result.data, "fetch_failed")
+    };
   }
-];
+  return { ok: true, data: result.data };
+}
 
 // src/mcp/server.ts
 function createMycoServer(vaultDir, client) {
@@ -14634,7 +14639,25 @@ function createMycoServer(vaultDir, client) {
       case TOOL_PLANS: {
         const plansInput = input;
         const result = await handleMycoPlans(plansInput, client);
-        logActivity(TOOL_PLANS, { count: result.length, duration_ms: Date.now() - start });
+        const count = Array.isArray(result) ? result.length : void 0;
+        logActivity(TOOL_PLANS, {
+          op: plansInput.op ?? "list",
+          id: plansInput.id,
+          session: plansInput.session,
+          count,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_SAVE_PLAN: {
+        const savePlanInput = input;
+        const result = await handleMycoSavePlan(savePlanInput, client);
+        logActivity(TOOL_SAVE_PLAN, {
+          session_id: savePlanInput.session_id,
+          source_path: savePlanInput.source_path,
+          plan_key: savePlanInput.plan_key,
+          duration_ms: Date.now() - start
+        });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       }
       case TOOL_SESSIONS: {
@@ -14707,6 +14730,82 @@ function createMycoServer(vaultDir, client) {
         logActivity(TOOL_COLLECTIVE_PROJECT, { project: collectiveInput.project, duration_ms: Date.now() - start });
         return { content: [{ type: "text", text: JSON.stringify(result) }] };
       }
+      case TOOL_CORTEX: {
+        const cortexInput = input;
+        const result = await handleMycoCortex(cortexInput, client);
+        logActivity(TOOL_CORTEX, {
+          op: cortexInput.op,
+          run_id: cortexInput.run_id,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_RUNS: {
+        const runsInput = input;
+        const result = await handleMycoRuns(runsInput, client);
+        logActivity(TOOL_RUNS, {
+          op: runsInput.op ?? "list",
+          id: runsInput.id,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_EVALUATIONS: {
+        const evalInput = input;
+        const result = await handleMycoEvaluations(evalInput, client);
+        logActivity(TOOL_EVALUATIONS, {
+          op: evalInput.op ?? "list",
+          id: evalInput.id,
+          task_id: evalInput.task_id,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_WRITE_INTENTS: {
+        const wiInput = input;
+        const result = await handleMycoWriteIntents(wiInput, client);
+        logActivity(TOOL_WRITE_INTENTS, {
+          run_id: wiInput.run_id,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_PHASE_AUDIT: {
+        const auditInput = input;
+        const result = await handleMycoPhaseAudit(auditInput, client);
+        logActivity(TOOL_PHASE_AUDIT, {
+          run_id: auditInput.run_id,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_RESUME_RUN: {
+        const resumeInput = input;
+        const result = await handleMycoResumeRun(resumeInput, client);
+        logActivity(TOOL_RESUME_RUN, {
+          id: resumeInput.id,
+          mode: resumeInput.mode,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+      case TOOL_DIGEST_REVISIONS: {
+        const drInput = input;
+        const result = await handleMycoDigestRevisions(drInput, client);
+        logActivity(TOOL_DIGEST_REVISIONS, {
+          agent_id: drInput.agent_id,
+          tier: drInput.tier,
+          ok: result.ok,
+          duration_ms: Date.now() - start
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
       default:
         throw new Error(`Unknown tool: ${name}`);
     }
@@ -14732,4 +14831,4 @@ export {
   createMycoServer,
   main
 };
-//# sourceMappingURL=server-AGVYZVP5.js.map
+//# sourceMappingURL=server-AZJSTQEK.js.map