@goondocks/myco 0.6.4 → 0.9.0

package/dist/executor-ONSDHPGX.js

@@ -0,0 +1,1441 @@
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  insertResolutionEvent
+} from "./chunk-YDN4OM33.js";
+import {
+  STATUS_COMPLETED,
+  STATUS_FAILED,
+  STATUS_RUNNING,
+  createSporeLineage,
+  errorMessage,
+  getRunningRun,
+  getUnprocessedBatches,
+  insertEntity,
+  insertGraphEdge,
+  insertReport,
+  insertRun,
+  insertTurn,
+  listDigestExtracts,
+  listEntities,
+  listGraphEdges,
+  markBatchProcessed,
+  updateRunStatus,
+  upsertDigestExtract
+} from "./chunk-OXZSXYAT.js";
+import {
+  fullTextSearch
+} from "./chunk-PT5IC642.js";
+import {
+  loadAllTasks
+} from "./chunk-BUSP3OJB.js";
+import {
+  getAgent,
+  getDefaultTask,
+  getTask,
+  loadAgentDefinition,
+  loadSystemPrompt,
+  resolveDefinitionsDir,
+  resolveEffectiveConfig
+} from "./chunk-JMJJEQ3P.js";
+import "./chunk-IB76KGBY.js";
+import {
+  DEFAULT_IMPORTANCE,
+  insertSpore,
+  listSpores,
+  updateSporeStatus
+} from "./chunk-3K5WGSJ4.js";
+import {
+  listSessions,
+  updateSession
+} from "./chunk-4LPQ26CK.js";
+import {
+  createSchema
+} from "./chunk-KV4OC4H3.js";
+import {
+  loadConfig
+} from "./chunk-MHSCMET3.js";
+import "./chunk-D7TYRPRM.js";
+import "./chunk-E4VLWIJC.js";
+import {
+  external_exports
+} from "./chunk-KH64DHOY.js";
+import {
+  getDatabase,
+  initDatabase,
+  vaultDbPath
+} from "./chunk-MYX5NCRH.js";
+import {
+  DEFAULT_AGENT_ID,
+  MS_PER_SECOND,
+  PHASE_SUMMARY_MAX_CHARS,
+  SEARCH_SIMILARITY_THRESHOLD,
+  epochSeconds
+} from "./chunk-5VZ52A4T.js";
+import "./chunk-WGTCA2NU.js";
+import {
+  getPluginVersion
+} from "./chunk-PB6TOLRQ.js";
+import {
+  findPackageRoot
+} from "./chunk-LPUQPDC2.js";
+import "./chunk-PZUWP5VK.js";
+
+// src/agent/executor.ts
+import crypto2 from "crypto";
+
+// src/agent/tools.ts
+import crypto from "crypto";
+import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+
+// src/db/queries/agent-state.ts
+var STATE_COLUMNS = [
+  "agent_id",
+  "key",
+  "value",
+  "updated_at"
+];
+var SELECT_COLUMNS = STATE_COLUMNS.join(", ");
+function toAgentStateRow(row) {
+  return {
+    agent_id: row.agent_id,
+    key: row.key,
+    value: row.value,
+    updated_at: row.updated_at
+  };
+}
+function setState(agentId, key, value, updatedAt) {
+  const db = getDatabase();
+  db.prepare(
+    `INSERT INTO agent_state (agent_id, key, value, updated_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT (agent_id, key) DO UPDATE SET
+       value      = EXCLUDED.value,
+       updated_at = EXCLUDED.updated_at`
+  ).run(agentId, key, value, updatedAt);
+  return toAgentStateRow(
+    db.prepare(`SELECT ${SELECT_COLUMNS} FROM agent_state WHERE agent_id = ? AND key = ?`).get(agentId, key)
+  );
+}
+function getStatesForAgent(agentId) {
+  const db = getDatabase();
+  const rows = db.prepare(
+    `SELECT ${SELECT_COLUMNS}
+     FROM agent_state
+     WHERE agent_id = ?
+     ORDER BY key ASC`
+  ).all(agentId);
+  return rows.map(toAgentStateRow);
+}
+
+// src/agent/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 textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager) {
+  let turnCounter = turnOffset;
+  function recordTurn(toolName, toolInput) {
+    turnCounter++;
+    try {
+      insertTurn({
+        run_id: runId,
+        agent_id: agentId,
+        turn_number: turnCounter,
+        tool_name: toolName,
+        tool_input: JSON.stringify(toolInput),
+        started_at: epochSeconds()
+      });
+    } catch {
+    }
+  }
+  const vaultUnprocessed = tool(
+    "vault_unprocessed",
+    "Get unprocessed prompt batches, ordered by id ASC. Supports cursor-based pagination.",
+    {
+      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")
+    },
+    async (args) => {
+      recordTurn("vault_unprocessed", args);
+      const batches = getUnprocessedBatches({
+        after_id: args.after_id,
+        limit: args.limit ?? DEFAULT_UNPROCESSED_LIMIT
+      });
+      return textResult(batches);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+  const vaultSpores = tool(
+    "vault_spores",
+    "List spores with optional filters (agent, observation type, status, session).",
+    {
+      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"),
+      limit: external_exports.number().optional().describe("Maximum number of spores to return")
+    },
+    async (args) => {
+      recordTurn("vault_spores", args);
+      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
+      });
+      return textResult(spores);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+  const vaultSessions = tool(
+    "vault_sessions",
+    "List sessions with optional status filter, ordered by created_at DESC.",
+    {
+      limit: external_exports.number().optional().describe("Maximum number of sessions to return"),
+      status: external_exports.string().optional().describe("Filter by status (active, completed)")
+    },
+    async (args) => {
+      recordTurn("vault_sessions", args);
+      const sessions = listSessions({
+        limit: args.limit ?? DEFAULT_SESSIONS_LIMIT,
+        status: args.status
+      });
+      return textResult(sessions);
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+  const vaultSearchFts = tool(
+    "vault_search_fts",
+    "Full-text search across prompt batches and activities using FTS5. Best for finding specific text, keywords, or session content. Does NOT search spores or entities.",
+    {
+      query: external_exports.string().describe("Search query text"),
+      type: external_exports.string().optional().describe("Restrict to a result type (prompt_batch, activity)"),
+      limit: external_exports.number().optional().describe("Maximum number of results to return")
+    },
+    async (args) => {
+      recordTurn("vault_search_fts", args);
+      try {
+        const results = fullTextSearch(args.query, {
+          type: args.type,
+          limit: args.limit ?? DEFAULT_SEARCH_LIMIT
+        });
+        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). Best for finding conceptually related content. Returns results ranked by similarity score.",
+    {
+      query: external_exports.string().describe("Search query text"),
+      namespace: external_exports.string().optional().describe("Restrict to a content type: spores, sessions"),
+      limit: external_exports.number().optional().describe("Maximum results to return")
+    },
+    async (args) => {
+      recordTurn("vault_search_semantic", 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 results = embeddingManager.searchVectors(queryVector, {
+          namespace: args.namespace,
+          limit: args.limit ?? DEFAULT_SEARCH_LIMIT,
+          threshold: SEARCH_SIMILARITY_THRESHOLD
+        });
+        return textResult({ results });
+      } catch {
+        return textResult({ results: [], message: "Semantic search unavailable" });
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+  const vaultState = tool(
+    "vault_state",
+    "Get all state key-value pairs for the current agent.",
+    {},
+    async () => {
+      recordTurn("vault_state", {});
+      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) => {
+      recordTurn("vault_entities", 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) => {
+      recordTurn("vault_edges", 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 } }
+  );
+  const vaultCreateSpore = tool(
+    "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,
+        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(() => {
+      });
+      recordTurn("vault_create_spore", args);
+      return textResult(spore);
+    }
+  );
+  const vaultCreateEntity = tool(
+    "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,
+        type: args.type,
+        name: args.name,
+        properties: props,
+        first_seen: now,
+        last_seen: now
+      });
+      recordTurn("vault_create_entity", args);
+      return textResult(entity);
+    }
+  );
+  const vaultCreateEdge = tool(
+    "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,
+        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
+      });
+      recordTurn("vault_create_edge", args);
+      return textResult(edge);
+    }
+  );
+  const vaultResolveSpore = tool(
+    "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,
+        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 {
+        }
+      }
+      recordTurn("vault_resolve_spore", args);
+      return textResult({ spore: updatedSpore, resolution_event_id: eventId });
+    }
+  );
+  const vaultUpdateSession = tool(
+    "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(() => {
+        });
+      }
+      recordTurn("vault_update_session", args);
+      return textResult(session);
+    }
+  );
+  const vaultSetState = tool(
+    "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);
+      recordTurn("vault_set_state", args);
+      return textResult(state);
+    }
+  );
+  const vaultReadDigest = tool(
+    "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) => {
+      recordTurn("vault_read_digest", 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 = tool(
+    "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
+      });
+      recordTurn("vault_write_digest", args);
+      return textResult(extract);
+    }
+  );
+  const vaultMarkProcessed = tool(
+    "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);
+      recordTurn("vault_mark_processed", args);
+      return textResult(batch);
+    }
+  );
+  const vaultReport = tool(
+    "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) => {
+      recordTurn("vault_report", 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);
+    }
+  );
+  return [
+    vaultUnprocessed,
+    vaultSpores,
+    vaultSessions,
+    vaultSearchFts,
+    vaultSearchSemantic,
+    vaultState,
+    vaultEntities,
+    vaultEdges,
+    vaultCreateSpore,
+    vaultCreateEntity,
+    vaultCreateEdge,
+    vaultResolveSpore,
+    vaultUpdateSession,
+    vaultSetState,
+    vaultReadDigest,
+    vaultWriteDigest,
+    vaultMarkProcessed,
+    vaultReport
+  ];
+}
+function createVaultToolServer(agentId, runId, embeddingManager) {
+  const tools = createVaultTools(agentId, runId, 0, embeddingManager);
+  return createSdkMcpServer({
+    name: "myco-vault",
+    version: getPluginVersion(),
+    tools
+  });
+}
+function createScopedVaultToolServer(agentId, runId, toolNames, turnOffset = 0, embeddingManager) {
+  const allTools = createVaultTools(agentId, runId, turnOffset, embeddingManager);
+  const nameSet = new Set(toolNames);
+  const scopedTools = allTools.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(tool2) {
+  if (!KNOWN_CONTEXT_QUERY_TOOLS.has(tool2)) {
+    throw new Error(`Unknown context query tool: "${tool2}"`);
+  }
+}
+async function executeQuery(agentId, tool2, limit) {
+  switch (tool2) {
+    case "vault_unprocessed":
+      return getUnprocessedBatches({ limit });
+    case "vault_spores":
+      return listSpores({ agent_id: agentId, limit });
+    case "vault_sessions":
+      return listSessions({ limit });
+    case "vault_state":
+      return getStatesForAgent(agentId);
+    default:
+      throw new Error(`Unknown context query tool: "${tool2}"`);
+  }
+}
+
+// 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 === "cloud") return void 0;
+  return { ...process.env, ...getProviderEnvVars(provider) };
+}
+function getProviderEnvVars(provider) {
+  switch (provider.type) {
+    case "cloud":
+      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/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: ";
+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);
+}
+var OLLAMA_PRELOAD_TIMEOUT_MS = 3e4;
+async function ensureOllamaContextVariant(model, contextLength) {
+  const { execFileSync } = await import("child_process");
+  const { writeFileSync, unlinkSync } = await import("fs");
+  const { tmpdir } = await import("os");
+  const { join } = await import("path");
+  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()}`);
+    writeFileSync(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;
+  }
+}
+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 = crypto2.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("-");
+}
+async function executePhase(query, phasePrompt, phaseModel, systemPrompt, toolServer, phase, env, sessionId, abortController) {
+  let phaseCost = 0;
+  let phaseTokens = 0;
+  let phaseTurns = 0;
+  let phaseSummary = "";
+  try {
+    for await (const message of query({
+      prompt: phasePrompt,
+      options: {
+        model: phaseModel,
+        systemPrompt,
+        mcpServers: { [MCP_SERVER_NAME]: toolServer },
+        maxTurns: phase.maxTurns,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        persistSession: PERSIST_SESSION,
+        env,
+        tools: [],
+        ...sessionId ? { sessionId } : {},
+        ...abortController ? { abortController } : {}
+      }
+    })) {
+      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.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) {
+    return {
+      name: phase.name,
+      status: "failed",
+      turnsUsed: phaseTurns,
+      tokensUsed: phaseTokens,
+      costUsd: phaseCost,
+      summary: `Error: ${errorMessage(err)}`
+    };
+  }
+}
+async function executeSingleQuery(config, systemPrompt, taskPrompt, agentId, runId, provider, embeddingManager, abortController) {
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const toolServer = createVaultToolServer(agentId, runId, embeddingManager);
+  const env = buildPhaseEnv(provider);
+  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 },
+      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) {
+  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;
+    let planResponse = "";
+    for await (const message of query({
+      prompt: orchestratorPrompt,
+      options: {
+        model: orchestratorModel,
+        maxTurns: orchestratorMaxTurns,
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        persistSession: PERSIST_SESSION,
+        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,
+        runningTurnCount + indexInWave * effectiveMaxTurns,
+        embeddingManager
+      );
+      const phaseProvider = phase.provider ?? phaseOverride?.provider ?? taskProviderOverride ?? config.execution?.provider;
+      const env = buildPhaseEnv(phaseProvider);
+      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 running = getRunningRun(agentId);
+  if (running) {
+    return {
+      runId: running.id,
+      status: STATUS_SKIPPED,
+      reason: SKIP_REASON_ALREADY_RUNNING
+    };
+  }
+  const definitionsDir = resolveDefinitionsDir();
+  const definition = loadAgentDefinition(definitionsDir);
+  const agentRow = getAgent(agentId);
+  const taskRow = options?.task ? getTask(options.task) : getDefaultTask(agentId);
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const taskName = taskRow?.id ?? options?.task;
+  const yamlTask = taskName ? allTasks.get(taskName) : void 0;
+  const taskOverrides = taskRow ? {
+    name: taskRow.id,
+    displayName: taskRow.display_name ?? taskRow.id,
+    description: taskRow.description ?? "",
+    agent: taskRow.agent_id,
+    prompt: taskRow.prompt,
+    isDefault: taskRow.is_default === 1,
+    ...taskRow.tool_overrides ? { toolOverrides: JSON.parse(taskRow.tool_overrides) } : {},
+    // Scalar config from YAML (model, turns, timeout) — DB doesn't store these
+    ...yamlTask?.model ? { model: yamlTask.model } : {},
+    ...yamlTask?.maxTurns ? { maxTurns: yamlTask.maxTurns } : {},
+    ...yamlTask?.timeoutSeconds ? { timeoutSeconds: yamlTask.timeoutSeconds } : {},
+    // Structural config from YAML
+    ...yamlTask?.phases ? { phases: yamlTask.phases } : {},
+    ...yamlTask?.execution ? { execution: yamlTask.execution } : {},
+    ...yamlTask?.contextQueries ? { contextQueries: yamlTask.contextQueries } : {},
+    ...yamlTask?.orchestrator ? { orchestrator: yamlTask.orchestrator } : {}
+  } : void 0;
+  const config = resolveEffectiveConfig(definition, agentRow, taskOverrides);
+  let taskProviderOverride;
+  let phaseProviderOverrides = {};
+  try {
+    const mycoConfig = loadConfig(vaultDir);
+    const toProviderConfig = (p) => ({
+      type: p.type,
+      baseUrl: p.base_url,
+      model: p.model,
+      contextLength: p.context_length
+    });
+    const taskConfig = taskName ? mycoConfig.agent.tasks?.[taskName] : void 0;
+    const globalProvider = mycoConfig.agent.provider;
+    if (taskConfig?.provider) {
+      taskProviderOverride = toProviderConfig(taskConfig.provider);
+    } else if (globalProvider) {
+      taskProviderOverride = toProviderConfig(globalProvider);
+    }
+    if (taskConfig?.phases) {
+      for (const [phaseName, phaseConfig] of Object.entries(taskConfig.phases)) {
+        phaseProviderOverrides[phaseName] = {
+          ...phaseConfig.provider ? { provider: toProviderConfig(phaseConfig.provider) } : {},
+          ...phaseConfig.maxTurns != null ? { maxTurns: phaseConfig.maxTurns } : {}
+        };
+      }
+    }
+  } catch {
+  }
+  const runId = options?.resumeRunId ?? crypto2.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 ?? "cloud",
+    ...effectiveProvider?.baseUrl ? { baseUrl: effectiveProvider.baseUrl } : {}
+  };
+  if (effectiveProvider?.type === "ollama" && effectiveProvider.contextLength && effectiveProvider.model) {
+    const variantModel = await ensureOllamaContextVariant(
+      effectiveProvider.model,
+      effectiveProvider.contextLength
+    );
+    taskProviderOverride = { ...taskProviderOverride, model: variantModel };
+  }
+  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();
+  }, timeoutMs);
+  timeoutId.unref?.();
+  let phaseResults;
+  try {
+    let tokensUsed;
+    let costUsd;
+    if (config.phases && config.phases.length > 0) {
+      const result = await executePhasedQuery(
+        config,
+        systemPrompt,
+        vaultContext,
+        agentId,
+        runId,
+        taskProviderOverride,
+        phaseProviderOverrides,
+        options?.instruction,
+        options?.embeddingManager,
+        taskAbortController
+      );
+      tokensUsed = result.tokensUsed;
+      costUsd = result.costUsd;
+      phaseResults = result.phases;
+    } 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
+      );
+      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);
+    }
+    return {
+      runId,
+      status: STATUS_FAILED,
+      error: errorMessage2,
+      ...phaseResults ? { phases: phaseResults } : {}
+    };
+  }
+}
+export {
+  composePhasePrompt,
+  composeTaskPrompt,
+  computeWaves,
+  runAgent
+};
+//# sourceMappingURL=executor-ONSDHPGX.js.map