opencode-swarm 7.74.1 → 7.74.3

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.74.1",
+    version: "7.74.3",
     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",
@@ -47713,6 +47713,7 @@ __export(exports_config_doctor, {
   runConfigDoctor: () => runConfigDoctor,
   restoreFromBackup: () => restoreFromBackup,
   removeStraySwarmDir: () => removeStraySwarmDir,
+  readDoctorArtifact: () => readDoctorArtifact,
   getConfigPaths: () => getConfigPaths,
   detectStraySwarmDirs: () => detectStraySwarmDirs,
   createConfigBackup: () => createConfigBackup,
@@ -47722,6 +47723,37 @@ import * as crypto4 from "crypto";
 import * as fs13 from "fs";
 import * as os7 from "os";
 import * as path35 from "path";
+function levenshteinDistance(a, b) {
+  const al = a.length;
+  const bl = b.length;
+  const matrix = [];
+  for (let i = 0;i <= al; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0;j <= bl; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1;i <= al; i++) {
+    for (let j = 1;j <= bl; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+    }
+  }
+  return matrix[al][bl];
+}
+function emitObjectTypeMismatch(key, value, findings) {
+  if (value !== undefined && (typeof value !== "object" || Array.isArray(value) || value === null)) {
+    findings.push({
+      id: `invalid-${key}-type`,
+      title: `Invalid ${key} type`,
+      description: `"${key}" must be an object, got ${typeof value}`,
+      severity: "error",
+      path: key,
+      currentValue: value,
+      autoFixable: false
+    });
+  }
+}
 function getUserConfigDir3() {
   return process.env.XDG_CONFIG_HOME || path35.join(os7.homedir(), ".config");
 }
@@ -47743,23 +47775,39 @@ function isValidConfigPath(configPath, directory) {
       }
     }
   }
-  for (const pattern of VALID_CONFIG_PATTERNS) {
-    if (pattern.test(normalizedPath)) {
-      return true;
-    }
-  }
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
-  const normalizedUser = userConfigPath.replace(/\\/g, "/");
-  const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
     const resolvedConfig = path35.resolve(configPath);
-    const resolvedUser = path35.resolve(normalizedUser);
-    const resolvedProject = path35.resolve(normalizedProject);
-    return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
+    const resolvedUser = path35.resolve(userConfigPath);
+    const resolvedProject = path35.resolve(projectConfigPath);
+    if (resolvedConfig !== resolvedUser && resolvedConfig !== resolvedProject) {
+      return false;
+    }
+    try {
+      if (fs13.existsSync(resolvedConfig)) {
+        const realConfig = fs13.realpathSync(resolvedConfig);
+        if (realConfig !== resolvedConfig) {
+          return false;
+        }
+      }
+    } catch {}
+    return true;
   } catch {
     return false;
   }
 }
