@goondocks/myco 0.14.4 → 0.15.1

package/dist/{executor-HKNINUWO.js → executor-4OXDK4ZA.js}

@@ -30,13 +30,13 @@ import {
   updateRunStatus,
   updateSkillRecord,
   upsertDigestExtract
-} from "./chunk-JJXVDCEX.js";
+} from "./chunk-75J2BR4P.js";
 import {
   fullTextSearch
 } from "./chunk-DTE3SHYK.js";
 import {
   loadAllTasks
-} from "./chunk-KNTJOMWY.js";
+} from "./chunk-3MEOYXOW.js";
 import {
   getAgent,
   getDefaultTask,
@@ -45,31 +45,31 @@ import {
   loadSystemPrompt,
   resolveDefinitionsDir,
   resolveEffectiveConfig
-} from "./chunk-NVCGF2DS.js";
+} from "./chunk-X4XFJG6I.js";
 import {
   insertTurn
 } from "./chunk-QLCD77AN.js";
 import {
   insertResolutionEvent
-} from "./chunk-TVV6PZOC.js";
+} from "./chunk-Z7TZJ2SP.js";
 import "./chunk-IB76KGBY.js";
 import {
   DEFAULT_IMPORTANCE,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-PX5KIOKY.js";
+} from "./chunk-SPJGJEFV.js";
 import {
   listSessions,
   updateSession
-} from "./chunk-X34OFKYU.js";
-import "./chunk-S66YG6QK.js";
+} from "./chunk-23FJUKCN.js";
+import "./chunk-LF5Z62X6.js";
 import {
   createSchema
-} from "./chunk-4VF6KQ2Z.js";
+} from "./chunk-DJQOYEK3.js";
 import {
   loadConfig
-} from "./chunk-PSYLKCWQ.js";
+} from "./chunk-4BQ5QE76.js";
 import {
   getDatabase,
   initDatabase,
@@ -77,7 +77,7 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   getPluginVersion
-} from "./chunk-TFBAV3PV.js";
+} from "./chunk-BFM6AM6R.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -90,23 +90,23 @@ import {
   TEAM_SOURCE_PREFIX,
   epochSeconds
 } from "./chunk-TRA3R4EC.js";
-import "./chunk-S6I62FAH.js";
+import "./chunk-CUADDHHU.js";
 import "./chunk-D7TYRPRM.js";
 import "./chunk-E4VLWIJC.js";
 import {
   external_exports
-} from "./chunk-KH64DHOY.js";
+} from "./chunk-GDY63YAW.js";
 import "./chunk-PZUWP5VK.js";
 
 // src/agent/executor.ts
-import crypto2 from "crypto";
+import crypto4 from "crypto";
 import { resolve as resolve2 } from "path";
 
 // src/agent/tools.ts
-import crypto from "crypto";
-import { writeFileSync, mkdirSync, rmSync } from "fs";
-import { resolve } from "path";
-import { tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+
+// src/agent/tools/read-tools.ts
+import { tool } from "@anthropic-ai/claude-agent-sdk";
 
 // src/db/queries/agent-state.ts
 var STATE_COLUMNS = [
@@ -148,77 +148,20 @@ function getStatesForAgent(agentId) {
   return rows.map(toAgentStateRow);
 }
 
-// src/agent/tools.ts
+// 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 textResult(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data) }] };
-}
-var MAX_SKILL_LINES = 500;
-var REQUIRED_FRONTMATTER_FIELDS = ["name", "description", "managed_by", "user-invocable", "allowed-tools"];
-function validateSkillContent(content, dirName) {
-  const issues = [];
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) {
-    issues.push("Missing YAML frontmatter (must start with --- and end with ---)");
-    return issues;
-  }
-  const frontmatter = fmMatch[1];
-  for (const field of REQUIRED_FRONTMATTER_FIELDS) {
-    if (!frontmatter.includes(`${field}:`)) {
-      issues.push(`Missing required frontmatter field: ${field}`);
-    }
-  }
-  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
-  if (nameMatch && !nameMatch[1].trim().startsWith("myco:")) {
-    issues.push(`Skill name must start with "myco:" prefix. Got: "${nameMatch[1].trim()}"`);
-  }
-  const managedMatch = frontmatter.match(/^managed_by:\s*(.+)$/m);
-  if (managedMatch && managedMatch[1].trim() !== "myco") {
-    issues.push(`managed_by must be "myco". Got: "${managedMatch[1].trim()}"`);
-  }
-  const allowedToolsMatch = frontmatter.match(/^allowed-tools:\s*(.+)$/m);
-  if (allowedToolsMatch) {
-    const toolsValue = allowedToolsMatch[1].trim();
-    if (toolsValue.includes("vault_")) {
-      issues.push(
-        "allowed-tools contains vault agent tool names (vault_*). Skills run in Claude Code sessions \u2014 use Claude Code tool names instead: Read, Edit, Write, Bash, Grep, Glob"
-      );
-    }
-  }
-  const listToolLines = frontmatter.match(/^\s+-\s+vault_\w+/gm);
-  if (listToolLines) {
-    issues.push(
-      "allowed-tools contains vault agent tool names (vault_*). Skills run in Claude Code sessions \u2014 use Claude Code tool names instead: Read, Edit, Write, Bash, Grep, Glob"
-    );
-  }
-  const lineCount = content.split("\n").length;
-  if (lineCount > MAX_SKILL_LINES) {
-    issues.push(`Skill is ${lineCount} lines (max ${MAX_SKILL_LINES})`);
-  }
-  return issues;
-}
-function createVaultTools(agentId, runId, options) {
-  const { turnOffset = 0, embeddingManager, teamClient, machineId, projectRoot, vaultDir } = options ?? {};
-  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 {
-    }
-  }
+function createReadTools(deps) {
+  const { agentId, embeddingManager, teamClient, machineId, recordTurn } = deps;
   const vaultUnprocessed = tool(
     "vault_unprocessed",
     "Get unprocessed prompt batches, ordered by id ASC. Supports cursor-based pagination.",
@@ -337,7 +280,7 @@ function createVaultTools(agentId, runId, options) {
         return textResult({ results: [], message: "Semantic search unavailable" });
       }
     },
-    { annotations: { readOnlyHint: true } }
+    { annotations: { readOnlyHint: true, openWorldHint: true } }
   );
   const vaultState = tool(
     "vault_state",
@@ -392,7 +335,24 @@ function createVaultTools(agentId, runId, options) {
     },
     { annotations: { readOnlyHint: true } }
   );
-  const vaultCreateSpore = tool(
+  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, recordTurn } = deps;
+  const vaultCreateSpore = tool2(
     "vault_create_spore",
     "Create a new spore (observation) in the vault. The agent_id is set automatically.",
     {
@@ -436,9 +396,10 @@ function createVaultTools(agentId, runId, options) {
       });
       recordTurn("vault_create_spore", args);
       return textResult(spore);
-    }
+    },
+    { annotations: { openWorldHint: true } }
   );
-  const vaultCreateEntity = tool(
+  const vaultCreateEntity = tool2(
     "vault_create_entity",
     "Create or update an entity in the knowledge graph. Uses UPSERT on (agent_id, type, name).",
     {
@@ -462,9 +423,10 @@ function createVaultTools(agentId, runId, options) {
       });
       recordTurn("vault_create_entity", args);
       return textResult(entity);
-    }
+    },
+    { annotations: { idempotentHint: true } }
   );
-  const vaultCreateEdge = tool(
+  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.",
     {
@@ -495,9 +457,10 @@ function createVaultTools(agentId, runId, options) {
       });
       recordTurn("vault_create_edge", args);
       return textResult(edge);
-    }
+    },
+    { annotations: { idempotentHint: true } }
   );
-  const vaultResolveSpore = tool(
+  const vaultResolveSpore = tool2(
     "vault_resolve_spore",
     "Resolve a spore by updating its status and recording a resolution event.",
     {
@@ -538,9 +501,10 @@ function createVaultTools(agentId, runId, options) {
       }
       recordTurn("vault_resolve_spore", args);
       return textResult({ spore: updatedSpore, resolution_event_id: eventId });
-    }
+    },
+    { annotations: { destructiveHint: true } }
   );
-  const vaultUpdateSession = tool(
+  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.",
     {
@@ -559,9 +523,10 @@ function createVaultTools(agentId, runId, options) {
       }
       recordTurn("vault_update_session", args);
       return textResult(session);
-    }
+    },
+    { annotations: { idempotentHint: true } }
   );
-  const vaultSetState = tool(
+  const vaultSetState = tool2(
     "vault_set_state",
     "Set a key-value state pair for the current agent. Used for bookmarks, cursors, and preferences.",
     {
@@ -573,9 +538,10 @@ function createVaultTools(agentId, runId, options) {
       const state = setState(agentId, args.key, args.value, now);
       recordTurn("vault_set_state", args);
       return textResult(state);
-    }
+    },
+    { annotations: { idempotentHint: true } }
   );
-  const vaultReadDigest = tool(
+  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.",
     {
@@ -597,7 +563,7 @@ function createVaultTools(agentId, runId, options) {
     },
     { annotations: { readOnlyHint: true } }
   );
-  const vaultWriteDigest = tool(
+  const vaultWriteDigest = tool2(
     "vault_write_digest",
     "Write or update a digest extract at a specific token tier. Uses UPSERT on (agent_id, tier).",
     {
@@ -614,9 +580,10 @@ function createVaultTools(agentId, runId, options) {
       });
       recordTurn("vault_write_digest", args);
       return textResult(extract);
-    }
+    },
+    { annotations: { idempotentHint: true } }
   );
-  const vaultMarkProcessed = tool(
+  const vaultMarkProcessed = tool2(
     "vault_mark_processed",
     "Mark a prompt batch as processed so it is not returned by vault_unprocessed.",
     {
@@ -626,9 +593,27 @@ function createVaultTools(agentId, runId, options) {
       const batch = markBatchProcessed(args.batch_id);
       recordTurn("vault_mark_processed", args);
       return textResult(batch);
-    }
+    },
+    { annotations: { destructiveHint: true } }
   );
-  const vaultReport = tool(
+  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, recordTurn } = 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.',
     {
@@ -648,9 +633,210 @@ function createVaultTools(agentId, runId, options) {
         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";
+
+// src/agent/tools/skill-validator.ts
+var MAX_SKILL_LINES = 500;
+var REQUIRED_FRONTMATTER_FIELDS = ["name", "description", "managed_by", "user-invocable", "allowed-tools"];
+var PROTECTED_FRONTMATTER_FIELDS = ["user-invocable", "allowed-tools"];
+var ALLOWED_CLAUDE_CODE_TOOLS = /* @__PURE__ */ new Set([
+  "Read",
+  "Edit",
+  "Write",
+  "MultiEdit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "NotebookRead",
+  "NotebookEdit",
+  "WebFetch",
+  "WebSearch",
+  "Task",
+  "TodoWrite"
+]);
+function extractFrontmatterField(content, field) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) return void 0;
+  const match = fmMatch[1].match(new RegExp(`^${field}:\\s*(.+)$`, "m"));
+  return match?.[1].trim();
+}
+function parseAllowedTools(rawValue) {
+  if (!rawValue) return null;
+  let stripped = rawValue.trim();
+  if (stripped.length === 0) return null;
+  if (stripped.startsWith("[") && stripped.endsWith("]")) {
+    stripped = stripped.slice(1, -1).trim();
+  }
+  if (stripped.length === 0) return null;
+  const parts = stripped.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter((s) => s.length > 0);
+  if (parts.length === 0) return null;
+  const sentinels = /* @__PURE__ */ new Set(["None", "none", "null", "Null", "~"]);
+  if (parts.some((p) => sentinels.has(p))) return null;
+  return parts;
+}
+function tokenSet(text) {
+  const stopwords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "and",
+    "or",
+    "but",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "should",
+    "could",
+    "may",
+    "might",
+    "must",
+    "can",
+    "this",
+    "that",
+    "these",
+    "those",
+    "with",
+    "from",
+    "into",
+    "onto",
+    "for",
+    "when",
+    "where",
+    "which",
+    "what",
+    "who",
+    "how",
+    "why",
+    "use",
+    "uses",
+    "used",
+    "using",
+    "not",
+    "also",
+    "than",
+    "then",
+    "ensure",
+    "ensures",
+    "make",
+    "makes"
+  ]);
+  return new Set(
+    text.toLowerCase().replace(/[^a-z0-9_\s]/g, " ").split(/\s+/).filter((w) => w.length >= 4 && !stopwords.has(w))
   );
-  const vaultSkillCandidates = tool(
+}
+function descriptionSimilarity(a, b) {
+  const aTokens = tokenSet(a);
+  const bTokens = tokenSet(b);
+  if (aTokens.size === 0 || bTokens.size === 0) return 0;
+  let intersection = 0;
+  for (const token of aTokens) {
+    if (bTokens.has(token)) intersection++;
+  }
+  const union = aTokens.size + bTokens.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+var DESCRIPTION_DUPLICATE_THRESHOLD = 0.4;
+function checkFrontmatterPreservation(existing, incoming) {
+  const violations = [];
+  for (const field of PROTECTED_FRONTMATTER_FIELDS) {
+    const oldValue = extractFrontmatterField(existing, field);
+    const newValue = extractFrontmatterField(incoming, field);
+    if (oldValue !== void 0 && newValue !== void 0 && oldValue !== newValue) {
+      violations.push(`${field}: was "${oldValue}", changed to "${newValue}"`);
+    }
+  }
+  const oldDesc = extractFrontmatterField(existing, "description");
+  const newDesc = extractFrontmatterField(incoming, "description");
+  if (oldDesc && newDesc && newDesc.length < oldDesc.length * 0.9) {
+    violations.push(
+      `description shortened from ${oldDesc.length} to ${newDesc.length} chars (${Math.round((1 - newDesc.length / oldDesc.length) * 100)}% reduction). Descriptions are the primary triggering mechanism \u2014 do not shorten them.`
+    );
+  }
+  return violations;
+}
+function validateSkillContent(content, dirName) {
+  const issues = [];
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    issues.push("Missing YAML frontmatter (must start with --- and end with ---)");
+    return issues;
+  }
+  const frontmatter = fmMatch[1];
+  for (const field of REQUIRED_FRONTMATTER_FIELDS) {
+    if (!frontmatter.includes(`${field}:`)) {
+      issues.push(`Missing required frontmatter field: ${field}`);
+    }
+  }
+  const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
+  if (nameMatch && !nameMatch[1].trim().startsWith("myco:")) {
+    issues.push(`Skill name must start with "myco:" prefix. Got: "${nameMatch[1].trim()}"`);
+  }
+  const managedMatch = frontmatter.match(/^managed_by:\s*(.+)$/m);
+  if (managedMatch && managedMatch[1].trim() !== "myco") {
+    issues.push(`managed_by must be "myco". Got: "${managedMatch[1].trim()}"`);
+  }
+  const allowedToolsMatch = frontmatter.match(/^allowed-tools:\s*(.+)$/m);
+  if (allowedToolsMatch) {
+    const rawValue = allowedToolsMatch[1].trim();
+    if (rawValue.includes("vault_")) {
+      issues.push(
+        "allowed-tools contains vault agent tool names (vault_*). Skills run in Claude Code sessions -- use Claude Code tool names instead: Read, Edit, Write, Bash, Grep, Glob"
+      );
+    } else {
+      const parsed = parseAllowedTools(rawValue);
+      if (parsed === null) {
+        issues.push(
+          `allowed-tools value is malformed or empty: "${rawValue}". Provide a comma-separated list of Claude Code tools, e.g. "Read, Edit, Write, Bash, Grep, Glob". Use the narrowest set the skill actually needs.`
+        );
+      } else {
+        const unknown = parsed.filter((t) => !ALLOWED_CLAUDE_CODE_TOOLS.has(t));
+        if (unknown.length > 0) {
+          issues.push(
+            `allowed-tools contains unknown tool name(s): ${unknown.join(", ")}. Valid Claude Code tools: ${[...ALLOWED_CLAUDE_CODE_TOOLS].join(", ")}.`
+          );
+        }
+      }
+    }
+  }
+  const listToolLines = frontmatter.match(/^\s+-\s+vault_\w+/gm);
+  if (listToolLines) {
+    issues.push(
+      "allowed-tools contains vault agent tool names (vault_*). Skills run in Claude Code sessions -- use Claude Code tool names instead: Read, Edit, Write, Bash, Grep, Glob"
+    );
+  }
+  const lineCount = content.split("\n").length;
+  if (lineCount > MAX_SKILL_LINES) {
+    issues.push(`Skill is ${lineCount} lines (max ${MAX_SKILL_LINES})`);
+  }
+  return issues;
+}
+
+// src/agent/tools/skill-tools.ts
+function createSkillTools(deps) {
+  const { agentId, machineId, projectRoot, vaultDir, recordTurn } = deps;
+  const vaultSkillCandidates = tool4(
     "vault_skill_candidates",
     "Manage skill candidates (identified topics that may become skills). Supports list, get, create, and update actions.",
     {
@@ -685,9 +871,22 @@ function createVaultTools(agentId, runId, options) {
           if (!args.topic || !args.rationale) {
             return textResult({ error: "topic and rationale are required for create action" });
           }
+          const activeSkills = listSkillRecords({ agent_id: agentId, status: "active", limit: 100 });
+          const topicLower = args.topic.toLowerCase();
+          const overlapping = activeSkills.filter((s) => {
+            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 now = epochSeconds();
           const candidate = insertCandidate({
-            id: crypto.randomUUID(),
+            id: crypto2.randomUUID(),
             agent_id: agentId,
             machine_id: machineId,
             topic: args.topic,
@@ -732,9 +931,10 @@ function createVaultTools(agentId, runId, options) {
         default:
           return textResult({ error: `Unknown action: ${args.action}` });
       }
-    }
+    },
+    { annotations: {} }
   );
-  const vaultSkillRecords = tool(
+  const vaultSkillRecords = tool4(
     "vault_skill_records",
     "Read, update, and delete skill records (materialized skills on disk). Supports list, get, update, and delete actions.",
     {
@@ -791,7 +991,7 @@ function createVaultTools(agentId, runId, options) {
               console.warn("[vault_skill_records] Failed to remove skill directory:", err instanceof Error ? err.message : err);
             }
             try {
-              const { syncSkillSymlinks } = await import("./installer-25TSX4SR.js");
+              const { syncSkillSymlinks } = await import("./installer-BTUNKWOU.js");
               syncSkillSymlinks(root, result.name, { remove: true });
             } catch (err) {
               console.warn("[vault_skill_records] Failed to remove symlinks:", err instanceof Error ? err.message : err);
@@ -802,9 +1002,10 @@ function createVaultTools(agentId, runId, options) {
         default:
           return textResult({ error: `Unknown action: ${args.action}` });
       }
-    }
+    },
+    { annotations: {} }
   );
-  const vaultWriteSkill = tool(
+  const vaultWriteSkill = tool4(
     "vault_write_skill",
     "Write a SKILL.md file to disk and create or update the corresponding skill record and lineage entry.",
     {
@@ -831,9 +1032,71 @@ function createVaultTools(agentId, runId, options) {
           error: 'Invalid skill name: must be a simple directory name without path separators or ".."'
         });
       }
+      const existingSameName = getSkillRecordByName(args.name);
+      if (!existingSameName) {
+        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) {
+              recordTurn("vault_write_skill", args);
+              return textResult({
+                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) {
+          recordTurn("vault_write_skill", args);
+          return textResult({
+            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
+          });
+        }
+      }
       const root = projectRoot ?? process.cwd();
       const skillDir = resolve(root, ".agents", "skills", args.name);
       const skillPath = resolve(skillDir, "SKILL.md");
+      if (existsSync(skillPath)) {
+        const existingContent = readFileSync(skillPath, "utf-8");
+        const violations = checkFrontmatterPreservation(existingContent, args.content);
+        if (violations.length > 0) {
+          recordTurn("vault_write_skill", args);
+          return textResult({
+            error: "Skill update rejected: protected frontmatter fields were changed. Read the existing skill and preserve these values exactly.",
+            violations
+          });
+        }
+      }
+      const skillDirPreexisted = existsSync(skillDir);
+      let priorSkillContent = null;
+      if (existsSync(skillPath)) {
+        try {
+          priorSkillContent = readFileSync(skillPath, "utf-8");
+        } catch {
+          priorSkillContent = null;
+        }
+      }
       try {
         mkdirSync(skillDir, { recursive: true });
         writeFileSync(skillPath, args.content, "utf-8");
@@ -841,7 +1104,7 @@ function createVaultTools(agentId, runId, options) {
         return textResult({ error: `Failed to write skill file: ${err instanceof Error ? err.message : String(err)}` });
       }
       try {
-        const { syncSkillSymlinks } = await import("./installer-25TSX4SR.js");
+        const { syncSkillSymlinks } = await import("./installer-BTUNKWOU.js");
         syncSkillSymlinks(root, args.name);
       } catch (err) {
         console.warn("[vault_write_skill] syncSkillSymlinks failed:", err instanceof Error ? err.message : err);
@@ -852,77 +1115,98 @@ function createVaultTools(agentId, runId, options) {
       let recordId = "";
       let generation = 0;
       const txDb = getDatabase();
-      txDb.transaction(() => {
-        if (existing) {
-          generation = existing.generation + 1;
-          recordId = existing.id;
-          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: crypto.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
-          });
-        } else {
-          recordId = crypto.randomUUID();
-          generation = 1;
-          insertSkillRecord({
-            id: recordId,
-            agent_id: agentId,
-            machine_id: machineId,
-            name: args.name,
-            display_name: args.display_name,
-            description: args.description,
-            candidate_id: args.candidate_id ?? null,
-            source_ids: args.source_ids,
-            path: relativePath,
-            created_at: now,
-            updated_at: now
-          });
-          insertLineage({
-            id: crypto.randomUUID(),
-            skill_id: recordId,
-            generation,
-            action: "created",
-            rationale: args.rationale ?? "Initial skill creation",
-            source_ids_added: args.source_ids,
-            content_snapshot: args.content,
-            created_at: now
-          });
-          const approvedCandidates = listCandidates({ status: "approved", limit: 10 });
-          let linkedCandidate = false;
-          if (args.candidate_id && !linkedCandidate) {
-            const exact = updateCandidate(args.candidate_id, {
-              status: "generated",
-              skill_id: recordId,
+      try {
+        txDb.transaction(() => {
+          if (existing) {
+            generation = existing.generation + 1;
+            recordId = existing.id;
+            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
             });
-            if (exact) linkedCandidate = true;
-          }
-          if (args.candidate_id && !linkedCandidate) {
-            const prefixMatch = approvedCandidates.find((c) => c.id.startsWith(args.candidate_id));
-            if (prefixMatch) {
-              updateCandidate(prefixMatch.id, {
+            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
+            });
+          } else {
+            recordId = crypto2.randomUUID();
+            generation = 1;
+            insertSkillRecord({
+              id: recordId,
+              agent_id: agentId,
+              machine_id: machineId,
+              name: args.name,
+              display_name: args.display_name,
+              description: args.description,
+              candidate_id: args.candidate_id ?? null,
+              source_ids: args.source_ids,
+              path: relativePath,
+              created_at: now,
+              updated_at: now
+            });
+            insertLineage({
+              id: crypto2.randomUUID(),
+              skill_id: recordId,
+              generation,
+              action: "created",
+              rationale: args.rationale ?? "Initial skill creation",
+              source_ids_added: args.source_ids,
+              content_snapshot: args.content,
+              created_at: now
+            });
+            const approvedCandidates = listCandidates({ status: "approved", limit: 10 });
+            let linkedCandidate = false;
+            if (args.candidate_id && !linkedCandidate) {
+              const exact = updateCandidate(args.candidate_id, {
                 status: "generated",
                 skill_id: recordId,
                 updated_at: now
               });
-              linkedCandidate = true;
+              if (exact) linkedCandidate = true;
             }
+            if (args.candidate_id && !linkedCandidate) {
+              const prefixMatch = approvedCandidates.find((c) => c.id.startsWith(args.candidate_id));
+              if (prefixMatch) {
+                updateCandidate(prefixMatch.id, {
+                  status: "generated",
+                  skill_id: recordId,
+                  updated_at: now
+                });
+                linkedCandidate = true;
+              }
+            }
+          }
+        })();
+      } catch (err) {
+        try {
+          if (priorSkillContent !== null) {
+            writeFileSync(skillPath, priorSkillContent, "utf-8");
+          } else if (!skillDirPreexisted) {
+            rmSync(skillDir, { recursive: true, force: true });
+          } else {
+            rmSync(skillPath, { force: true });
           }
+        } catch (rollbackErr) {
+          console.warn(
+            "[vault_write_skill] file rollback after DB failure also failed:",
+            rollbackErr instanceof Error ? rollbackErr.message : rollbackErr
+          );
         }
-      })();
+        recordTurn("vault_write_skill", args);
+        return textResult({
+          error: `Skill write aborted: database transaction failed and on-disk state was rolled back. ${err instanceof Error ? err.message : String(err)}`
+        });
+      }
       const isNew = generation === 1;
       notify(vaultDir, {
         domain: "skills",
@@ -939,32 +1223,85 @@ function createVaultTools(agentId, runId, options) {
         path: relativePath,
         generation
       });
-    }
+    },
+    { annotations: { openWorldHint: true } }
   );
   return [
-    vaultUnprocessed,
-    vaultSpores,
-    vaultSessions,
-    vaultSearchFts,
-    vaultSearchSemantic,
-    vaultState,
-    vaultEntities,
-    vaultEdges,
-    vaultCreateSpore,
-    vaultCreateEntity,
-    vaultCreateEdge,
-    vaultResolveSpore,
-    vaultUpdateSession,
-    vaultSetState,
-    vaultReadDigest,
-    vaultWriteDigest,
-    vaultMarkProcessed,
-    vaultReport,
     vaultSkillCandidates,
     vaultSkillRecords,
     vaultWriteSkill
   ];
 }
+
+// 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"
+]);
+function setsOverlap(a, b) {
+  for (const item of a) {
+    if (b.has(item)) return true;
+  }
+  return false;
+}
+function createVaultTools(agentId, runId, options) {
+  const { turnOffset = 0, embeddingManager, teamClient, machineId, projectRoot, vaultDir, onlyNames } = options ?? {};
+  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 deps = {
+    agentId,
+    runId,
+    embeddingManager,
+    teamClient,
+    machineId,
+    projectRoot,
+    vaultDir,
+    recordTurn
+  };
+  const needsAll = !onlyNames;
+  return [
+    ...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) : []
+  ];
+}
 function createVaultToolServer(agentId, runId, options) {
   const tools = createVaultTools(agentId, runId, options);
   return createSdkMcpServer({
@@ -974,9 +1311,10 @@ function createVaultToolServer(agentId, runId, options) {
   });
 }
 function createScopedVaultToolServer(agentId, runId, toolNames, options) {
-  const allTools = createVaultTools(agentId, runId, options);
   const nameSet = new Set(toolNames);
-  const scopedTools = allTools.filter((t) => nameSet.has(t.name));
+  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(),
@@ -1251,13 +1589,13 @@ var KNOWN_CONTEXT_QUERY_TOOLS = /* @__PURE__ */ new Set([
   "vault_sessions",
   "vault_state"
 ]);
-function validateTool(tool2) {
-  if (!KNOWN_CONTEXT_QUERY_TOOLS.has(tool2)) {
-    throw new Error(`Unknown context query tool: "${tool2}"`);
+function validateTool(tool5) {
+  if (!KNOWN_CONTEXT_QUERY_TOOLS.has(tool5)) {
+    throw new Error(`Unknown context query tool: "${tool5}"`);
   }
 }
-async function executeQuery(agentId, tool2, limit) {
-  switch (tool2) {
+async function executeQuery(agentId, tool5, limit) {
+  switch (tool5) {
     case "vault_unprocessed":
       return getUnprocessedBatches({ limit });
     case "vault_spores":
@@ -1267,7 +1605,7 @@ async function executeQuery(agentId, tool2, limit) {
     case "vault_state":
       return getStatesForAgent(agentId);
     default:
-      throw new Error(`Unknown context query tool: "${tool2}"`);
+      throw new Error(`Unknown context query tool: "${tool5}"`);
   }
 }
 
@@ -1306,62 +1644,87 @@ function getProviderEnvVars(provider) {
   }
 }
 
-// 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);
+// src/agent/config-resolver.ts
+function toProviderConfig(p) {
+  return {
+    type: p.type,
+    baseUrl: p.base_url,
+    model: p.model,
+    contextLength: p.context_length
+  };
 }
-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")}`);
+function resolveRunConfig(agentId, requestedTask, vaultDir) {
+  const definitionsDir = resolveDefinitionsDir();
+  const definition = loadAgentDefinition(definitionsDir);
+  const agentRow = getAgent(agentId);
+  const taskRow = requestedTask ? getTask(requestedTask) : getDefaultTask(agentId);
+  const allTasks = loadAllTasks(definitionsDir, vaultDir);
+  const taskName = taskRow?.id ?? requestedTask;
+  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 = {};
+  let taskParams;
+  try {
+    const mycoConfig = loadConfig(vaultDir);
+    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 } : {}
+        };
+      }
+    }
+    const yamlParams = yamlTask?.params;
+    const configParams = taskConfig?.params;
+    if (yamlParams || configParams) {
+      taskParams = { ...yamlParams, ...configParams };
+    }
+  } catch {
   }
-  parts.push(`${PROMPT_SECTION_CURRENT_PHASE}${phase.name}
-${phase.prompt}`);
-  return parts.join(PROMPT_SECTION_SEPARATOR);
+  return {
+    config,
+    definitionsDir,
+    taskProviderOverride,
+    phaseProviderOverrides,
+    taskName,
+    taskParams
+  };
 }
+
+// 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 { execFileSync } = await import("child_process");
-  const { writeFileSync: writeFileSync2, 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 {
@@ -1387,6 +1750,63 @@ PARAMETER num_ctx ${contextLength}
     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();
@@ -1428,7 +1848,7 @@ function computeWaves(phases) {
   return waves;
 }
 function phaseSessionId(runId, phaseName) {
-  const hash = crypto2.createHash("sha256").update(`${runId}-${phaseName}`).digest("hex");
+  const hash = crypto3.createHash("sha256").update(`${runId}-${phaseName}`).digest("hex");
   return [
     hash.slice(0, 8),
     hash.slice(8, 12),
@@ -1437,10 +1857,94 @@ function phaseSessionId(runId, phaseName) {
     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 DEBUG_TOOL_CALLS = process.env.MYCO_AGENT_DEBUG === "1";
+var TOOL_DEBUG_PREVIEW_CHARS = 240;
+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 (!DEBUG_TOOL_CALLS) 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 (!DEBUG_TOOL_CALLS) 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 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({
@@ -1460,6 +1964,13 @@ async function executePhase(query, phasePrompt, phaseModel, systemPrompt, toolSe
         ...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);
@@ -1469,6 +1980,11 @@ async function executePhase(query, phasePrompt, phaseModel, systemPrompt, toolSe
         }
       }
     }
+    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`);
     }
@@ -1581,7 +2097,8 @@ async function executePhasedQuery(config, systemPrompt, vaultContext, agentId, r
           turnOffset: runningTurnCount + indexInWave * effectiveMaxTurns,
           embeddingManager,
           projectRoot,
-          vaultDir
+          vaultDir,
+          readOnly: phase.readOnly
         }
       );
       const phaseProvider = phase.provider ?? phaseOverride?.provider ?? taskProviderOverride ?? config.execution?.provider;
@@ -1644,60 +2161,15 @@ async function runAgent(vaultDir, options) {
       }
     }
   }
-  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 {
+    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({
@@ -1718,12 +2190,18 @@ async function runAgent(vaultDir, options) {
     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
+  {
+    const resolved = await resolveOllamaContextVariants(
+      taskProviderOverride,
+      phaseProviderOverrides
     );
-    taskProviderOverride = { ...taskProviderOverride, model: variantModel };
+    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;
@@ -1834,4 +2312,4 @@ export {
   computeWaves,
   runAgent
 };
-//# sourceMappingURL=executor-HKNINUWO.js.map
+//# sourceMappingURL=executor-4OXDK4ZA.js.map