@goondocks/myco 0.20.2 → 0.21.0

package/dist/executor-HWW2QNZQ.js

@@ -1,2472 +0,0 @@
-import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
-import {
-  DESCRIPTION_DUPLICATE_THRESHOLD,
-  SKILL_GENERATE_TASK,
-  STATUS_COMPLETED,
-  STATUS_FAILED,
-  STATUS_RUNNING,
-  TOPIC_OVERLAP_THRESHOLD,
-  checkFrontmatterPreservation,
-  createSporeLineage,
-  deleteCandidate,
-  deleteSkillRecordCascade,
-  descriptionSimilarity,
-  errorMessage,
-  getCandidate,
-  getRunningRunForTask,
-  getSkillRecord,
-  getSkillRecordByName,
-  getStatesForAgent,
-  getUnprocessedBatches,
-  insertCandidate,
-  insertEntity,
-  insertGraphEdge,
-  insertLineage,
-  insertReport,
-  insertResolutionEvent,
-  insertRun,
-  insertSkillRecord,
-  listCandidates,
-  listDigestExtracts,
-  listEntities,
-  listGraphEdges,
-  listSkillRecords,
-  markBatchProcessed,
-  notify,
-  resolveRunConfig,
-  setState,
-  topicOverlapSimilarity,
-  updateCandidate,
-  updateRunStatus,
-  updateSkillRecord,
-  upsertDigestExtract,
-  validateSkillContent
-} from "./chunk-UYMFCYBF.js";
-import {
-  fullTextSearch,
-  hydrateSearchResults
-} from "./chunk-5XIVBO25.js";
-import "./chunk-6X2ERTQV.js";
-import {
-  getDefaultTask,
-  loadSystemPrompt
-} from "./chunk-CCRGY3QW.js";
-import {
-  insertTurn,
-  updateTurn
-} from "./chunk-6RFZWV4R.js";
-import {
-  cleanupStagedSkill,
-  readStagedManifest,
-  readStagedSkill,
-  writeStagedManifest,
-  writeStagedSkill
-} from "./chunk-U5EW2VIQ.js";
-import "./chunk-POEPHBQK.js";
-import {
-  DEFAULT_IMPORTANCE,
-  getSpore,
-  insertSpore,
-  listSpores,
-  updateSporeStatus
-} from "./chunk-4YFKBL3F.js";
-import {
-  getActiveSessionIds,
-  listSessions,
-  updateSession
-} from "./chunk-EVDQKYCG.js";
-import {
-  AGENT_SETTABLE_STATUSES,
-  CANDIDATE_STATUS,
-  createSchema
-} from "./chunk-MYOZLMB2.js";
-import "./chunk-OD4AA7PV.js";
-import {
-  getDatabase,
-  initDatabase,
-  vaultDbPath
-} from "./chunk-MYX5NCRH.js";
-import {
-  getPluginVersion
-} from "./chunk-XG5RRUYF.js";
-import {
-  findPackageRoot
-} from "./chunk-LPUQPDC2.js";
-import {
-  DEFAULT_AGENT_ID,
-  DEFAULT_LIST_LIMIT,
-  MS_PER_SECOND,
-  PHASE_SUMMARY_MAX_CHARS,
-  SEARCH_SIMILARITY_THRESHOLD,
-  TEAM_SOURCE_PREFIX,
-  epochSeconds
-} from "./chunk-FLLBJLHM.js";
-import "./chunk-UUHLLQXO.js";
-import "./chunk-6LQIMRTC.js";
-import "./chunk-ODXLRR4U.js";
-import {
-  external_exports
-} from "./chunk-U6PF3YII.js";
-import "./chunk-PZUWP5VK.js";
-
-// src/agent/executor.ts
-import crypto4 from "crypto";
-import { resolve as resolve2 } from "path";
-
-// src/agent/tools.ts
-import { createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
-
-// src/agent/tools/read-tools.ts
-import { tool } from "@anthropic-ai/claude-agent-sdk";
-
-// src/agent/tools/types.ts
-function textResult(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data) }] };
-}
-
-// src/agent/tools/read-tools.ts
-var DEFAULT_UNPROCESSED_LIMIT = 50;
-var DEFAULT_SPORES_LIMIT = 50;
-var DEFAULT_SESSIONS_LIMIT = 20;
-var DEFAULT_SEARCH_LIMIT = 10;
-var DEFAULT_ENTITIES_LIMIT = 50;
-var DEFAULT_EDGES_LIMIT = 50;
-function createReadTools(deps) {
-  const { agentId, embeddingManager, teamClient, machineId } = deps;
-  const vaultUnprocessed = tool(
-    "vault_unprocessed",
-    "Get unprocessed prompt batches, ordered by id ASC. Supports cursor-based pagination. Batches from in-flight sessions are excluded by default so intelligence tasks only process settled work; pass include_active=true only if you specifically need live data (e.g., title-summary).",
-    {
-      after_id: external_exports.number().optional().describe("Return batches with id greater than this"),
-      limit: external_exports.number().optional().describe("Maximum number of batches to return"),
-      include_active: external_exports.boolean().optional().describe("Include batches from sessions still in active status (default: false)")
-    },
-    async (args) => {
-      const batches = getUnprocessedBatches({
-        after_id: args.after_id,
-        limit: args.limit ?? DEFAULT_UNPROCESSED_LIMIT,
-        includeActive: args.include_active === true
-      });
-      return textResult(batches);
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultSpores = tool(
-    "vault_spores",
-    "List spores with optional filters (agent, observation type, status, session), or fetch exact spores by id for full-content inspection after a semantic shortlist. Spores from in-flight sessions are excluded by default; passing a specific session_id or ids bypasses this filter. Pass include_active=true to bulk-read live work.",
-    {
-      ids: external_exports.array(external_exports.string()).optional().describe("Fetch exact spores by id in the given order; bypasses active-session gating"),
-      agent_id: external_exports.string().optional().describe("Filter by agent ID"),
-      observation_type: external_exports.string().optional().describe("Filter by observation type (e.g., gotcha, decision)"),
-      status: external_exports.enum(["active", "superseded", "archived"]).optional().describe("Filter by status"),
-      session_id: external_exports.string().optional().describe("Filter by session ID (bypasses active-session gating)"),
-      limit: external_exports.number().optional().describe("Maximum number of spores to return"),
-      include_active: external_exports.boolean().optional().describe("Include spores from sessions still in active status (default: false)")
-    },
-    async (args) => {
-      if (args.ids && args.ids.length > 0) {
-        const spores2 = args.ids.map((id) => getSpore(id)).filter((spore) => spore !== null);
-        return textResult(spores2);
-      }
-      const spores = listSpores({
-        agent_id: args.agent_id,
-        observation_type: args.observation_type,
-        status: args.status,
-        session_id: args.session_id,
-        limit: args.limit ?? DEFAULT_SPORES_LIMIT,
-        includeActive: args.include_active === true
-      });
-      return textResult(spores);
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultSessions = tool(
-    "vault_sessions",
-    "List sessions with optional status filter, ordered by created_at DESC. In-flight sessions are excluded by default; pass include_active=true or an explicit status to see them.",
-    {
-      limit: external_exports.number().optional().describe("Maximum number of sessions to return"),
-      status: external_exports.string().optional().describe("Filter by status (active, completed)"),
-      include_active: external_exports.boolean().optional().describe("Include sessions still in active status (default: false)")
-    },
-    async (args) => {
-      const sessions = listSessions({
-        limit: args.limit ?? DEFAULT_SESSIONS_LIMIT,
-        status: args.status,
-        includeActive: args.include_active === true
-      });
-      return textResult(sessions);
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultSearchFts = tool(
-    "vault_search_fts",
-    "Full-text search across sessions, spores, prompt batches, and activities using FTS5. Best for finding exact keywords, file paths, function names, and specific text. Results from in-flight sessions are hidden by default so intelligence tasks only see settled work; pass include_active=true to bypass.",
-    {
-      query: external_exports.string().describe("Search query text"),
-      type: external_exports.string().optional().describe("Restrict to a result type (session, spore, prompt_batch, activity)"),
-      limit: external_exports.number().optional().describe("Maximum number of results to return"),
-      include_active: external_exports.boolean().optional().describe("Include results from sessions still in active status (default: false)")
-    },
-    async (args) => {
-      try {
-        const results = fullTextSearch(args.query, {
-          type: args.type,
-          limit: args.limit ?? DEFAULT_SEARCH_LIMIT,
-          includeActive: args.include_active === true
-        });
-        return textResult({ results });
-      } catch {
-        return textResult({ results: [], message: "Search unavailable" });
-      }
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultSearchSemantic = tool(
-    "vault_search_semantic",
-    "Semantic similarity search across embedded vault content (spores, sessions, plans, artifacts, skill_records). Best for finding conceptually related content. Returns results ranked by similarity score. Results from in-flight sessions are filtered out by default; pass include_active=true to bypass.",
-    {
-      query: external_exports.string().describe("Search query text"),
-      namespace: external_exports.string().optional().describe("Restrict to a content type: spores, sessions, plans, artifacts, skill_records. Omit to search all."),
-      limit: external_exports.number().optional().describe("Maximum results to return"),
-      include_active: external_exports.boolean().optional().describe("Include results from sessions still in active status (default: false)")
-    },
-    async (args) => {
-      if (!embeddingManager) {
-        return textResult({ results: [], message: "Embedding provider unavailable" });
-      }
-      try {
-        const queryVector = await embeddingManager.embedQuery(args.query);
-        if (!queryVector) {
-          return textResult({ results: [], message: "Embedding provider unavailable" });
-        }
-        const searchLimit = args.limit ?? DEFAULT_SEARCH_LIMIT;
-        const excludeActive = args.include_active !== true;
-        const activeIds = excludeActive ? getActiveSessionIds() : /* @__PURE__ */ new Set();
-        const [rawLocalResults, teamResults] = await Promise.all([
-          Promise.resolve(
-            embeddingManager.searchVectors(queryVector, {
-              namespace: args.namespace,
-              limit: searchLimit,
-              threshold: SEARCH_SIMILARITY_THRESHOLD
-            }).map((r) => ({ ...r, source: "local" }))
-          ),
-          teamClient ? teamClient.search(args.query, { limit: searchLimit }).then((res) => res.results.map((r) => ({ ...r, source: `${TEAM_SOURCE_PREFIX}${r.machine_id}` }))).catch(() => []) : Promise.resolve([])
-        ]);
-        const localResults = activeIds.size > 0 ? rawLocalResults.filter((r) => {
-          const sid = r.metadata?.session_id;
-          return typeof sid !== "string" || !activeIds.has(sid);
-        }) : rawLocalResults;
-        const hydratedLocalResults = hydrateSearchResults(localResults).map((r) => ({
-          ...r,
-          source: "local"
-        }));
-        let dedupedTeam = machineId ? teamResults.filter((r) => r.machine_id !== machineId) : teamResults;
-        if (activeIds.size > 0) {
-          dedupedTeam = dedupedTeam.filter((r) => {
-            const sid = r.metadata?.session_id;
-            return typeof sid !== "string" || !activeIds.has(sid);
-          });
-        }
-        const merged = [
-          ...hydratedLocalResults,
-          ...dedupedTeam
-        ].sort((a, b) => (b.score ?? 0) - (a.score ?? 0)).slice(0, searchLimit);
-        return textResult({ results: merged });
-      } catch {
-        return textResult({ results: [], message: "Semantic search unavailable" });
-      }
-    },
-    { annotations: { readOnlyHint: true, openWorldHint: true } }
-  );
-  const vaultState = tool(
-    "vault_state",
-    "Get all state key-value pairs for the current agent.",
-    {},
-    async () => {
-      const states = getStatesForAgent(agentId);
-      return textResult(states);
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultEntities = tool(
-    "vault_entities",
-    "List knowledge graph entities with optional filters.",
-    {
-      type: external_exports.enum(["component", "concept", "person"]).optional().describe("Filter by entity type"),
-      name: external_exports.string().optional().describe("Filter by entity name (exact match)"),
-      limit: external_exports.number().optional().describe("Maximum entities to return")
-    },
-    async (args) => {
-      const entities = listEntities({
-        agent_id: agentId,
-        type: args.type,
-        name: args.name,
-        limit: args.limit ?? DEFAULT_ENTITIES_LIMIT
-      });
-      return textResult(entities);
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultEdges = tool(
-    "vault_edges",
-    "List knowledge graph edges with optional filters. Use to check existing relationships before creating new ones.",
-    {
-      source_id: external_exports.string().optional().describe("Filter by source node ID"),
-      target_id: external_exports.string().optional().describe("Filter by target node ID"),
-      type: external_exports.string().optional().describe("Filter by edge type (REFERENCES, DEPENDS_ON, AFFECTS, etc.)"),
-      limit: external_exports.number().optional().describe("Maximum edges to return")
-    },
-    async (args) => {
-      const edges = listGraphEdges({
-        sourceId: args.source_id,
-        targetId: args.target_id,
-        type: args.type,
-        agentId,
-        limit: args.limit ?? DEFAULT_EDGES_LIMIT
-      });
-      return textResult(edges);
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  return [
-    vaultUnprocessed,
-    vaultSpores,
-    vaultSessions,
-    vaultSearchFts,
-    vaultSearchSemantic,
-    vaultState,
-    vaultEntities,
-    vaultEdges
-  ];
-}
-
-// src/agent/tools/write-tools.ts
-import crypto from "crypto";
-import { tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-function createWriteTools(deps) {
-  const { agentId, embeddingManager, machineId } = deps;
-  const vaultCreateSpore = tool2(
-    "vault_create_spore",
-    "Create a new spore (observation) in the vault. The agent_id is set automatically.",
-    {
-      observation_type: external_exports.string().describe("Type of observation (gotcha, decision, discovery, trade-off, bug_fix, etc.)"),
-      content: external_exports.string().describe("The observation content in markdown"),
-      session_id: external_exports.string().optional().describe("Associated session ID"),
-      prompt_batch_id: external_exports.number().optional().describe("Associated prompt batch ID"),
-      importance: external_exports.number().optional().describe("Importance score 1-10 (default 5)"),
-      tags: external_exports.array(external_exports.string()).optional().describe("Tags for categorization"),
-      context: external_exports.string().optional().describe("Additional context about the observation"),
-      file_path: external_exports.string().optional().describe("Related file path"),
-      properties: external_exports.string().optional().describe('JSON metadata (e.g., {"consolidated_from": [...]} for wisdom spores)')
-    },
-    async (args) => {
-      const id = crypto.randomUUID();
-      const now = epochSeconds();
-      const spore = insertSpore({
-        id,
-        agent_id: agentId,
-        machine_id: machineId,
-        observation_type: args.observation_type,
-        content: args.content,
-        session_id: args.session_id ?? null,
-        prompt_batch_id: args.prompt_batch_id ?? null,
-        importance: args.importance ?? DEFAULT_IMPORTANCE,
-        tags: args.tags ? JSON.stringify(args.tags) : null,
-        context: args.context ?? null,
-        file_path: args.file_path ?? null,
-        properties: args.properties ?? null,
-        created_at: now
-      });
-      try {
-        createSporeLineage(spore);
-      } catch {
-      }
-      embeddingManager?.onContentWritten("spores", spore.id, args.content, {
-        status: "active",
-        observation_type: args.observation_type,
-        session_id: args.session_id
-      }).catch(() => {
-      });
-      return textResult(spore);
-    },
-    { annotations: { openWorldHint: true } }
-  );
-  const vaultCreateEntity = tool2(
-    "vault_create_entity",
-    "Create or update an entity in the knowledge graph. Uses UPSERT on (agent_id, type, name).",
-    {
-      type: external_exports.enum(["component", "concept", "person"]).describe("Entity type"),
-      name: external_exports.string().describe("Entity name (unique within agent + type)"),
-      properties: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Additional properties as key-value pairs")
-    },
-    async (args) => {
-      const id = crypto.randomUUID();
-      const now = epochSeconds();
-      const props = args.properties ? JSON.stringify(args.properties) : null;
-      const entity = insertEntity({
-        id,
-        agent_id: agentId,
-        machine_id: machineId,
-        type: args.type,
-        name: args.name,
-        properties: props,
-        first_seen: now,
-        last_seen: now
-      });
-      return textResult(entity);
-    },
-    { annotations: { idempotentHint: true } }
-  );
-  const vaultCreateEdge = tool2(
-    "vault_create_edge",
-    "Create a semantic edge in the knowledge graph. Lineage edges (FROM_SESSION, EXTRACTED_FROM, HAS_BATCH, DERIVED_FROM) are created automatically \u2014 do NOT create those.",
-    {
-      source_id: external_exports.string().describe("Source node ID"),
-      source_type: external_exports.enum(["session", "batch", "spore", "entity"]).describe("Source node type"),
-      target_id: external_exports.string().describe("Target node ID"),
-      target_type: external_exports.enum(["session", "batch", "spore", "entity"]).describe("Target node type"),
-      type: external_exports.enum(["RELATES_TO", "SUPERSEDED_BY", "REFERENCES", "DEPENDS_ON", "AFFECTS"]).describe("Semantic edge type"),
-      session_id: external_exports.string().optional().describe("Session where this relationship was observed"),
-      confidence: external_exports.number().optional().describe("Confidence score 0-1 (default 1.0)"),
-      properties: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Additional properties as key-value pairs")
-    },
-    async (args) => {
-      const now = epochSeconds();
-      const props = args.properties ? JSON.stringify(args.properties) : void 0;
-      const edge = insertGraphEdge({
-        agent_id: agentId,
-        machine_id: machineId,
-        source_id: args.source_id,
-        source_type: args.source_type,
-        target_id: args.target_id,
-        target_type: args.target_type,
-        type: args.type,
-        session_id: args.session_id,
-        confidence: args.confidence,
-        properties: props,
-        created_at: now
-      });
-      return textResult(edge);
-    },
-    { annotations: { idempotentHint: true } }
-  );
-  const vaultResolveSpore = tool2(
-    "vault_resolve_spore",
-    "Resolve a spore by updating its status and recording a resolution event.",
-    {
-      spore_id: external_exports.string().describe("ID of the spore to resolve"),
-      action: external_exports.enum(["supersede", "archive", "merge", "split", "consolidate"]).describe("Resolution action"),
-      new_spore_id: external_exports.string().optional().describe("ID of the replacement spore (for supersede/merge)"),
-      reason: external_exports.string().optional().describe("Explanation for the resolution"),
-      session_id: external_exports.string().optional().describe("Session where this resolution occurred")
-    },
-    async (args) => {
-      const now = epochSeconds();
-      const statusMap = {
-        supersede: "superseded",
-        archive: "archived",
-        merge: "merged",
-        split: "split",
-        consolidate: "consolidated"
-      };
-      const newStatus = statusMap[args.action] ?? args.action;
-      const updatedSpore = updateSporeStatus(args.spore_id, newStatus, now);
-      const eventId = crypto.randomUUID();
-      insertResolutionEvent({
-        id: eventId,
-        agent_id: agentId,
-        machine_id: machineId,
-        spore_id: args.spore_id,
-        action: args.action,
-        new_spore_id: args.new_spore_id ?? null,
-        reason: args.reason ?? null,
-        session_id: args.session_id ?? null,
-        created_at: now
-      });
-      if (newStatus !== "active") {
-        try {
-          embeddingManager?.onStatusChanged("spores", args.spore_id, newStatus);
-        } catch {
-        }
-      }
-      return textResult({ spore: updatedSpore, resolution_event_id: eventId });
-    },
-    { annotations: { destructiveHint: true } }
-  );
-  const vaultUpdateSession = tool2(
-    "vault_update_session",
-    "Update a session title and/or summary. When generating for the first time, provide BOTH title and summary. Title should be under 80 characters and reflect the full session scope.",
-    {
-      session_id: external_exports.string().describe("Session ID to update"),
-      title: external_exports.string().optional().describe("New session title"),
-      summary: external_exports.string().optional().describe("New session summary")
-    },
-    async (args) => {
-      const updates = {};
-      if (args.title !== void 0) updates.title = args.title;
-      if (args.summary !== void 0) updates.summary = args.summary;
-      const session = updateSession(args.session_id, updates);
-      if (args.summary) {
-        embeddingManager?.onContentWritten("sessions", args.session_id, args.summary, {}).catch(() => {
-        });
-      }
-      return textResult(session);
-    },
-    { annotations: { idempotentHint: true } }
-  );
-  const vaultSetState = tool2(
-    "vault_set_state",
-    "Set a key-value state pair for the current agent. Used for bookmarks, cursors, and preferences.",
-    {
-      key: external_exports.string().describe("State key (e.g., last_processed_batch_id, cursor)"),
-      value: external_exports.string().describe("State value (stored as text)")
-    },
-    async (args) => {
-      const now = epochSeconds();
-      const state = setState(agentId, args.key, args.value, now);
-      return textResult(state);
-    },
-    { annotations: { idempotentHint: true } }
-  );
-  const vaultReadDigest = tool2(
-    "vault_read_digest",
-    "Read current digest extracts. Without a tier parameter, returns a summary of all tiers (content length, generation time). With a tier parameter, returns the full content for that specific tier.",
-    {
-      tier: external_exports.number().optional().describe("Specific tier to read in full (e.g., 1500, 5000, 10000). Omit to get summary of all tiers.")
-    },
-    async (args) => {
-      const extracts = listDigestExtracts(agentId);
-      if (args.tier !== void 0) {
-        const extract = extracts.find((e) => e.tier === args.tier);
-        if (!extract) return textResult({ tier: args.tier, content: null, message: "No digest at this tier" });
-        return textResult({ tier: extract.tier, content: extract.content, generated_at: extract.generated_at });
-      }
-      return textResult(extracts.map((e) => ({
-        tier: e.tier,
-        content_length: e.content.length,
-        generated_at: e.generated_at
-      })));
-    },
-    { annotations: { readOnlyHint: true } }
-  );
-  const vaultWriteDigest = tool2(
-    "vault_write_digest",
-    "Write or update a digest extract at a specific token tier. Uses UPSERT on (agent_id, tier).",
-    {
-      tier: external_exports.number().describe("Token budget tier (e.g., 1500, 5000, 10000)"),
-      content: external_exports.string().describe("The digest extract content in markdown")
-    },
-    async (args) => {
-      const now = epochSeconds();
-      const extract = upsertDigestExtract({
-        agent_id: agentId,
-        tier: args.tier,
-        content: args.content,
-        generated_at: now
-      });
-      return textResult(extract);
-    },
-    { annotations: { idempotentHint: true } }
-  );
-  const vaultMarkProcessed = tool2(
-    "vault_mark_processed",
-    "Mark a prompt batch as processed so it is not returned by vault_unprocessed.",
-    {
-      batch_id: external_exports.number().describe("ID of the prompt batch to mark as processed")
-    },
-    async (args) => {
-      const batch = markBatchProcessed(args.batch_id);
-      return textResult(batch);
-    },
-    { annotations: { destructiveHint: true } }
-  );
-  return [
-    vaultCreateSpore,
-    vaultCreateEntity,
-    vaultCreateEdge,
-    vaultResolveSpore,
-    vaultUpdateSession,
-    vaultSetState,
-    vaultReadDigest,
-    vaultWriteDigest,
-    vaultMarkProcessed
-  ];
-}
-
-// src/agent/tools/observability-tools.ts
-import { tool as tool3 } from "@anthropic-ai/claude-agent-sdk";
-function createObservabilityTools(deps) {
-  const { runId, agentId } = deps;
-  const vaultReport = tool3(
-    "vault_report",
-    'Record an observability report for the current run. Use action "skip" when skipping expected operations (e.g., not updating a session summary) with reasoning in the summary field.',
-    {
-      action: external_exports.string().describe("Action name (e.g., extract, consolidate, digest, skip)"),
-      summary: external_exports.string().describe("Human-readable summary of what was done"),
-      details: external_exports.record(external_exports.string(), external_exports.unknown()).optional().describe("Structured details as key-value pairs")
-    },
-    async (args) => {
-      const now = epochSeconds();
-      const report = insertReport({
-        run_id: runId,
-        agent_id: agentId,
-        action: args.action,
-        summary: args.summary,
-        details: args.details ? JSON.stringify(args.details) : null,
-        created_at: now
-      });
-      return textResult(report);
-    },
-    { annotations: {} }
-  );
-  return [vaultReport];
-}
-
-// src/agent/tools/skill-tools.ts
-import crypto2 from "crypto";
-import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from "fs";
-import { resolve } from "path";
-import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
-function createSkillTools(deps) {
-  const { agentId, machineId, projectRoot, vaultDir, embeddingManager } = deps;
-  function findOverlappingCandidate(newTopic, existing) {
-    let best = null;
-    for (const candidate of existing) {
-      const jaccard = descriptionSimilarity(newTopic, candidate.topic);
-      const overlap = topicOverlapSimilarity(newTopic, candidate.topic);
-      const hitsJaccard = jaccard >= DESCRIPTION_DUPLICATE_THRESHOLD;
-      const hitsOverlap = overlap >= TOPIC_OVERLAP_THRESHOLD;
-      if (!hitsJaccard && !hitsOverlap) continue;
-      const score = Math.max(jaccard, overlap);
-      if (!best || score > best.score) {
-        best = { candidate, score };
-      }
-    }
-    return best;
-  }
-  function candidateOverlapError(match) {
-    const common = `already has an existing candidate with a similar topic: "${match.topic}"`;
-    switch (match.status) {
-      case CANDIDATE_STATUS.DISMISSED:
-        return `Note: similar to dismissed candidate "${match.topic}". If this is a broader domain that subsumes the dismissed topic, creation is allowed.`;
-      case CANDIDATE_STATUS.GENERATED:
-        return `Candidate rejected: the vault ${common} that was already fulfilled by a generated skill. Do not re-identify.`;
-      case CANDIDATE_STATUS.APPROVED:
-        return `Candidate rejected: the vault ${common} that is already queued in approved state. Wait for the generate task to process it.`;
-      case CANDIDATE_STATUS.IDENTIFIED:
-        return `Candidate rejected: the vault ${common} already in the review queue. Update the existing candidate with new evidence (action: update) instead of creating a duplicate.`;
-      default:
-        return `Candidate rejected: the vault ${common} in status '${match.status}'.`;
-    }
-  }
-  function requireApprovedCandidate(candidateId) {
-    const candidate = getCandidate(candidateId);
-    if (!candidate) {
-      return {
-        error: `Candidate ${candidateId} not found. Skill writes require a candidate in the approved state.`
-      };
-    }
-    if (candidate.status !== CANDIDATE_STATUS.APPROVED) {
-      return {
-        error: `Candidate ${candidateId} is in '${candidate.status}' state. Skills can only be generated from candidates in 'approved' state \u2014 the human review step. If a candidate in an earlier state needs to become a skill, route it through the normal approval flow first.`,
-        candidate_status: candidate.status
-      };
-    }
-    return null;
-  }
-  function checkDedupGates(args) {
-    const existingSameName = getSkillRecordByName(args.name);
-    if (existingSameName) {
-      if (args.rejectSameName) {
-        return {
-          error: `Skill "${args.name}" already exists. This path is create-only. Use vault_write_skill to evolve the existing skill (it bumps the generation), or mark the current record stale via vault_skill_records first.`,
-          existing_skill: {
-            id: existingSameName.id,
-            name: existingSameName.name,
-            path: existingSameName.path
-          }
-        };
-      }
-      return null;
-    }
-    if (args.candidate_id) {
-      const candidate = getCandidate(args.candidate_id);
-      if (candidate?.skill_id) {
-        const linkedSkill = getSkillRecord(candidate.skill_id);
-        if (linkedSkill && linkedSkill.name !== args.name) {
-          return {
-            error: `Candidate ${args.candidate_id} is already fulfilled by skill "${linkedSkill.name}". Do not create a sibling skill. If the existing skill needs changes, write to the same name to evolve it (this bumps its generation), or mark it stale via vault_skill_records before replacing.`,
-            existing_skill: {
-              id: linkedSkill.id,
-              name: linkedSkill.name,
-              description: linkedSkill.description,
-              path: linkedSkill.path
-            }
-          };
-        }
-      }
-    }
-    const activeSkills = listSkillRecords({ agent_id: agentId, status: "active", limit: 200 });
-    let bestMatch = null;
-    for (const skill of activeSkills) {
-      const score = descriptionSimilarity(args.description, skill.description);
-      if (score >= DESCRIPTION_DUPLICATE_THRESHOLD && (!bestMatch || score > bestMatch.score)) {
-        bestMatch = { skill, score };
-      }
-    }
-    if (bestMatch) {
-      return {
-        error: `Description overlaps with existing active skill "${bestMatch.skill.name}" (Jaccard ${bestMatch.score.toFixed(2)}, threshold ${DESCRIPTION_DUPLICATE_THRESHOLD}). Do not create a duplicate. Either evolve the existing skill by writing to its name ("${bestMatch.skill.name}"), or reframe this skill so its description describes a distinct procedure.`,
-        overlapping_skill: {
-          id: bestMatch.skill.id,
-          name: bestMatch.skill.name,
-          description: bestMatch.skill.description,
-          path: bestMatch.skill.path
-        },
-        similarity: bestMatch.score
-      };
-    }
-    return null;
-  }
-  async function promoteNewSkill(params) {
-    const root = projectRoot ?? process.cwd();
-    const skillDir = resolve(root, ".agents", "skills", params.name);
-    const skillPath = resolve(skillDir, "SKILL.md");
-    const skillDirPreexisted = existsSync(skillDir);
-    async function cleanupCreatedSkillArtifactsOnRollback() {
-      try {
-        if (!skillDirPreexisted) {
-          rmSync(skillDir, { recursive: true, force: true });
-        } else {
-          rmSync(skillPath, { force: true });
-        }
-      } catch (rollbackErr) {
-        console.warn(
-          `[${params.label}] file rollback after DB failure also failed:`,
-          rollbackErr instanceof Error ? rollbackErr.message : rollbackErr
-        );
-      }
-      try {
-        const { syncSkillSymlinks } = await import("./installer-FS257JRZ.js");
-        syncSkillSymlinks(root, params.name, { remove: true });
-      } catch (rollbackErr) {
-        console.warn(
-          `[${params.label}] symlink rollback after DB failure also failed:`,
-          rollbackErr instanceof Error ? rollbackErr.message : rollbackErr
-        );
-      }
-    }
-    try {
-      mkdirSync(skillDir, { recursive: true });
-      writeFileSync(skillPath, params.content, "utf-8");
-    } catch (err) {
-      return {
-        error: `Failed to write skill file: ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    try {
-      const { syncSkillSymlinks } = await import("./installer-FS257JRZ.js");
-      syncSkillSymlinks(root, params.name);
-    } catch (err) {
-      console.warn(
-        `[${params.label}] syncSkillSymlinks failed:`,
-        err instanceof Error ? err.message : err
-      );
-    }
-    const now = epochSeconds();
-    const relativePath = `.agents/skills/${params.name}/SKILL.md`;
-    const recordId = crypto2.randomUUID();
-    const generation = 1;
-    const txDb = getDatabase();
-    try {
-      txDb.transaction(() => {
-        insertSkillRecord({
-          id: recordId,
-          agent_id: agentId,
-          machine_id: machineId,
-          name: params.name,
-          display_name: params.display_name,
-          description: params.description,
-          candidate_id: params.candidate_id ?? null,
-          source_ids: params.source_ids,
-          path: relativePath,
-          created_at: now,
-          updated_at: now
-        });
-        insertLineage({
-          id: crypto2.randomUUID(),
-          skill_id: recordId,
-          generation,
-          action: "created",
-          rationale: params.rationale ?? "Initial skill creation",
-          source_ids_added: params.source_ids,
-          content_snapshot: params.content,
-          created_at: now
-        });
-        params.linkCandidate?.(recordId, now);
-      })();
-    } catch (err) {
-      await cleanupCreatedSkillArtifactsOnRollback();
-      return {
-        error: `Skill write aborted: database transaction failed and on-disk state was rolled back. ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-    return {
-      id: recordId,
-      name: params.name,
-      path: relativePath,
-      generation
-    };
-  }
-  function emitSkillNotification(kind, opts) {
-    notify(vaultDir, {
-      domain: "skills",
-      type: kind === "created" ? "skill.created" : "skill.evolved",
-      title: `Skill ${kind}: ${opts.display_name}`,
-      message: opts.description.slice(0, 120),
-      link: `/skills?skill=${encodeURIComponent(opts.name)}`,
-      metadata: { skillId: opts.recordId, name: opts.name, generation: opts.generation }
-    });
-  }
-  const vaultSkillCandidates = tool4(
-    "vault_skill_candidates",
-    "Manage skill candidates (identified topics that may become skills). Supports list, get, create, and update actions.",
-    {
-      action: external_exports.enum(["list", "get", "create", "update", "delete"]).describe("Action to perform"),
-      id: external_exports.string().optional().describe("Candidate ID (required for get/update)"),
-      topic: external_exports.string().optional().describe("Skill topic (required for create)"),
-      rationale: external_exports.string().optional().describe("Why this should be a skill (required for create)"),
-      confidence: external_exports.number().optional().describe("Confidence score 0-1"),
-      status: external_exports.enum(AGENT_SETTABLE_STATUSES).optional().describe(
-        "Candidate status \u2014 agent-settable values only. 'identified' is the initial state; 'dismissed' retires a candidate. 'approved' and 'generated' are lifecycle transitions owned by the human UI and vault_finalize_skill respectively."
-      ),
-      source_ids: external_exports.string().optional().describe("JSON array of source spore/entity IDs"),
-      skill_id: external_exports.string().optional().describe("Associated skill record ID (after materialization)"),
-      supersedes: external_exports.string().optional().describe("JSON array of skill record names this candidate would replace (for domain-level candidates that subsume existing narrow skills)"),
-      limit: external_exports.number().optional().describe("Maximum candidates to return (for list)")
-    },
-    async (args) => {
-      switch (args.action) {
-        case "list": {
-          const candidates = listCandidates({
-            agent_id: agentId,
-            status: args.status,
-            limit: args.limit ?? DEFAULT_LIST_LIMIT
-          });
-          return textResult(candidates);
-        }
-        case "get": {
-          if (!args.id) return textResult({ error: "id is required for get action" });
-          const candidate = getCandidate(args.id);
-          if (!candidate) return textResult({ error: `Candidate not found: ${args.id}` });
-          return textResult(candidate);
-        }
-        case "create": {
-          if (!args.topic || !args.rationale) {
-            return textResult({ error: "topic and rationale are required for create action" });
-          }
-          let supersedesNames = [];
-          if (args.supersedes) {
-            try {
-              supersedesNames = JSON.parse(args.supersedes);
-            } catch {
-            }
-          }
-          const supersedesSet = new Set(supersedesNames);
-          const activeSkills = listSkillRecords({ agent_id: agentId, status: "active", limit: 100 });
-          const topicLower = args.topic.toLowerCase();
-          const overlapping = activeSkills.filter((s) => {
-            if (supersedesSet.has(s.name)) return false;
-            const nameWords = s.name.split("-").filter((w) => w.length > 2);
-            if (nameWords.length < 2) return false;
-            return nameWords.every((w) => topicLower.includes(w));
-          });
-          if (overlapping.length > 0) {
-            return textResult({
-              error: "Candidate rejected: active skill(s) already cover this topic. Update the existing skill via vault_skill_records instead.",
-              overlapping_skills: overlapping.map((s) => ({ name: s.name, display_name: s.display_name, description: s.description }))
-            });
-          }
-          const allExisting = listCandidates({ agent_id: agentId, limit: 500 });
-          const match = findOverlappingCandidate(args.topic, allExisting);
-          let dismissedMatch;
-          if (match) {
-            if (match.candidate.status === CANDIDATE_STATUS.DISMISSED) {
-              dismissedMatch = match;
-            } else {
-              return textResult({
-                error: candidateOverlapError(match.candidate),
-                existing_candidate: {
-                  id: match.candidate.id,
-                  status: match.candidate.status,
-                  topic: match.candidate.topic
-                },
-                similarity: match.score
-              });
-            }
-          }
-          const now = epochSeconds();
-          const candidate = insertCandidate({
-            id: crypto2.randomUUID(),
-            agent_id: agentId,
-            machine_id: machineId,
-            topic: args.topic,
-            rationale: args.rationale,
-            confidence: args.confidence,
-            status: args.status,
-            source_ids: args.source_ids,
-            supersedes: args.supersedes,
-            created_at: now,
-            updated_at: now
-          });
-          const result = { ...candidate };
-          if (dismissedMatch) {
-            result.warning = candidateOverlapError(dismissedMatch.candidate);
-            result.similar_dismissed_candidate = {
-              id: dismissedMatch.candidate.id,
-              topic: dismissedMatch.candidate.topic
-            };
-          }
-          notify(vaultDir, {
-            domain: "skills",
-            type: "skill.surveyed",
-            title: `Skill candidate: ${args.topic}`,
-            message: args.rationale.slice(0, 120),
-            link: "/skills?tab=candidates",
-            metadata: { candidateId: candidate.id, topic: args.topic }
-          });
-          return textResult(result);
-        }
-        case "update": {
-          if (!args.id) return textResult({ error: "id is required for update action" });
-          const now = epochSeconds();
-          const updated = updateCandidate(args.id, {
-            ...args.topic !== void 0 ? { topic: args.topic } : {},
-            ...args.rationale !== void 0 ? { rationale: args.rationale } : {},
-            ...args.confidence !== void 0 ? { confidence: args.confidence } : {},
-            ...args.status !== void 0 ? { status: args.status } : {},
-            ...args.source_ids !== void 0 ? { source_ids: args.source_ids } : {},
-            ...args.skill_id !== void 0 ? { skill_id: args.skill_id } : {},
-            ...args.supersedes !== void 0 ? { supersedes: args.supersedes } : {},
-            updated_at: now
-          });
-          if (!updated) return textResult({ error: `Candidate not found: ${args.id}` });
-          return textResult(updated);
-        }
-        case "delete": {
-          if (!args.id) return textResult({ error: "id is required for delete action" });
-          const deleted = deleteCandidate(args.id);
-          if (!deleted) return textResult({ error: `Candidate not found: ${args.id}` });
-          return textResult({ deleted: true, id: args.id });
-        }
-        default:
-          return textResult({ error: `Unknown action: ${args.action}` });
-      }
-    },
-    { annotations: {} }
-  );
-  const vaultSkillRecords = tool4(
-    "vault_skill_records",
-    "Read, update, and delete skill records (materialized skills on disk). Supports list, get, update, and delete actions. The get action includes the full SKILL.md file content.",
-    {
-      action: external_exports.enum(["list", "get", "update", "delete"]).describe("Action to perform"),
-      id: external_exports.string().optional().describe("Skill record ID or name (required for get/update/delete)"),
-      status: external_exports.enum(["active", "stale", "retired"]).optional().describe("Filter by status"),
-      generation: external_exports.number().optional().describe("New generation number (for update)"),
-      source_ids: external_exports.string().optional().describe("JSON array of source IDs (for update)"),
-      description: external_exports.string().optional().describe("Updated description (for update)"),
-      limit: external_exports.number().optional().describe("Maximum records to return (for list)")
-    },
-    async (args) => {
-      switch (args.action) {
-        case "list": {
-          const records = listSkillRecords({
-            agent_id: agentId,
-            status: args.status,
-            limit: args.limit ?? DEFAULT_LIST_LIMIT
-          });
-          return textResult(records);
-        }
-        case "get": {
-          if (!args.id) return textResult({ error: "id is required for get action" });
-          const record = getSkillRecord(args.id) ?? getSkillRecordByName(args.id);
-          if (!record) return textResult({ error: `Skill record not found: ${args.id}` });
-          const result = { ...record };
-          if (record.path && projectRoot) {
-            try {
-              result.content = readFileSync(resolve(projectRoot, record.path), "utf-8");
-            } catch {
-            }
-          }
-          return textResult(result);
-        }
-        case "update": {
-          if (!args.id) return textResult({ error: "id is required for update action" });
-          const existing = getSkillRecord(args.id) ?? getSkillRecordByName(args.id);
-          if (!existing) return textResult({ error: `Skill record not found: ${args.id}` });
-          const now = epochSeconds();
-          const updated = updateSkillRecord(existing.id, {
-            ...args.status !== void 0 ? { status: args.status } : {},
-            ...args.generation !== void 0 ? { generation: args.generation } : {},
-            ...args.source_ids !== void 0 ? { source_ids: args.source_ids } : {},
-            ...args.description !== void 0 ? { description: args.description } : {},
-            updated_at: now
-          });
-          if (!updated) return textResult({ error: `Failed to update skill record: ${existing.id}` });
-          return textResult(updated);
-        }
-        case "delete": {
-          if (!args.id) return textResult({ error: "id is required for delete action" });
-          const result = deleteSkillRecordCascade(args.id);
-          if (!result) return textResult({ error: `Skill record not found: ${args.id}` });
-          try {
-            embeddingManager?.onRemoved("skill_records", result.id);
-          } catch {
-          }
-          const root = projectRoot ?? process.cwd();
-          if (!/[/\\]|\.\./.test(result.name)) {
-            const skillDir = resolve(root, ".agents", "skills", result.name);
-            try {
-              rmSync(skillDir, { recursive: true, force: true });
-            } catch (err) {
-              console.warn("[vault_skill_records] Failed to remove skill directory:", err instanceof Error ? err.message : err);
-            }
-            try {
-              const { syncSkillSymlinks } = await import("./installer-FS257JRZ.js");
-              syncSkillSymlinks(root, result.name, { remove: true });
-            } catch (err) {
-              console.warn("[vault_skill_records] Failed to remove symlinks:", err instanceof Error ? err.message : err);
-            }
-          }
-          return textResult({ deleted: true, id: result.id, name: result.name });
-        }
-        default:
-          return textResult({ error: `Unknown action: ${args.action}` });
-      }
-    },
-    { annotations: {} }
-  );
-  const vaultWriteSkill = tool4(
-    "vault_write_skill",
-    "Write a SKILL.md file to disk and create or update the corresponding skill record and lineage entry.",
-    {
-      name: external_exports.string().describe("Skill directory name (kebab-case, NO colon). The myco: prefix goes in the SKILL.md frontmatter name field, not here."),
-      display_name: external_exports.string().describe("Human-readable display name"),
-      description: external_exports.string().describe("Short description of what the skill does"),
-      content: external_exports.string().describe("Full SKILL.md content in markdown"),
-      source_ids: external_exports.string().optional().describe("JSON array of source spore/entity IDs"),
-      candidate_id: external_exports.string().optional().describe("Candidate ID that prompted this skill creation"),
-      rationale: external_exports.string().optional().describe("Why this skill was created or updated")
-    },
-    async (args) => {
-      const validationErrors = validateSkillContent(args.content, args.name);
-      if (validationErrors.length > 0) {
-        return textResult({
-          error: "Skill validation failed. Fix these issues and try again.",
-          issues: validationErrors
-        });
-      }
-      if (!args.name || /[/\\]|\.\./.test(args.name)) {
-        return textResult({
-          error: 'Invalid skill name: must be a simple directory name without path separators or ".."'
-        });
-      }
-      const dedupError = checkDedupGates({
-        candidate_id: args.candidate_id,
-        name: args.name,
-        description: args.description
-      });
-      if (dedupError) {
-        return textResult(dedupError);
-      }
-      const existing = getSkillRecordByName(args.name);
-      const root = projectRoot ?? process.cwd();
-      const skillPath = resolve(root, ".agents", "skills", args.name, "SKILL.md");
-      if (existsSync(skillPath)) {
-        const existingContent = readFileSync(skillPath, "utf-8");
-        const violations = checkFrontmatterPreservation(existingContent, args.content);
-        if (violations.length > 0) {
-          return textResult({
-            error: "Skill update rejected: protected frontmatter fields were changed. Read the existing skill and preserve these values exactly.",
-            violations
-          });
-        }
-      }
-      if (!existing) {
-        if (args.candidate_id) {
-          const candidateError = requireApprovedCandidate(args.candidate_id);
-          if (candidateError) {
-            return textResult(candidateError);
-          }
-        }
-        const linkCandidate = (recordId2, now2) => {
-          if (!args.candidate_id) return;
-          const exact = updateCandidate(args.candidate_id, {
-            status: CANDIDATE_STATUS.GENERATED,
-            skill_id: recordId2,
-            updated_at: now2
-          });
-          if (exact) return;
-          const approvedCandidates = listCandidates({ status: CANDIDATE_STATUS.APPROVED, limit: 10 });
-          const prefixMatch = approvedCandidates.find((c) => c.id.startsWith(args.candidate_id));
-          if (prefixMatch) {
-            updateCandidate(prefixMatch.id, {
-              status: CANDIDATE_STATUS.GENERATED,
-              skill_id: recordId2,
-              updated_at: now2
-            });
-          }
-        };
-        const result = await promoteNewSkill({
-          name: args.name,
-          display_name: args.display_name,
-          description: args.description,
-          content: args.content,
-          source_ids: args.source_ids,
-          candidate_id: args.candidate_id,
-          rationale: args.rationale,
-          linkCandidate,
-          label: "vault_write_skill"
-        });
-        if ("error" in result) return textResult(result);
-        emitSkillNotification("created", {
-          name: result.name,
-          display_name: args.display_name,
-          description: args.description,
-          recordId: result.id,
-          generation: result.generation
-        });
-        embeddingManager?.onContentWritten("skill_records", result.id, args.description, {
-          status: "active",
-          name: args.name
-        }).catch(() => {
-        });
-        return textResult(result);
-      }
-      const priorSkillContent = readFileSync(skillPath, "utf-8");
-      try {
-        writeFileSync(skillPath, args.content, "utf-8");
-      } catch (err) {
-        return textResult({ error: `Failed to write skill file: ${err instanceof Error ? err.message : String(err)}` });
-      }
-      try {
-        const { syncSkillSymlinks } = await import("./installer-FS257JRZ.js");
-        syncSkillSymlinks(root, args.name);
-      } catch (err) {
-        console.warn("[vault_write_skill] syncSkillSymlinks failed:", err instanceof Error ? err.message : err);
-      }
-      const now = epochSeconds();
-      const relativePath = `.agents/skills/${args.name}/SKILL.md`;
-      const generation = existing.generation + 1;
-      const recordId = existing.id;
-      const txDb = getDatabase();
-      try {
-        txDb.transaction(() => {
-          updateSkillRecord(existing.id, {
-            display_name: args.display_name,
-            description: args.description,
-            generation,
-            ...args.source_ids !== void 0 ? { source_ids: args.source_ids } : {},
-            path: relativePath,
-            updated_at: now
-          });
-          insertLineage({
-            id: crypto2.randomUUID(),
-            skill_id: existing.id,
-            generation,
-            action: "updated",
-            rationale: args.rationale ?? "Skill content updated",
-            source_ids_added: args.source_ids,
-            content_snapshot: args.content,
-            created_at: now
-          });
-        })();
-      } catch (err) {
-        try {
-          writeFileSync(skillPath, priorSkillContent, "utf-8");
-        } catch (rollbackErr) {
-          console.warn(
-            "[vault_write_skill] file rollback after DB failure also failed:",
-            rollbackErr instanceof Error ? rollbackErr.message : rollbackErr
-          );
-        }
-        return textResult({
-          error: `Skill write aborted: database transaction failed and on-disk state was rolled back. ${err instanceof Error ? err.message : String(err)}`
-        });
-      }
-      emitSkillNotification("evolved", {
-        name: args.name,
-        display_name: args.display_name,
-        description: args.description,
-        recordId,
-        generation
-      });
-      embeddingManager?.onContentWritten("skill_records", recordId, args.description, {
-        status: "active",
-        name: args.name
-      }).catch(() => {
-      });
-      return textResult({
-        id: recordId,
-        name: args.name,
-        path: relativePath,
-        generation
-      });
-    },
-    { annotations: { openWorldHint: true } }
-  );
-  const vaultStageSkill = tool4(
-    "vault_stage_skill",
-    "Stage a provisional SKILL.md under .myco/staging/skills/<candidate_id>/ for later promotion by vault_finalize_skill. Use this from the skill-generate draft phase. The write is NOT live \u2014 the skill does not appear under .agents/skills/ and no DB rows are created until vault_finalize_skill is called with the same candidate_id.",
-    {
-      candidate_id: external_exports.string().describe(
-        "Candidate ID from the instruction. Required \u2014 staging is keyed by candidate so the validate phase (and on-failure cleanup) can find the staged content."
-      ),
-      name: external_exports.string().describe("Final skill directory name (kebab-case, no colon). Stored in the manifest for finalize."),
-      display_name: external_exports.string().describe("Human-readable display name"),
-      description: external_exports.string().describe("Short description \u2014 used for the dedup gate and the final skill record"),
-      content: external_exports.string().describe("Full SKILL.md content in markdown including frontmatter"),
-      source_ids: external_exports.string().optional().describe("JSON array of source spore/entity IDs"),
-      rationale: external_exports.string().optional().describe("Why this skill is being created \u2014 stored in lineage after finalize")
-    },
-    async (args) => {
-      if (!vaultDir) {
-        return textResult({
-          error: "vault_stage_skill requires vaultDir on the tool deps \u2014 staging has no location otherwise"
-        });
-      }
-      const validationErrors = validateSkillContent(args.content, args.name);
-      if (validationErrors.length > 0) {
-        return textResult({
-          error: "Skill validation failed. Fix these issues and re-stage.",
-          issues: validationErrors
-        });
-      }
-      if (!args.name || /[/\\]|\.\./.test(args.name)) {
-        return textResult({
-          error: 'Invalid skill name: must be a simple directory name without path separators or ".."'
-        });
-      }
-      const candidateError = requireApprovedCandidate(args.candidate_id);
-      if (candidateError) return textResult(candidateError);
-      const dedupError = checkDedupGates({
-        candidate_id: args.candidate_id,
-        name: args.name,
-        description: args.description,
-        rejectSameName: true
-      });
-      if (dedupError) return textResult(dedupError);
-      let stagingFilePath;
-      try {
-        stagingFilePath = writeStagedSkill(vaultDir, args.candidate_id, args.content);
-        const manifest = {
-          candidate_id: args.candidate_id,
-          name: args.name,
-          display_name: args.display_name,
-          description: args.description,
-          source_ids: args.source_ids ?? "[]",
-          rationale: args.rationale ?? "Initial draft"
-        };
-        writeStagedManifest(vaultDir, args.candidate_id, manifest);
-      } catch (err) {
-        return textResult({
-          error: `Failed to write staged skill: ${err instanceof Error ? err.message : String(err)}`
-        });
-      }
-      return textResult({
-        candidate_id: args.candidate_id,
-        staging_path: stagingFilePath,
-        status: "staged"
-      });
-    },
-    { annotations: { openWorldHint: true } }
-  );
-  const vaultFinalizeSkill = tool4(
-    "vault_finalize_skill",
-    "Promote a staged skill to live at .agents/skills/<name>/ and insert the skill_records / lineage rows. Call this from skill-generate validate phase after your quality checks pass. Requires vault_stage_skill to have been called earlier with the same candidate_id; reads the staged SKILL.md + manifest rather than taking duplicate metadata.",
-    {
-      candidate_id: external_exports.string().describe("Candidate ID whose staged skill should be promoted. Must match a previous vault_stage_skill call.")
-    },
-    async (args) => {
-      if (!vaultDir) {
-        return textResult({
-          error: "vault_finalize_skill requires vaultDir on the tool deps"
-        });
-      }
-      const stagedContent = readStagedSkill(vaultDir, args.candidate_id);
-      const manifest = readStagedManifest(vaultDir, args.candidate_id);
-      if (!stagedContent || !manifest) {
-        return textResult({
-          error: `No staged skill found for candidate ${args.candidate_id}. Call vault_stage_skill first.`
-        });
-      }
-      const candidateError = requireApprovedCandidate(args.candidate_id);
-      if (candidateError) return textResult(candidateError);
-      const validationErrors = validateSkillContent(stagedContent, manifest.name);
-      if (validationErrors.length > 0) {
-        return textResult({
-          error: "Staged skill failed validation on finalize. Re-stage with valid content.",
-          issues: validationErrors
-        });
-      }
-      const dedupError = checkDedupGates({
-        candidate_id: args.candidate_id,
-        name: manifest.name,
-        description: manifest.description,
-        rejectSameName: true
-      });
-      if (dedupError) return textResult(dedupError);
-      const result = await promoteNewSkill({
-        name: manifest.name,
-        display_name: manifest.display_name,
-        description: manifest.description,
-        content: stagedContent,
-        source_ids: manifest.source_ids,
-        candidate_id: manifest.candidate_id,
-        rationale: manifest.rationale,
-        linkCandidate: (recordId, now) => {
-          updateCandidate(manifest.candidate_id, {
-            status: CANDIDATE_STATUS.GENERATED,
-            skill_id: recordId,
-            updated_at: now
-          });
-        },
-        label: "vault_finalize_skill"
-      });
-      if ("error" in result) return textResult(result);
-      cleanupStagedSkill(vaultDir, args.candidate_id);
-      emitSkillNotification("created", {
-        name: manifest.name,
-        display_name: manifest.display_name,
-        description: manifest.description,
-        recordId: result.id,
-        generation: result.generation
-      });
-      embeddingManager?.onContentWritten("skill_records", result.id, manifest.description, {
-        status: "active",
-        name: manifest.name
-      }).catch(() => {
-      });
-      return textResult(result);
-    },
-    { annotations: { openWorldHint: true } }
-  );
-  return [
-    vaultSkillCandidates,
-    vaultSkillRecords,
-    vaultWriteSkill,
-    vaultStageSkill,
-    vaultFinalizeSkill
-  ];
-}
-
-// src/agent/tools.ts
-var READ_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "vault_unprocessed",
-  "vault_spores",
-  "vault_sessions",
-  "vault_search_fts",
-  "vault_search_semantic",
-  "vault_state",
-  "vault_entities",
-  "vault_edges"
-]);
-var WRITE_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "vault_create_spore",
-  "vault_create_entity",
-  "vault_create_edge",
-  "vault_resolve_spore",
-  "vault_update_session",
-  "vault_set_state",
-  "vault_read_digest",
-  "vault_write_digest",
-  "vault_mark_processed"
-]);
-var OBSERVABILITY_TOOL_NAMES = /* @__PURE__ */ new Set(["vault_report"]);
-var SKILL_TOOL_NAMES = /* @__PURE__ */ new Set([
-  "vault_skill_candidates",
-  "vault_skill_records",
-  "vault_write_skill",
-  "vault_stage_skill",
-  "vault_finalize_skill"
-]);
-var TOOL_OUTPUT_SUMMARY_LIMIT = 240;
-var VAULT_TOOL_COUNT = READ_TOOL_NAMES.size + WRITE_TOOL_NAMES.size + OBSERVABILITY_TOOL_NAMES.size + SKILL_TOOL_NAMES.size;
-function setsOverlap(a, b) {
-  for (const item of a) {
-    if (b.has(item)) return true;
-  }
-  return false;
-}
-function truncateSummary(text) {
-  if (!text) return null;
-  return text.length > TOOL_OUTPUT_SUMMARY_LIMIT ? `${text.slice(0, TOOL_OUTPUT_SUMMARY_LIMIT - 1)}\u2026` : text;
-}
-function summarizeToolResult(result) {
-  if (!result || typeof result !== "object") return null;
-  const content = result.content;
-  if (!Array.isArray(content) || content.length === 0) return null;
-  const first = content[0];
-  if (!first || first.type !== "text" || typeof first.text !== "string") return null;
-  return truncateSummary(first.text.replace(/\s+/g, " ").trim());
-}
-function summarizeToolError(error) {
-  if (error instanceof Error && error.message) {
-    return truncateSummary(error.message) ?? "Tool failed";
-  }
-  return truncateSummary(String(error)) ?? "Tool failed";
-}
-function createVaultTools(agentId, runId, options) {
-  const { turnOffset = 0, embeddingManager, teamClient, machineId, projectRoot, vaultDir, onlyNames } = options ?? {};
-  let turnCounter = turnOffset;
-  function recordTurn(toolName, toolInput) {
-    turnCounter++;
-    try {
-      const turn = insertTurn({
-        run_id: runId,
-        agent_id: agentId,
-        turn_number: turnCounter,
-        tool_name: toolName,
-        tool_input: JSON.stringify(toolInput),
-        started_at: epochSeconds()
-      });
-      return turn.id;
-    } catch {
-      return null;
-    }
-  }
-  const deps = {
-    agentId,
-    runId,
-    embeddingManager,
-    teamClient,
-    machineId,
-    projectRoot,
-    vaultDir,
-    recordTurn
-  };
-  const needsAll = !onlyNames;
-  const tools = [
-    ...needsAll || setsOverlap(onlyNames, READ_TOOL_NAMES) ? createReadTools(deps) : [],
-    ...needsAll || setsOverlap(onlyNames, WRITE_TOOL_NAMES) ? createWriteTools(deps) : [],
-    ...needsAll || setsOverlap(onlyNames, OBSERVABILITY_TOOL_NAMES) ? createObservabilityTools(deps) : [],
-    ...needsAll || setsOverlap(onlyNames, SKILL_TOOL_NAMES) ? createSkillTools(deps) : []
-  ];
-  return tools.map((toolDef) => wrapToolWithAudit(toolDef));
-  function wrapToolWithAudit(toolDef) {
-    const originalHandler = toolDef.handler;
-    return {
-      ...toolDef,
-      handler: async (args, extra) => {
-        const turnId = recordTurn(toolDef.name, args);
-        try {
-          const result = await originalHandler(args, extra);
-          if (turnId !== null) {
-            try {
-              updateTurn(turnId, {
-                tool_output_summary: summarizeToolResult(result),
-                completed_at: epochSeconds()
-              });
-            } catch {
-            }
-          }
-          return result;
-        } catch (error) {
-          if (turnId !== null) {
-            try {
-              updateTurn(turnId, {
-                tool_output_summary: summarizeToolError(error),
-                completed_at: epochSeconds()
-              });
-            } catch {
-            }
-          }
-          throw error;
-        }
-      }
-    };
-  }
-}
-function createVaultToolServer(agentId, runId, options) {
-  const tools = createVaultTools(agentId, runId, options);
-  return createSdkMcpServer({
-    name: "myco-vault",
-    version: getPluginVersion(),
-    tools
-  });
-}
-function createScopedVaultToolServer(agentId, runId, toolNames, options) {
-  const nameSet = new Set(toolNames);
-  const allTools = createVaultTools(agentId, runId, { ...options, onlyNames: nameSet });
-  const eligible = options?.readOnly ? allTools.filter((t) => t.annotations?.readOnlyHint === true) : allTools;
-  const scopedTools = eligible.filter((t) => nameSet.has(t.name));
-  return createSdkMcpServer({
-    name: "myco-vault",
-    version: getPluginVersion(),
-    tools: scopedTools
-  });
-}
-
-// src/agent/context.ts
-var STATE_UNSET = "(unset)";
-var STATE_KEY_LAST_PROCESSED_BATCH = "last_processed_batch_id";
-var SPORE_STATUS_ACTIVE = "active";
-function countRows(table, conditions = []) {
-  const db = getDatabase();
-  const whereParts = [];
-  const params = [];
-  for (const { clause, value } of conditions) {
-    whereParts.push(clause);
-    params.push(value);
-  }
-  const whereClause = whereParts.length > 0 ? `WHERE ${whereParts.join(" AND ")}` : "";
-  const row = db.prepare(
-    `SELECT count(*) AS count FROM ${table} ${whereClause}`
-  ).get(...params);
-  return Number(row.count);
-}
-function buildVaultContext(agentId) {
-  const states = getStatesForAgent(agentId);
-  const totalSessions = countRows("sessions");
-  const totalActiveSpores = countRows("spores", [{ clause: "status = ?", value: SPORE_STATUS_ACTIVE }]);
-  const totalEntities = countRows("entities");
-  const totalEdges = countRows("graph_edges");
-  const unprocessedBatches = countRows("prompt_batches", [{ clause: "processed = ?", value: 0 }]);
-  const lastDigestAt = getLastDigestTimestamp(agentId);
-  const stateMap = new Map(states.map((s) => [s.key, s.value]));
-  const lastProcessedBatchId = stateMap.get(STATE_KEY_LAST_PROCESSED_BATCH) ?? STATE_UNSET;
-  const lines = [
-    "## Current Vault State",
-    `agent_id: ${agentId}`,
-    `last_processed_batch_id: ${lastProcessedBatchId}`,
-    `unprocessed_batches: ${unprocessedBatches}`,
-    `total_sessions: ${totalSessions}`,
-    `total_active_spores: ${totalActiveSpores}`,
-    `total_entities: ${totalEntities}`,
-    `total_edges: ${totalEdges}`,
-    `last_digest_at: ${lastDigestAt}`
-  ];
-  return lines.join("\n");
-}
-function getLastDigestTimestamp(agentId) {
-  const db = getDatabase();
-  const row = db.prepare(
-    `SELECT MAX(generated_at) AS max_at
-     FROM digest_extracts
-     WHERE agent_id = ?`
-  ).get(agentId);
-  return row?.max_at ?? 0;
-}
-
-// src/agent/orchestrator.ts
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-// src/intelligence/response.ts
-var REASONING_PATTERNS = [
-  // <think>...</think>answer  (DeepSeek, Qwen, GLM, many others)
-  /<think>[\s\S]*?<\/think>\s*/gi,
-  // Implicit opening: reasoning...</think>answer  (GLM-4.7 observed)
-  /^[\s\S]*?<\/think>\s*/i,
-  // <reasoning>...</reasoning>answer
-  /<reasoning>[\s\S]*?<\/reasoning>\s*/gi,
-  // <|thinking|>...<|/thinking|>answer
-  /<\|thinking\|>[\s\S]*?<\|\/thinking\|>\s*/gi,
-  // Plain-text "Thinking Process:" block followed by actual content
-  // (Qwen 3.5 via LM Studio without native thinking mode)
-  // Matches from "Thinking Process:" up to the last numbered step, then the synthesis follows
-  /^Thinking Process:[\s\S]*?(?=\n(?:## |# |\*\*[A-Z]))/i
-];
-function stripReasoningTokens(text) {
-  if (!text) return text;
-  for (const pattern of REASONING_PATTERNS) {
-    const stripped = text.replace(pattern, "").trim();
-    if (stripped && stripped !== text.trim()) {
-      return stripped;
-    }
-  }
-  return text;
-}
-function extractJson(text) {
-  const cleaned = stripReasoningTokens(text);
-  const fenceMatch = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
-  if (fenceMatch) {
-    return JSON.parse(fenceMatch[1].trim());
-  }
-  const objectMatch = cleaned.match(/\{[\s\S]*\}/);
-  if (objectMatch) {
-    return JSON.parse(objectMatch[0]);
-  }
-  return JSON.parse(cleaned);
-}
-
-// src/agent/orchestrator.ts
-var DEFAULT_ORCHESTRATOR_MAX_TURNS = 3;
-var ORCHESTRATOR_PROMPT_FILE = "orchestrator.md";
-var PHASE_PROMPT_PREVIEW_CHARS = 100;
-var ORCHESTRATOR_GUIDANCE_HEADER = "## Orchestrator Guidance";
-var NO_CONTEXT_QUERIES_TEXT = "No context queries configured.";
-var FALLBACK_REASONING_PARSE_ERROR = "Orchestrator response could not be parsed \u2014 running all phases with defaults.";
-var FALLBACK_REASONING_MISSING_PHASES = "Orchestrator plan missing phases array \u2014 running all phases with defaults.";
-var PLACEHOLDER_VAULT_STATE = "{{vault_state}}";
-var PLACEHOLDER_PHASE_DEFINITIONS = "{{phase_definitions}}";
-var PLACEHOLDER_CONTEXT_RESULTS = "{{context_results}}";
-var cachedPromptTemplate;
-function loadPromptTemplate() {
-  if (!cachedPromptTemplate) {
-    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
-    const adjacentPath = path.join(scriptDir, "prompts", ORCHESTRATOR_PROMPT_FILE);
-    if (fs.existsSync(adjacentPath)) {
-      cachedPromptTemplate = fs.readFileSync(adjacentPath, "utf-8");
-      return cachedPromptTemplate;
-    }
-    const root = findPackageRoot(scriptDir);
-    if (root) {
-      const distPath = path.join(root, "dist", "src", "agent", "prompts", ORCHESTRATOR_PROMPT_FILE);
-      if (fs.existsSync(distPath)) {
-        cachedPromptTemplate = fs.readFileSync(distPath, "utf-8");
-        return cachedPromptTemplate;
-      }
-      const srcPath = path.join(root, "src", "agent", "prompts", ORCHESTRATOR_PROMPT_FILE);
-      cachedPromptTemplate = fs.readFileSync(srcPath, "utf-8");
-      return cachedPromptTemplate;
-    }
-    cachedPromptTemplate = fs.readFileSync(adjacentPath, "utf-8");
-  }
-  return cachedPromptTemplate;
-}
-function composeOrchestratorPrompt(vaultState, phases, contextResults) {
-  const template = loadPromptTemplate();
-  const phaseList = formatPhaseList(phases);
-  const contextSection = formatContextResults(contextResults);
-  return template.replace(PLACEHOLDER_VAULT_STATE, vaultState).replace(PLACEHOLDER_PHASE_DEFINITIONS, phaseList).replace(PLACEHOLDER_CONTEXT_RESULTS, contextSection);
-}
-function parseOrchestratorPlan(response, phases) {
-  const trimmed = response.trim();
-  if (!trimmed) {
-    return buildRunAllPlan(phases, FALLBACK_REASONING_PARSE_ERROR);
-  }
-  try {
-    const parsed = extractJson(trimmed);
-    if (!isOrchestratorPlanShape(parsed)) {
-      return buildRunAllPlan(phases, FALLBACK_REASONING_MISSING_PHASES);
-    }
-    return parsed;
-  } catch {
-    return buildRunAllPlan(phases, FALLBACK_REASONING_PARSE_ERROR);
-  }
-}
-function applyDirectives(phases, directives) {
-  const directiveMap = new Map(
-    directives.map((d) => [d.name, d])
-  );
-  const result = [];
-  for (const phase of phases) {
-    const directive = directiveMap.get(phase.name);
-    if (!directive) {
-      result.push(phase);
-      continue;
-    }
-    if (directive.skip) {
-      if (phase.required) {
-        console.warn(
-          `[orchestrator] Cannot skip required phase "${phase.name}" \u2014 keeping it. Reason: ${directive.skipReason ?? "none given"}`
-        );
-        result.push(applyNonSkipDirective(phase, directive));
-      }
-      continue;
-    }
-    result.push(applyNonSkipDirective(phase, directive));
-  }
-  return result;
-}
-function applyNonSkipDirective(phase, directive) {
-  let updated = { ...phase };
-  if (directive.maxTurns !== void 0) {
-    updated = { ...updated, maxTurns: directive.maxTurns };
-  }
-  if (directive.contextNotes) {
-    updated = {
-      ...updated,
-      prompt: `${updated.prompt}
-
-${ORCHESTRATOR_GUIDANCE_HEADER}
-
-${directive.contextNotes}`
-    };
-  }
-  return updated;
-}
-function formatPhaseList(phases) {
-  if (phases.length === 0) {
-    return "(no phases defined)";
-  }
-  return phases.map((p) => {
-    const preview = p.prompt.slice(0, PHASE_PROMPT_PREVIEW_CHARS);
-    const ellipsis = p.prompt.length > PHASE_PROMPT_PREVIEW_CHARS ? "..." : "";
-    return `- **${p.name}** (maxTurns: ${p.maxTurns}, required: ${p.required}): ${preview}${ellipsis}`;
-  }).join("\n");
-}
-function formatContextResults(results) {
-  if (results.length === 0) {
-    return NO_CONTEXT_QUERIES_TEXT;
-  }
-  return results.map((r) => {
-    const dataSection = r.error ? `Error: ${r.error}` : JSON.stringify(r.data, null, 2);
-    return `### ${r.tool}
-Purpose: ${r.purpose}
-
-${dataSection}`;
-  }).join("\n\n");
-}
-function isOrchestratorPlanShape(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  return Array.isArray(obj["phases"]);
-}
-function buildRunAllPlan(phases, reasoning) {
-  return {
-    phases: phases.map((p) => ({ name: p.name, skip: false })),
-    reasoning
-  };
-}
-
-// src/agent/context-queries.ts
-var DEFAULT_CONTEXT_QUERY_LIMIT = 10;
-async function executeContextQueries(agentId, queries) {
-  for (const query of queries) {
-    validateTool(query.tool);
-  }
-  const settled = await Promise.allSettled(
-    queries.map(async (query) => {
-      const limit = query.limit ?? DEFAULT_CONTEXT_QUERY_LIMIT;
-      const data = await executeQuery(agentId, query.tool, limit);
-      return { tool: query.tool, purpose: query.purpose, data };
-    })
-  );
-  const results = [];
-  for (let i = 0; i < settled.length; i++) {
-    const outcome = settled[i];
-    const query = queries[i];
-    if (outcome.status === "fulfilled") {
-      results.push(outcome.value);
-    } else {
-      const message = errorMessage(outcome.reason);
-      if (query.required) {
-        throw new Error(
-          `Required context query "${query.tool}" failed: ${message}`
-        );
-      }
-      results.push({
-        tool: query.tool,
-        purpose: query.purpose,
-        data: null,
-        error: message
-      });
-    }
-  }
-  return results;
-}
-var KNOWN_CONTEXT_QUERY_TOOLS = /* @__PURE__ */ new Set([
-  "vault_unprocessed",
-  "vault_spores",
-  "vault_sessions",
-  "vault_state"
-]);
-function validateTool(tool5) {
-  if (!KNOWN_CONTEXT_QUERY_TOOLS.has(tool5)) {
-    throw new Error(`Unknown context query tool: "${tool5}"`);
-  }
-}
-async function executeQuery(agentId, tool5, limit) {
-  switch (tool5) {
-    case "vault_unprocessed":
-      return getUnprocessedBatches({ limit, includeActive: false });
-    case "vault_spores":
-      return listSpores({ agent_id: agentId, limit, includeActive: false });
-    case "vault_sessions":
-      return listSessions({ limit, includeActive: false });
-    case "vault_state":
-      return getStatesForAgent(agentId);
-    default:
-      throw new Error(`Unknown context query tool: "${tool5}"`);
-  }
-}
-
-// src/agent/provider.ts
-var ENV_ANTHROPIC_BASE_URL = "ANTHROPIC_BASE_URL";
-var ENV_ANTHROPIC_AUTH_TOKEN = "ANTHROPIC_AUTH_TOKEN";
-var ENV_ANTHROPIC_API_KEY = "ANTHROPIC_API_KEY";
-var ENV_OLLAMA_NUM_CTX = "OLLAMA_NUM_CTX";
-var DEFAULT_OLLAMA_URL = "http://localhost:11434";
-var DEFAULT_LMSTUDIO_URL = "http://localhost:1234";
-var OLLAMA_AUTH_TOKEN = "ollama";
-var LMSTUDIO_AUTH_TOKEN = "lmstudio";
-function buildPhaseEnv(provider) {
-  if (!provider || provider.type === "anthropic") return void 0;
-  return { ...process.env, ...getProviderEnvVars(provider) };
-}
-function getProviderEnvVars(provider) {
-  switch (provider.type) {
-    case "anthropic":
-      return {};
-    case "ollama":
-      return {
-        [ENV_ANTHROPIC_BASE_URL]: provider.baseUrl ?? DEFAULT_OLLAMA_URL,
-        [ENV_ANTHROPIC_AUTH_TOKEN]: OLLAMA_AUTH_TOKEN,
-        [ENV_ANTHROPIC_API_KEY]: "",
-        ...provider.contextLength ? { [ENV_OLLAMA_NUM_CTX]: String(provider.contextLength) } : {}
-      };
-    case "lmstudio":
-      return {
-        [ENV_ANTHROPIC_BASE_URL]: provider.baseUrl ?? DEFAULT_LMSTUDIO_URL,
-        [ENV_ANTHROPIC_AUTH_TOKEN]: provider.apiKey ?? LMSTUDIO_AUTH_TOKEN,
-        [ENV_ANTHROPIC_API_KEY]: ""
-      };
-    default:
-      return {};
-  }
-}
-
-// src/agent/ollama-context.ts
-import { execFileSync } from "child_process";
-import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-var OLLAMA_PRELOAD_TIMEOUT_MS = 3e4;
-var DEFAULT_OLLAMA_CONTEXT_LENGTH = 32768;
-async function ensureOllamaContextVariant(model, contextLength) {
-  const baseName = model.replace(/:latest$/, "");
-  const variantName = `${baseName}-ctx${contextLength}`;
-  try {
-    execFileSync("ollama", ["show", variantName], { stdio: "ignore" });
-    return variantName;
-  } catch {
-  }
-  try {
-    const modelfilePath = join(tmpdir(), `myco-modelfile-${Date.now()}`);
-    writeFileSync2(modelfilePath, `FROM ${model}
-PARAMETER num_ctx ${contextLength}
-`);
-    execFileSync("ollama", ["create", variantName, "-f", modelfilePath], {
-      stdio: "ignore",
-      timeout: OLLAMA_PRELOAD_TIMEOUT_MS
-    });
-    try {
-      unlinkSync(modelfilePath);
-    } catch {
-    }
-    return variantName;
-  } catch {
-    return model;
-  }
-}
-async function resolveOllamaContextVariants(taskProvider, phaseOverrides, createVariant = ensureOllamaContextVariant) {
-  const seen = /* @__PURE__ */ new Map();
-  const recordOllama = (p) => {
-    if (p?.type !== "ollama" || !p.model) return;
-    const ctx = p.contextLength ?? DEFAULT_OLLAMA_CONTEXT_LENGTH;
-    const set = seen.get(p.model) ?? /* @__PURE__ */ new Set();
-    set.add(ctx);
-    seen.set(p.model, set);
-  };
-  recordOllama(taskProvider);
-  for (const override of Object.values(phaseOverrides)) {
-    recordOllama(override.provider);
-  }
-  if (seen.size === 0) {
-    return { taskProvider, phaseOverrides, conflicts: [] };
-  }
-  const resolvedContext = /* @__PURE__ */ new Map();
-  const conflicts = [];
-  for (const [model, values] of seen) {
-    const sorted = [...values].sort((a, b) => a - b);
-    const max = sorted[sorted.length - 1];
-    resolvedContext.set(model, max);
-    if (sorted.length > 1) {
-      conflicts.push({ model, values: sorted, resolved: max });
-    }
-  }
-  const variantEntries = await Promise.all(
-    [...resolvedContext.entries()].map(async ([model, ctx]) => {
-      const variant = await createVariant(model, ctx);
-      return [model, variant];
-    })
-  );
-  const variantByModel = new Map(variantEntries);
-  const rewriteProvider = (p) => {
-    if (!p) return p;
-    if (p.type !== "ollama" || !p.model) return p;
-    const variant = variantByModel.get(p.model);
-    const resolvedCtx = resolvedContext.get(p.model);
-    if (!variant) return p;
-    return { ...p, model: variant, contextLength: resolvedCtx };
-  };
-  const rewrittenPhaseOverrides = {};
-  for (const [name, override] of Object.entries(phaseOverrides)) {
-    rewrittenPhaseOverrides[name] = {
-      ...override,
-      ...override.provider ? { provider: rewriteProvider(override.provider) } : {}
-    };
-  }
-  return {
-    taskProvider: rewriteProvider(taskProvider),
-    phaseOverrides: rewrittenPhaseOverrides,
-    conflicts
-  };
-}
-
-// src/agent/wave-computation.ts
-import crypto3 from "crypto";
-function computeWaves(phases) {
-  const nameToPhase = new Map(phases.map((p) => [p.name, p]));
-  const inDegree = /* @__PURE__ */ new Map();
-  const dependents = /* @__PURE__ */ new Map();
-  for (const phase of phases) {
-    inDegree.set(phase.name, 0);
-    dependents.set(phase.name, []);
-  }
-  for (const phase of phases) {
-    const deps = phase.dependsOn ?? [];
-    for (const dep of deps) {
-      if (!nameToPhase.has(dep)) continue;
-      inDegree.set(phase.name, (inDegree.get(phase.name) ?? 0) + 1);
-      dependents.get(dep).push(phase.name);
-    }
-  }
-  const waves = [];
-  const completed = /* @__PURE__ */ new Set();
-  while (completed.size < phases.length) {
-    const wave = [];
-    for (const phase of phases) {
-      if (completed.has(phase.name)) continue;
-      if ((inDegree.get(phase.name) ?? 0) === 0) {
-        wave.push(phase);
-      }
-    }
-    if (wave.length === 0) {
-      const remaining = phases.filter((p) => !completed.has(p.name)).map((p) => p.name);
-      throw new Error(`Circular dependency detected among phases: ${remaining.join(", ")}`);
-    }
-    waves.push(wave);
-    for (const phase of wave) {
-      completed.add(phase.name);
-      for (const dependent of dependents.get(phase.name) ?? []) {
-        inDegree.set(dependent, (inDegree.get(dependent) ?? 0) - 1);
-      }
-    }
-  }
-  return waves;
-}
-function phaseSessionId(runId, phaseName) {
-  const hash = crypto3.createHash("sha256").update(`${runId}-${phaseName}`).digest("hex");
-  return [
-    hash.slice(0, 8),
-    hash.slice(8, 12),
-    hash.slice(12, 16),
-    hash.slice(16, 20),
-    hash.slice(20, 32)
-  ].join("-");
-}
-
-// src/agent/executor.ts
-var STATUS_SKIPPED = "skipped";
-var SKIP_REASON_ALREADY_RUNNING = "already_running";
-var PROMPT_SECTION_TASK = "## Task: ";
-var PROMPT_SECTION_INSTRUCTION = "## User Instruction";
-var PROMPT_SECTION_SEPARATOR = "\n\n";
-var MCP_SERVER_NAME = "myco-vault";
-var PERSIST_SESSION = true;
-var PROMPT_SECTION_PRIOR_PHASES = "## Prior Phase Results";
-var PROMPT_SECTION_CURRENT_PHASE = "## Current Phase: ";
-var TOOL_DEBUG_PREVIEW_CHARS = 240;
-function debugToolCallsEnabled() {
-  return process.env.MYCO_AGENT_DEBUG === "1";
-}
-function previewPayload(value) {
-  const str = typeof value === "string" ? value : JSON.stringify(value);
-  if (str === void 0) return "";
-  return str.length > TOOL_DEBUG_PREVIEW_CHARS ? `${str.slice(0, TOOL_DEBUG_PREVIEW_CHARS)}\u2026(${str.length - TOOL_DEBUG_PREVIEW_CHARS} more chars)` : str;
-}
-function logToolUseBlocks(phaseName, message) {
-  if (!debugToolCallsEnabled()) return;
-  const blocks = message.message?.content;
-  if (!Array.isArray(blocks)) return;
-  for (const block of blocks) {
-    if (block.type === "tool_use") {
-      console.log(
-        `[agent:debug] ${phaseName} tool_use: ${block.name ?? "unknown"} input=${previewPayload(block.input)}`
-      );
-    }
-  }
-}
-function logToolResultBlocks(phaseName, message) {
-  if (!debugToolCallsEnabled()) return;
-  const blocks = message.message?.content;
-  if (!Array.isArray(blocks)) return;
-  for (const block of blocks) {
-    if (block.type === "tool_result") {
-      const flag = block.is_error ? " [ERROR]" : "";
-      console.log(
-        `[agent:debug] ${phaseName} tool_result${flag}: ${previewPayload(block.content)}`
-      );
-    }
-  }
-}
-function abortReasonMessage(abortController) {
-  if (!abortController?.signal.aborted) return null;
-  const reason = abortController.signal.reason;
-  if (reason instanceof Error) return reason.message;
-  if (typeof reason === "string" && reason.length > 0) return reason;
-  return "Agent run aborted";
-}
-function composeTaskPrompt(vaultContext, taskDisplayName, taskPrompt, instruction) {
-  const sessionIdMatch = instruction?.match(/\b([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\b/i);
-  const sessionId = sessionIdMatch?.[1] ?? "";
-  let resolvedPrompt = taskPrompt;
-  resolvedPrompt = resolvedPrompt.replace(/\{\{session_id\}\}/g, sessionId);
-  resolvedPrompt = resolvedPrompt.replace(/\{\{instruction\}\}/g, instruction ?? "");
-  const parts = [
-    vaultContext,
-    `${PROMPT_SECTION_TASK}${taskDisplayName}
-${resolvedPrompt}`
-  ];
-  if (instruction) {
-    parts.push(`${PROMPT_SECTION_INSTRUCTION}
-${instruction}`);
-  }
-  return parts.join(PROMPT_SECTION_SEPARATOR);
-}
-function composePhasePrompt(vaultContext, taskDisplayName, taskOverview, phase, priorPhaseResults, instruction) {
-  const parts = [
-    vaultContext,
-    `${PROMPT_SECTION_TASK}${taskDisplayName}
-${taskOverview}`
-  ];
-  if (instruction) {
-    parts.push(`${PROMPT_SECTION_INSTRUCTION}
-${instruction}`);
-  }
-  if (priorPhaseResults.length > 0 && !phase.skipPriorContext) {
-    const summaries = priorPhaseResults.map((pr) => {
-      const truncated = pr.summary.length > PHASE_SUMMARY_MAX_CHARS ? pr.summary.slice(0, PHASE_SUMMARY_MAX_CHARS) + "..." : pr.summary;
-      return `### ${pr.name} (${pr.status})
-${truncated}`;
-    });
-    parts.push(`${PROMPT_SECTION_PRIOR_PHASES}
-${summaries.join("\n\n")}`);
-  }
-  parts.push(`${PROMPT_SECTION_CURRENT_PHASE}${phase.name}
-${phase.prompt}`);
-  return parts.join(PROMPT_SECTION_SEPARATOR);
-}
-async function executePhase(query, phasePrompt, phaseModel, systemPrompt, toolServer, phase, env, sessionId, abortController) {
-  let phaseCost = 0;
-  let phaseTokens = 0;
-  let phaseTurns = 0;
-  let agenticTurns = 0;
-  let phaseSummary = "";
-  try {
-    for await (const message of query({
-      prompt: phasePrompt,
-      options: {
-        model: phaseModel,
-        systemPrompt,
-        mcpServers: { [MCP_SERVER_NAME]: toolServer },
-        strictMcpConfig: true,
-        maxTurns: phase.maxTurns,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        persistSession: PERSIST_SESSION,
-        env,
-        tools: [],
-        ...sessionId ? { sessionId } : {},
-        ...abortController ? { abortController } : {}
-      }
-    })) {
-      if (message.type === "assistant") {
-        agenticTurns++;
-        logToolUseBlocks(phase.name, message);
-      }
-      if (message.type === "user") {
-        logToolResultBlocks(phase.name, message);
-      }
-      if (message.type === "result") {
-        phaseCost = message.total_cost_usd ?? 0;
-        phaseTokens = (message.usage.input_tokens ?? 0) + (message.usage.output_tokens ?? 0);
-        phaseTurns = message.num_turns ?? 0;
-        if ("result" in message && typeof message.result === "string") {
-          phaseSummary = message.result;
-        }
-      }
-    }
-    if (phase.maxTurns) {
-      console.log(
-        `[agent] Phase "${phase.name}": num_turns=${phaseTurns}, assistant_msgs=${agenticTurns}, budget=${phase.maxTurns}`
-      );
-    }
-    if (phase.required && phaseTurns === 0) {
-      console.warn(`[agent] Required phase "${phase.name}" produced 0 turns`);
-    }
-    return {
-      name: phase.name,
-      status: "completed",
-      turnsUsed: phaseTurns,
-      tokensUsed: phaseTokens,
-      costUsd: phaseCost,
-      summary: phaseSummary
-    };
-  } catch (err) {
-    const abortReason = abortReasonMessage(abortController);
-    return {
-      name: phase.name,
-      status: "failed",
-      turnsUsed: phaseTurns,
-      tokensUsed: phaseTokens,
-      costUsd: phaseCost,
-      summary: abortReason ? `Error: ${abortReason}` : `Error: ${errorMessage(err)}`
-    };
-  }
-}
-async function executeSingleQuery(config, systemPrompt, taskPrompt, agentId, runId, provider, embeddingManager, abortController, vaultDir) {
-  const { query } = await import("@anthropic-ai/claude-agent-sdk");
-  const toolServer = createVaultToolServer(agentId, runId, { embeddingManager, vaultDir });
-  const baseEnv = buildPhaseEnv(provider);
-  const env = { ...baseEnv ?? process.env, MYCO_AGENT_SESSION: "1" };
-  const effectiveModel = provider?.model ?? config.model;
-  let resultCostUsd = 0;
-  let resultTokens = 0;
-  for await (const message of query({
-    prompt: taskPrompt,
-    options: {
-      model: effectiveModel,
-      systemPrompt,
-      mcpServers: { [MCP_SERVER_NAME]: toolServer },
-      strictMcpConfig: true,
-      maxTurns: config.maxTurns,
-      permissionMode: "bypassPermissions",
-      allowDangerouslySkipPermissions: true,
-      persistSession: PERSIST_SESSION,
-      env,
-      tools: [],
-      ...abortController ? { abortController } : {}
-    }
-  })) {
-    if (message.type === "result") {
-      resultCostUsd = message.total_cost_usd ?? 0;
-      resultTokens = (message.usage.input_tokens ?? 0) + (message.usage.output_tokens ?? 0);
-    }
-  }
-  return { tokensUsed: resultTokens, costUsd: resultCostUsd };
-}
-async function executePhasedQuery(config, systemPrompt, vaultContext, agentId, runId, taskProviderOverride, phaseProviderOverrides, instruction, embeddingManager, abortController, projectRoot, vaultDir) {
-  const { query } = await import("@anthropic-ai/claude-agent-sdk");
-  const phases = config.phases;
-  const phaseResults = [];
-  let totalTokens = 0;
-  let totalCost = 0;
-  let runningTurnCount = 0;
-  let effectivePhases = [...phases];
-  if (config.orchestrator?.enabled) {
-    const contextQueries = config.contextQueries ? Object.values(config.contextQueries).flat() : [];
-    const contextResults = contextQueries.length > 0 ? await executeContextQueries(agentId, contextQueries) : [];
-    const orchestratorPrompt = composeOrchestratorPrompt(vaultContext, phases, contextResults);
-    const orchestratorModel = config.orchestrator.model ?? config.model;
-    const orchestratorMaxTurns = config.orchestrator.maxTurns ?? DEFAULT_ORCHESTRATOR_MAX_TURNS;
-    const orchestratorEnv = { ...buildPhaseEnv(taskProviderOverride) ?? process.env, MYCO_AGENT_SESSION: "1" };
-    let planResponse = "";
-    for await (const message of query({
-      prompt: orchestratorPrompt,
-      options: {
-        model: orchestratorModel,
-        maxTurns: orchestratorMaxTurns,
-        permissionMode: "bypassPermissions",
-        allowDangerouslySkipPermissions: true,
-        persistSession: PERSIST_SESSION,
-        strictMcpConfig: true,
-        env: orchestratorEnv,
-        tools: []
-      }
-    })) {
-      if (message.type === "result" && "result" in message && typeof message.result === "string") {
-        planResponse = message.result;
-      }
-    }
-    const plan = parseOrchestratorPlan(planResponse, phases);
-    effectivePhases = applyDirectives(phases, plan.phases);
-  }
-  const declarationOrder = new Map(phases.map((p, i) => [p.name, i]));
-  const waves = computeWaves(effectivePhases);
-  for (const wave of waves) {
-    const executions = wave.map((phase, indexInWave) => {
-      const phasePrompt = composePhasePrompt(
-        vaultContext,
-        config.taskDisplayName,
-        config.taskPrompt,
-        phase,
-        phaseResults,
-        instruction
-      );
-      const phaseOverride = phaseProviderOverrides?.[phase.name];
-      const effectiveMaxTurns = phaseOverride?.maxTurns ?? phase.maxTurns;
-      const phaseModel = phase.model ?? phaseOverride?.provider?.model ?? taskProviderOverride?.model ?? config.model;
-      const toolServer = createScopedVaultToolServer(
-        agentId,
-        runId,
-        phase.tools,
-        {
-          turnOffset: runningTurnCount + indexInWave * effectiveMaxTurns,
-          embeddingManager,
-          projectRoot,
-          vaultDir,
-          readOnly: phase.readOnly
-        }
-      );
-      const phaseProvider = phase.provider ?? phaseOverride?.provider ?? taskProviderOverride ?? config.execution?.provider;
-      const baseEnv = buildPhaseEnv(phaseProvider);
-      const env = { ...baseEnv ?? process.env, MYCO_AGENT_SESSION: "1" };
-      const sessionId = phaseSessionId(runId, phase.name);
-      const effectivePhase = effectiveMaxTurns !== phase.maxTurns ? { ...phase, maxTurns: effectiveMaxTurns } : phase;
-      return executePhase(query, phasePrompt, phaseModel, systemPrompt, toolServer, effectivePhase, env, sessionId, abortController);
-    });
-    const settled = await Promise.allSettled(executions);
-    const waveResults = settled.map((outcome, i) => {
-      if (outcome.status === "fulfilled") {
-        return outcome.value;
-      }
-      return {
-        name: wave[i].name,
-        status: "failed",
-        turnsUsed: 0,
-        tokensUsed: 0,
-        costUsd: 0,
-        summary: `Error: ${errorMessage(outcome.reason)}`
-      };
-    });
-    waveResults.sort(
-      (a, b) => (declarationOrder.get(a.name) ?? 0) - (declarationOrder.get(b.name) ?? 0)
-    );
-    for (const result of waveResults) {
-      phaseResults.push(result);
-      totalTokens += result.tokensUsed;
-      totalCost += result.costUsd;
-      runningTurnCount += result.turnsUsed;
-    }
-    const shouldStop = wave.some((phase, i) => {
-      if (!phase.required) return false;
-      const outcome = settled[i];
-      if (outcome.status === "rejected") return true;
-      return outcome.value.status === "failed";
-    });
-    if (shouldStop) {
-      break;
-    }
-  }
-  return { tokensUsed: totalTokens, costUsd: totalCost, phases: phaseResults };
-}
-async function runAgent(vaultDir, options) {
-  const db = initDatabase(vaultDbPath(vaultDir));
-  createSchema(db);
-  const agentId = options?.agentId ?? DEFAULT_AGENT_ID;
-  const requestedTask = options?.task;
-  {
-    const effectiveTask = requestedTask ?? getDefaultTask(agentId)?.id;
-    if (effectiveTask) {
-      const runningId = getRunningRunForTask(agentId, effectiveTask);
-      if (runningId) {
-        return {
-          runId: runningId,
-          status: STATUS_SKIPPED,
-          reason: SKIP_REASON_ALREADY_RUNNING
-        };
-      }
-    }
-  }
-  const {
-    config,
-    definitionsDir,
-    taskProviderOverride: resolvedTaskProvider,
-    phaseProviderOverrides: resolvedPhaseOverrides
-  } = resolveRunConfig(agentId, requestedTask, vaultDir);
-  let taskProviderOverride = resolvedTaskProvider;
-  let phaseProviderOverrides = resolvedPhaseOverrides;
-  const runId = options?.resumeRunId ?? crypto4.randomUUID();
-  const now = epochSeconds();
-  if (!options?.resumeRunId) {
-    insertRun({
-      id: runId,
-      agent_id: agentId,
-      task: config.taskName,
-      instruction: options?.instruction ?? null,
-      status: STATUS_RUNNING,
-      started_at: now
-    });
-  }
-  const systemPrompt = loadSystemPrompt(definitionsDir, config.systemPromptPath);
-  const vaultContext = buildVaultContext(agentId);
-  const effectiveProvider = taskProviderOverride ?? config.execution?.provider;
-  const effectiveModel = effectiveProvider?.model ?? config.model;
-  const runMeta = {
-    model: effectiveModel,
-    provider: effectiveProvider?.type ?? "anthropic",
-    ...effectiveProvider?.baseUrl ? { baseUrl: effectiveProvider.baseUrl } : {}
-  };
-  {
-    const resolved = await resolveOllamaContextVariants(
-      taskProviderOverride,
-      phaseProviderOverrides
-    );
-    taskProviderOverride = resolved.taskProvider;
-    phaseProviderOverrides = resolved.phaseOverrides;
-    for (const conflict of resolved.conflicts) {
-      console.warn(
-        `[agent] Ollama model "${conflict.model}" referenced with conflicting context_length values [${conflict.values.join(", ")}] \u2014 reconciled to ${conflict.resolved} to avoid loading multiple variants. Configure one value per model to silence this warning.`
-      );
-    }
-  }
-  const taskAbortController = new AbortController();
-  const timeoutMs = config.timeoutSeconds * MS_PER_SECOND;
-  const timeoutId = setTimeout(() => {
-    console.warn(`[agent] Run ${runId} exceeded timeout (${config.timeoutSeconds}s), aborting`);
-    taskAbortController.abort(new Error(`Agent run timed out after ${config.timeoutSeconds} seconds`));
-  }, timeoutMs);
-  timeoutId.unref?.();
-  let phaseResults;
-  try {
-    let tokensUsed;
-    let costUsd;
-    if (config.phases && config.phases.length > 0) {
-      const projectRoot = resolve2(vaultDir, "..");
-      const result = await executePhasedQuery(
-        config,
-        systemPrompt,
-        vaultContext,
-        agentId,
-        runId,
-        taskProviderOverride,
-        phaseProviderOverrides,
-        options?.instruction,
-        options?.embeddingManager,
-        taskAbortController,
-        projectRoot,
-        vaultDir
-      );
-      tokensUsed = result.tokensUsed;
-      costUsd = result.costUsd;
-      phaseResults = result.phases;
-      const requiredPhaseNames = new Set(
-        config.phases.filter((p) => p.required).map((p) => p.name)
-      );
-      const failedRequired = phaseResults.find(
-        (p) => p.status === "failed" && requiredPhaseNames.has(p.name)
-      );
-      if (failedRequired) {
-        throw new Error(
-          `Required phase "${failedRequired.name}" failed: ${failedRequired.summary}`
-        );
-      }
-    } else {
-      const taskPrompt = composeTaskPrompt(
-        vaultContext,
-        config.taskDisplayName,
-        config.taskPrompt,
-        options?.instruction
-      );
-      const singleProvider = taskProviderOverride ?? config.execution?.provider;
-      const result = await executeSingleQuery(
-        config,
-        systemPrompt,
-        taskPrompt,
-        agentId,
-        runId,
-        singleProvider,
-        options?.embeddingManager,
-        taskAbortController,
-        vaultDir
-      );
-      tokensUsed = result.tokensUsed;
-      costUsd = result.costUsd;
-    }
-    clearTimeout(timeoutId);
-    const completedAt = epochSeconds();
-    updateRunStatus(runId, STATUS_COMPLETED, {
-      completed_at: completedAt,
-      tokens_used: tokensUsed,
-      cost_usd: costUsd,
-      actions_taken: JSON.stringify({ ...runMeta, ...phaseResults ? { phases: phaseResults } : {} })
-    });
-    return {
-      runId,
-      status: STATUS_COMPLETED,
-      tokensUsed,
-      costUsd,
-      ...phaseResults ? { phases: phaseResults } : {}
-    };
-  } catch (err) {
-    clearTimeout(timeoutId);
-    let errorMessage2;
-    if (err instanceof Error) {
-      errorMessage2 = err.message || err.constructor.name || "Error (no message)";
-      if (err.stack) errorMessage2 += `
-${err.stack.split("\n").slice(0, 3).join("\n")}`;
-    } else if (typeof err === "string") {
-      errorMessage2 = err || "Empty string error";
-    } else {
-      try {
-        errorMessage2 = JSON.stringify(err);
-      } catch {
-        errorMessage2 = "Unserializable error";
-      }
-    }
-    const failedAt = epochSeconds();
-    console.error(`[agent] Run ${runId} failed: ${errorMessage2}`);
-    try {
-      updateRunStatus(runId, STATUS_FAILED, {
-        completed_at: failedAt,
-        error: errorMessage2,
-        // Preserve phase results collected before the failure
-        actions_taken: JSON.stringify({ ...runMeta, ...phaseResults ? { phases: phaseResults } : {} })
-      });
-    } catch (dbErr) {
-      console.error(`[agent] Failed to save error to DB:`, dbErr);
-    }
-    await cleanupOnTaskFailure({
-      taskName: config.taskName,
-      vaultDir,
-      runContext: options?.runContext
-    });
-    return {
-      runId,
-      status: STATUS_FAILED,
-      error: errorMessage2,
-      ...phaseResults ? { phases: phaseResults } : {}
-    };
-  }
-}
-async function cleanupOnTaskFailure(args) {
-  if (args.taskName !== SKILL_GENERATE_TASK) return;
-  if (!args.vaultDir) return;
-  const candidateId = args.runContext?.candidate_id;
-  if (!candidateId) return;
-  try {
-    const { cleanupStagedSkill: cleanupStagedSkill2 } = await import("./skill-staging-SWM7UC5D.js");
-    cleanupStagedSkill2(args.vaultDir, candidateId);
-    console.warn(
-      `[agent] skill-generate failed \u2014 cleaned up staging for candidate ${candidateId}`
-    );
-  } catch (cleanupErr) {
-    console.warn(
-      `[agent] Failed to clean staging for candidate ${candidateId}:`,
-      cleanupErr instanceof Error ? cleanupErr.message : cleanupErr
-    );
-  }
-}
-export {
-  cleanupOnTaskFailure,
-  composePhasePrompt,
-  composeTaskPrompt,
-  computeWaves,
-  runAgent
-};
-//# sourceMappingURL=executor-HWW2QNZQ.js.map