opencode-swarm 6.86.3 → 6.86.6

package/dist/cli/index.js

@@ -14230,11 +14230,17 @@ async function readLedgerEvents(directory) {
     const lines = content.trim().split(`
 `).filter((line) => line.trim() !== "");
     const events = [];
+    let skippedCount = 0;
     for (const line of lines) {
       try {
         const event = JSON.parse(line);
         events.push(event);
-      } catch {}
+      } catch {
+        skippedCount++;
+      }
+    }
+    if (skippedCount > 0) {
+      console.warn(`[ledger] Skipped ${skippedCount} malformed line(s) in plan-ledger.jsonl`);
     }
     events.sort((a, b) => a.seq - b.seq);
     return events;
@@ -14331,10 +14337,13 @@ async function takeSnapshotEvent(directory, plan, options) {
   }, { planHashAfter: options?.planHashAfter });
 }
 async function replayFromLedger(directory, _options) {
-  const events = await readLedgerEvents(directory);
+  const { events, truncated, badSuffix } = await readLedgerEventsWithIntegrity(directory);
   if (events.length === 0) {
     return null;
   }
+  if (truncated && badSuffix !== null) {
+    await quarantineLedgerSuffix(directory, badSuffix);
+  }
   const targetPlanId = events[0].plan_id;
   const relevantEvents = events.filter((e) => e.plan_id === targetPlanId);
   {
@@ -14455,6 +14464,46 @@ function applyEventToPlan(plan, event) {
       throw new Error(`applyEventToPlan: unhandled event type "${event.event_type}" at seq ${event.seq}`);
   }
 }
+async function readLedgerEventsWithIntegrity(directory) {
+  const ledgerPath = getLedgerPath(directory);
+  if (!fs.existsSync(ledgerPath)) {
+    return { events: [], truncated: false, badSuffix: null };
+  }
+  try {
+    const content = fs.readFileSync(ledgerPath, "utf8");
+    const lines = content.split(`
+`);
+    const events = [];
+    let truncated = false;
+    let badSuffix = null;
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim() === "") {
+        continue;
+      }
+      try {
+        const event = JSON.parse(line);
+        events.push(event);
+      } catch {
+        truncated = true;
+        badSuffix = lines.slice(i).join(`
+`);
+        break;
+      }
+    }
+    events.sort((a, b) => a.seq - b.seq);
+    return { events, truncated, badSuffix };
+  } catch {
+    return { events: [], truncated: false, badSuffix: null };
+  }
+}
+async function quarantineLedgerSuffix(directory, badSuffix) {
+  try {
+    const quarantinePath = path2.join(directory, ".swarm", "plan-ledger.quarantine");
+    fs.writeFileSync(quarantinePath, badSuffix, "utf8");
+    console.warn(`[ledger] Corrupted suffix quarantined to ${path2.relative(directory, quarantinePath)}`);
+  } catch {}
+}
 async function loadLastApprovedPlan(directory, expectedPlanId) {
   const events = await readLedgerEvents(directory);
   if (events.length === 0) {
@@ -17619,15 +17668,15 @@ __export(exports_config_doctor, {
   applySafeAutoFixes: () => applySafeAutoFixes
 });
 import * as crypto3 from "crypto";
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import * as os5 from "os";
-import * as path19 from "path";
+import * as path18 from "path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path19.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path18.join(os5.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path19.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path19.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path18.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path18.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -17652,9 +17701,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path19.resolve(configPath);
-    const resolvedUser = path19.resolve(normalizedUser);
-    const resolvedProject = path19.resolve(normalizedProject);
+    const resolvedConfig = path18.resolve(configPath);
+    const resolvedUser = path18.resolve(normalizedUser);
+    const resolvedProject = path18.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -17664,19 +17713,19 @@ function createConfigBackup(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let content = null;
-  if (fs9.existsSync(projectConfigPath)) {
+  if (fs8.existsSync(projectConfigPath)) {
     try {
-      content = fs9.readFileSync(projectConfigPath, "utf-8");
+      content = fs8.readFileSync(projectConfigPath, "utf-8");
     } catch (error93) {
       log("[ConfigDoctor] project config read failed", {
         error: error93 instanceof Error ? error93.message : String(error93)
       });
     }
   }
-  if (content === null && fs9.existsSync(userConfigPath)) {
+  if (content === null && fs8.existsSync(userConfigPath)) {
     configPath = userConfigPath;
     try {
-      content = fs9.readFileSync(userConfigPath, "utf-8");
+      content = fs8.readFileSync(userConfigPath, "utf-8");
     } catch (error93) {
       log("[ConfigDoctor] user config read failed", {
         error: error93 instanceof Error ? error93.message : String(error93)
@@ -17694,12 +17743,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path19.join(directory, ".swarm");
-  if (!fs9.existsSync(swarmDir)) {
-    fs9.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path18.join(directory, ".swarm");
+  if (!fs8.existsSync(swarmDir)) {
+    fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path19.join(swarmDir, backupFilename);
+  const backupPath = path18.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -17707,15 +17756,15 @@ function writeBackupArtifact(directory, backup) {
     content: backup.content,
     preview: backup.content.substring(0, 500) + (backup.content.length > 500 ? "..." : "")
   };
-  fs9.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
+  fs8.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
   return backupPath;
 }
 function restoreFromBackup(backupPath, directory) {
-  if (!fs9.existsSync(backupPath)) {
+  if (!fs8.existsSync(backupPath)) {
     return null;
   }
   try {
-    const artifact = JSON.parse(fs9.readFileSync(backupPath, "utf-8"));
+    const artifact = JSON.parse(fs8.readFileSync(backupPath, "utf-8"));
     if (!artifact.content || !artifact.configPath || !artifact.contentHash) {
       return null;
     }
@@ -17729,11 +17778,11 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path19.dirname(targetPath);
-    if (!fs9.existsSync(targetDir)) {
-      fs9.mkdirSync(targetDir, { recursive: true });
+    const targetDir = path18.dirname(targetPath);
+    if (!fs8.existsSync(targetDir)) {
+      fs8.mkdirSync(targetDir, { recursive: true });
     }
-    fs9.writeFileSync(targetPath, artifact.content, "utf-8");
+    fs8.writeFileSync(targetPath, artifact.content, "utf-8");
     return targetPath;
   } catch {
     return null;
@@ -17743,12 +17792,12 @@ function readConfigFromFile(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let configContent = null;
-  if (fs9.existsSync(projectConfigPath)) {
+  if (fs8.existsSync(projectConfigPath)) {
     configPath = projectConfigPath;
-    configContent = fs9.readFileSync(projectConfigPath, "utf-8");
-  } else if (fs9.existsSync(userConfigPath)) {
+    configContent = fs8.readFileSync(projectConfigPath, "utf-8");
+  } else if (fs8.existsSync(userConfigPath)) {
     configPath = userConfigPath;
-    configContent = fs9.readFileSync(userConfigPath, "utf-8");
+    configContent = fs8.readFileSync(userConfigPath, "utf-8");
   }
   if (configContent === null) {
     return null;
@@ -17760,9 +17809,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path20, value, _config) {
+function validateConfigKey(path19, value, _config) {
   const findings = [];
-  switch (path20) {
+  switch (path19) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -18009,27 +18058,27 @@ function validateConfigKey(path20, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path20, config3, findings) {
+function walkConfigAndValidate(obj, path19, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path20 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path20, obj, config3);
+  if (path19 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path19, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path20, obj, config3);
+    const keyFindings = validateConfigKey(path19, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path20}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path19}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path20 ? `${path20}.${key}` : key;
+    const newPath = path19 ? `${path19}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -18044,9 +18093,9 @@ function runConfigDoctor(config3, directory) {
   const hasAutoFixableIssues = findings.some((f) => f.autoFixable && f.proposedFix?.risk === "low");
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configSource = "defaults";
-  if (fs9.existsSync(projectConfigPath)) {
+  if (fs8.existsSync(projectConfigPath)) {
     configSource = projectConfigPath;
-  } else if (fs9.existsSync(userConfigPath)) {
+  } else if (fs8.existsSync(userConfigPath)) {
     configSource = userConfigPath;
   }
   return {
@@ -18075,12 +18124,12 @@ function applySafeAutoFixes(directory, result) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let configContent;
-  if (fs9.existsSync(projectConfigPath)) {
+  if (fs8.existsSync(projectConfigPath)) {
     configPath = projectConfigPath;
-    configContent = fs9.readFileSync(projectConfigPath, "utf-8");
-  } else if (fs9.existsSync(userConfigPath)) {
+    configContent = fs8.readFileSync(projectConfigPath, "utf-8");
+  } else if (fs8.existsSync(userConfigPath)) {
     configPath = userConfigPath;
-    configContent = fs9.readFileSync(userConfigPath, "utf-8");
+    configContent = fs8.readFileSync(userConfigPath, "utf-8");
   } else {
     return { appliedFixes, updatedConfigPath: null };
   }
@@ -18149,22 +18198,22 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path19.dirname(configPath);
-    if (!fs9.existsSync(configDir)) {
-      fs9.mkdirSync(configDir, { recursive: true });
+    const configDir = path18.dirname(configPath);
+    if (!fs8.existsSync(configDir)) {
+      fs8.mkdirSync(configDir, { recursive: true });
     }
-    fs9.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
+    fs8.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
     updatedConfigPath = configPath;
   }
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path19.join(directory, ".swarm");
-  if (!fs9.existsSync(swarmDir)) {
-    fs9.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path18.join(directory, ".swarm");
+  if (!fs8.existsSync(swarmDir)) {
+    fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path19.join(swarmDir, artifactFilename);
+  const artifactPath = path18.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -18185,7 +18234,7 @@ function writeDoctorArtifact(directory, result) {
       } : null
     }))
   };
-  fs9.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
+  fs8.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
   return artifactPath;
 }
 function shouldRunOnStartup(automationConfig) {
@@ -18525,9 +18574,78 @@ var init_evidence_summary_service = __esm(() => {
 });
 
 // src/cli/index.ts
-import * as fs22 from "fs";
+import * as fs21 from "fs";
 import * as os6 from "os";
-import * as path33 from "path";
+import * as path32 from "path";
+// package.json
+var package_default = {
+  name: "opencode-swarm",
+  version: "6.86.6",
+  description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
+  main: "dist/index.js",
+  types: "dist/index.d.ts",
+  bin: {
+    "opencode-swarm": "./dist/cli/index.js"
+  },
+  type: "module",
+  engines: {
+    bun: ">=1.0.0"
+  },
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "https://github.com/zaxbysauce/opencode-swarm.git"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  keywords: [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "agents",
+    "orchestration",
+    "swarm",
+    "multi-agent",
+    "llm"
+  ],
+  files: [
+    "dist",
+    "dist/lang/grammars",
+    "README.md",
+    "LICENSE"
+  ],
+  scripts: {
+    clean: `bun -e "require('fs').rmSync('dist',{recursive:true,force:true})"`,
+    build: "bun run clean && bun run scripts/copy-grammars.ts && bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && bun run scripts/copy-grammars.ts --to-dist && tsc --emitDeclarationOnly",
+    typecheck: "tsc --noEmit",
+    test: "bun test",
+    lint: "biome lint .",
+    format: "biome format . --write",
+    check: "biome check --write .",
+    dev: "bun run build && opencode",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@opencode-ai/plugin": "^1.1.53",
+    "@opencode-ai/sdk": "^1.1.53",
+    "@vscode/tree-sitter-wasm": "^0.3.0",
+    "p-limit": "^7.3.0",
+    picomatch: "^4.0.4",
+    "proper-lockfile": "^4.1.2",
+    "quick-lru": "^7.3.0",
+    "web-tree-sitter": "^0.25.0",
+    zod: "^4.1.8"
+  },
+  devDependencies: {
+    "@biomejs/biome": "2.3.14",
+    "@types/picomatch": "^4.0.3",
+    "bun-types": "1.3.8",
+    "js-yaml": "^4.1.1",
+    typescript: "^5.7.3"
+  }
+};
 
 // src/commands/acknowledge-spec-drift.ts
 init_utils2();
@@ -18604,71 +18722,6 @@ ${warnings.map((w) => `  - ${w}`).join(`
   return baseMessage + warningMessage + cautionMessage;
 }
 
-// src/commands/agents.ts
-function handleAgentsCommand(agents, guardrails) {
-  const entries = Object.entries(agents);
-  if (entries.length === 0) {
-    return "No agents registered.";
-  }
-  const lines = [`## Registered Agents (${entries.length} total)`, ""];
-  for (const [key, agent] of entries) {
-    const model = agent.config.model || "default";
-    const temp = agent.config.temperature !== undefined ? agent.config.temperature.toString() : "default";
-    const tools = agent.config.tools || {};
-    const isReadOnly = tools.write === false || tools.edit === false;
-    const access = isReadOnly ? "\uD83D\uDD12 read-only" : "\u270F\uFE0F read-write";
-    const desc = agent.description || agent.config.description || "";
-    const hasCustomProfile = guardrails?.profiles?.[key] !== undefined;
-    const profileIndicator = hasCustomProfile ? " | \u26A1 custom limits" : "";
-    lines.push(`- **${key}** | model: \`${model}\` | temp: ${temp} | ${access}${profileIndicator}`);
-    if (desc) {
-      lines.push(`  ${desc}`);
-    }
-  }
-  if (guardrails?.profiles && Object.keys(guardrails.profiles).length > 0) {
-    lines.push("", "### Guardrail Profiles", "");
-    for (const [profileName, profile] of Object.entries(guardrails.profiles)) {
-      const overrides = [];
-      if (profile.max_tool_calls !== undefined) {
-        overrides.push(`max_tool_calls=${profile.max_tool_calls}`);
-      }
-      if (profile.max_duration_minutes !== undefined) {
-        overrides.push(`max_duration_minutes=${profile.max_duration_minutes}`);
-      }
-      if (profile.max_repetitions !== undefined) {
-        overrides.push(`max_repetitions=${profile.max_repetitions}`);
-      }
-      if (profile.max_consecutive_errors !== undefined) {
-        overrides.push(`max_consecutive_errors=${profile.max_consecutive_errors}`);
-      }
-      if (profile.warning_threshold !== undefined) {
-        overrides.push(`warning_threshold=${profile.warning_threshold}`);
-      }
-      const overrideStr = overrides.length > 0 ? overrides.join(", ") : "no overrides";
-      lines.push(`- **${profileName}**: ${overrideStr}`);
-    }
-  }
-  return lines.join(`
-`);
-}
-
-// src/commands/analyze.ts
-async function handleAnalyzeCommand(_directory, args) {
-  const description = args.join(" ").trim();
-  if (description) {
-    return `[MODE: ANALYZE] ${description}`;
-  }
-  return "[MODE: ANALYZE] Please analyze the spec against the plan using MODE: ANALYZE.";
-}
-
-// src/config/loader.ts
-import * as fs2 from "fs";
-import * as os2 from "os";
-import * as path4 from "path";
-
-// src/config/schema.ts
-init_zod();
-
 // src/tools/tool-names.ts
 var TOOL_NAMES = [
   "diff",
@@ -18981,6 +19034,57 @@ for (const [agentName, tools] of Object.entries(AGENT_TOOL_MAP)) {
 }
 
 // src/config/schema.ts
+init_zod();
+var KNOWN_SWARM_PREFIXES = [
+  "paid",
+  "local",
+  "cloud",
+  "enterprise",
+  "mega",
+  "default",
+  "custom",
+  "team",
+  "project",
+  "swarm",
+  "synthetic"
+];
+var SEPARATORS = ["_", "-", " "];
+function stripKnownSwarmPrefix(agentName) {
+  if (!agentName)
+    return agentName;
+  const normalized = agentName.toLowerCase();
+  let stripped = normalized;
+  let previous = "";
+  while (stripped !== previous) {
+    previous = stripped;
+    for (const prefix of KNOWN_SWARM_PREFIXES) {
+      for (const sep2 of SEPARATORS) {
+        const prefixWithSep = prefix + sep2;
+        if (stripped.startsWith(prefixWithSep)) {
+          stripped = stripped.slice(prefixWithSep.length);
+          break;
+        }
+      }
+      if (stripped !== previous)
+        break;
+    }
+  }
+  if (ALL_AGENT_NAMES.includes(stripped)) {
+    return stripped;
+  }
+  for (const agent of ALL_AGENT_NAMES) {
+    for (const sep2 of SEPARATORS) {
+      const suffix = sep2 + agent;
+      if (normalized.endsWith(suffix)) {
+        return agent;
+      }
+    }
+    if (normalized === agent) {
+      return agent;
+    }
+  }
+  return agentName;
+}
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   variant: exports_external.string().min(1).optional(),
@@ -19585,6 +19689,7 @@ var PluginConfigSchema = exports_external.object({
   council: CouncilConfigSchema.optional(),
   parallelization: ParallelizationConfigSchema.optional(),
   turbo_mode: exports_external.boolean().default(false).optional(),
+  quiet: exports_external.boolean().default(false).optional(),
   full_auto: exports_external.object({
     enabled: exports_external.boolean().default(false),
     critic_model: exports_external.string().optional(),
@@ -19599,7 +19704,78 @@ var PluginConfigSchema = exports_external.object({
   })
 });
 
+// src/commands/agents.ts
+function handleAgentsCommand(agents, guardrails) {
+  const entries = Object.entries(agents);
+  if (entries.length === 0) {
+    return "No agents registered.";
+  }
+  const allAgentKeys = entries.map(([key]) => key);
+  const registeredBaseNames = allAgentKeys.map((key) => stripKnownSwarmPrefix(key)).filter((stripped) => ALL_SUBAGENT_NAMES.includes(stripped));
+  const unregistered = ALL_SUBAGENT_NAMES.filter((name) => !registeredBaseNames.includes(name));
+  const hasUnregistered = unregistered.length > 0;
+  const headerLabel = hasUnregistered ? `${entries.length} registered + ${unregistered.length} unregistered` : `${entries.length} total`;
+  const lines = [`## Registered Agents (${headerLabel})`, ""];
+  for (const [key, agent] of entries) {
+    const model = agent.config.model || "default";
+    const temp = agent.config.temperature !== undefined ? agent.config.temperature.toString() : "default";
+    const tools = agent.config.tools || {};
+    const isReadOnly = tools.write === false || tools.edit === false;
+    const access = isReadOnly ? "\uD83D\uDD12 read-only" : "\u270F\uFE0F read-write";
+    const desc = agent.description || agent.config.description || "";
+    const hasCustomProfile = guardrails?.profiles?.[key] !== undefined;
+    const profileIndicator = hasCustomProfile ? " | \u26A1 custom limits" : "";
+    lines.push(`- **${key}** | model: \`${model}\` | temp: ${temp} | ${access}${profileIndicator}`);
+    if (desc) {
+      lines.push(`  ${desc}`);
+    }
+  }
+  if (hasUnregistered) {
+    lines.push("", "### Unregistered Subagents");
+    for (const name of unregistered) {
+      lines.push(`- **${name}** (requires configuration)`);
+    }
+  }
+  if (guardrails?.profiles && Object.keys(guardrails.profiles).length > 0) {
+    lines.push("", "### Guardrail Profiles", "");
+    for (const [profileName, profile] of Object.entries(guardrails.profiles)) {
+      const overrides = [];
+      if (profile.max_tool_calls !== undefined) {
+        overrides.push(`max_tool_calls=${profile.max_tool_calls}`);
+      }
+      if (profile.max_duration_minutes !== undefined) {
+        overrides.push(`max_duration_minutes=${profile.max_duration_minutes}`);
+      }
+      if (profile.max_repetitions !== undefined) {
+        overrides.push(`max_repetitions=${profile.max_repetitions}`);
+      }
+      if (profile.max_consecutive_errors !== undefined) {
+        overrides.push(`max_consecutive_errors=${profile.max_consecutive_errors}`);
+      }
+      if (profile.warning_threshold !== undefined) {
+        overrides.push(`warning_threshold=${profile.warning_threshold}`);
+      }
+      const overrideStr = overrides.length > 0 ? overrides.join(", ") : "no overrides";
+      lines.push(`- **${profileName}**: ${overrideStr}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/commands/analyze.ts
+async function handleAnalyzeCommand(_directory, args) {
+  const description = args.join(" ").trim();
+  if (description) {
+    return `[MODE: ANALYZE] ${description}`;
+  }
+  return "[MODE: ANALYZE] Please analyze the spec against the plan using MODE: ANALYZE.";
+}
+
 // src/config/loader.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path4 from "path";
 var CONFIG_FILENAME = "opencode-swarm.json";
 var MAX_CONFIG_FILE_BYTES = 102400;
 function getUserConfigDir() {
@@ -20292,6 +20468,9 @@ var DeltaSpecSchema = exports_external.union([
   SwarmSpecSchema,
   SpecDeltaSchema
 ]);
+// src/services/warning-buffer.ts
+var deferredWarnings = [];
+
 // src/agents/index.ts
 var warnedAgents = new Set;
 
@@ -33621,8 +33800,8 @@ async function handleClarifyCommand(_directory, args) {
 
 // src/commands/close.ts
 import { execFileSync } from "child_process";
-import { promises as fs8 } from "fs";
-import path13 from "path";
+import { promises as fs7 } from "fs";
+import path12 from "path";
 init_manager2();
 
 // src/git/branch.ts
@@ -34311,31 +34490,10 @@ async function runAutoPromotion(directory, config3) {
 // src/commands/close.ts
 init_utils2();
 
-// src/plan/checkpoint.ts
-init_plan_schema();
-init_ledger();
-init_manager();
-import * as fs7 from "fs";
-import * as path11 from "path";
-async function writeCheckpoint(directory) {
-  try {
-    const plan = await loadPlan(directory);
-    if (!plan)
-      return;
-    const jsonPath = path11.join(directory, "SWARM_PLAN.json");
-    const mdPath = path11.join(directory, "SWARM_PLAN.md");
-    fs7.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
-    const md = derivePlanMarkdown(plan);
-    fs7.writeFileSync(mdPath, md, "utf8");
-  } catch (error93) {
-    console.warn(`[checkpoint] Failed to write SWARM_PLAN checkpoint: ${error93 instanceof Error ? error93.message : String(error93)}`);
-  }
-}
-
 // src/session/snapshot-writer.ts
 init_utils2();
 import { mkdirSync as mkdirSync7, renameSync as renameSync5 } from "fs";
-import * as path12 from "path";
+import * as path11 from "path";
 init_utils();
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
@@ -34426,7 +34584,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path12.dirname(resolvedPath);
+    const dir = path11.dirname(resolvedPath);
     mkdirSync7(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await Bun.write(tempPath, content);
@@ -34819,21 +34977,21 @@ var ACTIVE_STATE_TO_CLEAN = [
 ];
 async function handleCloseCommand(directory, args) {
   const planPath = validateSwarmPath(directory, "plan.json");
-  const swarmDir = path13.join(directory, ".swarm");
+  const swarmDir = path12.join(directory, ".swarm");
   let planExists = false;
   let planData = {
-    title: path13.basename(directory) || "Ad-hoc session",
+    title: path12.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
-    const content = await fs8.readFile(planPath, "utf-8");
+    const content = await fs7.readFile(planPath, "utf-8");
     planData = JSON.parse(content);
     planExists = true;
   } catch (error93) {
     if (error93?.code !== "ENOENT") {
       return `\u274C Failed to read plan.json: ${error93 instanceof Error ? error93.message : String(error93)}`;
     }
-    const swarmDirExists = await fs8.access(swarmDir).then(() => true).catch(() => false);
+    const swarmDirExists = await fs7.access(swarmDir).then(() => true).catch(() => false);
     if (!swarmDirExists) {
       return `\u274C No .swarm/ directory found in ${directory}. Run /swarm close from the project root, or run /swarm plan first.`;
     }
@@ -34927,10 +35085,10 @@ async function handleCloseCommand(directory, args) {
       warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path13.join(swarmDir, "close-lessons.md");
+  const lessonsFilePath = path12.join(swarmDir, "close-lessons.md");
   let explicitLessons = [];
   try {
-    const lessonsText = await fs8.readFile(lessonsFilePath, "utf-8");
+    const lessonsText = await fs7.readFile(lessonsFilePath, "utf-8");
     explicitLessons = lessonsText.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {}
@@ -34944,7 +35102,7 @@ async function handleCloseCommand(directory, args) {
     console.warn("[close-command] curateAndStoreSwarm error:", error93);
   }
   if (curationSucceeded && explicitLessons.length > 0) {
-    await fs8.unlink(lessonsFilePath).catch(() => {});
+    await fs7.unlink(lessonsFilePath).catch(() => {});
   }
   if (planExists && !planAlreadyDone) {
     for (const phase of phases) {
@@ -34964,7 +35122,7 @@ async function handleCloseCommand(directory, args) {
       }
     }
     try {
-      await fs8.writeFile(planPath, JSON.stringify(planData, null, 2), "utf-8");
+      await fs7.writeFile(planPath, JSON.stringify(planData, null, 2), "utf-8");
     } catch (error93) {
       const msg = error93 instanceof Error ? error93.message : String(error93);
       warnings.push(`Failed to persist terminal plan.json state: ${msg}`);
@@ -34973,53 +35131,53 @@ async function handleCloseCommand(directory, args) {
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const suffix = Math.random().toString(36).slice(2, 8);
-  const archiveDir = path13.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
+  const archiveDir = path12.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
   let archiveResult = "";
   let archivedFileCount = 0;
   const archivedActiveStateFiles = new Set;
   try {
-    await fs8.mkdir(archiveDir, { recursive: true });
+    await fs7.mkdir(archiveDir, { recursive: true });
     for (const artifact of ARCHIVE_ARTIFACTS) {
-      const srcPath = path13.join(swarmDir, artifact);
-      const destPath = path13.join(archiveDir, artifact);
+      const srcPath = path12.join(swarmDir, artifact);
+      const destPath = path12.join(archiveDir, artifact);
       try {
-        await fs8.copyFile(srcPath, destPath);
+        await fs7.copyFile(srcPath, destPath);
         archivedFileCount++;
         if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
           archivedActiveStateFiles.add(artifact);
         }
       } catch {}
     }
-    const evidenceDir = path13.join(swarmDir, "evidence");
-    const archiveEvidenceDir = path13.join(archiveDir, "evidence");
+    const evidenceDir = path12.join(swarmDir, "evidence");
+    const archiveEvidenceDir = path12.join(archiveDir, "evidence");
     try {
-      const evidenceEntries = await fs8.readdir(evidenceDir);
+      const evidenceEntries = await fs7.readdir(evidenceDir);
       if (evidenceEntries.length > 0) {
-        await fs8.mkdir(archiveEvidenceDir, { recursive: true });
+        await fs7.mkdir(archiveEvidenceDir, { recursive: true });
         for (const entry of evidenceEntries) {
-          const srcEntry = path13.join(evidenceDir, entry);
-          const destEntry = path13.join(archiveEvidenceDir, entry);
+          const srcEntry = path12.join(evidenceDir, entry);
+          const destEntry = path12.join(archiveEvidenceDir, entry);
           try {
-            const stat = await fs8.stat(srcEntry);
+            const stat = await fs7.stat(srcEntry);
             if (stat.isDirectory()) {
-              await fs8.mkdir(destEntry, { recursive: true });
-              const subEntries = await fs8.readdir(srcEntry);
+              await fs7.mkdir(destEntry, { recursive: true });
+              const subEntries = await fs7.readdir(srcEntry);
               for (const sub of subEntries) {
-                await fs8.copyFile(path13.join(srcEntry, sub), path13.join(destEntry, sub)).catch(() => {});
+                await fs7.copyFile(path12.join(srcEntry, sub), path12.join(destEntry, sub)).catch(() => {});
               }
             } else {
-              await fs8.copyFile(srcEntry, destEntry);
+              await fs7.copyFile(srcEntry, destEntry);
             }
             archivedFileCount++;
           } catch {}
         }
       }
     } catch {}
-    const sessionStatePath = path13.join(swarmDir, "session", "state.json");
+    const sessionStatePath = path12.join(swarmDir, "session", "state.json");
     try {
-      const archiveSessionDir = path13.join(archiveDir, "session");
-      await fs8.mkdir(archiveSessionDir, { recursive: true });
-      await fs8.copyFile(sessionStatePath, path13.join(archiveSessionDir, "state.json"));
+      const archiveSessionDir = path12.join(archiveDir, "session");
+      await fs7.mkdir(archiveSessionDir, { recursive: true });
+      await fs7.copyFile(sessionStatePath, path12.join(archiveSessionDir, "state.json"));
       archivedFileCount++;
     } catch {}
     archiveResult = `Archived ${archivedFileCount} artifact(s) to .swarm/archive/swarm-${timestamp}/`;
@@ -35042,9 +35200,9 @@ async function handleCloseCommand(directory, args) {
         warnings.push(`Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path13.join(swarmDir, artifact);
+      const filePath = path12.join(swarmDir, artifact);
       try {
-        await fs8.unlink(filePath);
+        await fs7.unlink(filePath);
         cleanedFiles.push(artifact);
       } catch {}
     }
@@ -35052,23 +35210,42 @@ async function handleCloseCommand(directory, args) {
     warnings.push("Skipped active-state cleanup because no active-state files were archived. Files preserved to prevent data loss.");
   }
   try {
-    const swarmFiles = await fs8.readdir(swarmDir);
+    const swarmFiles = await fs7.readdir(swarmDir);
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs8.unlink(path13.join(swarmDir, backup));
+        await fs7.unlink(path12.join(swarmDir, backup));
         configBackupsRemoved++;
       } catch {}
     }
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs8.unlink(path13.join(swarmDir, sibling));
+        await fs7.unlink(path12.join(swarmDir, sibling));
       } catch {}
     }
   } catch {}
+  let swarmPlanFilesRemoved = 0;
+  const swarmPlanJsonPath = path12.join(directory, "SWARM_PLAN.json");
+  const swarmPlanMdPath = path12.join(directory, "SWARM_PLAN.md");
+  try {
+    await fs7.unlink(swarmPlanJsonPath);
+    swarmPlanFilesRemoved++;
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      warnings.push(`Failed to remove SWARM_PLAN.json: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  try {
+    await fs7.unlink(swarmPlanMdPath);
+    swarmPlanFilesRemoved++;
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      warnings.push(`Failed to remove SWARM_PLAN.md: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
   clearAllScopes(directory);
-  const contextPath = path13.join(swarmDir, "context.md");
+  const contextPath = path12.join(swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -35081,7 +35258,7 @@ async function handleCloseCommand(directory, args) {
   ].join(`
 `);
   try {
-    await fs8.writeFile(contextPath, contextContent, "utf-8");
+    await fs7.writeFile(contextPath, contextContent, "utf-8");
   } catch (error93) {
     const msg = error93 instanceof Error ? error93.message : String(error93);
     warnings.push(`Failed to reset context.md: ${msg}`);
@@ -35183,6 +35360,9 @@ async function handleCloseCommand(directory, args) {
     ] : [],
     "- Reset context.md for next session",
     ...configBackupsRemoved > 0 ? [`- Removed ${configBackupsRemoved} stale config backup file(s)`] : [],
+    ...swarmPlanFilesRemoved > 0 ? [
+      `- Removed ${swarmPlanFilesRemoved} root-level SWARM_PLAN checkpoint artifact(s)`
+    ] : [],
     ...prunedBranches.length > 0 ? [
       `- Pruned ${prunedBranches.length} stale local git branch(es): ${prunedBranches.join(", ")}`
     ] : [],
@@ -35212,7 +35392,7 @@ async function handleCloseCommand(directory, args) {
   ].join(`
 `);
   try {
-    await fs8.writeFile(closeSummaryPath, summaryContent, "utf-8");
+    await fs7.writeFile(closeSummaryPath, summaryContent, "utf-8");
   } catch (error93) {
     const msg = error93 instanceof Error ? error93.message : String(error93);
     warnings.push(`Failed to write close-summary.md: ${msg}`);
@@ -35225,7 +35405,6 @@ async function handleCloseCommand(directory, args) {
     warnings.push(`flushPendingSnapshot failed: ${msg}`);
     console.warn("[close-command] flushPendingSnapshot error:", error93);
   }
-  await writeCheckpoint(directory).catch(() => {});
   const preservedClient = swarmState.opencodeClient;
   const preservedFullAutoFlag = swarmState.fullAutoEnabledInConfig;
   const preservedCuratorInitNames = swarmState.curatorInitAgentNames;
@@ -35269,14 +35448,14 @@ ${otherWarnings.map((w) => `- ${w}`).join(`
 
 // src/commands/config.ts
 import * as os4 from "os";
-import * as path14 from "path";
+import * as path13 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path14.join(os4.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path13.join(os4.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config3 = loadPluginConfig(directory);
-  const userConfigPath = path14.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path14.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path13.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path13.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -35362,7 +35541,7 @@ async function handleCouncilCommand(_directory, args) {
 }
 
 // src/hooks/hive-promoter.ts
-import path15 from "path";
+import path14 from "path";
 
 // src/background/event-bus.ts
 init_utils();
@@ -35617,7 +35796,7 @@ async function promoteToHive(directory, lesson, category) {
     schema_version: 1,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
-    source_project: path15.basename(directory) || "unknown",
+    source_project: path14.basename(directory) || "unknown",
     encounter_score: 1
   };
   await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
@@ -35695,14 +35874,14 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
-import path17 from "path";
+import path16 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 path16 from "path";
+import * as path15 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process3.execFile);
@@ -35804,7 +35983,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path15.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -35812,7 +35991,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path16.extname(entry.name);
+        const ext = path15.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -35834,8 +36013,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path16.dirname(sourceFile);
-          const resolvedPath = path16.resolve(sourceDir, importPath);
+          const sourceDir = path15.dirname(sourceFile);
+          const resolvedPath = path15.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -35860,8 +36039,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path16.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path16.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path15.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path15.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -35873,7 +36052,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path16.basename(filePath);
+    const base = path15.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -35883,16 +36062,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path16.basename(fileA) && baseA !== path16.basename(fileB);
+  return baseA === baseB && baseA !== path15.basename(fileA) && baseA !== path15.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path16.dirname(fileA);
-  const dirB = path16.dirname(fileB);
+  const dirA = path15.dirname(fileA);
+  const dirB = path15.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path16.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path16.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path15.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path15.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -35946,8 +36125,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path16.basename(pair.fileA);
-    const baseB = path16.basename(pair.fileB);
+    const baseA = path15.basename(pair.fileA);
+    const baseB = path15.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.`;
@@ -36057,7 +36236,7 @@ async function handleDarkMatterCommand(directory, args) {
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path17.basename(path17.resolve(directory));
+      const projectName = path16.basename(path16.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -36078,12 +36257,13 @@ 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 path18 from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
+import path17 from "path";
 import { fileURLToPath } from "url";
 init_manager2();
 init_utils2();
 init_manager();
+var { version: version3 } = package_default;
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
   for (const phase of plan.phases) {
@@ -36379,7 +36559,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path18.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path17.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync8(configPath)) {
     return {
       name: "Config Parseability",
@@ -36388,7 +36568,7 @@ async function checkConfigParseability(directory) {
     };
   }
   try {
-    const content = readFileSync6(configPath, "utf-8");
+    const content = readFileSync5(configPath, "utf-8");
     JSON.parse(content);
     return {
       name: "Config Parseability",
@@ -36408,7 +36588,7 @@ 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");
+  return isSource || isCliBundle ? path17.join(thisDir, "..", "lang", "grammars") : path17.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -36432,14 +36612,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path18.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path17.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync8(path18.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync8(path17.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync8(path18.join(grammarDir, file3))) {
+    if (!existsSync8(path17.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -36457,7 +36637,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path18.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path17.join(directory, ".swarm/checkpoints.json");
   if (!existsSync8(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -36466,7 +36646,7 @@ async function checkCheckpointManifest(directory) {
     };
   }
   try {
-    const content = readFileSync6(manifestPath, "utf-8");
+    const content = readFileSync5(manifestPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
       return {
@@ -36509,7 +36689,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
   if (!existsSync8(eventsPath)) {
     return {
       name: "Event Stream",
@@ -36518,7 +36698,7 @@ async function checkEventStreamIntegrity(directory) {
     };
   }
   try {
-    const content = readFileSync6(eventsPath, "utf-8");
+    const content = readFileSync5(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     let malformedCount = 0;
@@ -36550,7 +36730,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
   if (!existsSync8(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -36559,7 +36739,7 @@ async function checkSteeringDirectives(directory) {
     };
   }
   try {
-    const content = readFileSync6(eventsPath, "utf-8");
+    const content = readFileSync5(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     const directivesIssued = [];
@@ -36606,7 +36786,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path18.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path17.join(directory, ".swarm/curator-summary.json");
     if (!existsSync8(summaryPath)) {
       return {
         name: "Curator",
@@ -36615,7 +36795,7 @@ async function checkCurator(directory) {
       };
     }
     try {
-      const content = readFileSync6(summaryPath, "utf-8");
+      const content = readFileSync5(summaryPath, "utf-8");
       const parsed = JSON.parse(content);
       if (typeof parsed.schema_version !== "number" || parsed.schema_version !== 1) {
         return {
@@ -36650,6 +36830,11 @@ async function checkCurator(directory) {
 }
 async function getDiagnoseData(directory) {
   const checks5 = [];
+  checks5.push({
+    name: "Version",
+    status: "\u2705",
+    detail: version3
+  });
   const plan = await loadPlanJsonOnly(directory);
   if (plan) {
     checks5.push({
@@ -36754,7 +36939,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path18.join(directory, ".swarm", "evidence");
+    const evidenceDir = path17.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();
@@ -36777,6 +36962,13 @@ async function getDiagnoseData(directory) {
       detail: "No snapshots yet (snapshots written on next session start)"
     });
   }
+  if (deferredWarnings.length > 0) {
+    checks5.push({
+      name: "Deferred Warnings",
+      status: "\u26A0\uFE0F",
+      detail: `${deferredWarnings.length} warning(s) deferred from init (run with verbose logs for details)`
+    });
+  }
   const passCount = checks5.filter((c) => c.status === "\u2705").length;
   const totalCount = checks5.length;
   const allPassed = passCount === totalCount;
@@ -36795,6 +36987,14 @@ function formatDiagnoseMarkdown(diagnose) {
     "",
     `**Result**: ${diagnose.allPassed ? "\u2705 All checks passed" : `\u26A0\uFE0F ${diagnose.passCount}/${diagnose.totalCount} checks passed`}`
   ];
+  if (deferredWarnings.length > 0) {
+    lines.push("");
+    lines.push("## Deferred Warnings");
+    lines.push("");
+    for (const warning of deferredWarnings) {
+      lines.push(`- ${warning}`);
+    }
+  }
   return lines.join(`
 `);
 }
@@ -36806,16 +37006,16 @@ async function handleDiagnoseCommand(directory, _args) {
 init_config_doctor();
 
 // src/services/tool-doctor.ts
-import * as fs11 from "fs";
-import * as path21 from "path";
-
-// src/build/discovery.ts
 import * as fs10 from "fs";
 import * as path20 from "path";
 
+// src/build/discovery.ts
+import * as fs9 from "fs";
+import * as path19 from "path";
+
 // src/lang/detector.ts
 import { access as access2, readdir as readdir2 } from "fs/promises";
-import { extname as extname2, join as join16 } from "path";
+import { extname as extname2, join as join15 } from "path";
 
 // src/lang/profiles.ts
 class LanguageRegistry {
@@ -37795,7 +37995,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access2(join16(dir, detectFile));
+          await access2(join15(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -37816,7 +38016,7 @@ async function detectProjectLanguages(projectDir) {
     const topEntries = await readdir2(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        await scanDir(join16(projectDir, entry.name));
+        await scanDir(join15(projectDir, entry.name));
       }
     }
   } catch {}
@@ -37971,16 +38171,16 @@ function findBuildFiles(workingDir, patterns) {
     if (pattern.includes("*")) {
       const dir = workingDir;
       try {
-        const files = fs10.readdirSync(dir);
+        const files = fs9.readdirSync(dir);
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path20.join(dir, matches[0]);
+          return path19.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path20.join(workingDir, pattern);
-      if (fs10.existsSync(filePath)) {
+      const filePath = path19.join(workingDir, pattern);
+      if (fs9.existsSync(filePath)) {
         return filePath;
       }
     }
@@ -37988,12 +38188,12 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path20.join(workingDir, "package.json");
-  if (!fs10.existsSync(packageJsonPath)) {
+  const packageJsonPath = path19.join(workingDir, "package.json");
+  if (!fs9.existsSync(packageJsonPath)) {
     return [];
   }
   try {
-    const content = fs10.readFileSync(packageJsonPath, "utf-8");
+    const content = fs9.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.scripts || typeof pkg.scripts !== "object") {
       return [];
@@ -38029,8 +38229,8 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path20.join(workingDir, pattern);
-        if (fs10.existsSync(filePath)) {
+        const filePath = path19.join(workingDir, pattern);
+        if (fs9.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
       }
@@ -38040,9 +38240,9 @@ function findAllBuildFiles(workingDir) {
 }
 function findFilesRecursive(dir, regex, results) {
   try {
-    const entries = fs10.readdirSync(dir, { withFileTypes: true });
+    const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path20.join(dir, entry.name);
+      const fullPath = path19.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)) {
@@ -38065,8 +38265,8 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path20.join(workingDir, cmd.detectFile);
-        if (!fs10.existsSync(detectFilePath)) {
+        const detectFilePath = path19.join(workingDir, cmd.detectFile);
+        if (!fs9.existsSync(detectFilePath)) {
           continue;
         }
       }
@@ -38189,7 +38389,7 @@ var BINARY_CHECKLIST = [
 function extractRegisteredToolKeys(indexPath) {
   const registeredKeys = new Set;
   try {
-    const content = fs11.readFileSync(indexPath, "utf-8");
+    const content = fs10.readFileSync(indexPath, "utf-8");
     const toolBlockMatch = content.match(/tool:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/s);
     if (!toolBlockMatch) {
       return registeredKeys;
@@ -38240,9 +38440,9 @@ function checkBinaryReadiness() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path21.resolve(import.meta.dir, "..", "..");
-  const indexPath = path21.join(resolvedPluginRoot, "src", "index.ts");
-  if (!fs11.existsSync(indexPath)) {
+  const resolvedPluginRoot = pluginRoot ?? path20.resolve(import.meta.dir, "..", "..");
+  const indexPath = path20.join(resolvedPluginRoot, "src", "index.ts");
+  if (!fs10.existsSync(indexPath)) {
     return {
       findings: [
         {
@@ -39162,12 +39362,12 @@ async function handleHistoryCommand(directory, _args) {
 }
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import * as path22 from "path";
+import * as path21 from "path";
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path22.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path22.join(directory, ".swarm", "context.md");
+  const sentinelPath = path21.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path21.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync12(sentinelPath)) {
     return {
@@ -39363,16 +39563,16 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path22.join(directory, "package.json");
+  const packageJsonPath = path21.join(directory, "package.json");
   if (existsSync12(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         return pkg.name;
       }
     } catch {}
   }
-  return path22.basename(directory);
+  return path21.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -39384,7 +39584,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir3(path22.dirname(sentinelPath), { recursive: true });
+  await mkdir3(path21.dirname(sentinelPath), { recursive: true });
   await writeFile4(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 
@@ -39620,13 +39820,13 @@ async function handlePlanCommand(directory, args) {
 // src/services/preflight-service.ts
 init_manager2();
 init_manager();
-import * as fs18 from "fs";
-import * as path29 from "path";
+import * as fs17 from "fs";
+import * as path28 from "path";
 
 // src/tools/lint.ts
 init_zod();
-import * as fs12 from "fs";
-import * as path23 from "path";
+import * as fs11 from "fs";
+import * as path22 from "path";
 init_utils();
 
 // src/utils/path-security.ts
@@ -39672,9 +39872,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  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");
+  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");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -39690,7 +39890,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs12.existsSync(path23.join(cwd, gradlewName)) ? path23.join(cwd, gradlewName) : null;
+  const gradlew = fs11.existsSync(path22.join(cwd, gradlewName)) ? path22.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -39724,12 +39924,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs12.existsSync(path23.join(cwd, "ruff.toml")))
+  if (fs11.existsSync(path22.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path23.join(cwd, "pyproject.toml");
-    if (fs12.existsSync(pyproject)) {
-      const content = fs12.readFileSync(pyproject, "utf-8");
+    const pyproject = path22.join(cwd, "pyproject.toml");
+    if (fs11.existsSync(pyproject)) {
+      const content = fs11.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -39737,21 +39937,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs12.existsSync(path23.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs11.existsSync(path22.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs12.existsSync(path23.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs11.existsSync(path22.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  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"));
+  const hasMaven = fs11.existsSync(path22.join(cwd, "pom.xml"));
+  const hasGradle = fs11.existsSync(path22.join(cwd, "build.gradle")) || fs11.existsSync(path22.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs11.existsSync(path22.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs12.existsSync(path23.join(cwd, "build.gradle.kts")) || fs12.existsSync(path23.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs11.existsSync(path22.join(cwd, "build.gradle.kts")) || fs11.existsSync(path22.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs12.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs11.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -39760,7 +39960,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs12.readdirSync(cwd);
+    const files = fs11.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -39768,14 +39968,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs12.existsSync(path23.join(cwd, "CMakeLists.txt"))) {
+  if (fs11.existsSync(path22.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path23.join(cwd, "src")];
+    const dirsToCheck = [cwd, path22.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs12.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs11.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -39786,13 +39986,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs12.existsSync(path23.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs11.existsSync(path22.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs12.existsSync(path23.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs11.existsSync(path22.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  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"));
+  return (fs11.existsSync(path22.join(cwd, "Gemfile")) || fs11.existsSync(path22.join(cwd, "gems.rb")) || fs11.existsSync(path22.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -39820,10 +40020,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path23.join(dir, "node_modules", ".bin", binName);
-    if (fs12.existsSync(candidate))
+    const candidate = path22.join(dir, "node_modules", ".bin", binName);
+    if (fs11.existsSync(candidate))
       return candidate;
-    const parent = path23.dirname(dir);
+    const parent = path22.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -39832,11 +40032,11 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path23.delimiter)) {
+  for (const dir of searchPath.split(path22.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path23.join(dir, binName);
-    if (fs12.existsSync(candidate))
+    const candidate = path22.join(dir, binName);
+    if (fs11.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -39844,17 +40044,17 @@ function findBinInEnvPath(binName) {
 async function detectAvailableLinter(directory) {
   if (!directory)
     return null;
-  if (!fs12.existsSync(directory))
+  if (!fs11.existsSync(directory))
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  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 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 localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path23.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path23.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path22.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path22.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -39877,7 +40077,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs12.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs11.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -39891,7 +40091,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs12.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs11.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -40062,8 +40262,8 @@ For Rust: rustup component add clippy`
 
 // src/tools/secretscan.ts
 init_zod();
-import * as fs13 from "fs";
-import * as path24 from "path";
+import * as fs12 from "fs";
+import * as path23 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -40290,11 +40490,11 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path24.join(scanDir, ".secretscanignore");
+  const ignorePath = path23.join(scanDir, ".secretscanignore");
   try {
-    if (!fs13.existsSync(ignorePath))
+    if (!fs12.existsSync(ignorePath))
       return [];
-    const content = fs13.readFileSync(ignorePath, "utf8");
+    const content = fs12.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -40313,7 +40513,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path24.matchesGlob(relPath, pattern))
+    if (path23.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -40334,7 +40534,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path24.extname(filePath).toLowerCase();
+  const ext = path23.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -40409,11 +40609,11 @@ function createRedactedContext(line, findings) {
   result += line.slice(lastEnd);
   return result;
 }
-var O_NOFOLLOW = process.platform !== "win32" ? fs13.constants.O_NOFOLLOW : undefined;
+var O_NOFOLLOW = process.platform !== "win32" ? fs12.constants.O_NOFOLLOW : undefined;
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs13.lstatSync(filePath);
+    const lstat = fs12.lstatSync(filePath);
     if (lstat.isSymbolicLink()) {
       return findings;
     }
@@ -40422,14 +40622,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs13.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs12.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs13.readFileSync(fd);
+        buffer = fs12.readFileSync(fd);
       } finally {
-        fs13.closeSync(fd);
+        fs12.closeSync(fd);
       }
     } else {
-      buffer = fs13.readFileSync(filePath);
+      buffer = fs12.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -40471,9 +40671,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path24.resolve(scanDir);
-  const resolvedRealPath = path24.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path24.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path23.resolve(scanDir);
+  const resolvedRealPath = path23.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path23.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -40484,7 +40684,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs13.readdirSync(dir);
+    entries = fs12.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -40499,15 +40699,15 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path24.join(dir, entry);
-    const relPath = path24.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path23.join(dir, entry);
+    const relPath = path23.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
     }
     let lstat;
     try {
-      lstat = fs13.lstatSync(fullPath);
+      lstat = fs12.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -40519,7 +40719,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat.isDirectory()) {
       let realPath;
       try {
-        realPath = fs13.realpathSync(fullPath);
+        realPath = fs12.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -40535,7 +40735,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 = path24.extname(fullPath).toLowerCase();
+      const ext = path23.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -40601,15 +40801,15 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path24.resolve(directory);
+      const _scanDirRaw = path23.resolve(directory);
       const scanDir = (() => {
         try {
-          return fs13.realpathSync(_scanDirRaw);
+          return fs12.realpathSync(_scanDirRaw);
         } catch {
           return _scanDirRaw;
         }
       })();
-      if (!fs13.existsSync(scanDir)) {
+      if (!fs12.existsSync(scanDir)) {
         const errorResult = {
           error: "directory not found",
           scan_dir: directory,
@@ -40620,7 +40820,7 @@ var secretscan = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const dirStat = fs13.statSync(scanDir);
+      const dirStat = fs12.statSync(scanDir);
       if (!dirStat.isDirectory()) {
         const errorResult = {
           error: "target must be a directory, not a file",
@@ -40671,7 +40871,7 @@ var secretscan = createSwarmTool({
           break;
         const fileFindings = scanFileForSecrets(filePath);
         try {
-          const stat2 = fs13.statSync(filePath);
+          const stat2 = fs12.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES) {
             skippedFiles++;
             continue;
@@ -40760,12 +40960,12 @@ async function runSecretscan(directory) {
 
 // src/tools/test-runner.ts
 init_zod();
-import * as fs17 from "fs";
-import * as path28 from "path";
+import * as fs16 from "fs";
+import * as path27 from "path";
 
 // src/test-impact/analyzer.ts
-import fs14 from "fs";
-import path25 from "path";
+import fs13 from "fs";
+import path24 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;
@@ -40776,7 +40976,7 @@ function normalizePath(p) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat2 = fs14.statSync(sourcePath);
+      const stat2 = fs13.statSync(sourcePath);
       if (stat2.mtimeMs > generatedAtMs) {
         return true;
       }
@@ -40790,15 +40990,15 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path25.resolve(fromDir, importPath);
-  if (path25.extname(resolved)) {
-    if (fs14.existsSync(resolved) && fs14.statSync(resolved).isFile()) {
+  const resolved = path24.resolve(fromDir, importPath);
+  if (path24.extname(resolved)) {
+    if (fs13.existsSync(resolved) && fs13.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
   } else {
     for (const ext of EXTENSIONS_TO_TRY) {
       const withExt = resolved + ext;
-      if (fs14.existsSync(withExt) && fs14.statSync(withExt).isFile()) {
+      if (fs13.existsSync(withExt) && fs13.statSync(withExt).isFile()) {
         return normalizePath(withExt);
       }
     }
@@ -40817,13 +41017,13 @@ function findTestFilesSync(cwd) {
   function walk(dir, visitedInodes) {
     let entries;
     try {
-      entries = fs14.readdirSync(dir, { withFileTypes: true });
+      entries = fs13.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     let dirInode;
     try {
-      dirInode = fs14.statSync(dir).ino;
+      dirInode = fs13.statSync(dir).ino;
     } catch {
       return;
     }
@@ -40836,12 +41036,12 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path25.join(dir, entry.name), visitedInodes);
+          walk(path24.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(path25.join(dir, entry.name)));
+          testFiles.push(normalizePath(path24.join(dir, entry.name)));
         }
       }
     }
@@ -40871,7 +41071,7 @@ async function buildImpactMapInternal(cwd) {
   for (const testFile of testFiles) {
     let content;
     try {
-      content = fs14.readFileSync(testFile, "utf-8");
+      content = fs13.readFileSync(testFile, "utf-8");
     } catch {
       continue;
     }
@@ -40879,7 +41079,7 @@ async function buildImpactMapInternal(cwd) {
       continue;
     }
     const imports = extractImports(content);
-    const testDir = path25.dirname(testFile);
+    const testDir = path24.dirname(testFile);
     for (const importPath of imports) {
       const resolvedSource = resolveRelativeImport(testDir, importPath);
       if (resolvedSource === null) {
@@ -40901,10 +41101,10 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd) {
-  const cachePath = path25.join(cwd, ".swarm", "cache", "impact-map.json");
-  if (fs14.existsSync(cachePath)) {
+  const cachePath = path24.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs13.existsSync(cachePath)) {
     try {
-      const content = fs14.readFileSync(cachePath, "utf-8");
+      const content = fs13.readFileSync(cachePath, "utf-8");
       const data = JSON.parse(content);
       const map3 = data.map;
       const generatedAt = new Date(data.generatedAt).getTime();
@@ -40916,17 +41116,17 @@ async function loadImpactMap(cwd) {
   return buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  const cacheDir = path25.join(cwd, ".swarm", "cache");
-  const cachePath = path25.join(cacheDir, "impact-map.json");
-  if (!fs14.existsSync(cacheDir)) {
-    fs14.mkdirSync(cacheDir, { recursive: true });
+  const cacheDir = path24.join(cwd, ".swarm", "cache");
+  const cachePath = path24.join(cacheDir, "impact-map.json");
+  if (!fs13.existsSync(cacheDir)) {
+    fs13.mkdirSync(cacheDir, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
     fileCount: Object.keys(impactMap).length,
     map: impactMap
   };
-  fs14.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  fs13.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function analyzeImpact(changedFiles, cwd) {
   if (!Array.isArray(changedFiles)) {
@@ -40943,7 +41143,7 @@ async function analyzeImpact(changedFiles, cwd) {
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   for (const changedFile of validFiles) {
-    const normalizedChanged = normalizePath(path25.resolve(changedFile));
+    const normalizedChanged = normalizePath(path24.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -41189,14 +41389,14 @@ function detectFlakyTests(allHistory) {
 }
 
 // src/test-impact/history-store.ts
-import fs15 from "fs";
-import path26 from "path";
+import fs14 from "fs";
+import path25 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 path26.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
+  return path25.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -41256,9 +41456,9 @@ function appendTestRun(record3, workingDir) {
     changedFiles: sanitizeChangedFiles(record3.changedFiles || [])
   };
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path26.dirname(historyPath);
-  if (!fs15.existsSync(historyDir)) {
-    fs15.mkdirSync(historyDir, { recursive: true });
+  const historyDir = path25.dirname(historyPath);
+  if (!fs14.existsSync(historyDir)) {
+    fs14.mkdirSync(historyDir, { recursive: true });
   }
   const existingRecords = readAllRecords(historyPath);
   existingRecords.push(sanitizedRecord);
@@ -41283,24 +41483,24 @@ function appendTestRun(record3, workingDir) {
 `)}
 `;
     const tempPath = `${historyPath}.tmp`;
-    fs15.writeFileSync(tempPath, content, "utf-8");
-    fs15.renameSync(tempPath, historyPath);
+    fs14.writeFileSync(tempPath, content, "utf-8");
+    fs14.renameSync(tempPath, historyPath);
   } catch (err) {
     try {
       const tempPath = `${historyPath}.tmp`;
-      if (fs15.existsSync(tempPath)) {
-        fs15.unlinkSync(tempPath);
+      if (fs14.existsSync(tempPath)) {
+        fs14.unlinkSync(tempPath);
       }
     } catch {}
     throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 function readAllRecords(historyPath) {
-  if (!fs15.existsSync(historyPath)) {
+  if (!fs14.existsSync(historyPath)) {
     return [];
   }
   try {
-    const content = fs15.readFileSync(historyPath, "utf-8");
+    const content = fs14.readFileSync(historyPath, "utf-8");
     const lines = content.split(`
 `);
     const records = [];
@@ -41329,8 +41529,8 @@ function getAllHistory(workingDir) {
 }
 
 // src/tools/resolve-working-directory.ts
-import * as fs16 from "fs";
-import * as path27 from "path";
+import * as fs15 from "fs";
+import * as path26 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -41350,18 +41550,18 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path27.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path27.sep);
+  const normalizedDir = path26.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path26.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path27.resolve(normalizedDir);
+  const resolvedDir = path26.resolve(normalizedDir);
   let statResult;
   try {
-    statResult = fs16.statSync(resolvedDir);
+    statResult = fs15.statSync(resolvedDir);
   } catch {
     return {
       success: false,
@@ -41374,17 +41574,17 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path27.resolve(fallbackDirectory);
+  const resolvedFallback = path26.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
-    fs16.statSync(resolvedFallback);
+    fs15.statSync(resolvedFallback);
     fallbackExists = true;
   } catch {
     fallbackExists = false;
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path27.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path26.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -41474,19 +41674,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs17.existsSync(path28.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs16.existsSync(path27.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs17.existsSync(path28.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs16.existsSync(path27.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  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"));
+  const hasBuildFile = fs16.existsSync(path27.join(cwd, "build.gradle")) || fs16.existsSync(path27.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs16.existsSync(path27.join(cwd, "gradlew")) || fs16.existsSync(path27.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs17.readdirSync(cwd);
+    const files = fs16.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -41494,32 +41694,32 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  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"));
+  const hasSource = fs16.existsSync(path27.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs16.existsSync(path27.join(cwd, "CMakeCache.txt")) || fs16.existsSync(path27.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs17.existsSync(path28.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs16.existsSync(path27.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs17.existsSync(path28.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs16.existsSync(path27.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  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 hasRSpecFile = fs16.existsSync(path27.join(cwd, ".rspec"));
+  const hasGemfile = fs16.existsSync(path27.join(cwd, "Gemfile"));
+  const hasSpecDir = fs16.existsSync(path27.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs17.existsSync(path28.join(cwd, "test")) && (fs17.existsSync(path28.join(cwd, "Gemfile")) || fs17.existsSync(path28.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs16.existsSync(path27.join(cwd, "test")) && (fs16.existsSync(path27.join(cwd, "Gemfile")) || fs16.existsSync(path27.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path28.join(baseDir, "package.json");
-    if (fs17.existsSync(packageJsonPath)) {
-      const content = fs17.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path27.join(baseDir, "package.json");
+    if (fs16.existsSync(packageJsonPath)) {
+      const content = fs16.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -41538,38 +41738,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs17.existsSync(path28.join(baseDir, "bun.lockb")) || fs17.existsSync(path28.join(baseDir, "bun.lock"))) {
+      if (fs16.existsSync(path27.join(baseDir, "bun.lockb")) || fs16.existsSync(path27.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    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");
+    const pyprojectTomlPath = path27.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path27.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path27.join(baseDir, "requirements.txt");
+    if (fs16.existsSync(pyprojectTomlPath)) {
+      const content = fs16.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs17.existsSync(setupCfgPath)) {
-      const content = fs17.readFileSync(setupCfgPath, "utf-8");
+    if (fs16.existsSync(setupCfgPath)) {
+      const content = fs16.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs17.existsSync(requirementsTxtPath)) {
-      const content = fs17.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs16.existsSync(requirementsTxtPath)) {
+      const content = fs16.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path28.join(baseDir, "Cargo.toml");
-    if (fs17.existsSync(cargoTomlPath)) {
-      const content = fs17.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path27.join(baseDir, "Cargo.toml");
+    if (fs16.existsSync(cargoTomlPath)) {
+      const content = fs16.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -41578,10 +41778,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    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)) {
+    const pesterConfigPath = path27.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path27.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path27.join(baseDir, "tests.ps1");
+    if (fs16.existsSync(pesterConfigPath) || fs16.existsSync(pesterConfigJsonPath) || fs16.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -41623,12 +41823,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path28.isAbsolute(file3) ? path28.resolve(file3) : path28.resolve(workingDir, file3);
+  return path27.isAbsolute(file3) ? path27.resolve(file3) : path27.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path28.relative(workingDir, absolutePath);
+  return path27.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -41665,18 +41865,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path28.dirname(relativePath);
+  const relativeDir = path27.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path28.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path28.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path27.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path27.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path28.join(workingDir, "src/test/java", path28.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path27.join(workingDir, "src/test/java", path27.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path28.join(workingDir, "src/test/kotlin", path28.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path27.join(workingDir, "src/test/kotlin", path27.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -41704,23 +41904,23 @@ function isLanguageSpecificTestFile(basename4) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename4 = path28.basename(filePath);
+  const basename4 = path27.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 = path28.relative(workingDir, absoluteFile);
-    const basename4 = path28.basename(absoluteFile);
-    const dirname11 = path28.dirname(absoluteFile);
-    const preferRelativeOutput = !path28.isAbsolute(file3);
+    const relativeFile = path27.relative(workingDir, absoluteFile);
+    const basename4 = path27.basename(absoluteFile);
+    const dirname11 = path27.dirname(absoluteFile);
+    const preferRelativeOutput = !path27.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename4.replace(/\.[^.]+$/, "");
-    const ext = path28.extname(basename4);
+    const ext = path27.extname(basename4);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -41729,7 +41929,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path28.join(dirname11, candidateName));
+    ].map((candidateName) => path27.join(dirname11, candidateName));
     const testDirectoryNames = [
       basename4,
       ...genericTestNames,
@@ -41738,11 +41938,11 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path28.join(dirname11, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path28.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path27.join(dirname11, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path27.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs17.existsSync(testFile)) {
+      if (fs16.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -41759,8 +41959,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs17.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path28.dirname(absoluteTestFile);
+      const content = fs16.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path27.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -41768,8 +41968,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path28.resolve(testDir, importPath);
-          const existingExt = path28.extname(resolvedImport);
+          resolvedImport = path27.resolve(testDir, importPath);
+          const existingExt = path27.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -41780,7 +41980,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs17.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs16.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -41789,12 +41989,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path28.basename(resolvedImport, path28.extname(resolvedImport));
-        const importDir = path28.dirname(resolvedImport);
+        const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
+        const importDir = path27.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          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");
+          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");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -41807,8 +42007,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path28.resolve(testDir, importPath);
-          const existingExt = path28.extname(resolvedImport);
+          let resolvedImport = path27.resolve(testDir, importPath);
+          const existingExt = path27.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -41819,18 +42019,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs17.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs16.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path28.dirname(resolvedImport);
-          const importBasename = path28.basename(resolvedImport, path28.extname(resolvedImport));
+          const importDir = path27.dirname(resolvedImport);
+          const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            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");
+            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");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -41933,8 +42133,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs17.existsSync(path28.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs17.existsSync(path28.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs16.existsSync(path27.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs16.existsSync(path27.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -41951,7 +42151,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs17.existsSync(path28.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs16.existsSync(path27.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -42579,7 +42779,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file3) => {
         if (directTestFiles.includes(file3))
           return false;
-        const ext = path28.extname(file3).toLowerCase();
+        const ext = path27.extname(file3).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -42614,7 +42814,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path28.extname(f).toLowerCase();
+        const ext = path27.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -42641,7 +42841,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path28.extname(f).toLowerCase();
+        const ext = path27.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -42659,8 +42859,8 @@ var test_runner = createSwarmTool({
         const impactResult = await analyzeImpact(sourceFiles, workingDir);
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path28.relative(workingDir, absPath);
-            return path28.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path27.relative(workingDir, absPath);
+            return path27.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -42753,8 +42953,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path29.normalize(dir);
-  const absolutePath = path29.isAbsolute(normalized) ? normalized : path29.resolve(normalized);
+  const normalized = path28.normalize(dir);
+  const absolutePath = path28.isAbsolute(normalized) ? normalized : path28.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -42777,9 +42977,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path29.join(dir, "package.json");
-    if (fs18.existsSync(packagePath)) {
-      const content = fs18.readFileSync(packagePath, "utf-8");
+    const packagePath = path28.join(dir, "package.json");
+    if (fs17.existsSync(packagePath)) {
+      const content = fs17.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -42788,9 +42988,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path29.join(dir, "CHANGELOG.md");
-    if (fs18.existsSync(changelogPath)) {
-      const content = fs18.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path28.join(dir, "CHANGELOG.md");
+    if (fs17.existsSync(changelogPath)) {
+      const content = fs17.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -42802,10 +43002,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path29.join(dir, file3);
-    if (fs18.existsSync(filePath)) {
+    const filePath = path28.join(dir, file3);
+    if (fs17.existsSync(filePath)) {
       try {
-        const content = fs18.readFileSync(filePath, "utf-8").trim();
+        const content = fs17.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -43129,8 +43329,8 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path29.join(dir, ".swarm", "spec.md");
-    if (!fs18.existsSync(specPath)) {
+    const specPath = path28.join(dir, ".swarm", "spec.md");
+    if (!fs17.existsSync(specPath)) {
       return {
         type: "req_coverage",
         status: "skip",
@@ -43511,7 +43711,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/commands/reset.ts
-import * as fs19 from "fs";
+import * as fs18 from "fs";
 
 // src/background/manager.ts
 init_utils();
@@ -44212,8 +44412,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs19.existsSync(resolvedPath)) {
-        fs19.unlinkSync(resolvedPath);
+      if (fs18.existsSync(resolvedPath)) {
+        fs18.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -44230,8 +44430,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs19.existsSync(summariesPath)) {
-      fs19.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs18.existsSync(summariesPath)) {
+      fs18.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -44251,14 +44451,14 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 init_utils2();
-import * as fs20 from "fs";
-import * as path30 from "path";
+import * as fs19 from "fs";
+import * as path29 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs20.existsSync(statePath)) {
-      fs20.unlinkSync(statePath);
+    if (fs19.existsSync(statePath)) {
+      fs19.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -44267,15 +44467,15 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path30.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs20.existsSync(sessionDir)) {
-      const files = fs20.readdirSync(sessionDir);
+    const sessionDir = path29.dirname(validateSwarmPath(directory, "session/state.json"));
+    if (fs19.existsSync(sessionDir)) {
+      const files = fs19.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 (fs20.lstatSync(filePath).isFile()) {
-          fs20.unlinkSync(filePath);
+        const filePath = path29.join(sessionDir, file3);
+        if (fs19.lstatSync(filePath).isFile()) {
+          fs19.unlinkSync(filePath);
           deletedCount++;
         }
       }
@@ -44303,7 +44503,7 @@ async function handleResetSessionCommand(directory, _args) {
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
-import * as path31 from "path";
+import * as path30 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -44327,7 +44527,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path31.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path30.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -44379,19 +44579,21 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 }
 
 // src/commands/rollback.ts
+init_plan_schema();
 init_utils2();
-import * as fs21 from "fs";
-import * as path32 from "path";
+init_ledger();
+import * as fs20 from "fs";
+import * as path31 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs21.existsSync(manifestPath2)) {
+    if (!fs20.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs21.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs20.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -44413,12 +44615,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs21.existsSync(manifestPath)) {
+  if (!fs20.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs21.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs20.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -44428,28 +44630,69 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs21.existsSync(checkpointDir)) {
+  if (!fs20.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs21.readdirSync(checkpointDir);
+  const checkpointFiles = fs20.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
   const swarmDir = validateSwarmPath(directory, "");
+  const EXCLUDE_FILES = new Set([
+    "plan-ledger.jsonl",
+    "plan-ledger.quarantine"
+  ]);
   const successes = [];
   const failures = [];
   for (const file3 of checkpointFiles) {
-    const src = path32.join(checkpointDir, file3);
-    const dest = path32.join(swarmDir, file3);
+    if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
+      continue;
+    }
+    const src = path31.join(checkpointDir, file3);
+    const dest = path31.join(swarmDir, file3);
     try {
-      fs21.cpSync(src, dest, { recursive: true, force: true });
+      fs20.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
     }
   }
   if (failures.length > 0) {
-    return `Rollback partially completed. Successfully restored ${successes.length} files: ${successes.join(", ") || "none"}. Failed on ${failures.length} files: ${failures.map((f) => f.file).join(", ")}. Check permissions and disk space.`;
+    return [
+      `Rollback partially completed. Successfully restored ${successes.length} files.`,
+      `Failed on ${failures.length} files:`,
+      ...failures.map((f) => `  - ${f.file}: ${f.error}`),
+      "",
+      "Some files could not be restored. The .swarm/ directory may be in an inconsistent state.",
+      "Check permissions and disk space, then retry the rollback."
+    ].join(`
+`);
+  }
+  const existingLedgerPath = path31.join(swarmDir, "plan-ledger.jsonl");
+  if (fs20.existsSync(existingLedgerPath)) {
+    fs20.unlinkSync(existingLedgerPath);
+  }
+  try {
+    const planJsonPath = path31.join(swarmDir, "plan.json");
+    if (fs20.existsSync(planJsonPath)) {
+      const planRaw = fs20.readFileSync(planJsonPath, "utf-8");
+      const plan = PlanSchema.parse(JSON.parse(planRaw));
+      const planId = `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
+      const planHash = computePlanHash(plan);
+      await initLedger(directory, planId, planHash, plan);
+      await appendLedgerEvent(directory, {
+        event_type: "plan_rebuilt",
+        source: "rollback",
+        plan_id: planId
+      });
+    }
+  } catch (initError) {
+    return [
+      `Rollback restored files but failed to initialize ledger: ${initError instanceof Error ? initError.message : String(initError)}`,
+      "The .swarm/plan.json has been restored but the ledger may be out of sync.",
+      "Run /swarm reset-session to reinitialize the ledger."
+    ].join(`
+`);
   }
   const eventsPath = validateSwarmPath(directory, "events.jsonl");
   const rollbackEvent = {
@@ -44459,7 +44702,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs21.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs20.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
@@ -44502,11 +44745,11 @@ async function handleSimulateCommand(directory, args) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs22 = await import("fs/promises");
-  const path33 = await import("path");
-  const reportPath = path33.join(directory, ".swarm", "simulate-report.md");
-  await fs22.mkdir(path33.dirname(reportPath), { recursive: true });
-  await fs22.writeFile(reportPath, report, "utf-8");
+  const fs21 = await import("fs/promises");
+  const path32 = await import("path");
+  const reportPath = path32.join(directory, ".swarm", "simulate-report.md");
+  await fs21.mkdir(path32.dirname(reportPath), { recursive: true });
+  await fs21.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -45039,19 +45282,20 @@ function resolveCommand(tokens) {
 }
 
 // src/cli/index.ts
-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(os6.homedir(), ".cache"), "opencode", "packages", "opencode-swarm@latest");
+var { version: version4 } = package_default;
+var CONFIG_DIR = path32.join(process.env.XDG_CONFIG_HOME || path32.join(os6.homedir(), ".config"), "opencode");
+var OPENCODE_CONFIG_PATH = path32.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path32.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path32.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_PLUGIN_CACHE_PATH = path32.join(process.env.XDG_CACHE_HOME || path32.join(os6.homedir(), ".cache"), "opencode", "packages", "opencode-swarm@latest");
 function ensureDir(dir) {
-  if (!fs22.existsSync(dir)) {
-    fs22.mkdirSync(dir, { recursive: true });
+  if (!fs21.existsSync(dir)) {
+    fs21.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs22.readFileSync(filepath, "utf-8");
+    const content = fs21.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -45059,15 +45303,31 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs22.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs21.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
+function writeProjectConfigIfMissing(cwd) {
+  try {
+    const opencodeDir = path32.join(cwd, ".opencode");
+    const projectConfigPath = path32.join(opencodeDir, "opencode-swarm.json");
+    if (fs21.existsSync(projectConfigPath)) {
+      return;
+    }
+    ensureDir(opencodeDir);
+    const starterConfig = { agents: {} };
+    saveJson(projectConfigPath, starterConfig);
+    console.log("\u2713 Created project config at:", projectConfigPath);
+  } catch (error93) {
+    console.warn("\u26A0 Could not create project config \u2014 installation will continue:");
+    console.warn(`  ${error93 instanceof Error ? error93.message : String(error93)}`);
+  }
+}
 async function install() {
   console.log(`\uD83D\uDC1D Installing OpenCode Swarm...
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path33.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path32.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);
@@ -45099,15 +45359,15 @@ async function install() {
   console.log("\u2713 Added opencode-swarm to OpenCode plugins");
   console.log("\u2713 Disabled default OpenCode agents (explore, general)");
   try {
-    if (fs22.existsSync(OPENCODE_PLUGIN_CACHE_PATH)) {
-      fs22.rmSync(OPENCODE_PLUGIN_CACHE_PATH, { recursive: true, force: true });
+    if (fs21.existsSync(OPENCODE_PLUGIN_CACHE_PATH)) {
+      fs21.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 (!fs22.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs21.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: {
         coder: {
@@ -45182,6 +45442,7 @@ async function install() {
   } else {
     console.log("\u2713 Plugin config already exists at:", PLUGIN_CONFIG_PATH);
   }
+  writeProjectConfigIfMissing(process.cwd());
   console.log(`
 \uD83D\uDCC1 Configuration files:`);
   console.log(`   OpenCode config: ${OPENCODE_CONFIG_PATH}`);
@@ -45210,7 +45471,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs22.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs21.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -45242,13 +45503,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs22.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs22.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs21.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs21.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs22.existsSync(PROMPTS_DIR)) {
-        fs22.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs21.existsSync(PROMPTS_DIR)) {
+        fs21.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }
@@ -45311,6 +45572,10 @@ Examples:
 }
 async function main() {
   const args = process.argv.slice(2);
+  if (args.includes("-v") || args.includes("--version")) {
+    console.log(`opencode-swarm ${version4}`);
+    process.exit(0);
+  }
   if (args.includes("-h") || args.includes("--help")) {
     printHelp();
     process.exit(0);