+function atomicWriteFileSync(filePath, content) {
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+  fs13.writeFileSync(tmpPath, content, "utf-8");
+  try {
+    fs13.renameSync(tmpPath, filePath);
+  } catch {
+    try {
+      fs13.unlinkSync(filePath);
+    } catch {}
+    fs13.renameSync(tmpPath, filePath);
+  }
+}
 function createConfigBackup(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
@@ -47807,13 +47855,18 @@ function writeBackupArtifact(directory, backup) {
     content: backup.content,
     preview: backup.content.substring(0, 500) + (backup.content.length > 500 ? "..." : "")
   };
-  fs13.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
+  atomicWriteFileSync(backupPath, JSON.stringify(artifact, null, 2));
   return backupPath;
 }
 function restoreFromBackup(backupPath, directory) {
   if (!fs13.existsSync(backupPath)) {
     return null;
   }
+  const swarmDir = path35.resolve(path35.join(directory, ".swarm"));
+  const resolvedBackup = path35.resolve(backupPath);
+  if (!resolvedBackup.startsWith(swarmDir + path35.sep) && resolvedBackup !== swarmDir) {
+    return null;
+  }
   try {
     const artifact = JSON.parse(fs13.readFileSync(backupPath, "utf-8"));
     if (!artifact.content || !artifact.configPath || !artifact.contentHash) {
@@ -47828,12 +47881,13 @@ function restoreFromBackup(backupPath, directory) {
     if (!isLegacyHash && computedHash !== storedHash) {
       return null;
     }
+    log("[ConfigDoctor] Warning: restoring from backup with legacy numeric hash (pre-SHA-256). Consider re-backing up.", {});
     const targetPath = artifact.configPath;
     const targetDir = path35.dirname(targetPath);
     if (!fs13.existsSync(targetDir)) {
       fs13.mkdirSync(targetDir, { recursive: true });
     }
-    fs13.writeFileSync(targetPath, artifact.content, "utf-8");
+    atomicWriteFileSync(targetPath, artifact.content);
     return targetPath;
   } catch {
     return null;
@@ -47856,12 +47910,28 @@ function readConfigFromFile(directory) {
   try {
     const config3 = JSON.parse(configContent);
     return { config: config3, configPath };
-  } catch {
+  } catch (error93) {
+    log(`[ConfigDoctor] Failed to parse config file: ${configPath}`, {
+      error: error93 instanceof Error ? error93.message : String(error93)
+    });
     return null;
   }
 }
-function validateConfigKey(path36, value, _config) {
+function validateConfigKey(path36, value) {
   const findings = [];
+  for (const [depPath, depInfo] of DEPRECATED_FIELDS) {
+    if (path36 === depPath && !depInfo.isDefaultValue(value)) {
+      findings.push({
+        id: "deprecated-field",
+        title: `Deprecated config field: ${depPath}`,
+        description: `Config field "${depPath}" is deprecated. Replacement: ${depInfo.replacement}.`,
+        severity: "info",
+        path: depPath,
+        currentValue: value,
+        autoFixable: false
+      });
+    }
+  }
   switch (path36) {
     case "agents": {
       if (value !== undefined) {
@@ -47979,8 +48049,9 @@ function validateConfigKey(path36, value, _config) {
       break;
     }
     case "hooks": {
-      const hooks = value;
-      if (hooks) {
+      emitObjectTypeMismatch("hooks", value, findings);
+      if (value !== undefined && typeof value === "object" && !Array.isArray(value) && value !== null) {
+        const hooks = value;
         const validHooks = [
           "system_enhancer",
           "compaction",
@@ -48061,8 +48132,42 @@ function validateConfigKey(path36, value, _config) {
       break;
     }
     case "swarms": {
-      const swarms = value;
-      if (swarms && typeof swarms === "object") {
+      if (value !== undefined) {
+        if (typeof value !== "object" || Array.isArray(value) || value === null) {
+          findings.push({
+            id: "invalid-swarms-type",
+            title: "Invalid swarms type",
+            description: `"swarms" must be an object, got ${typeof value}`,
+            severity: "error",
+            path: "swarms",
+            currentValue: value,
+            autoFixable: false
+          });
+          break;
+        }
+        const swarms = value;
+        if (Object.keys(swarms).length === 0) {
+          findings.push({
+            id: "empty-swarms",
+            title: "Empty swarms configuration",
+            description: 'The "swarms" field is an empty object. No swarm configurations are defined.',
+            severity: "info",
+            path: "swarms",
+            autoFixable: false
+          });
+        }
+        for (const swarmId of Object.keys(swarms)) {
+          if (swarmId.includes("..") || swarmId.includes("/") || swarmId.includes("\\") || swarmId.includes("\x00")) {
+            findings.push({
+              id: "swarm-id-path-traversal",
+              title: "Path traversal in swarm ID",
+              description: `Swarm ID "${swarmId}" contains path traversal characters.`,
+              severity: "error",
+              path: `swarms.${swarmId}`,
+              autoFixable: false
+            });
+          }
+        }
         const validAgents = new Set(ALL_AGENT_NAMES);
         for (const [swarmId, swarmConfig] of Object.entries(swarms)) {
           const swarm = swarmConfig;
@@ -48096,36 +48201,376 @@ function validateConfigKey(path36, value, _config) {
       }
       break;
     }
+    case "default_agent": {
+      if (value !== undefined && typeof value !== "string") {
+        findings.push({
+          id: "invalid-default_agent-type",
+          title: "Invalid default_agent type",
+          description: `"default_agent" must be a string, got ${typeof value}`,
+          severity: "error",
+          path: "default_agent",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "auto_select_architect": {
+      if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
+        findings.push({
+          id: "invalid-auto_select_architect-type",
+          title: "Invalid auto_select_architect type",
+          description: `"auto_select_architect" must be a boolean or string, got ${typeof value}`,
+          severity: "error",
+          path: "auto_select_architect",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "pipeline": {
+      emitObjectTypeMismatch("pipeline", value, findings);
+      break;
+    }
+    case "phase_complete": {
+      emitObjectTypeMismatch("phase_complete", value, findings);
+      break;
+    }
+    case "execution_mode": {
+      const validModes = ["strict", "balanced", "fast"];
+      if (value !== undefined && !validModes.includes(value)) {
+        findings.push({
+          id: "invalid-execution_mode-type",
+          title: "Invalid execution_mode",
+          description: `"execution_mode" must be one of: ${validModes.join(", ")}, got "${value}"`,
+          severity: "error",
+          path: "execution_mode",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "inject_phase_reminders": {
+      if (value !== undefined && typeof value !== "boolean") {
+        findings.push({
+          id: "invalid-inject_phase_reminders-type",
+          title: "Invalid inject_phase_reminders type",
+          description: `"inject_phase_reminders" must be a boolean, got ${typeof value}`,
+          severity: "error",
+          path: "inject_phase_reminders",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "gates": {
+      emitObjectTypeMismatch("gates", value, findings);
+      break;
+    }
+    case "context_budget": {
+      emitObjectTypeMismatch("context_budget", value, findings);
+      break;
+    }
+    case "guardrails": {
+      emitObjectTypeMismatch("guardrails", value, findings);
+      break;
+    }
+    case "watchdog": {
+      emitObjectTypeMismatch("watchdog", value, findings);
+      break;
+    }
+    case "self_review": {
+      emitObjectTypeMismatch("self_review", value, findings);
+      break;
+    }
+    case "tool_filter": {
+      emitObjectTypeMismatch("tool_filter", value, findings);
+      break;
+    }
+    case "authority": {
+      emitObjectTypeMismatch("authority", value, findings);
+      break;
+    }
+    case "plan_cursor": {
+      emitObjectTypeMismatch("plan_cursor", value, findings);
+      break;
+    }
+    case "context_map": {
+      emitObjectTypeMismatch("context_map", value, findings);
+      break;
+    }
+    case "evidence": {
+      emitObjectTypeMismatch("evidence", value, findings);
+      break;
+    }
+    case "summaries": {
+      emitObjectTypeMismatch("summaries", value, findings);
+      break;
+    }
+    case "review_passes": {
+      emitObjectTypeMismatch("review_passes", value, findings);
+      break;
+    }
+    case "adversarial_detection": {
+      emitObjectTypeMismatch("adversarial_detection", value, findings);
+      break;
+    }
+    case "adversarial_testing": {
+      emitObjectTypeMismatch("adversarial_testing", value, findings);
+      break;
+    }
+    case "integration_analysis": {
+      emitObjectTypeMismatch("integration_analysis", value, findings);
+      break;
+    }
+    case "docs": {
+      emitObjectTypeMismatch("docs", value, findings);
+      break;
+    }
+    case "design_docs": {
+      emitObjectTypeMismatch("design_docs", value, findings);
+      break;
+    }
+    case "ui_review": {
+      emitObjectTypeMismatch("ui_review", value, findings);
+      break;
+    }
+    case "compaction_advisory": {
+      emitObjectTypeMismatch("compaction_advisory", value, findings);
+      break;
+    }
+    case "lint": {
+      emitObjectTypeMismatch("lint", value, findings);
+      break;
+    }
+    case "secretscan": {
+      emitObjectTypeMismatch("secretscan", value, findings);
+      break;
+    }
+    case "checkpoint": {
+      emitObjectTypeMismatch("checkpoint", value, findings);
+      break;
+    }
+    case "automation": {
+      emitObjectTypeMismatch("automation", value, findings);
+      break;
+    }
+    case "knowledge": {
+      emitObjectTypeMismatch("knowledge", value, findings);
+      break;
+    }
+    case "memory": {
+      emitObjectTypeMismatch("memory", value, findings);
+      break;
+    }
+    case "curator": {
+      emitObjectTypeMismatch("curator", value, findings);
+      break;
+    }
+    case "architectural_supervision": {
+      emitObjectTypeMismatch("architectural_supervision", value, findings);
+      break;
+    }
+    case "knowledge_application": {
+      emitObjectTypeMismatch("knowledge_application", value, findings);
+      break;
+    }
+    case "skillPropagation": {
+      emitObjectTypeMismatch("skillPropagation", value, findings);
+      break;
+    }
+    case "skill_improver": {
+      emitObjectTypeMismatch("skill_improver", value, findings);
+      break;
+    }
+    case "spec_writer": {
+      emitObjectTypeMismatch("spec_writer", value, findings);
+      break;
+    }
+    case "tool_output": {
+      emitObjectTypeMismatch("tool_output", value, findings);
+      break;
+    }
+    case "slop_detector": {
+      emitObjectTypeMismatch("slop_detector", value, findings);
+      break;
+    }
+    case "todo_gate": {
+      emitObjectTypeMismatch("todo_gate", value, findings);
+      break;
+    }
+    case "incremental_verify": {
+      emitObjectTypeMismatch("incremental_verify", value, findings);
+      break;
+    }
+    case "compaction_service": {
+      emitObjectTypeMismatch("compaction_service", value, findings);
+      break;
+    }
+    case "prm": {
+      emitObjectTypeMismatch("prm", value, findings);
+      break;
+    }
+    case "council": {
+      emitObjectTypeMismatch("council", value, findings);
+      break;
+    }
+    case "parallelization": {
+      emitObjectTypeMismatch("parallelization", value, findings);
+      break;
+    }
+    case "worktree": {
+      emitObjectTypeMismatch("worktree", value, findings);
+      break;
+    }
+    case "turbo": {
+      emitObjectTypeMismatch("turbo", value, findings);
+      break;
+    }
+    case "turbo_mode": {
+      if (value !== undefined && typeof value !== "boolean") {
+        findings.push({
+          id: "invalid-turbo_mode-type",
+          title: "Invalid turbo_mode type",
+          description: `"turbo_mode" must be a boolean, got ${typeof value}`,
+          severity: "error",
+          path: "turbo_mode",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "quiet": {
+      if (value !== undefined && typeof value !== "boolean") {
+        findings.push({
+          id: "invalid-quiet-type",
+          title: "Invalid quiet type",
+          description: `"quiet" must be a boolean, got ${typeof value}`,
+          severity: "error",
+          path: "quiet",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "version_check": {
+      if (value !== undefined && typeof value !== "boolean") {
+        findings.push({
+          id: "invalid-version_check-type",
+          title: "Invalid version_check type",
+          description: `"version_check" must be a boolean, got ${typeof value}`,
+          severity: "error",
+          path: "version_check",
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
+    case "full_auto": {
+      emitObjectTypeMismatch("full_auto", value, findings);
+      break;
+    }
+    case "pr_monitor": {
+      emitObjectTypeMismatch("pr_monitor", value, findings);
+      break;
+    }
+    case "external_skills": {
+      emitObjectTypeMismatch("external_skills", value, findings);
+      break;
+    }
+    default: {
+      const topLevel = path36.split(".")[0];
+      if (KNOWN_TOP_LEVEL_KEYS.has(topLevel)) {
+        break;
+      }
+      const MAX_SUGGESTION_KEY_LENGTH = 100;
+      const lowerTopLevel = topLevel.toLowerCase();
+      let suggestion;
+      let matchCount = 0;
+      if (lowerTopLevel.length <= MAX_SUGGESTION_KEY_LENGTH) {
+        for (const knownKey of KNOWN_TOP_LEVEL_KEYS) {
+          if (levenshteinDistance(lowerTopLevel, knownKey.toLowerCase()) <= 2) {
+            matchCount++;
+            if (matchCount === 1) {
+              suggestion = knownKey;
+            }
+          }
+        }
+      }
+      if (matchCount === 1 && suggestion) {
+        findings.push({
+          id: "unknown-config-key",
+          title: `Unknown config key: ${topLevel}`,
+          description: `Unknown config key "${path36}" is not in the schema. Did you mean "${suggestion}"?`,
+          severity: "warn",
+          path: path36,
+          currentValue: value,
+          autoFixable: false
+        });
+      } else {
+        findings.push({
+          id: "unknown-config-key",
+          title: `Unknown config key: ${topLevel}`,
+          description: `Unknown config key "${path36}" is not in the schema.`,
+          severity: "warn",
+          path: path36,
+          currentValue: value,
+          autoFixable: false
+        });
+      }
+      break;
+    }
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path36, config3, findings) {
+function walkConfigAndValidate(obj, path36, findings, visited = new WeakSet) {
   if (obj === null || obj === undefined) {
     return;
   }
   if (path36 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path36, obj, config3);
+    const keyFindings = validateConfigKey(path36, obj);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path36, obj, config3);
+    const keyFindings = validateConfigKey(path36, obj);
     findings.push(...keyFindings);
     return;
   }
+  if (visited.has(obj)) {
+    findings.push({
+      id: "circular-reference",
+      title: `Circular reference detected at ${path36}`,
+      description: `Config value at "${path36}" contains a circular reference. Validation stopped at this path to prevent stack overflow.`,
+      severity: "error",
+      path: path36,
+      currentValue: "[circular]",
+      autoFixable: false
+    });
+    return;
+  }
+  visited.add(obj);
   if (Array.isArray(obj)) {
+    const arrayFindings = validateConfigKey(path36, obj);
+    findings.push(...arrayFindings);
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path36}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path36}[${index}]`, findings, visited);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
     const newPath = path36 ? `${path36}.${key}` : key;
-    walkConfigAndValidate(value, newPath, config3, findings);
+    walkConfigAndValidate(value, newPath, findings, visited);
   }
 }
 function runConfigDoctor(config3, directory) {
   const findings = [];
-  walkConfigAndValidate(config3, "", config3, findings);
+  walkConfigAndValidate(config3, "", findings);
   const summary = {
     info: findings.filter((f) => f.severity === "info").length,
     warn: findings.filter((f) => f.severity === "warn").length,
@@ -48243,11 +48688,45 @@ function applySafeAutoFixes(directory, result) {
     if (!fs13.existsSync(configDir)) {
       fs13.mkdirSync(configDir, { recursive: true });
     }
-    fs13.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
+    atomicWriteFileSync(configPath, JSON.stringify(config3, null, 2));
     updatedConfigPath = configPath;
   }
   return { appliedFixes, updatedConfigPath };
 }
+function readDoctorArtifact(directory) {
+  try {
+    const artifactPath = path35.join(directory, ".swarm", "config-doctor.json");
+    if (!fs13.existsSync(artifactPath)) {
+      return null;
+    }
+    const content = fs13.readFileSync(artifactPath, "utf-8");
+    const artifact = JSON.parse(content);
+    const summary = artifact.summary;
+    if (!summary || typeof summary !== "object") {
+      return null;
+    }
+    const infoVal = summary.info;
+    const warnVal = summary.warn;
+    const errorVal = summary.error;
+    if (typeof infoVal !== "number" || !Number.isFinite(infoVal) || typeof warnVal !== "number" || !Number.isFinite(warnVal) || typeof errorVal !== "number" || !Number.isFinite(errorVal)) {
+      return null;
+    }
+    const ts = artifact.timestamp;
+    if (typeof ts !== "number" || !Number.isFinite(ts)) {
+      return null;
+    }
+    const findingsCount = infoVal + warnVal + errorVal;
+    const findings = artifact.findings;
+    const autoFixableCount = Array.isArray(findings) ? findings.filter((f) => f.autoFixable === true).length : 0;
+    return {
+      timestamp: new Date(ts).toISOString(),
+      findingsCount,
+      autoFixableCount
+    };
+  } catch {
+    return null;
+  }
+}
 function writeDoctorArtifact(directory, result) {
   const swarmDir = path35.join(directory, ".swarm");
   if (!fs13.existsSync(swarmDir)) {
@@ -48275,7 +48754,7 @@ function writeDoctorArtifact(directory, result) {
       } : null
     }))
   };
-  fs13.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
+  atomicWriteFileSync(artifactPath, JSON.stringify(guiOutput, null, 2));
   return artifactPath;
 }
 function shouldRunOnStartup(automationConfig) {
@@ -48428,15 +48907,46 @@ function removeStraySwarmDir(projectRoot, strayPath) {
     };
   }
 }
-var VALID_CONFIG_PATTERNS, DANGEROUS_PATH_SEGMENTS;
+var KNOWN_TOP_LEVEL_KEYS, DEPRECATED_FIELDS, DANGEROUS_PATH_SEGMENTS;
 var init_config_doctor = __esm(() => {
   init_constants();
   init_schema();
   init_utils();
-  VALID_CONFIG_PATTERNS = [
-    /^\.config[\\/]opencode[\\/]opencode-swarm\.json$/,
-    /\.opencode[\\/]opencode-swarm\.json$/
-  ];
+  KNOWN_TOP_LEVEL_KEYS = new Set(Object.keys(PluginConfigSchema.shape));
+  DEPRECATED_FIELDS = new Map([
+    [
+      "skill_improver.model",
+      {
+        message: "deprecated",
+        replacement: "agents.skill_improver.model",
+        isDefaultValue: (v) => v === null
+      }
+    ],
+    [
+      "skill_improver.fallback_models",
+      {
+        message: "deprecated",
+        replacement: "agents.skill_improver.fallback_models",
+        isDefaultValue: (v) => Array.isArray(v) && v.length === 0
+      }
+    ],
+    [
+      "spec_writer.model",
+      {
+        message: "deprecated",
+        replacement: "agents.spec_writer.model",
+        isDefaultValue: (v) => v === null
+      }
+    ],
+    [
+      "spec_writer.fallback_models",
+      {
+        message: "deprecated",
+        replacement: "agents.spec_writer.fallback_models",
+        isDefaultValue: (v) => Array.isArray(v) && v.length === 0
+      }
+    ]
+  ]);
   DANGEROUS_PATH_SEGMENTS = new Set([
     "__proto__",
     "constructor",
@@ -50099,7 +50609,14 @@ async function handleDoctorCommand(directory, args) {
     const fixResult = await runConfigDoctorWithFixes2(directory, config3, true);
     output = formatDoctorMarkdown(fixResult.result);
   } else {
-    output = formatDoctorMarkdown(result);
+    const lastRun = readDoctorArtifact(directory);
+    let markdown = formatDoctorMarkdown(result);
+    if (lastRun) {
+      markdown = `Last run: ${lastRun.timestamp}, ${lastRun.findingsCount} findings (${lastRun.autoFixableCount} auto-fixable)
+
+` + markdown;
+    }
+    output = markdown;
   }
   const strayDirs = detectStraySwarmDirs(directory);
   if (strayDirs.length > 0) {
@@ -51408,7 +51925,7 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync15, openSync as openSync5, renameSync as renameSync9 } from "fs";
+import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync15, openSync as openSync5, renameSync as renameSync10 } from "fs";
 import * as path38 from "path";
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -51527,7 +52044,7 @@ async function writeSnapshot(directory, state) {
         closeSync5(fd);
       }
     } catch {}
-    renameSync9(tempPath, resolvedPath);
+    renameSync10(tempPath, resolvedPath);
   } catch (error93) {
     log("[snapshot-writer] write failed", {
       error: error93 instanceof Error ? error93.message : String(error93)
@@ -51560,7 +52077,7 @@ var init_snapshot_writer = __esm(() => {
 
 // src/commands/handoff.ts
 import crypto5 from "crypto";
-import { renameSync as renameSync10, unlinkSync as unlinkSync6 } from "fs";
+import { renameSync as renameSync11, unlinkSync as unlinkSync7 } from "fs";
 async function handleHandoffCommand(directory, _args) {
   const handoffData = await getHandoffData(directory);
   const markdown = formatHandoffMarkdown(handoffData);
@@ -51569,10 +52086,10 @@ async function handleHandoffCommand(directory, _args) {
     const tempPath = `${resolvedPath}.tmp.${crypto5.randomUUID()}`;
     await bunWrite(tempPath, markdown);
     try {
-      renameSync10(tempPath, resolvedPath);
+      renameSync11(tempPath, resolvedPath);
     } catch (renameErr) {
       try {
-        unlinkSync6(tempPath);
+        unlinkSync7(tempPath);
       } catch {}
       throw renameErr;
     }
@@ -51581,10 +52098,10 @@ async function handleHandoffCommand(directory, _args) {
     const promptTempPath = `${promptPath}.tmp.${crypto5.randomUUID()}`;
     await bunWrite(promptTempPath, continuationPrompt);
     try {
-      renameSync10(promptTempPath, promptPath);
+      renameSync11(promptTempPath, promptPath);
     } catch (renameErr) {
       try {
-        unlinkSync6(promptTempPath);
+        unlinkSync7(promptTempPath);
       } catch {}
       throw renameErr;
     }
@@ -64742,8 +65259,6 @@ var init_write_retro2 = __esm(() => {
 });
 
 // src/commands/command-dispatch.ts
-import fs35 from "fs";
-import path65 from "path";
 function normalizeSwarmCommandInput(command, argumentText) {
   if (command !== "swarm" && !command.startsWith("swarm-")) {
     return { isSwarmCommand: false, tokens: [] };
@@ -64778,25 +65293,6 @@ ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
 
 `);
 }
-function maybeMarkFirstRun(directory) {
-  const sentinelPath = path65.join(directory, ".swarm", ".first-run-complete");
-  try {
-    const swarmDir = path65.join(directory, ".swarm");
-    fs35.mkdirSync(swarmDir, { recursive: true });
-    fs35.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
-`, { flag: "wx" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function prependWelcome(text) {
-  const welcomeMessage = `Welcome to OpenCode Swarm!
-` + `
-` + `Run \`/swarm help\` to see all available commands, or \`/swarm config\` to review your configuration.
-`;
-  return welcomeMessage + text;
-}
 async function executeSwarmCommand(args) {
   const {
     directory,
@@ -64804,7 +65300,6 @@ async function executeSwarmCommand(args) {
     sessionID,
     tokens,
     packageRoot,
-    includeWelcome = false,
     buildHelpText,
     policy
   } = args;
@@ -64838,9 +65333,6 @@ ${text}`;
       }
     }
   }
-  if (includeWelcome && maybeMarkFirstRun(directory)) {
-    text = prependWelcome(text);
-  }
   return {
     text,
     resolved: resolved ?? undefined,
@@ -65463,7 +65955,7 @@ var init_commands = __esm(() => {
 });
 
 // src/commands/registry.ts
-function levenshteinDistance(a, b) {
+function levenshteinDistance2(a, b) {
   const matrix = [];
   for (let i = 0;i <= b.length; i++) {
     matrix[i] = [i];
@@ -65590,24 +66082,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path66 = [];
+      const path65 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path66.indexOf(current);
+          const cycleStart = path65.indexOf(current);
           const fullChain = [
             name,
-            ...path66.slice(0, cycleStart > 0 ? cycleStart : path66.length),
+            ...path65.slice(0, cycleStart > 0 ? cycleStart : path65.length),
             current
           ].join(" \u2192 ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path66.push(current);
+        path65.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -66329,7 +66821,7 @@ Subcommands:
     handleHelpCommand,
     validateAliases,
     resolveCommand,
-    levenshteinDistance,
+    levenshteinDistance: levenshteinDistance2,
     findSimilarCommands,
     buildDetailedHelp
   };
@@ -66351,72 +66843,72 @@ init_package();
 init_registry();
 init_cache_paths();
 init_constants();
-import * as fs36 from "fs";
+import * as fs35 from "fs";
 import * as os10 from "os";
-import * as path66 from "path";
+import * as path65 from "path";
 var { version: version5 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
-var OPENCODE_CONFIG_PATH = path66.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path66.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path66.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_CONFIG_PATH = path65.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path65.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path65.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
-  const resolved = path66.resolve(p);
-  const home = path66.resolve(os10.homedir());
+  const resolved = path65.resolve(p);
+  const home = path65.resolve(os10.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path66.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path65.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path66.basename(resolved);
+  const leaf = path65.basename(resolved);
   if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
     return false;
   }
-  const parent = path66.basename(path66.dirname(resolved));
+  const parent = path65.basename(path65.dirname(resolved));
   if (parent !== "packages" && parent !== "node_modules") {
     return false;
   }
-  const grandparent = path66.basename(path66.dirname(path66.dirname(resolved)));
+  const grandparent = path65.basename(path65.dirname(path65.dirname(resolved)));
   if (grandparent !== "opencode") {
     return false;
   }
   return true;
 }
 function isSafeLockFilePath(p) {
-  const resolved = path66.resolve(p);
-  const home = path66.resolve(os10.homedir());
+  const resolved = path65.resolve(p);
+  const home = path65.resolve(os10.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path66.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path65.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path66.basename(resolved);
+  const leaf = path65.basename(resolved);
   if (leaf !== "bun.lock" && leaf !== "bun.lockb" && leaf !== "package-lock.json") {
     return false;
   }
-  const parent = path66.basename(path66.dirname(resolved));
+  const parent = path65.basename(path65.dirname(resolved));
   if (parent !== "opencode") {
     return false;
   }
-  const grandparent = path66.basename(path66.dirname(path66.dirname(resolved)));
+  const grandparent = path65.basename(path65.dirname(path65.dirname(resolved)));
   if (grandparent === "opencode") {
     return false;
   }
   return true;
 }
 function ensureDir(dir) {
-  if (!fs36.existsSync(dir)) {
-    fs36.mkdirSync(dir, { recursive: true });
+  if (!fs35.existsSync(dir)) {
+    fs35.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs36.readFileSync(filepath, "utf-8");
+    const content = fs35.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -66424,14 +66916,14 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs36.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs35.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path66.join(cwd, ".opencode");
-    const projectConfigPath = path66.join(opencodeDir, "opencode-swarm.json");
-    if (fs36.existsSync(projectConfigPath)) {
+    const opencodeDir = path65.join(cwd, ".opencode");
+    const projectConfigPath = path65.join(opencodeDir, "opencode-swarm.json");
+    if (fs35.existsSync(projectConfigPath)) {
       return;
     }
     ensureDir(opencodeDir);
@@ -66447,7 +66939,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path66.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path65.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);
@@ -66494,7 +66986,7 @@ async function install() {
     console.warn(`\u26A0 Could not clear opencode lock file \u2014 you may need to delete it manually:
   ${failed}`);
   }
-  if (!fs36.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs35.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: { ...DEFAULT_AGENT_CONFIGS },
       max_iterations: 5
@@ -66573,14 +67065,14 @@ function evictPluginCaches() {
   const cleared = [];
   const failed = [];
   for (const cachePath of OPENCODE_PLUGIN_CACHE_PATHS) {
-    if (!fs36.existsSync(cachePath))
+    if (!fs35.existsSync(cachePath))
       continue;
     if (!isSafeCachePath(cachePath)) {
       failed.push(`${cachePath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs36.rmSync(cachePath, { recursive: true, force: true });
+      fs35.rmSync(cachePath, { recursive: true, force: true });
       cleared.push(cachePath);
     } catch (err) {
       failed.push(`${cachePath} (${err instanceof Error ? err.message : String(err)})`);
@@ -66592,14 +67084,14 @@ function evictLockFiles() {
   const cleared = [];
   const failed = [];
   for (const lockPath of OPENCODE_PLUGIN_LOCK_FILE_PATHS) {
-    if (!fs36.existsSync(lockPath))
+    if (!fs35.existsSync(lockPath))
       continue;
     if (!isSafeLockFilePath(lockPath)) {
       failed.push(`${lockPath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs36.unlinkSync(lockPath);
+      fs35.unlinkSync(lockPath);
       cleared.push(lockPath);
     } catch (err) {
       const code = err?.code;
@@ -66618,7 +67110,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs36.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs35.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -66650,13 +67142,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs36.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs36.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs35.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs35.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs36.existsSync(PROMPTS_DIR)) {
-        fs36.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs35.existsSync(PROMPTS_DIR)) {
+        fs35.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }