@goondocks/myco 0.12.10 → 0.14.0

package/dist/{executor-LKDWMGC7.js → executor-W5MKZH7B.js}

@@ -1,33 +1,42 @@
 import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
-import {
-  insertResolutionEvent
-} from "./chunk-LGPBVBFY.js";
 import {
   STATUS_COMPLETED,
   STATUS_FAILED,
   STATUS_RUNNING,
   createSporeLineage,
+  deleteCandidate,
+  deleteSkillRecordCascade,
   errorMessage,
-  getRunningRun,
+  getCandidate,
+  getRunningRunForTask,
+  getSkillRecord,
+  getSkillRecordByName,
   getUnprocessedBatches,
+  insertCandidate,
   insertEntity,
   insertGraphEdge,
+  insertLineage,
   insertReport,
   insertRun,
-  insertTurn,
+  insertSkillRecord,
+  listCandidates,
   listDigestExtracts,
   listEntities,
   listGraphEdges,
+  listSkillRecords,
   markBatchProcessed,
+  notify,
+  updateCandidate,
   updateRunStatus,
+  updateSkillRecord,
   upsertDigestExtract
-} from "./chunk-TCGOSLW6.js";
+} from "./chunk-JJXVDCEX.js";
 import {
   fullTextSearch
-} from "./chunk-D4M2AV65.js";
+} from "./chunk-DTE3SHYK.js";
 import {
   loadAllTasks
-} from "./chunk-D4ESHOOJ.js";
+} from "./chunk-KNTJOMWY.js";
 import {
   getAgent,
   getDefaultTask,
@@ -36,45 +45,52 @@ import {
   loadSystemPrompt,
   resolveDefinitionsDir,
   resolveEffectiveConfig
-} from "./chunk-7NBDELZB.js";
+} from "./chunk-NVCGF2DS.js";
+import {
+  insertTurn
+} from "./chunk-QLCD77AN.js";
+import {
+  insertResolutionEvent
+} from "./chunk-TVV6PZOC.js";
 import "./chunk-IB76KGBY.js";
 import {
   DEFAULT_IMPORTANCE,
   insertSpore,
   listSpores,
   updateSporeStatus
-} from "./chunk-Q2AYS2QE.js";
+} from "./chunk-PX5KIOKY.js";
 import {
   listSessions,
   updateSession
-} from "./chunk-JROOQQH6.js";
-import "./chunk-4VSNNMEU.js";
+} from "./chunk-X34OFKYU.js";
+import "./chunk-S66YG6QK.js";
 import {
   createSchema
-} from "./chunk-PW5QVY44.js";
+} from "./chunk-4VF6KQ2Z.js";
 import {
   loadConfig
-} from "./chunk-OAGY5APE.js";
+} from "./chunk-PSYLKCWQ.js";
 import {
   getDatabase,
   initDatabase,
   vaultDbPath
 } from "./chunk-MYX5NCRH.js";
+import {
+  getPluginVersion
+} from "./chunk-ZKXW46HZ.js";
+import {
+  findPackageRoot
+} from "./chunk-LPUQPDC2.js";
 import {
   DEFAULT_AGENT_ID,
+  DEFAULT_LIST_LIMIT,
   MS_PER_SECOND,
   PHASE_SUMMARY_MAX_CHARS,
   SEARCH_SIMILARITY_THRESHOLD,
   TEAM_SOURCE_PREFIX,
   epochSeconds
-} from "./chunk-PIRWYDOH.js";
+} from "./chunk-TRA3R4EC.js";
 import "./chunk-S6I62FAH.js";
-import {
-  getPluginVersion
-} from "./chunk-FYGFMIS6.js";
-import {
-  findPackageRoot
-} from "./chunk-LPUQPDC2.js";
 import "./chunk-D7TYRPRM.js";
 import "./chunk-E4VLWIJC.js";
 import {
@@ -84,9 +100,12 @@ import "./chunk-PZUWP5VK.js";
 
 // src/agent/executor.ts
 import crypto2 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";
 
 // src/db/queries/agent-state.ts
@@ -139,7 +158,37 @@ var DEFAULT_EDGES_LIMIT = 50;
 function textResult(data) {
   return { content: [{ type: "text", text: JSON.stringify(data) }] };
 }
-function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, teamClient, machineId) {
+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 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++;
@@ -214,10 +263,10 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
   );
   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.",
