@goondocks/myco 0.15.0 → 0.15.1

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

@@ -77,7 +77,7 @@ import {
 } from "./chunk-MYX5NCRH.js";
 import {
   getPluginVersion
-} from "./chunk-OMZCVRX6.js";
+} from "./chunk-BFM6AM6R.js";
 import {
   findPackageRoot
 } from "./chunk-LPUQPDC2.js";
@@ -649,12 +649,115 @@ import { tool as tool4 } from "@anthropic-ai/claude-agent-sdk";
 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))
+  );
+}
+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) {
@@ -696,11 +799,25 @@ function validateSkillContent(content, dirName) {
   }
   const allowedToolsMatch = frontmatter.match(/^allowed-tools:\s*(.+)$/m);
   if (allowedToolsMatch) {
-    const toolsValue = allowedToolsMatch[1].trim();
-    if (toolsValue.includes("vault_")) {
+    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);
@@ -915,6 +1032,48 @@ function createSkillTools(deps) {
           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");
@@ -929,6 +1088,15 @@ function createSkillTools(deps) {
           });
         }
       }
+      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");
@@ -947,77 +1115,98 @@ function createSkillTools(deps) {
       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: 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,
+      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",
@@ -1534,6 +1723,7 @@ import { writeFileSync as writeFileSync2, unlinkSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 var OLLAMA_PRELOAD_TIMEOUT_MS = 3e4;
+var DEFAULT_OLLAMA_CONTEXT_LENGTH = 32768;
 async function ensureOllamaContextVariant(model, contextLength) {
   const baseName = model.replace(/:latest$/, "");
   const variantName = `${baseName}-ctx${contextLength}`;
@@ -1560,6 +1750,60 @@ 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";
@@ -1624,6 +1868,38 @@ 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] ?? "";
@@ -1690,6 +1966,10 @@ async function executePhase(query, phasePrompt, phaseModel, systemPrompt, toolSe
     })) {
       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;
@@ -1885,9 +2165,10 @@ async function runAgent(vaultDir, options) {
     config,
     definitionsDir,
     taskProviderOverride: resolvedTaskProvider,
-    phaseProviderOverrides
+    phaseProviderOverrides: resolvedPhaseOverrides
   } = resolveRunConfig(agentId, requestedTask, vaultDir);
   let taskProviderOverride = resolvedTaskProvider;
+  let phaseProviderOverrides = resolvedPhaseOverrides;
   const runId = options?.resumeRunId ?? crypto4.randomUUID();
   const now = epochSeconds();
   if (!options?.resumeRunId) {
@@ -1909,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;
@@ -2025,4 +2312,4 @@ export {
   computeWaves,
   runAgent
 };
-//# sourceMappingURL=executor-7XOKS6HS.js.map
+//# sourceMappingURL=executor-4OXDK4ZA.js.map