opencode-swarm 6.85.2 → 6.85.4

package/dist/cli/index.js

@@ -17611,13 +17611,13 @@ __export(exports_config_doctor, {
 import * as crypto3 from "crypto";
 import * as fs9 from "fs";
 import * as os5 from "os";
-import * as path18 from "path";
+import * as path19 from "path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path18.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path19.join(os5.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path18.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path18.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path19.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path19.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -17642,9 +17642,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path18.resolve(configPath);
-    const resolvedUser = path18.resolve(normalizedUser);
-    const resolvedProject = path18.resolve(normalizedProject);
+    const resolvedConfig = path19.resolve(configPath);
+    const resolvedUser = path19.resolve(normalizedUser);
+    const resolvedProject = path19.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -17684,12 +17684,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path18.join(directory, ".swarm");
+  const swarmDir = path19.join(directory, ".swarm");
   if (!fs9.existsSync(swarmDir)) {
     fs9.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path18.join(swarmDir, backupFilename);
+  const backupPath = path19.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -17719,7 +17719,7 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path18.dirname(targetPath);
+    const targetDir = path19.dirname(targetPath);
     if (!fs9.existsSync(targetDir)) {
       fs9.mkdirSync(targetDir, { recursive: true });
     }
@@ -17750,9 +17750,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path19, value, _config) {
+function validateConfigKey(path20, value, _config) {
   const findings = [];
-  switch (path19) {
+  switch (path20) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -17999,27 +17999,27 @@ function validateConfigKey(path19, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path19, config3, findings) {
+function walkConfigAndValidate(obj, path20, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path19 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path19, obj, config3);
+  if (path20 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path20, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path19, obj, config3);
+    const keyFindings = validateConfigKey(path20, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path19}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path20}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path19 ? `${path19}.${key}` : key;
+    const newPath = path20 ? `${path20}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -18139,7 +18139,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path18.dirname(configPath);
+    const configDir = path19.dirname(configPath);
     if (!fs9.existsSync(configDir)) {
       fs9.mkdirSync(configDir, { recursive: true });
     }
@@ -18149,12 +18149,12 @@ function applySafeAutoFixes(directory, result) {
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path18.join(directory, ".swarm");
+  const swarmDir = path19.join(directory, ".swarm");
   if (!fs9.existsSync(swarmDir)) {
     fs9.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path18.join(swarmDir, artifactFilename);
+  const artifactPath = path19.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -18515,8 +18515,8 @@ var init_evidence_summary_service = __esm(() => {
 });
 
 // src/cli/index.ts
-import * as fs23 from "fs";
-import * as os7 from "os";
+import * as fs22 from "fs";
+import * as os6 from "os";
 import * as path33 from "path";
 
 // src/commands/acknowledge-spec-drift.ts
@@ -20842,6 +20842,7 @@ async function handleBrainstormCommand(_directory, args) {
 init_zod();
 
 // src/tools/checkpoint.ts
+init_zod();
 import * as child_process from "child_process";
 import * as fs6 from "fs";
 import * as path8 from "path";
@@ -33184,7 +33185,8 @@ function createSwarmTool(opts) {
     execute: async (args, ctx) => {
       const directory = ctx?.directory ?? process.cwd();
       try {
-        return await opts.execute(args, directory, ctx);
+        const result = await opts.execute(args, directory, ctx);
+        return result;
       } catch (error93) {
         const message = error93 instanceof Error ? error93.message : String(error93);
         return JSON.stringify({
@@ -33410,8 +33412,8 @@ function handleDelete(label, directory) {
 var checkpoint = createSwarmTool({
   description: "Save, restore, list, and delete git checkpoints. " + "Use save to create a named snapshot, restore to return to a checkpoint (soft reset), " + "list to see all checkpoints, and delete to remove a checkpoint from the log. " + "Git commits are preserved on delete.",
   args: {
-    action: tool.schema.string().describe("Action to perform: save, restore, list, or delete"),
-    label: tool.schema.string().optional().describe("Checkpoint label (required for save, restore, delete)")
+    action: exports_external.string().describe("Action to perform: save, restore, list, or delete"),
+    label: exports_external.string().optional().describe("Checkpoint label (required for save, restore, delete)")
   },
   execute: async (args, directory) => {
     if (!isGitRepo()) {
@@ -33485,7 +33487,8 @@ var CheckpointResultSchema = exports_external.object({
   checkpoints: exports_external.array(exports_external.unknown()).optional()
 }).passthrough();
 function safeParseResult(result) {
-  const parsed = CheckpointResultSchema.safeParse(JSON.parse(result));
+  const jsonStr = typeof result === "string" ? result : result.output;
+  const parsed = CheckpointResultSchema.safeParse(JSON.parse(jsonStr));
   if (!parsed.success) {
     return {
       success: false,
@@ -33671,7 +33674,7 @@ function resolveSwarmRejectedPath(directory) {
 }
 function resolveHiveKnowledgePath() {
   const platform = process.platform;
-  const home = os3.homedir();
+  const home = process.env.HOME || os3.homedir();
   let dataDir;
   if (platform === "win32") {
     dataDir = path9.join(process.env.LOCALAPPDATA || path9.join(home, "AppData", "Local"), "opencode-swarm", "Data");
@@ -34429,6 +34432,7 @@ async function flushPendingSnapshot(directory) {
 }
 
 // src/tools/write-retro.ts
+init_zod();
 init_evidence_schema();
 init_manager2();
 async function executeWriteRetro(args, directory) {
@@ -34734,22 +34738,22 @@ async function executeWriteRetro(args, directory) {
 var write_retro = createSwarmTool({
   description: "Write a retrospective evidence bundle for a completed phase. " + "Accepts flat retro fields and writes a correctly-wrapped EvidenceBundle to " + ".swarm/evidence/retro-{phase}/evidence.json. " + "Use this instead of manually writing retro JSON to avoid schema validation failures in phase_complete.",
   args: {
-    phase: tool.schema.number().int().min(1).max(99).describe("The phase number being completed (e.g., 1, 2, 3)"),
-    summary: tool.schema.string().describe("Human-readable summary of the phase"),
-    task_count: tool.schema.number().int().min(1).max(9999).describe("Count of tasks completed in this phase"),
-    task_complexity: tool.schema.enum(["trivial", "simple", "moderate", "complex"]).describe("Complexity level of the completed tasks"),
-    total_tool_calls: tool.schema.number().int().min(0).max(9999).describe("Total number of tool calls in this phase"),
-    coder_revisions: tool.schema.number().int().min(0).max(999).describe("Number of coder revisions made"),
-    reviewer_rejections: tool.schema.number().int().min(0).max(999).describe("Number of reviewer rejections received"),
-    loop_detections: tool.schema.number().int().min(0).max(9999).optional().describe("Number of loop detection events in this phase"),
-    circuit_breaker_trips: tool.schema.number().int().min(0).max(9999).optional().describe("Number of circuit breaker trips in this phase"),
-    test_failures: tool.schema.number().int().min(0).max(9999).describe("Number of test failures encountered"),
-    security_findings: tool.schema.number().int().min(0).max(999).describe("Number of security findings"),
-    integration_issues: tool.schema.number().int().min(0).max(999).describe("Number of integration issues"),
-    lessons_learned: tool.schema.array(tool.schema.string()).max(5).optional().describe("Key lessons learned from this phase (max 5)"),
-    top_rejection_reasons: tool.schema.array(tool.schema.string()).optional().describe("Top reasons for reviewer rejections"),
-    task_id: tool.schema.string().optional().describe("Optional custom task ID (defaults to retro-{phase})"),
-    metadata: tool.schema.record(tool.schema.string(), tool.schema.unknown()).optional().describe("Optional additional metadata")
+    phase: exports_external.number().int().min(1).max(99).describe("The phase number being completed (e.g., 1, 2, 3)"),
+    summary: exports_external.string().describe("Human-readable summary of the phase"),
+    task_count: exports_external.number().int().min(1).max(9999).describe("Count of tasks completed in this phase"),
+    task_complexity: exports_external.enum(["trivial", "simple", "moderate", "complex"]).describe("Complexity level of the completed tasks"),
+    total_tool_calls: exports_external.number().int().min(0).max(9999).describe("Total number of tool calls in this phase"),
+    coder_revisions: exports_external.number().int().min(0).max(999).describe("Number of coder revisions made"),
+    reviewer_rejections: exports_external.number().int().min(0).max(999).describe("Number of reviewer rejections received"),
+    loop_detections: exports_external.number().int().min(0).max(9999).optional().describe("Number of loop detection events in this phase"),
+    circuit_breaker_trips: exports_external.number().int().min(0).max(9999).optional().describe("Number of circuit breaker trips in this phase"),
+    test_failures: exports_external.number().int().min(0).max(9999).describe("Number of test failures encountered"),
+    security_findings: exports_external.number().int().min(0).max(999).describe("Number of security findings"),
+    integration_issues: exports_external.number().int().min(0).max(999).describe("Number of integration issues"),
+    lessons_learned: exports_external.array(exports_external.string()).max(5).optional().describe("Key lessons learned from this phase (max 5)"),
+    top_rejection_reasons: exports_external.array(exports_external.string()).optional().describe("Top reasons for reviewer rejections"),
+    task_id: exports_external.string().optional().describe("Optional custom task ID (defaults to retro-{phase})"),
+    metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional().describe("Optional additional metadata")
   },
   execute: async (args, directory) => {
     const rawPhase = args.phase !== undefined ? Number(args.phase) : 0;
@@ -35346,6 +35350,9 @@ async function handleCouncilCommand(_directory, args) {
   return `[${tokens.join(" ")}] ${question}`;
 }
 
+// src/hooks/hive-promoter.ts
+import path15 from "path";
+
 // src/background/event-bus.ts
 init_utils();
 
@@ -35567,6 +35574,86 @@ async function checkHivePromotions(swarmEntries, config3) {
     total_hive_entries: hiveEntries.length
   };
 }
+async function promoteToHive(directory, lesson, category) {
+  const trimmedLesson = lesson.trim();
+  const hiveEntries = await readKnowledge(resolveHiveKnowledgePath());
+  const validationResult = validateLesson(trimmedLesson, hiveEntries.map((e) => e.lesson), {
+    category: category || "process",
+    scope: "global",
+    confidence: 1
+  });
+  if (validationResult.severity === "error") {
+    throw new Error(`Lesson rejected by validator: ${validationResult.reason}`);
+  }
+  if (findNearDuplicate(trimmedLesson, hiveEntries, 0.6)) {
+    return `Lesson already exists in hive (near-duplicate).`;
+  }
+  const newHiveEntry = {
+    id: crypto.randomUUID(),
+    tier: "hive",
+    lesson: trimmedLesson,
+    category: category || "process",
+    tags: [],
+    scope: "global",
+    confidence: 1,
+    status: "promoted",
+    confirmed_by: [],
+    retrieval_outcomes: {
+      applied_count: 0,
+      succeeded_after_count: 0,
+      failed_after_count: 0
+    },
+    schema_version: 1,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    source_project: path15.basename(directory) || "unknown",
+    encounter_score: 1
+  };
+  await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
+  return `Promoted to hive: "${trimmedLesson.slice(0, 50)}${trimmedLesson.length > 50 ? "..." : ""}" (confidence: 1.0, source: manual)`;
+}
+async function promoteFromSwarm(directory, lessonId) {
+  const swarmEntries = await readKnowledge(resolveSwarmKnowledgePath(directory));
+  const swarmEntry = swarmEntries.find((e) => e.id === lessonId);
+  if (!swarmEntry) {
+    throw new Error(`Lesson ${lessonId} not found in .swarm/knowledge.jsonl`);
+  }
+  const hiveEntries = await readKnowledge(resolveHiveKnowledgePath());
+  const validationResult = validateLesson(swarmEntry.lesson, hiveEntries.map((e) => e.lesson), {
+    category: swarmEntry.category,
+    scope: swarmEntry.scope,
+    confidence: swarmEntry.confidence
+  });
+  if (validationResult.severity === "error") {
+    throw new Error(`Lesson rejected by validator: ${validationResult.reason}`);
+  }
+  if (findNearDuplicate(swarmEntry.lesson, hiveEntries, 0.6)) {
+    return `Lesson already exists in hive (near-duplicate).`;
+  }
+  const newHiveEntry = {
+    id: crypto.randomUUID(),
+    tier: "hive",
+    lesson: swarmEntry.lesson,
+    category: swarmEntry.category,
+    tags: swarmEntry.tags,
+    scope: swarmEntry.scope,
+    confidence: 1,
+    status: "promoted",
+    confirmed_by: [],
+    retrieval_outcomes: {
+      applied_count: 0,
+      succeeded_after_count: 0,
+      failed_after_count: 0
+    },
+    schema_version: 1,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    source_project: swarmEntry.project_name,
+    encounter_score: 1
+  };
+  await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
+  return `Promoted lesson ${lessonId} from swarm to hive: "${swarmEntry.lesson.slice(0, 50)}${swarmEntry.lesson.length > 50 ? "..." : ""}"`;
+}
 
 // src/commands/curate.ts
 async function handleCurateCommand(directory, _args) {
@@ -35597,13 +35684,14 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
-import path16 from "path";
+import path17 from "path";
 
 // src/tools/co-change-analyzer.ts
+init_zod();
 import * as child_process3 from "child_process";
 import { randomUUID } from "crypto";
 import { readdir, readFile as readFile3, stat } from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process3.execFile);
@@ -35705,7 +35793,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path15.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -35713,7 +35801,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path15.extname(entry.name);
+        const ext = path16.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -35735,8 +35823,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path15.dirname(sourceFile);
-          const resolvedPath = path15.resolve(sourceDir, importPath);
+          const sourceDir = path16.dirname(sourceFile);
+          const resolvedPath = path16.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -35761,8 +35849,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path15.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path15.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path16.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path16.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -35774,7 +35862,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path15.basename(filePath);
+    const base = path16.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -35784,16 +35872,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path15.basename(fileA) && baseA !== path15.basename(fileB);
+  return baseA === baseB && baseA !== path16.basename(fileA) && baseA !== path16.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path15.dirname(fileA);
-  const dirB = path15.dirname(fileB);
+  const dirA = path16.dirname(fileA);
+  const dirB = path16.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path15.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path15.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path16.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path16.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -35847,8 +35935,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path15.basename(pair.fileA);
-    const baseB = path15.basename(pair.fileB);
+    const baseA = path16.basename(pair.fileA);
+    const baseB = path16.basename(pair.fileB);
     let lesson = `Files ${pair.fileA} and ${pair.fileB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
     if (lesson.length > 280) {
       lesson = `Files ${baseA} and ${baseB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
@@ -35906,10 +35994,10 @@ Consider adding explicit documentation or extracting the shared concern.`;
 var co_change_analyzer = createSwarmTool({
   description: "Detects hidden couplings (dark matter) by analyzing git history to find file pairs that frequently co-change but have no import relationship. Useful for identifying architectural concerns that are not explicitly documented.",
   args: {
-    min_commits: tool.schema.number().optional().describe("Minimum commit count to analyze (default: 20)"),
-    min_co_changes: tool.schema.number().optional().describe("Minimum co-change count to consider (default: 3)"),
-    threshold: tool.schema.number().optional().describe("NPMI threshold for filtering (default: 0.5)"),
-    max_commits: tool.schema.number().optional().describe("Maximum commits to analyze (default: 500)")
+    min_commits: exports_external.number().optional().describe("Minimum commit count to analyze (default: 20)"),
+    min_co_changes: exports_external.number().optional().describe("Minimum co-change count to consider (default: 3)"),
+    threshold: exports_external.number().optional().describe("NPMI threshold for filtering (default: 0.5)"),
+    max_commits: exports_external.number().optional().describe("Maximum commits to analyze (default: 500)")
   },
   async execute(args, directory) {
     let minCommits;
@@ -35958,7 +36046,7 @@ async function handleDarkMatterCommand(directory, args) {
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path16.basename(path16.resolve(directory));
+      const projectName = path17.basename(path17.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -35980,7 +36068,7 @@ async function handleDarkMatterCommand(directory, args) {
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
 import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import { fileURLToPath } from "url";
 init_manager2();
 init_utils2();
@@ -36280,7 +36368,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path17.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path18.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync8(configPath)) {
     return {
       name: "Config Parseability",
@@ -36305,6 +36393,12 @@ async function checkConfigParseability(directory) {
     };
   }
 }
+function resolveGrammarDir(thisDir) {
+  const normalized = thisDir.replace(/\\/g, "/");
+  const isSource = normalized.endsWith("/src/services");
+  const isCliBundle = normalized.endsWith("/cli");
+  return isSource || isCliBundle ? path18.join(thisDir, "..", "lang", "grammars") : path18.join(thisDir, "lang", "grammars");
+}
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
     "tree-sitter-javascript.wasm",
@@ -36327,15 +36421,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path17.dirname(fileURLToPath(import.meta.url));
-  const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/services");
-  const grammarDir = isSource ? path17.join(thisDir, "..", "lang", "grammars") : path17.join(thisDir, "lang", "grammars");
+  const thisDir = path18.dirname(fileURLToPath(import.meta.url));
+  const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync8(path17.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync8(path18.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync8(path17.join(grammarDir, file3))) {
+    if (!existsSync8(path18.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -36353,7 +36446,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path17.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path18.join(directory, ".swarm/checkpoints.json");
   if (!existsSync8(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -36405,7 +36498,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
   if (!existsSync8(eventsPath)) {
     return {
       name: "Event Stream",
@@ -36446,7 +36539,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
   if (!existsSync8(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -36502,7 +36595,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path17.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path18.join(directory, ".swarm/curator-summary.json");
     if (!existsSync8(summaryPath)) {
       return {
         name: "Curator",
@@ -36650,7 +36743,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path17.join(directory, ".swarm", "evidence");
+    const evidenceDir = path18.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync8(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -36703,11 +36796,11 @@ init_config_doctor();
 
 // src/services/tool-doctor.ts
 import * as fs11 from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 
 // src/build/discovery.ts
 import * as fs10 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 
 // src/lang/detector.ts
 import { access as access2, readdir as readdir2 } from "fs/promises";
@@ -37211,7 +37304,7 @@ LANGUAGE_REGISTRY.register({
   displayName: "C# / .NET",
   tier: 2,
   extensions: [".cs", ".csx"],
-  treeSitter: { grammarId: "c_sharp", wasmFile: "tree-sitter-c_sharp.wasm" },
+  treeSitter: { grammarId: "csharp", wasmFile: "tree-sitter-c-sharp.wasm" },
   build: {
     detectFiles: ["*.csproj", "*.sln", "Directory.Build.props"],
     commands: [
@@ -37871,11 +37964,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path19.join(dir, matches[0]);
+          return path20.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path19.join(workingDir, pattern);
+      const filePath = path20.join(workingDir, pattern);
       if (fs10.existsSync(filePath)) {
         return filePath;
       }
@@ -37884,7 +37977,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path19.join(workingDir, "package.json");
+  const packageJsonPath = path20.join(workingDir, "package.json");
   if (!fs10.existsSync(packageJsonPath)) {
     return [];
   }
@@ -37925,7 +38018,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path19.join(workingDir, pattern);
+        const filePath = path20.join(workingDir, pattern);
         if (fs10.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -37938,7 +38031,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs10.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path19.join(dir, entry.name);
+      const fullPath = path20.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -37961,7 +38054,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path19.join(workingDir, cmd.detectFile);
+        const detectFilePath = path20.join(workingDir, cmd.detectFile);
         if (!fs10.existsSync(detectFilePath)) {
           continue;
         }
@@ -38136,8 +38229,8 @@ function checkBinaryReadiness() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path20.resolve(import.meta.dir, "..", "..");
-  const indexPath = path20.join(resolvedPluginRoot, "src", "index.ts");
+  const resolvedPluginRoot = pluginRoot ?? path21.resolve(import.meta.dir, "..", "..");
+  const indexPath = path21.join(resolvedPluginRoot, "src", "index.ts");
   if (!fs11.existsSync(indexPath)) {
     return {
       findings: [
@@ -39060,10 +39153,10 @@ async function handleHistoryCommand(directory, _args) {
 import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path21.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path21.join(directory, ".swarm", "context.md");
+  const sentinelPath = path22.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path22.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync12(sentinelPath)) {
     return {
@@ -39259,7 +39352,7 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path21.join(directory, "package.json");
+  const packageJsonPath = path22.join(directory, "package.json");
   if (existsSync12(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
@@ -39268,7 +39361,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path21.basename(directory);
+  return path22.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -39280,7 +39373,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir3(path21.dirname(sentinelPath), { recursive: true });
+  await mkdir3(path22.dirname(sentinelPath), { recursive: true });
   await writeFile4(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 
@@ -39517,11 +39610,12 @@ async function handlePlanCommand(directory, args) {
 init_manager2();
 init_manager();
 import * as fs18 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 
 // src/tools/lint.ts
+init_zod();
 import * as fs12 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 init_utils();
 
 // src/utils/path-security.ts
@@ -39567,9 +39661,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path22.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path22.join(binDir, "biome.EXE") : path22.join(binDir, "biome");
-  const eslintBin = isWindows ? path22.join(binDir, "eslint.cmd") : path22.join(binDir, "eslint");
+  const binDir = path23.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path23.join(binDir, "biome.EXE") : path23.join(binDir, "biome");
+  const eslintBin = isWindows ? path23.join(binDir, "eslint.cmd") : path23.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -39585,7 +39679,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs12.existsSync(path22.join(cwd, gradlewName)) ? path22.join(cwd, gradlewName) : null;
+  const gradlew = fs12.existsSync(path23.join(cwd, gradlewName)) ? path23.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -39619,10 +39713,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs12.existsSync(path22.join(cwd, "ruff.toml")))
+  if (fs12.existsSync(path23.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path22.join(cwd, "pyproject.toml");
+    const pyproject = path23.join(cwd, "pyproject.toml");
     if (fs12.existsSync(pyproject)) {
       const content = fs12.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -39632,19 +39726,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs12.existsSync(path22.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs12.existsSync(path23.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs12.existsSync(path22.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs12.existsSync(path23.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs12.existsSync(path22.join(cwd, "pom.xml"));
-  const hasGradle = fs12.existsSync(path22.join(cwd, "build.gradle")) || fs12.existsSync(path22.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs12.existsSync(path22.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs12.existsSync(path23.join(cwd, "pom.xml"));
+  const hasGradle = fs12.existsSync(path23.join(cwd, "build.gradle")) || fs12.existsSync(path23.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs12.existsSync(path23.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs12.existsSync(path22.join(cwd, "build.gradle.kts")) || fs12.existsSync(path22.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs12.existsSync(path23.join(cwd, "build.gradle.kts")) || fs12.existsSync(path23.join(cwd, "build.gradle")) || (() => {
     try {
       return fs12.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -39663,11 +39757,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs12.existsSync(path22.join(cwd, "CMakeLists.txt"))) {
+  if (fs12.existsSync(path23.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path22.join(cwd, "src")];
+    const dirsToCheck = [cwd, path23.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs12.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -39681,13 +39775,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs12.existsSync(path22.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs12.existsSync(path23.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs12.existsSync(path22.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs12.existsSync(path23.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs12.existsSync(path22.join(cwd, "Gemfile")) || fs12.existsSync(path22.join(cwd, "gems.rb")) || fs12.existsSync(path22.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs12.existsSync(path23.join(cwd, "Gemfile")) || fs12.existsSync(path23.join(cwd, "gems.rb")) || fs12.existsSync(path23.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -39715,10 +39809,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path22.join(dir, "node_modules", ".bin", binName);
+    const candidate = path23.join(dir, "node_modules", ".bin", binName);
     if (fs12.existsSync(candidate))
       return candidate;
-    const parent = path22.dirname(dir);
+    const parent = path23.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -39727,10 +39821,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path22.delimiter)) {
+  for (const dir of searchPath.split(path23.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path22.join(dir, binName);
+    const candidate = path23.join(dir, binName);
     if (fs12.existsSync(candidate))
       return candidate;
   }
@@ -39743,13 +39837,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path22.join(projectDir, "node_modules", ".bin", "biome.EXE") : path22.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path22.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path22.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path23.join(projectDir, "node_modules", ".bin", "biome.EXE") : path23.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path23.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path23.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path22.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path22.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path23.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path23.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -39911,7 +40005,7 @@ async function runAdditionalLint(linter, mode, cwd) {
 var lint = createSwarmTool({
   description: "Run project linter in check or fix mode. Supports biome, eslint (JS/TS), ruff (Python), clippy (Rust), golangci-lint (Go), checkstyle (Java), ktlint (Kotlin), dotnet-format (C#), cppcheck (C/C++), swiftlint (Swift), dart analyze (Dart), and rubocop (Ruby). Returns JSON with success status, exit code, and output for architect pre-reviewer gate. Use check mode for CI/linting and fix mode to automatically apply fixes.",
   args: {
-    mode: tool.schema.enum(["fix", "check"]).describe('Linting mode: "check" for read-only lint check, "fix" to automatically apply fixes')
+    mode: exports_external.enum(["fix", "check"]).describe('Linting mode: "check" for read-only lint check, "fix" to automatically apply fixes')
   },
   async execute(args, directory) {
     if (!validateArgs(args)) {
@@ -39956,8 +40050,9 @@ For Rust: rustup component add clippy`
 });
 
 // src/tools/secretscan.ts
+init_zod();
 import * as fs13 from "fs";
-import * as path23 from "path";
+import * as path24 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -40184,7 +40279,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path23.join(scanDir, ".secretscanignore");
+  const ignorePath = path24.join(scanDir, ".secretscanignore");
   try {
     if (!fs13.existsSync(ignorePath))
       return [];
@@ -40207,7 +40302,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path23.matchesGlob(relPath, pattern))
+    if (path24.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -40228,7 +40323,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path24.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -40365,9 +40460,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path23.resolve(scanDir);
-  const resolvedRealPath = path23.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path23.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path24.resolve(scanDir);
+  const resolvedRealPath = path24.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path24.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -40393,8 +40488,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path23.join(dir, entry);
-    const relPath = path23.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path24.join(dir, entry);
+    const relPath = path24.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -40429,7 +40524,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path23.extname(fullPath).toLowerCase();
+      const ext = path24.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -40442,8 +40537,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 var secretscan = createSwarmTool({
   description: "Scan directory for potential secrets (API keys, tokens, passwords) using regex patterns and entropy heuristics. Returns metadata-only findings with redacted previews - NEVER returns raw secrets. Excludes common directories (node_modules, .git, dist, etc.) by default. Supports glob patterns (e.g. **/.svelte-kit/**, **/*.test.ts) and reads .secretscanignore at the scan root.",
   args: {
-    directory: tool.schema.string().describe('Directory to scan for secrets (e.g., "." or "./src")'),
-    exclude: tool.schema.array(tool.schema.string()).optional().describe("Patterns to exclude: plain directory names (e.g. node_modules), relative paths, or globs (e.g. **/.svelte-kit/**, **/*.test.ts). Added to default exclusions.")
+    directory: exports_external.string().describe('Directory to scan for secrets (e.g., "." or "./src")'),
+    exclude: exports_external.array(exports_external.string()).optional().describe("Patterns to exclude: plain directory names (e.g. node_modules), relative paths, or globs (e.g. **/.svelte-kit/**, **/*.test.ts). Added to default exclusions.")
   },
   async execute(args, _directory, _ctx) {
     const typedArgs = args;
@@ -40495,7 +40590,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path23.resolve(directory);
+      const _scanDirRaw = path24.resolve(directory);
       const scanDir = (() => {
         try {
           return fs13.realpathSync(_scanDirRaw);
@@ -40637,7 +40732,8 @@ var secretscan = createSwarmTool({
 async function runSecretscan(directory) {
   try {
     const result = await secretscan.execute({ directory }, {});
-    return JSON.parse(result);
+    const jsonStr = typeof result === "string" ? result : result.output;
+    return JSON.parse(jsonStr);
   } catch (e) {
     const errorResult = {
       error: e instanceof Error ? `scan failed: ${e.message}` : "scan failed: unknown error",
@@ -40652,12 +40748,13 @@ async function runSecretscan(directory) {
 }
 
 // src/tools/test-runner.ts
+init_zod();
 import * as fs17 from "fs";
-import * as path27 from "path";
+import * as path28 from "path";
 
 // src/test-impact/analyzer.ts
 import fs14 from "fs";
-import path24 from "path";
+import path25 from "path";
 var IMPORT_REGEX_ES = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
 var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
@@ -40682,8 +40779,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path24.resolve(fromDir, importPath);
-  if (path24.extname(resolved)) {
+  const resolved = path25.resolve(fromDir, importPath);
+  if (path25.extname(resolved)) {
     if (fs14.existsSync(resolved) && fs14.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -40728,12 +40825,12 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path24.join(dir, entry.name), visitedInodes);
+          walk(path25.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name = entry.name;
         if (/\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name)) {
-          testFiles.push(normalizePath(path24.join(dir, entry.name)));
+          testFiles.push(normalizePath(path25.join(dir, entry.name)));
         }
       }
     }
@@ -40771,7 +40868,7 @@ async function buildImpactMapInternal(cwd) {
       continue;
     }
     const imports = extractImports(content);
-    const testDir = path24.dirname(testFile);
+    const testDir = path25.dirname(testFile);
     for (const importPath of imports) {
       const resolvedSource = resolveRelativeImport(testDir, importPath);
       if (resolvedSource === null) {
@@ -40793,7 +40890,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd) {
-  const cachePath = path24.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path25.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs14.existsSync(cachePath)) {
     try {
       const content = fs14.readFileSync(cachePath, "utf-8");
@@ -40808,8 +40905,8 @@ async function loadImpactMap(cwd) {
   return buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  const cacheDir = path24.join(cwd, ".swarm", "cache");
-  const cachePath = path24.join(cacheDir, "impact-map.json");
+  const cacheDir = path25.join(cwd, ".swarm", "cache");
+  const cachePath = path25.join(cacheDir, "impact-map.json");
   if (!fs14.existsSync(cacheDir)) {
     fs14.mkdirSync(cacheDir, { recursive: true });
   }
@@ -40835,7 +40932,7 @@ async function analyzeImpact(changedFiles, cwd) {
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   for (const changedFile of validFiles) {
-    const normalizedChanged = normalizePath(path24.resolve(changedFile));
+    const normalizedChanged = normalizePath(path25.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -41082,13 +41179,13 @@ function detectFlakyTests(allHistory) {
 
 // src/test-impact/history-store.ts
 import fs15 from "fs";
-import path25 from "path";
+import path26 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
 var MAX_CHANGED_FILES = 50;
 function getHistoryPath(workingDir) {
-  return path25.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
+  return path26.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -41148,7 +41245,7 @@ function appendTestRun(record3, workingDir) {
     changedFiles: sanitizeChangedFiles(record3.changedFiles || [])
   };
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path25.dirname(historyPath);
+  const historyDir = path26.dirname(historyPath);
   if (!fs15.existsSync(historyDir)) {
     fs15.mkdirSync(historyDir, { recursive: true });
   }
@@ -41222,7 +41319,7 @@ function getAllHistory(workingDir) {
 
 // src/tools/resolve-working-directory.ts
 import * as fs16 from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -41242,15 +41339,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path26.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path26.sep);
+  const normalizedDir = path27.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path27.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path26.resolve(normalizedDir);
+  const resolvedDir = path27.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs16.statSync(resolvedDir);
@@ -41266,7 +41363,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path26.resolve(fallbackDirectory);
+  const resolvedFallback = path27.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs16.statSync(resolvedFallback);
@@ -41276,7 +41373,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path26.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path27.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -41366,14 +41463,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs17.existsSync(path27.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs17.existsSync(path28.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs17.existsSync(path27.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs17.existsSync(path28.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs17.existsSync(path27.join(cwd, "build.gradle")) || fs17.existsSync(path27.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs17.existsSync(path27.join(cwd, "gradlew")) || fs17.existsSync(path27.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs17.existsSync(path28.join(cwd, "build.gradle")) || fs17.existsSync(path28.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs17.existsSync(path28.join(cwd, "gradlew")) || fs17.existsSync(path28.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -41386,30 +41483,30 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs17.existsSync(path27.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs17.existsSync(path27.join(cwd, "CMakeCache.txt")) || fs17.existsSync(path27.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs17.existsSync(path28.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs17.existsSync(path28.join(cwd, "CMakeCache.txt")) || fs17.existsSync(path28.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs17.existsSync(path27.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs17.existsSync(path28.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs17.existsSync(path27.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs17.existsSync(path28.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs17.existsSync(path27.join(cwd, ".rspec"));
-  const hasGemfile = fs17.existsSync(path27.join(cwd, "Gemfile"));
-  const hasSpecDir = fs17.existsSync(path27.join(cwd, "spec"));
+  const hasRSpecFile = fs17.existsSync(path28.join(cwd, ".rspec"));
+  const hasGemfile = fs17.existsSync(path28.join(cwd, "Gemfile"));
+  const hasSpecDir = fs17.existsSync(path28.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs17.existsSync(path27.join(cwd, "test")) && (fs17.existsSync(path27.join(cwd, "Gemfile")) || fs17.existsSync(path27.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs17.existsSync(path28.join(cwd, "test")) && (fs17.existsSync(path28.join(cwd, "Gemfile")) || fs17.existsSync(path28.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path27.join(baseDir, "package.json");
+    const packageJsonPath = path28.join(baseDir, "package.json");
     if (fs17.existsSync(packageJsonPath)) {
       const content = fs17.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -41430,16 +41527,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs17.existsSync(path27.join(baseDir, "bun.lockb")) || fs17.existsSync(path27.join(baseDir, "bun.lock"))) {
+      if (fs17.existsSync(path28.join(baseDir, "bun.lockb")) || fs17.existsSync(path28.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path27.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path27.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path27.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path28.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path28.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path28.join(baseDir, "requirements.txt");
     if (fs17.existsSync(pyprojectTomlPath)) {
       const content = fs17.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -41459,7 +41556,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path27.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path28.join(baseDir, "Cargo.toml");
     if (fs17.existsSync(cargoTomlPath)) {
       const content = fs17.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -41470,9 +41567,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path27.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path27.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path27.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path28.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path28.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path28.join(baseDir, "tests.ps1");
     if (fs17.existsSync(pesterConfigPath) || fs17.existsSync(pesterConfigJsonPath) || fs17.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -41515,12 +41612,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path27.isAbsolute(file3) ? path27.resolve(file3) : path27.resolve(workingDir, file3);
+  return path28.isAbsolute(file3) ? path28.resolve(file3) : path28.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path27.relative(workingDir, absolutePath);
+  return path28.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -41557,18 +41654,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path27.dirname(relativePath);
+  const relativeDir = path28.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path27.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path27.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path28.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path28.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path27.join(workingDir, "src/test/java", path27.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path28.join(workingDir, "src/test/java", path28.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path27.join(workingDir, "src/test/kotlin", path27.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path28.join(workingDir, "src/test/kotlin", path28.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -41596,23 +41693,23 @@ function isLanguageSpecificTestFile(basename4) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename4 = path27.basename(filePath);
+  const basename4 = path28.basename(filePath);
   return hasCompoundTestExtension(basename4) || basename4.includes(".spec.") || basename4.includes(".test.") || isLanguageSpecificTestFile(basename4) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path27.relative(workingDir, absoluteFile);
-    const basename4 = path27.basename(absoluteFile);
-    const dirname11 = path27.dirname(absoluteFile);
-    const preferRelativeOutput = !path27.isAbsolute(file3);
+    const relativeFile = path28.relative(workingDir, absoluteFile);
+    const basename4 = path28.basename(absoluteFile);
+    const dirname11 = path28.dirname(absoluteFile);
+    const preferRelativeOutput = !path28.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename4.replace(/\.[^.]+$/, "");
-    const ext = path27.extname(basename4);
+    const ext = path28.extname(basename4);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -41621,7 +41718,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path27.join(dirname11, candidateName));
+    ].map((candidateName) => path28.join(dirname11, candidateName));
     const testDirectoryNames = [
       basename4,
       ...genericTestNames,
@@ -41630,8 +41727,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path27.join(dirname11, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path27.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path28.join(dirname11, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path28.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs17.existsSync(testFile)) {
@@ -41652,7 +41749,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs17.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path27.dirname(absoluteTestFile);
+      const testDir = path28.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -41660,8 +41757,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path27.resolve(testDir, importPath);
-          const existingExt = path27.extname(resolvedImport);
+          resolvedImport = path28.resolve(testDir, importPath);
+          const existingExt = path28.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -41681,12 +41778,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
-        const importDir = path27.dirname(resolvedImport);
+        const importBasename = path28.basename(resolvedImport, path28.extname(resolvedImport));
+        const importDir = path28.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path27.dirname(sourceFile);
-          const sourceBasename = path27.basename(sourceFile, path27.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path27.join(sourceDir, "__tests__") || importDir === path27.join(sourceDir, "tests") || importDir === path27.join(sourceDir, "test") || importDir === path27.join(sourceDir, "spec");
+          const sourceDir = path28.dirname(sourceFile);
+          const sourceBasename = path28.basename(sourceFile, path28.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path28.join(sourceDir, "__tests__") || importDir === path28.join(sourceDir, "tests") || importDir === path28.join(sourceDir, "test") || importDir === path28.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -41699,8 +41796,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path27.resolve(testDir, importPath);
-          const existingExt = path27.extname(resolvedImport);
+          let resolvedImport = path28.resolve(testDir, importPath);
+          const existingExt = path28.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -41717,12 +41814,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path27.dirname(resolvedImport);
-          const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
+          const importDir = path28.dirname(resolvedImport);
+          const importBasename = path28.basename(resolvedImport, path28.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path27.dirname(sourceFile);
-            const sourceBasename = path27.basename(sourceFile, path27.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path27.join(sourceDir, "__tests__") || importDir === path27.join(sourceDir, "tests") || importDir === path27.join(sourceDir, "test") || importDir === path27.join(sourceDir, "spec");
+            const sourceDir = path28.dirname(sourceFile);
+            const sourceBasename = path28.basename(sourceFile, path28.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path28.join(sourceDir, "__tests__") || importDir === path28.join(sourceDir, "tests") || importDir === path28.join(sourceDir, "test") || importDir === path28.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -41825,8 +41922,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs17.existsSync(path27.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs17.existsSync(path27.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs17.existsSync(path28.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs17.existsSync(path28.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -41843,7 +41940,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs17.existsSync(path27.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs17.existsSync(path28.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -42341,12 +42438,12 @@ function analyzeFailures(workingDir) {
 var test_runner = createSwarmTool({
   description: 'Run project tests with framework detection. Supports bun, vitest, jest, mocha, pytest, cargo, pester, go-test, maven, gradle, dotnet-test, ctest, swift-test, dart-test, rspec, and minitest. Returns deterministic normalized JSON with framework, scope, command, totals, coverage, duration, success status, and failures. Use scope "all" for full suite, "convention" to accept direct test files or map source files to test files, "graph" to find related tests via imports from source files, or "impact" to find tests covering changed source files using test-impact analysis.',
   args: {
-    scope: tool.schema.enum(["all", "convention", "graph", "impact"]).optional().describe('Test scope: "all" runs full suite, "convention" accepts direct test files or maps source files to tests by naming, "graph" finds related tests via imports from source files, "impact" finds tests covering changed source files via test-impact analysis'),
-    files: tool.schema.array(tool.schema.string()).optional().describe('Specific files to test. For "convention", pass source files or direct test files. For "graph" and "impact", pass source files only.'),
-    coverage: tool.schema.boolean().optional().describe("Enable coverage reporting if supported"),
-    timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default 60000, max 300000)"),
-    allow_full_suite: tool.schema.boolean().optional().describe('Explicit opt-in for scope "all". Required because full-suite output can destabilize SSE streaming.'),
-    working_directory: tool.schema.string().optional().describe("Explicit project root directory. When provided, tests run relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
+    scope: exports_external.enum(["all", "convention", "graph", "impact"]).optional().describe('Test scope: "all" runs full suite, "convention" accepts direct test files or maps source files to tests by naming, "graph" finds related tests via imports from source files, "impact" finds tests covering changed source files via test-impact analysis'),
+    files: exports_external.array(exports_external.string()).optional().describe('Specific files to test. For "convention", pass source files or direct test files. For "graph" and "impact", pass source files only.'),
+    coverage: exports_external.boolean().optional().describe("Enable coverage reporting if supported"),
+    timeout_ms: exports_external.number().optional().describe("Timeout in milliseconds (default 60000, max 300000)"),
+    allow_full_suite: exports_external.boolean().optional().describe('Explicit opt-in for scope "all". Required because full-suite output can destabilize SSE streaming.'),
+    working_directory: exports_external.string().optional().describe("Explicit project root directory. When provided, tests run relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
   },
   async execute(args, directory) {
     let workingDirInput;
@@ -42471,7 +42568,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file3) => {
         if (directTestFiles.includes(file3))
           return false;
-        const ext = path27.extname(file3).toLowerCase();
+        const ext = path28.extname(file3).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -42506,7 +42603,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path27.extname(f).toLowerCase();
+        const ext = path28.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -42533,7 +42630,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path27.extname(f).toLowerCase();
+        const ext = path28.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -42551,8 +42648,8 @@ var test_runner = createSwarmTool({
         const impactResult = await analyzeImpact(sourceFiles, workingDir);
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path27.relative(workingDir, absPath);
-            return path27.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path28.relative(workingDir, absPath);
+            return path28.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -42645,8 +42742,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path28.normalize(dir);
-  const absolutePath = path28.isAbsolute(normalized) ? normalized : path28.resolve(normalized);
+  const normalized = path29.normalize(dir);
+  const absolutePath = path29.isAbsolute(normalized) ? normalized : path29.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -42669,7 +42766,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path28.join(dir, "package.json");
+    const packagePath = path29.join(dir, "package.json");
     if (fs18.existsSync(packagePath)) {
       const content = fs18.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -42680,7 +42777,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path28.join(dir, "CHANGELOG.md");
+    const changelogPath = path29.join(dir, "CHANGELOG.md");
     if (fs18.existsSync(changelogPath)) {
       const content = fs18.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -42694,7 +42791,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path28.join(dir, file3);
+    const filePath = path29.join(dir, file3);
     if (fs18.existsSync(filePath)) {
       try {
         const content = fs18.readFileSync(filePath, "utf-8").trim();
@@ -43021,7 +43118,7 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path28.join(dir, ".swarm", "spec.md");
+    const specPath = path29.join(dir, ".swarm", "spec.md");
     if (!fs18.existsSync(specPath)) {
       return {
         type: "req_coverage",
@@ -43234,144 +43331,6 @@ async function handlePreflightCommand(directory, _args) {
   const report = await runPreflight(directory, phase);
   return formatPreflightMarkdown(report);
 }
-// src/knowledge/hive-promoter.ts
-import * as fs19 from "fs";
-import * as os6 from "os";
-import * as path29 from "path";
-var DANGEROUS_PATTERNS = [
-  [/rm\s+-rf/, "rm\\s+-rf"],
-  [/:\s*!\s*\|/, ":\\s*!\\s*\\|"],
-  [/\|\s*sh\b/, "\\|\\s*sh\\b"],
-  [/`[^`]*`/, "`[^`]*`"],
-  [/\$\(/, "\\$\\("],
-  [/;\s*rm\s+\//, ";\\s*rm\\s+\\/"],
-  [/>\s*\/dev\//, ">\\s*\\/dev\\/"],
-  [/\bmkfs\b/, "\\bmkfs\\b"],
-  [/\bdd\s+if=/, "\\bdd\\s+if="],
-  [/chmod\s+[0-7]*7[0-7]{2}/, "chmod\\s+[0-7]*7[0-7]\\{2\\}"],
-  [/\bchown\s+-R\b/, "\\bchown\\s+-R\\b"],
-  [/(?<!\.)\beval\s*\(/, "(?<!\\.)\\beval\\s*\\("],
-  [/(?<!\.)\bexec\s*\(/, "(?<!\\.)\\bexec\\s*\\("]
-];
-var SHELL_COMMAND_START = /^(grep|find|ls|cat|sed|awk|curl|wget|ssh|scp|git|mv|cp|mkdir|touch|echo|printf|python|python3|node|bash|sh|zsh|apt|yum|brew)\s/;
-function validateLesson2(text) {
-  if (!text || !text.trim()) {
-    return { valid: false, reason: "Lesson text cannot be empty" };
-  }
-  for (const [pattern, patternSource] of DANGEROUS_PATTERNS) {
-    if (pattern.test(text)) {
-      return {
-        valid: false,
-        reason: `Dangerous pattern detected: ${patternSource}`
-      };
-    }
-  }
-  const trimmed = text.trim();
-  if (SHELL_COMMAND_START.test(trimmed)) {
-    const lastChar = trimmed[trimmed.length - 1];
-    if (![".", "!", "?", ";"].includes(lastChar)) {
-      return {
-        valid: false,
-        reason: "Lesson appears to contain raw shell commands"
-      };
-    }
-  }
-  return { valid: true };
-}
-function getHiveFilePath() {
-  const platform = process.platform;
-  const home = os6.homedir();
-  let dataDir;
-  if (platform === "win32") {
-    dataDir = path29.join(process.env.LOCALAPPDATA || path29.join(home, "AppData", "Local"), "opencode-swarm", "Data");
-  } else if (platform === "darwin") {
-    dataDir = path29.join(home, "Library", "Application Support", "opencode-swarm");
-  } else {
-    dataDir = path29.join(process.env.XDG_DATA_HOME || path29.join(home, ".local", "share"), "opencode-swarm");
-  }
-  return path29.join(dataDir, "hive-knowledge.jsonl");
-}
-async function promoteToHive(_directory, lesson, category) {
-  const trimmed = (lesson ?? "").trim();
-  if (!trimmed) {
-    throw new Error("Lesson text required");
-  }
-  const validation = validateLesson2(trimmed);
-  if (!validation.valid) {
-    throw new Error(`Lesson rejected by validator: ${validation.reason}`);
-  }
-  const hivePath = getHiveFilePath();
-  const hiveDir = path29.dirname(hivePath);
-  if (!fs19.existsSync(hiveDir)) {
-    fs19.mkdirSync(hiveDir, { recursive: true });
-  }
-  const now = new Date;
-  const entry = {
-    id: `hive-manual-${now.getTime()}`,
-    lesson: trimmed,
-    category: category || "process",
-    scope_tag: "global",
-    confidence: 1,
-    status: "promoted",
-    promotion_source: "manual",
-    promotedAt: now.toISOString(),
-    retrievalOutcomes: { applied: 0, succeededAfter: 0, failedAfter: 0 }
-  };
-  fs19.appendFileSync(hivePath, `${JSON.stringify(entry)}
-`, "utf-8");
-  const preview = `${trimmed.slice(0, 50)}${trimmed.length > 50 ? "..." : ""}`;
-  return `Promoted to hive: "${preview}" (confidence: 1.0, source: manual)`;
-}
-async function promoteFromSwarm(directory, lessonId) {
-  const knowledgePath = path29.join(directory, ".swarm", "knowledge.jsonl");
-  const entries = [];
-  if (fs19.existsSync(knowledgePath)) {
-    const content = fs19.readFileSync(knowledgePath, "utf-8");
-    for (const line of content.split(`
-`)) {
-      const t = line.trim();
-      if (!t)
-        continue;
-      try {
-        entries.push(JSON.parse(t));
-      } catch {}
-    }
-  }
-  const swarmEntry = entries.find((e) => e.id === lessonId);
-  if (!swarmEntry) {
-    throw new Error(`Lesson ${lessonId} not found in .swarm/knowledge.jsonl`);
-  }
-  const lessonText = typeof swarmEntry.lesson === "string" ? swarmEntry.lesson.trim() : "";
-  if (!lessonText) {
-    throw new Error("Lesson text required");
-  }
-  const validation = validateLesson2(lessonText);
-  if (!validation.valid) {
-    throw new Error(`Lesson rejected by validator: ${validation.reason}`);
-  }
-  const hivePath = getHiveFilePath();
-  const hiveDir = path29.dirname(hivePath);
-  if (!fs19.existsSync(hiveDir)) {
-    fs19.mkdirSync(hiveDir, { recursive: true });
-  }
-  const now = new Date;
-  const hiveEntry = {
-    id: `hive-manual-${now.getTime()}`,
-    lesson: lessonText,
-    category: typeof swarmEntry.category === "string" ? swarmEntry.category : "process",
-    scope_tag: typeof swarmEntry.scope === "string" ? swarmEntry.scope : "global",
-    confidence: 1,
-    status: "promoted",
-    promotion_source: "manual",
-    promotedAt: now.toISOString(),
-    retrievalOutcomes: { applied: 0, succeededAfter: 0, failedAfter: 0 }
-  };
-  fs19.appendFileSync(hivePath, `${JSON.stringify(hiveEntry)}
-`, "utf-8");
-  const preview = `${lessonText.slice(0, 50)}${lessonText.length > 50 ? "..." : ""}`;
-  return `Promoted to hive: "${preview}" (confidence: 1.0, source: manual)`;
-}
-
 // src/commands/promote.ts
 async function handlePromoteCommand(directory, args) {
   let category;
@@ -43393,12 +43352,6 @@ async function handlePromoteCommand(directory, args) {
   if (!lessonText && !lessonId) {
     return `Usage: /swarm promote "<lesson text>" or /swarm promote --from-swarm <id>`;
   }
-  if (lessonText) {
-    const validation = validateLesson2(lessonText);
-    if (!validation.valid) {
-      return `Lesson rejected by validator: ${validation.reason}`;
-    }
-  }
   if (lessonId) {
     try {
       return await promoteFromSwarm(directory, lessonId);
@@ -43547,7 +43500,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/commands/reset.ts
-import * as fs20 from "fs";
+import * as fs19 from "fs";
 
 // src/background/manager.ts
 init_utils();
@@ -44248,8 +44201,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs20.existsSync(resolvedPath)) {
-        fs20.unlinkSync(resolvedPath);
+      if (fs19.existsSync(resolvedPath)) {
+        fs19.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -44266,8 +44219,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs20.existsSync(summariesPath)) {
-      fs20.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs19.existsSync(summariesPath)) {
+      fs19.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -44287,14 +44240,14 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 init_utils2();
-import * as fs21 from "fs";
+import * as fs20 from "fs";
 import * as path30 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs21.existsSync(statePath)) {
-      fs21.unlinkSync(statePath);
+    if (fs20.existsSync(statePath)) {
+      fs20.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -44304,14 +44257,14 @@ async function handleResetSessionCommand(directory, _args) {
   }
   try {
     const sessionDir = path30.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs21.existsSync(sessionDir)) {
-      const files = fs21.readdirSync(sessionDir);
+    if (fs20.existsSync(sessionDir)) {
+      const files = fs20.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
         const filePath = path30.join(sessionDir, file3);
-        if (fs21.lstatSync(filePath).isFile()) {
-          fs21.unlinkSync(filePath);
+        if (fs20.lstatSync(filePath).isFile()) {
+          fs20.unlinkSync(filePath);
           deletedCount++;
         }
       }
@@ -44416,18 +44369,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs22 from "fs";
+import * as fs21 from "fs";
 import * as path32 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs22.existsSync(manifestPath2)) {
+    if (!fs21.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs22.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs21.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -44449,12 +44402,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs22.existsSync(manifestPath)) {
+  if (!fs21.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs22.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs21.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -44464,10 +44417,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs22.existsSync(checkpointDir)) {
+  if (!fs21.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs22.readdirSync(checkpointDir);
+  const checkpointFiles = fs21.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -44478,7 +44431,7 @@ async function handleRollbackCommand(directory, args) {
     const src = path32.join(checkpointDir, file3);
     const dest = path32.join(swarmDir, file3);
     try {
-      fs22.cpSync(src, dest, { recursive: true, force: true });
+      fs21.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -44495,7 +44448,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs22.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs21.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
@@ -44538,11 +44491,11 @@ async function handleSimulateCommand(directory, args) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs23 = await import("fs/promises");
+  const fs22 = await import("fs/promises");
   const path33 = await import("path");
   const reportPath = path33.join(directory, ".swarm", "simulate-report.md");
-  await fs23.mkdir(path33.dirname(reportPath), { recursive: true });
-  await fs23.writeFile(reportPath, report, "utf-8");
+  await fs22.mkdir(path33.dirname(reportPath), { recursive: true });
+  await fs22.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -45075,19 +45028,19 @@ function resolveCommand(tokens) {
 }
 
 // src/cli/index.ts
-var CONFIG_DIR = path33.join(process.env.XDG_CONFIG_HOME || path33.join(os7.homedir(), ".config"), "opencode");
+var CONFIG_DIR = path33.join(process.env.XDG_CONFIG_HOME || path33.join(os6.homedir(), ".config"), "opencode");
 var OPENCODE_CONFIG_PATH = path33.join(CONFIG_DIR, "opencode.json");
 var PLUGIN_CONFIG_PATH = path33.join(CONFIG_DIR, "opencode-swarm.json");
 var PROMPTS_DIR = path33.join(CONFIG_DIR, "opencode-swarm");
-var OPENCODE_PLUGIN_CACHE_PATH = path33.join(process.env.XDG_CACHE_HOME || path33.join(os7.homedir(), ".cache"), "opencode", "packages", "opencode-swarm@latest");
+var OPENCODE_PLUGIN_CACHE_PATH = path33.join(process.env.XDG_CACHE_HOME || path33.join(os6.homedir(), ".cache"), "opencode", "packages", "opencode-swarm@latest");
 function ensureDir(dir) {
-  if (!fs23.existsSync(dir)) {
-    fs23.mkdirSync(dir, { recursive: true });
+  if (!fs22.existsSync(dir)) {
+    fs22.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs23.readFileSync(filepath, "utf-8");
+    const content = fs22.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -45095,7 +45048,7 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs23.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs22.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 async function install() {
@@ -45135,15 +45088,15 @@ async function install() {
   console.log("\u2713 Added opencode-swarm to OpenCode plugins");
   console.log("\u2713 Disabled default OpenCode agents (explore, general)");
   try {
-    if (fs23.existsSync(OPENCODE_PLUGIN_CACHE_PATH)) {
-      fs23.rmSync(OPENCODE_PLUGIN_CACHE_PATH, { recursive: true, force: true });
+    if (fs22.existsSync(OPENCODE_PLUGIN_CACHE_PATH)) {
+      fs22.rmSync(OPENCODE_PLUGIN_CACHE_PATH, { recursive: true, force: true });
       console.log("\u2713 Cleared opencode plugin cache (next start will fetch latest)");
     }
   } catch {
     console.warn("\u26A0 Could not clear opencode plugin cache \u2014 you may need to delete it manually:");
     console.warn(`  ${OPENCODE_PLUGIN_CACHE_PATH}`);
   }
-  if (!fs23.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs22.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: {
         coder: {
@@ -45246,7 +45199,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs23.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs22.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -45278,13 +45231,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs23.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs23.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs22.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs22.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs23.existsSync(PROMPTS_DIR)) {
-        fs23.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs22.existsSync(PROMPTS_DIR)) {
+        fs22.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }