opencode-swarm 7.74.2 → 7.75.0

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.74.2",
+    version: "7.75.0",
     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",
@@ -18015,6 +18015,7 @@ __export(exports_schema, {
   AutomationModeSchema: () => AutomationModeSchema,
   AutomationConfigSchema: () => AutomationConfigSchema,
   AutomationCapabilitiesSchema: () => AutomationCapabilitiesSchema,
+  AutoReviewConfigSchema: () => AutoReviewConfigSchema,
   AuthorityConfigSchema: () => AuthorityConfigSchema,
   ArchitecturalSupervisionConfigSchema: () => ArchitecturalSupervisionConfigSchema,
   AgentThinkingConfigSchema: () => AgentThinkingConfigSchema,
@@ -18100,7 +18101,7 @@ function resolveExternalSkillsConfig(input) {
   };
   return merged;
 }
-var _internals5, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentReasoningConfigSchema, AgentThinkingConfigSchema, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, PluginConfigSchema;
+var _internals5, SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentReasoningConfigSchema, AgentThinkingConfigSchema, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AutoReviewConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, DesignDocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, ContextMapConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, MemoryConfigSchema, CuratorConfigSchema, ArchitecturalSupervisionConfigSchema, KnowledgeApplicationConfigSchema, SkillPropagationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, PrMonitorConfigSchema, ParallelizationConfigSchema, WorktreeIsolationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, ExternalSkillCandidateSourceTypeSchema, ExternalSkillCandidateEvaluationVerdictSchema, DiscoverySourceSchema, ExternalSkillCandidateSchema, ExternalSkillsConfigSchema, DEFAULT_EXTERNAL_SKILLS_CONFIG, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_constants();
@@ -18288,6 +18289,12 @@ var init_schema = __esm(() => {
       "**/token/**"
     ])
   });
+  AutoReviewConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(false),
+    trigger: exports_external.enum(["task_completion", "phase_boundary", "both"]).default("phase_boundary"),
+    timeout_ms: exports_external.number().int().min(1e4).max(1800000).default(300000),
+    max_diff_kb: exports_external.number().int().min(16).max(2048).default(256)
+  });
   AdversarialDetectionConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
     policy: exports_external.enum(["warn", "gate", "ignore"]).default("warn"),
@@ -18971,6 +18978,7 @@ var init_schema = __esm(() => {
     guardrails: GuardrailsConfigSchema.optional(),
     watchdog: WatchdogConfigSchema.optional(),
     self_review: SelfReviewConfigSchema.optional(),
+    auto_review: AutoReviewConfigSchema.optional(),
     tool_filter: ToolFilterConfigSchema.optional(),
     authority: AuthorityConfigSchema.optional(),
     plan_cursor: PlanCursorConfigSchema.optional(),
@@ -19021,6 +19029,7 @@ var init_schema = __esm(() => {
     version_check: exports_external.boolean().default(true).optional(),
     full_auto: exports_external.object({
       enabled: exports_external.boolean().default(false),
+      locked: exports_external.boolean().default(false),
       critic_model: exports_external.string().optional(),
       max_interactions_per_phase: exports_external.number().int().min(5).max(200).default(50),
       deadlock_threshold: exports_external.number().int().min(2).max(10).default(3),
@@ -19034,6 +19043,7 @@ var init_schema = __esm(() => {
         protected_paths: exports_external.array(exports_external.string()).default([
           ".git",
           ".github/workflows",
+          ".opencode",
           ".swarm",
           "package.json",
           "package-lock.json",
@@ -19061,6 +19071,7 @@ var init_schema = __esm(() => {
         protected_paths: [
           ".git",
           ".github/workflows",
+          ".opencode",
           ".swarm",
           "package.json",
           "package-lock.json",
@@ -19112,6 +19123,7 @@ var init_schema = __esm(() => {
       }))
     }).optional().default(() => ({
       enabled: false,
+      locked: false,
       max_interactions_per_phase: 50,
       deadlock_threshold: 3,
       escalation_mode: "pause",
@@ -19124,6 +19136,7 @@ var init_schema = __esm(() => {
         protected_paths: [
           ".git",
           ".github/workflows",
+          ".opencode",
           ".swarm",
           "package.json",
           "package-lock.json",
@@ -19319,6 +19332,15 @@ function sanitizeExternalSkillsConfig(raw) {
   delete cleaned.external_skills;
   return cleaned;
 }
+function rawFullAutoLocked(raw) {
+  if (!raw || typeof raw !== "object")
+    return false;
+  const fullAuto = raw.full_auto;
+  if (!fullAuto || typeof fullAuto !== "object" || Array.isArray(fullAuto)) {
+    return false;
+  }
+  return fullAuto.locked === true;
+}
 function loadPluginConfig(directory) {
   const userConfigPath = path7.join(getUserConfigDir(), "opencode", CONFIG_FILENAME);
   const projectConfigPath = path7.join(directory, ".opencode", CONFIG_FILENAME);
@@ -19332,6 +19354,13 @@ function loadPluginConfig(directory) {
   if (rawProjectConfig) {
     mergedRaw = deepMerge(mergedRaw, rawProjectConfig);
   }
+  if (rawFullAutoLocked(rawUserConfig) || rawFullAutoLocked(rawProjectConfig)) {
+    const fullAutoRaw = mergedRaw.full_auto && typeof mergedRaw.full_auto === "object" && !Array.isArray(mergedRaw.full_auto) ? mergedRaw.full_auto : {};
+    mergedRaw = {
+      ...mergedRaw,
+      full_auto: { ...fullAutoRaw, locked: true }
+    };
+  }
   mergedRaw = migratePresetsConfig(mergedRaw);
   mergedRaw = sanitizeExternalSkillsConfig(mergedRaw);
   const result = PluginConfigSchema.safeParse(mergedRaw);
@@ -19364,8 +19393,9 @@ function loadPluginConfigWithMeta(directory) {
   const userResult = loadRawConfigFromPath(userConfigPath);
   const projectResult = loadRawConfigFromPath(projectConfigPath);
   const loadedFromFile = userResult.fileExisted || projectResult.fileExisted;
+  const configHadErrors = userResult.hadError || projectResult.hadError;
   const config2 = loadPluginConfig(directory);
-  return { config: config2, loadedFromFile };
+  return { config: config2, loadedFromFile, configHadErrors };
 }
 var CONFIG_FILENAME = "opencode-swarm.json", MAX_CONFIG_FILE_BYTES = 102400;
 var init_loader = __esm(() => {
@@ -47713,6 +47743,7 @@ __export(exports_config_doctor, {
   runConfigDoctor: () => runConfigDoctor,
   restoreFromBackup: () => restoreFromBackup,
   removeStraySwarmDir: () => removeStraySwarmDir,
+  readDoctorArtifact: () => readDoctorArtifact,
   getConfigPaths: () => getConfigPaths,
   detectStraySwarmDirs: () => detectStraySwarmDirs,
   createConfigBackup: () => createConfigBackup,
@@ -47722,6 +47753,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 +47805,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 +47885,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 +47911,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 +47940,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 +48079,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 +48162,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 +48231,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 +48718,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 +48784,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 +48937,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 +50639,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) {
@@ -50725,6 +51272,25 @@ function emptyCounters() {
     consecutiveNoProgressTurns: 0
   };
 }
+function sanitizeRunState(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  const r = raw;
+  if (typeof r.sessionID !== "string" || !r.sessionID)
+    return null;
+  const mode = VALID_RUN_MODES.has(r.mode) ? r.mode : "supervised";
+  const status = VALID_RUN_STATUSES.has(r.status) ? r.status : "idle";
+  return { ...raw, mode, status };
+}
+function sanitizeSessions(raw) {
+  const result = {};
+  for (const [id, session] of Object.entries(raw)) {
+    const sanitized = sanitizeRunState(session);
+    if (sanitized)
+      result[id] = sanitized;
+  }
+  return result;
+}
 function emptyState(sessionID, mode = "supervised") {
   const now = nowISO();
   return {
@@ -50789,26 +51355,45 @@ function clearStateUnreadable() {
   stateUnreadable = false;
   stateUnreadableReason = "";
 }
+function isFullAutoStateUnreadable() {
+  return { unreadable: stateUnreadable, reason: stateUnreadableReason };
+}
 function readPersisted(directory) {
   try {
     const filePath = validateSwarmPath(directory, STATE_FILE);
-    if (!fs15.existsSync(filePath)) {
+    let stats;
+    try {
+      stats = fs15.statSync(filePath);
+    } catch {
       clearStateUnreadable();
+      readCache.delete(filePath);
       return emptyPersisted();
     }
+    const cached3 = readCache.get(filePath);
+    if (cached3 && cached3.mtimeMs === stats.mtimeMs && cached3.size === stats.size) {
+      clearStateUnreadable();
+      return structuredClone(cached3.state);
+    }
     const raw = fs15.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 2 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable(`malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
+      readCache.delete(filePath);
       return emptyPersisted();
     }
     clearStateUnreadable();
-    return {
+    const state = {
       version: 2,
       updatedAt: parsed.updatedAt ?? nowISO(),
       oversightSequence: typeof parsed.oversightSequence === "number" ? parsed.oversightSequence : 0,
-      sessions: parsed.sessions
+      sessions: sanitizeSessions(parsed.sessions)
     };
+    readCache.set(filePath, {
+      mtimeMs: stats.mtimeMs,
+      size: stats.size,
+      state: structuredClone(state)
+    });
+    return state;
   } catch (error93) {
     const reason = error93 instanceof Error ? error93.message : String(error93);
     error(`[full-auto/state] Failed to read ${STATE_FILE}: ${reason} \u2014 attempting .bak recovery`);
@@ -50824,7 +51409,7 @@ function readPersisted(directory) {
             version: 2,
             updatedAt: parsed.updatedAt ?? nowISO(),
             oversightSequence: typeof parsed.oversightSequence === "number" ? parsed.oversightSequence : 0,
-            sessions: parsed.sessions
+            sessions: sanitizeSessions(parsed.sessions)
           };
         }
       }
@@ -50832,6 +51417,7 @@ function readPersisted(directory) {
       error(`[full-auto/state] .bak recovery also failed: ${bakError instanceof Error ? bakError.message : String(bakError)}`);
     }
     markStateUnreadable(`canonical=${reason}; .bak=missing-or-corrupt`);
+    readCache.clear();
     return emptyPersisted();
   }
 }
@@ -50869,6 +51455,7 @@ function writePersisted(directory, persisted) {
       }
     } catch {}
     fs15.renameSync(tmpPath, filePath);
+    readCache.delete(filePath);
     const readback = fs15.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(readback);
     if (parsed?.version !== 2) {
@@ -50880,6 +51467,10 @@ function writePersisted(directory, persisted) {
     throw new Error(`Full-Auto state persistence failed: ${msg}`);
   }
 }
+function loadFullAutoRunState(directory, sessionID) {
+  const persisted = readPersisted(directory);
+  return persisted.sessions[sessionID];
+}
 function startFullAutoRun(directory, sessionID, config3, options = {}) {
   return withStateLock(directory, () => {
     const persisted = readPersisted(directory);
@@ -50911,14 +51502,15 @@ function startFullAutoRun(directory, sessionID, config3, options = {}) {
     return state;
   });
 }
-function pauseFullAutoRun(directory, sessionID, reason) {
+function disarmFullAutoRun(directory, sessionID, reason) {
   return withStateLock(directory, () => {
     const persisted = readPersisted(directory);
     const state = persisted.sessions[sessionID];
     if (!state)
       return;
-    state.status = "paused";
+    state.status = "idle";
     state.pauseReason = reason;
+    state.terminateReason = undefined;
     state.updatedAt = nowISO();
     persisted.sessions[sessionID] = state;
     writePersisted(directory, persisted);
@@ -50939,15 +51531,26 @@ function terminateFullAutoRun(directory, sessionID, reason) {
     return state;
   });
 }
-var import_proper_lockfile8, lockfile8, STATE_FILE = "full-auto-state.json", stateUnreadable = false, stateUnreadableReason = "";
+var import_proper_lockfile8, lockfile8, STATE_FILE = "full-auto-state.json", VALID_RUN_MODES, VALID_RUN_STATUSES, stateUnreadable = false, stateUnreadableReason = "", readCache;
 var init_state2 = __esm(() => {
   init_utils2();
   init_logger();
   import_proper_lockfile8 = __toESM(require_proper_lockfile(), 1);
   lockfile8 = import_proper_lockfile8.default;
+  VALID_RUN_MODES = new Set(["assisted", "supervised", "strict"]);
+  VALID_RUN_STATUSES = new Set([
+    "idle",
+    "running",
+    "paused",
+    "terminated"
+  ]);
+  readCache = new Map;
 });
 
 // src/commands/full-auto.ts
+function isValidMode(value) {
+  return VALID_MODES.includes(value);
+}
 async function handleFullAutoCommand(directory, args, sessionID) {
   if (!sessionID || sessionID.trim() === "") {
     return "Error: No active session context. Full-Auto Mode requires an active session. Use /swarm-full-auto from within an OpenCode session, or start a session first.";
@@ -50957,39 +51560,63 @@ async function handleFullAutoCommand(directory, args, sessionID) {
     return "Error: No active session. Full-Auto Mode requires an active session to operate.";
   }
   const arg = args[0]?.toLowerCase();
+  if (arg === "status") {
+    return buildStatusReport(directory, sessionID, session.fullAutoMode);
+  }
   let newFullAutoMode;
+  let modeOverride;
   if (arg === "on") {
     newFullAutoMode = true;
+    const modeArg = args[1]?.toLowerCase();
+    if (modeArg) {
+      if (!isValidMode(modeArg)) {
+        return `Error: invalid Full-Auto mode '${args[1]}'. Valid modes: ${VALID_MODES.join(", ")}.`;
+      }
+      modeOverride = modeArg;
+    }
   } else if (arg === "off") {
     newFullAutoMode = false;
+  } else if (arg && isValidMode(arg)) {
+    newFullAutoMode = true;
+    modeOverride = arg;
   } else {
     newFullAutoMode = !session.fullAutoMode;
   }
-  if (newFullAutoMode && !swarmState.fullAutoEnabledInConfig) {
-    return "Error: Full-Auto Mode cannot be enabled because full_auto.enabled is not set to true in the swarm plugin config. The autonomous oversight hook is inactive without config-level enablement. Set full_auto.enabled = true in your opencode-swarm config and restart.";
-  }
   let v2Status = "unavailable";
   let modeLabel = "supervised";
   let denialMaxConsecutive = 3;
   let denialMaxTotal = 20;
   let failClosed = true;
   let durableError;
+  let criticModelAdvisory = "";
   try {
-    const { config: config3 } = loadPluginConfigWithMeta(directory);
+    const { config: config3, configHadErrors } = loadPluginConfigWithMeta(directory);
     const fullAutoConfig = config3.full_auto;
-    modeLabel = fullAutoConfig?.mode ?? "supervised";
+    if (newFullAutoMode && configHadErrors) {
+      return "Error: Full-Auto Mode cannot be enabled \u2014 a swarm plugin config file exists but could not be loaded, so full_auto.locked cannot be verified. Fix the config file (see warnings above) and retry.";
+    }
+    if (newFullAutoMode && fullAutoConfig?.locked === true) {
+      return "Error: Full-Auto Mode is locked for this project (full_auto.locked is true in the swarm plugin config). Runtime activation is disabled by configuration; remove the lock to use /swarm full-auto on.";
+    }
+    const effectiveMode = modeOverride ?? fullAutoConfig?.mode ?? "supervised";
+    modeLabel = effectiveMode;
     denialMaxConsecutive = fullAutoConfig?.denials?.max_consecutive ?? 3;
     denialMaxTotal = fullAutoConfig?.denials?.max_total ?? 20;
     failClosed = fullAutoConfig?.fail_closed !== false;
     if (newFullAutoMode) {
-      startFullAutoRun(directory, sessionID, fullAutoConfig);
+      startFullAutoRun(directory, sessionID, fullAutoConfig ? { ...fullAutoConfig, mode: effectiveMode } : undefined);
       v2Status = "running";
+      const criticModel = fullAutoConfig?.critic_model ?? config3.agents?.critic?.model;
+      const architectModel = config3.agents?.architect?.model;
+      if (criticModel && architectModel && criticModel === architectModel) {
+        criticModelAdvisory = " WARNING: critic model matches architect model \u2014 set full_auto.critic_model (or agents.critic.model) to a different model for independent oversight.";
+      }
     } else {
-      const paused = pauseFullAutoRun(directory, sessionID, "/swarm full-auto off");
-      if (!paused) {
+      const disarmed = disarmFullAutoRun(directory, sessionID, "/swarm full-auto off");
+      if (!disarmed) {
         terminateFullAutoRun(directory, sessionID, "never started");
       }
-      v2Status = "paused";
+      v2Status = "idle";
     }
   } catch (error93) {
     durableError = error93 instanceof Error ? error93.message : String(error93);
@@ -51018,13 +51645,54 @@ async function handleFullAutoCommand(directory, args, sessionID) {
     "Full-Auto Mode enabled",
     `(v2 mode=${modeLabel}, fail_closed=${failClosed},`,
     `denials max ${denialMaxConsecutive} consecutive / ${denialMaxTotal} total)`
-  ].join(" ");
+  ].join(" ") + criticModelAdvisory;
+}
+function buildStatusReport(directory, sessionID, sessionFlag) {
+  const lines = [];
+  lines.push(`Full-Auto session flag: ${sessionFlag ? "on" : "off"}`);
+  try {
+    const { config: config3, configHadErrors } = loadPluginConfigWithMeta(directory);
+    if (configHadErrors) {
+      lines.push("Config: UNREADABLE (a config file exists but could not be loaded; `full_auto.locked` cannot be verified, so runtime activation refuses by fail-closed default). Fix the config file to restore normal status.");
+    }
+    if (config3.full_auto?.locked === true) {
+      lines.push("Config: locked (runtime activation disabled via full_auto.locked)");
+    }
+  } catch {}
+  try {
+    const runState = loadFullAutoRunState(directory, sessionID);
+    const stateHealth = isFullAutoStateUnreadable();
+    if (stateHealth.unreadable) {
+      lines.push(`Durable run-state: UNREADABLE (${stateHealth.reason}). Non-read-only tools are blocked fail-closed until .swarm/full-auto-state.json (or .bak) is restored or deleted.`);
+    } else if (!runState) {
+      lines.push("Durable run-state: none (no Full-Auto run for this session)");
+    } else {
+      lines.push(`Durable run-state: ${runState.status} (mode=${runState.mode})`);
+      if (runState.pauseReason) {
+        lines.push(`Pause reason: ${runState.pauseReason}`);
+      }
+      if (runState.terminateReason) {
+        lines.push(`Terminate reason: ${runState.terminateReason}`);
+      }
+      lines.push(`Counters: ${runState.counters.toolCalls} tool calls, ${runState.counters.architectTurns} architect turns, ${runState.counters.oversightChecks} oversight checks`);
+      lines.push(`Denials: ${runState.denialCounters.consecutive} consecutive / ${runState.denialCounters.total} total`);
+      if (runState.lastOversightVerdict) {
+        lines.push(`Last oversight verdict: ${runState.lastOversightVerdict}${runState.lastOversightAt ? ` at ${runState.lastOversightAt}` : ""}`);
+      }
+    }
+  } catch (error93) {
+    lines.push(`Durable run-state: unreadable (${error93 instanceof Error ? error93.message : String(error93)})`);
+  }
+  return lines.join(`
+`);
 }
+var VALID_MODES;
 var init_full_auto = __esm(() => {
   init_config();
   init_state2();
   init_state();
   init_logger();
+  VALID_MODES = ["assisted", "supervised", "strict"];
 });
 
 // src/services/handoff-service.ts
@@ -51408,7 +52076,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 +52195,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 +52228,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 +52237,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 +52249,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 +65410,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 +65444,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 +65451,6 @@ async function executeSwarmCommand(args) {
     sessionID,
     tokens,
     packageRoot,
-    includeWelcome = false,
     buildHelpText,
     policy
   } = args;
@@ -64838,9 +65484,6 @@ ${text}`;
       }
     }
   }
-  if (includeWelcome && maybeMarkFirstRun(directory)) {
-    text = prependWelcome(text);
-  }
   return {
     text,
     resolved: resolved ?? undefined,
@@ -65463,7 +66106,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 +66233,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 || "";
       }
     }
@@ -66184,9 +66827,9 @@ Subcommands:
     },
     "full-auto": {
       handler: (ctx) => handleFullAutoCommand(ctx.directory, ctx.args, ctx.sessionID),
-      description: "Toggle Full-Auto Mode for the active session [on|off]",
-      args: "on, off",
-      details: 'Toggles Full-Auto Mode which enables autonomous execution without confirmation prompts. When enabled, the architect proceeds through implementation steps automatically. Session-scoped \u2014 resets on new session. Use "on" or "off" to set explicitly, or toggle with no argument.',
+      description: "Toggle Full-Auto Mode for the active session [on [mode]|off|status]",
+      args: "on [assisted|supervised|strict], off, status",
+      details: 'First-class toggle for Full-Auto Mode \u2014 autonomous execution with the critic reviewing escalations on your behalf. No config-level enablement is required: "on" activates immediately (unless full_auto.locked is true in config), "off" disarms the run and returns the session to normal interactive operation, "status" reports the durable run state. ' + 'An optional mode after "on" overrides full_auto.mode for this run: assisted (critic consulted only on policy escalations), supervised (default \u2014 risky/high-impact actions reviewed by the critic), strict (ALL plan mutations reviewed by the critic). ' + "While active, the critic answers architect questions and reviews phase boundaries, delegations, and risky actions on your behalf; only ESCALATE_TO_HUMAN verdicts halt the run for your input. The run state is durable (.swarm/full-auto-state.json) and survives restarts; toggle with no argument flips the current state.",
       category: "utility"
     },
     "auto-proceed": {
@@ -66329,7 +66972,7 @@ Subcommands:
     handleHelpCommand,
     validateAliases,
     resolveCommand,
-    levenshteinDistance,
+    levenshteinDistance: levenshteinDistance2,
     findSimilarCommands,
     buildDetailedHelp
   };
@@ -66351,72 +66994,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 +67067,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 +67090,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 +67137,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 +67216,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 +67235,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 +67261,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 +67293,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;
       }