+    "Full-text search across sessions, spores, prompt batches, and activities using FTS5. Best for finding exact keywords, file paths, function names, and specific text. Searches: session titles/summaries, spore content, user prompts, AI response summaries, tool calls.",
     {
       query: external_exports.string().describe("Search query text"),
-      type: external_exports.string().optional().describe("Restrict to a result type (prompt_batch, activity)"),
+      type: external_exports.string().optional().describe("Restrict to a result type (session, spore, prompt_batch, activity)"),
       limit: external_exports.number().optional().describe("Maximum number of results to return")
     },
     async (args) => {
@@ -348,6 +397,7 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
       const spore = insertSpore({
         id,
         agent_id: agentId,
+        machine_id: machineId,
         observation_type: args.observation_type,
         content: args.content,
         session_id: args.session_id ?? null,
@@ -388,6 +438,7 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
       const entity = insertEntity({
         id,
         agent_id: agentId,
+        machine_id: machineId,
         type: args.type,
         name: args.name,
         properties: props,
@@ -416,6 +467,7 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
       const props = args.properties ? JSON.stringify(args.properties) : void 0;
       const edge = insertGraphEdge({
         agent_id: agentId,
+        machine_id: machineId,
         source_id: args.source_id,
         source_type: args.source_type,
         target_id: args.target_id,
@@ -455,6 +507,7 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
       insertResolutionEvent({
         id: eventId,
         agent_id: agentId,
+        machine_id: machineId,
         spore_id: args.spore_id,
         action: args.action,
         new_spore_id: args.new_spore_id ?? null,
@@ -582,6 +635,297 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
       return textResult(report);
     }
   );
+  const vaultSkillCandidates = tool(
+    "vault_skill_candidates",
+    "Manage skill candidates (identified topics that may become skills). Supports list, get, create, and update actions.",
+    {
+      action: external_exports.enum(["list", "get", "create", "update", "delete"]).describe("Action to perform"),
+      id: external_exports.string().optional().describe("Candidate ID (required for get/update)"),
+      topic: external_exports.string().optional().describe("Skill topic (required for create)"),
+      rationale: external_exports.string().optional().describe("Why this should be a skill (required for create)"),
+      confidence: external_exports.number().optional().describe("Confidence score 0-1"),
+      status: external_exports.enum(["identified", "approved", "generated", "dismissed"]).optional().describe("Candidate status. Only these values are valid."),
+      source_ids: external_exports.string().optional().describe("JSON array of source spore/entity IDs"),
+      skill_id: external_exports.string().optional().describe("Associated skill record ID (after materialization)"),
+      limit: external_exports.number().optional().describe("Maximum candidates to return (for list)")
+    },
+    async (args) => {
+      recordTurn("vault_skill_candidates", args);
+      switch (args.action) {
+        case "list": {
+          const candidates = listCandidates({
+            agent_id: agentId,
+            status: args.status,
+            limit: args.limit ?? DEFAULT_LIST_LIMIT
+          });
+          return textResult(candidates);
+        }
+        case "get": {
+          if (!args.id) return textResult({ error: "id is required for get action" });
+          const candidate = getCandidate(args.id);
+          if (!candidate) return textResult({ error: `Candidate not found: ${args.id}` });
+          return textResult(candidate);
+        }
+        case "create": {
+          if (!args.topic || !args.rationale) {
+            return textResult({ error: "topic and rationale are required for create action" });
+          }
+          const now = epochSeconds();
+          const candidate = insertCandidate({
+            id: crypto.randomUUID(),
+            agent_id: agentId,
+            machine_id: machineId,
+            topic: args.topic,
+            rationale: args.rationale,
+            confidence: args.confidence,
+            status: args.status,
+            source_ids: args.source_ids,
+            created_at: now,
+            updated_at: now
+          });
+          notify(vaultDir, {
+            domain: "skills",
+            type: "skill.surveyed",
+            title: `Skill candidate: ${args.topic}`,
+            message: args.rationale.slice(0, 120),
+            link: "/skills?tab=candidates",
+            metadata: { candidateId: candidate.id, topic: args.topic }
+          });
+          return textResult(candidate);
+        }
+        case "update": {
+          if (!args.id) return textResult({ error: "id is required for update action" });
+          const now = epochSeconds();
+          const updated = updateCandidate(args.id, {
+            ...args.topic !== void 0 ? { topic: args.topic } : {},
+            ...args.rationale !== void 0 ? { rationale: args.rationale } : {},
+            ...args.confidence !== void 0 ? { confidence: args.confidence } : {},
+            ...args.status !== void 0 ? { status: args.status } : {},
+            ...args.source_ids !== void 0 ? { source_ids: args.source_ids } : {},
+            ...args.skill_id !== void 0 ? { skill_id: args.skill_id } : {},
+            updated_at: now
+          });
+          if (!updated) return textResult({ error: `Candidate not found: ${args.id}` });
+          return textResult(updated);
+        }
+        case "delete": {
+          if (!args.id) return textResult({ error: "id is required for delete action" });
+          const deleted = deleteCandidate(args.id);
+          if (!deleted) return textResult({ error: `Candidate not found: ${args.id}` });
+          return textResult({ deleted: true, id: args.id });
+        }
+        default:
+          return textResult({ error: `Unknown action: ${args.action}` });
+      }
+    }
+  );
+  const vaultSkillRecords = tool(
+    "vault_skill_records",
+    "Read, update, and delete skill records (materialized skills on disk). Supports list, get, update, and delete actions.",
+    {
+      action: external_exports.enum(["list", "get", "update", "delete"]).describe("Action to perform"),
+      id: external_exports.string().optional().describe("Skill record ID or name (required for get/update/delete)"),
+      status: external_exports.enum(["active", "stale", "retired"]).optional().describe("Filter by status"),
+      generation: external_exports.number().optional().describe("New generation number (for update)"),
+      source_ids: external_exports.string().optional().describe("JSON array of source IDs (for update)"),
+      description: external_exports.string().optional().describe("Updated description (for update)"),
+      limit: external_exports.number().optional().describe("Maximum records to return (for list)")
+    },
+    async (args) => {
+      recordTurn("vault_skill_records", args);
+      switch (args.action) {
+        case "list": {
+          const records = listSkillRecords({
+            agent_id: agentId,
+            status: args.status,
+            limit: args.limit ?? DEFAULT_LIST_LIMIT
+          });
+          return textResult(records);
+        }
+        case "get": {
+          if (!args.id) return textResult({ error: "id is required for get action" });
+          const record = getSkillRecord(args.id) ?? getSkillRecordByName(args.id);
+          if (!record) return textResult({ error: `Skill record not found: ${args.id}` });
+          return textResult(record);
+        }
+        case "update": {
+          if (!args.id) return textResult({ error: "id is required for update action" });
+          const existing = getSkillRecord(args.id) ?? getSkillRecordByName(args.id);
+          if (!existing) return textResult({ error: `Skill record not found: ${args.id}` });
+          const now = epochSeconds();
+          const updated = updateSkillRecord(existing.id, {
+            ...args.status !== void 0 ? { status: args.status } : {},
+            ...args.generation !== void 0 ? { generation: args.generation } : {},
+            ...args.source_ids !== void 0 ? { source_ids: args.source_ids } : {},
+            ...args.description !== void 0 ? { description: args.description } : {},
+            updated_at: now
+          });
+          if (!updated) return textResult({ error: `Failed to update skill record: ${existing.id}` });
+          return textResult(updated);
+        }
+        case "delete": {
+          if (!args.id) return textResult({ error: "id is required for delete action" });
+          const result = deleteSkillRecordCascade(args.id);
+          if (!result) return textResult({ error: `Skill record not found: ${args.id}` });
+          const root = projectRoot ?? process.cwd();
+          if (!/[/\\]|\.\./.test(result.name)) {
+            const skillDir = resolve(root, ".agents", "skills", result.name);
+            try {
+              rmSync(skillDir, { recursive: true, force: true });
+            } catch (err) {
+              console.warn("[vault_skill_records] Failed to remove skill directory:", err instanceof Error ? err.message : err);
+            }
+            try {
+              const { syncSkillSymlinks } = await import("./installer-25TSX4SR.js");
+              syncSkillSymlinks(root, result.name, { remove: true });
+            } catch (err) {
+              console.warn("[vault_skill_records] Failed to remove symlinks:", err instanceof Error ? err.message : err);
+            }
+          }
+          return textResult({ deleted: true, id: result.id, name: result.name });
+        }
+        default:
+          return textResult({ error: `Unknown action: ${args.action}` });
+      }
+    }
+  );
+  const vaultWriteSkill = tool(
+    "vault_write_skill",
+    "Write a SKILL.md file to disk and create or update the corresponding skill record and lineage entry.",
+    {
+      name: external_exports.string().describe("Skill directory name (kebab-case, NO colon). The myco: prefix goes in the SKILL.md frontmatter name field, not here."),
+      display_name: external_exports.string().describe("Human-readable display name"),
+      description: external_exports.string().describe("Short description of what the skill does"),
+      content: external_exports.string().describe("Full SKILL.md content in markdown"),
+      source_ids: external_exports.string().optional().describe("JSON array of source spore/entity IDs"),
+      candidate_id: external_exports.string().optional().describe("Candidate ID that prompted this skill creation"),
+      rationale: external_exports.string().optional().describe("Why this skill was created or updated")
+    },
+    async (args) => {
+      const validationErrors = validateSkillContent(args.content, args.name);
+      if (validationErrors.length > 0) {
+        recordTurn("vault_write_skill", args);
+        return textResult({
+          error: "Skill validation failed. Fix these issues and try again.",
+          issues: validationErrors
+        });
+      }
+      if (!args.name || /[/\\]|\.\./.test(args.name)) {
+        recordTurn("vault_write_skill", args);
+        return textResult({
+          error: 'Invalid skill name: must be a simple directory name without path separators or ".."'
+        });
+      }
+      const root = projectRoot ?? process.cwd();
+      const skillDir = resolve(root, ".agents", "skills", args.name);
+      const skillPath = resolve(skillDir, "SKILL.md");
+      try {
+        mkdirSync(skillDir, { recursive: true });
+        writeFileSync(skillPath, args.content, "utf-8");
+      } catch (err) {
+        return textResult({ error: `Failed to write skill file: ${err instanceof Error ? err.message : String(err)}` });
+      }
+      try {
+        const { syncSkillSymlinks } = await import("./installer-25TSX4SR.js");
+        syncSkillSymlinks(root, args.name);
+      } catch (err) {
+        console.warn("[vault_write_skill] syncSkillSymlinks failed:", err instanceof Error ? err.message : err);
+      }
+      const now = epochSeconds();
+      const relativePath = `.agents/skills/${args.name}/SKILL.md`;
+      const existing = getSkillRecordByName(args.name);
+      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,
+              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, {
+                status: "generated",
+                skill_id: recordId,
+                updated_at: now
+              });
+              linkedCandidate = true;
+            }
+          }
+        }
+      })();
+      const isNew = generation === 1;
+      notify(vaultDir, {
+        domain: "skills",
+        type: isNew ? "skill.created" : "skill.evolved",
+        title: isNew ? `Skill created: ${args.display_name}` : `Skill evolved: ${args.display_name}`,
+        message: args.description.slice(0, 120),
+        link: `/skills?skill=${encodeURIComponent(args.name)}`,
+        metadata: { skillId: recordId, name: args.name, generation }
+      });
+      recordTurn("vault_write_skill", args);
+      return textResult({
+        id: recordId,
+        name: args.name,
+        path: relativePath,
+        generation
+      });
+    }
+  );
   return [
     vaultUnprocessed,
     vaultSpores,
@@ -600,19 +944,22 @@ function createVaultTools(agentId, runId, turnOffset = 0, embeddingManager, team
     vaultReadDigest,
     vaultWriteDigest,
     vaultMarkProcessed,
-    vaultReport
+    vaultReport,
+    vaultSkillCandidates,
+    vaultSkillRecords,
+    vaultWriteSkill
   ];
 }
-function createVaultToolServer(agentId, runId, embeddingManager) {
-  const tools = createVaultTools(agentId, runId, 0, embeddingManager);
+function createVaultToolServer(agentId, runId, options) {
+  const tools = createVaultTools(agentId, runId, options);
   return createSdkMcpServer({
     name: "myco-vault",
     version: getPluginVersion(),
     tools
   });
 }
-function createScopedVaultToolServer(agentId, runId, toolNames, turnOffset = 0, embeddingManager) {
-  const allTools = createVaultTools(agentId, runId, turnOffset, embeddingManager);
+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));
   return createSdkMcpServer({
@@ -997,7 +1344,7 @@ ${phase.prompt}`);
 var OLLAMA_PRELOAD_TIMEOUT_MS = 3e4;
 async function ensureOllamaContextVariant(model, contextLength) {
   const { execFileSync } = await import("child_process");
-  const { writeFileSync, unlinkSync } = await import("fs");
+  const { writeFileSync: writeFileSync2, unlinkSync } = await import("fs");
   const { tmpdir } = await import("os");
   const { join } = await import("path");
   const baseName = model.replace(/:latest$/, "");
@@ -1009,7 +1356,7 @@ async function ensureOllamaContextVariant(model, contextLength) {
   }
   try {
     const modelfilePath = join(tmpdir(), `myco-modelfile-${Date.now()}`);
-    writeFileSync(modelfilePath, `FROM ${model}
+    writeFileSync2(modelfilePath, `FROM ${model}
 PARAMETER num_ctx ${contextLength}
 `);
     execFileSync("ollama", ["create", variantName, "-f", modelfilePath], {
@@ -1128,9 +1475,9 @@ async function executePhase(query, phasePrompt, phaseModel, systemPrompt, toolSe
     };
   }
 }
-async function executeSingleQuery(config, systemPrompt, taskPrompt, agentId, runId, provider, embeddingManager, abortController) {
+async function executeSingleQuery(config, systemPrompt, taskPrompt, agentId, runId, provider, embeddingManager, abortController, vaultDir) {
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
-  const toolServer = createVaultToolServer(agentId, runId, embeddingManager);
+  const toolServer = createVaultToolServer(agentId, runId, { embeddingManager, vaultDir });
   const env = buildPhaseEnv(provider);
   const effectiveModel = provider?.model ?? config.model;
   let resultCostUsd = 0;
@@ -1157,7 +1504,7 @@ async function executeSingleQuery(config, systemPrompt, taskPrompt, agentId, run
   }
   return { tokensUsed: resultTokens, costUsd: resultCostUsd };
 }
-async function executePhasedQuery(config, systemPrompt, vaultContext, agentId, runId, taskProviderOverride, phaseProviderOverrides, instruction, embeddingManager, abortController) {
+async function executePhasedQuery(config, systemPrompt, vaultContext, agentId, runId, taskProviderOverride, phaseProviderOverrides, instruction, embeddingManager, abortController, projectRoot, vaultDir) {
   const { query } = await import("@anthropic-ai/claude-agent-sdk");
   const phases = config.phases;
   const phaseResults = [];
@@ -1209,8 +1556,12 @@ async function executePhasedQuery(config, systemPrompt, vaultContext, agentId, r
         agentId,
         runId,
         phase.tools,
-        runningTurnCount + indexInWave * effectiveMaxTurns,
-        embeddingManager
+        {
+          turnOffset: runningTurnCount + indexInWave * effectiveMaxTurns,
+          embeddingManager,
+          projectRoot,
+          vaultDir
+        }
       );
       const phaseProvider = phase.provider ?? phaseOverride?.provider ?? taskProviderOverride ?? config.execution?.provider;
       const env = buildPhaseEnv(phaseProvider);
@@ -1257,13 +1608,19 @@ 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 requestedTask = options?.task;
+  {
+    const effectiveTask = requestedTask ?? getDefaultTask(agentId)?.id;
+    if (effectiveTask) {
+      const runningId = getRunningRunForTask(agentId, effectiveTask);
+      if (runningId) {
+        return {
+          runId: runningId,
+          status: STATUS_SKIPPED,
+          reason: SKIP_REASON_ALREADY_RUNNING
+        };
+      }
+    }
   }
   const definitionsDir = resolveDefinitionsDir();
   const definition = loadAgentDefinition(definitionsDir);
@@ -1358,6 +1715,7 @@ async function runAgent(vaultDir, options) {
     let tokensUsed;
     let costUsd;
     if (config.phases && config.phases.length > 0) {
+      const projectRoot = resolve2(vaultDir, "..");
       const result = await executePhasedQuery(
         config,
         systemPrompt,
@@ -1368,7 +1726,9 @@ async function runAgent(vaultDir, options) {
         phaseProviderOverrides,
         options?.instruction,
         options?.embeddingManager,
-        taskAbortController
+        taskAbortController,
+        projectRoot,
+        vaultDir
       );
       tokensUsed = result.tokensUsed;
       costUsd = result.costUsd;
@@ -1389,7 +1749,8 @@ async function runAgent(vaultDir, options) {
         runId,
         singleProvider,
         options?.embeddingManager,
-        taskAbortController
+        taskAbortController,
+        vaultDir
       );
       tokensUsed = result.tokensUsed;
       costUsd = result.costUsd;
@@ -1451,4 +1812,4 @@ export {
   computeWaves,
   runAgent
 };
-//# sourceMappingURL=executor-LKDWMGC7.js.map
+//# sourceMappingURL=executor-W5MKZH7B.js.map