opencode-swarm 7.14.0 → 7.16.0

package/dist/cli/index.js

@@ -34,7 +34,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.14.0",
+    version: "7.16.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",
@@ -16061,7 +16061,13 @@ var init_tool_names = __esm(() => {
     "skill_inspect",
     "skill_improve",
     "spec_write",
-    "knowledge_ack"
+    "knowledge_ack",
+    "lean_turbo_plan_lanes",
+    "lean_turbo_acquire_locks",
+    "lean_turbo_runner_status",
+    "lean_turbo_review",
+    "lean_turbo_run_phase",
+    "lean_turbo_status"
   ];
   TOOL_NAME_SET = new Set(TOOL_NAMES);
 });
@@ -16100,7 +16106,7 @@ function freezeSet(items) {
   });
   return proxy;
 }
-var QA_AGENTS, PIPELINE_AGENTS, ORCHESTRATOR_NAME = "architect", ALL_SUBAGENT_NAMES, ALL_AGENT_NAMES, OPENCODE_NATIVE_AGENTS, CLAUDE_CODE_NATIVE_COMMANDS, AGENT_TOOL_MAP, DEFAULT_AGENT_CONFIGS;
+var QA_AGENTS, PIPELINE_AGENTS, ORCHESTRATOR_NAME = "architect", ALL_SUBAGENT_NAMES, ALL_AGENT_NAMES, OPENCODE_NATIVE_AGENTS, CLAUDE_CODE_NATIVE_COMMANDS, AGENT_TOOL_MAP, TOOL_DESCRIPTIONS, DEFAULT_AGENT_CONFIGS;
 var init_constants = __esm(() => {
   init_tool_names();
   QA_AGENTS = ["reviewer", "critic", "critic_oversight"];
@@ -16307,7 +16313,13 @@ var init_constants = __esm(() => {
       "skill_apply",
       "skill_inspect",
       "skill_improve",
-      "knowledge_ack"
+      "knowledge_ack",
+      "lean_turbo_plan_lanes",
+      "lean_turbo_acquire_locks",
+      "lean_turbo_runner_status",
+      "lean_turbo_review",
+      "lean_turbo_run_phase",
+      "lean_turbo_status"
     ],
     explorer: [
       "complexity_hotspots",
@@ -16504,6 +16516,81 @@ var init_constants = __esm(() => {
       "spec_write"
     ]
   };
+  TOOL_DESCRIPTIONS = {
+    symbols: "code symbol search",
+    checkpoint: "state snapshots",
+    diff: "structured git diff with contract change detection",
+    diff_summary: "filter classified AST changes by category, risk level, or file for reviewer drill-down",
+    imports: "dependency audit",
+    lint: "code quality",
+    placeholder_scan: "todo and FIXME comment detection",
+    secretscan: "secret detection",
+    sast_scan: "static analysis security scan",
+    syntax_check: "syntax validation",
+    test_runner: "auto-detect and run tests",
+    test_impact: "identify test files impacted by changed source files via import analysis",
+    mutation_test: "executes pre-generated mutation patches against tests, evaluates kill rate against quality gate thresholds",
+    generate_mutants: "generate LLM-based mutation testing patches for source files; returns MutationPatch[] for direct consumption by the mutation_test tool",
+    write_mutation_evidence: "write mutation gate evidence for a completed phase; normalizes PASS/WARN/FAIL/SKIP verdicts and writes .swarm/evidence/{phase}/mutation-gate.json",
+    pkg_audit: "dependency vulnerability scan \u2014 npm/pip/cargo",
+    complexity_hotspots: "git churn \xD7 complexity risk map",
+    schema_drift: "OpenAPI spec vs route drift",
+    todo_extract: "structured TODO/FIXME extraction",
+    evidence_check: "verify task evidence completeness",
+    sbom_generate: "SBOM generation for dependency inventory",
+    build_check: "build verification",
+    quality_budget: "code quality budget check",
+    pre_check_batch: "parallel verification: lint:check + secretscan + sast_scan + quality_budget",
+    update_task_status: "mark tasks complete, track phase progress",
+    write_retro: "document phase retrospectives via phase_complete workflow, capture lessons learned",
+    write_drift_evidence: "write drift verification evidence for a completed phase",
+    write_hallucination_evidence: "write hallucination verification evidence for a completed phase",
+    write_final_council_evidence: "write final council evidence for project completion",
+    declare_scope: "declare file scope for next coder delegation",
+    phase_complete: "mark a phase as complete and track dispatched agents",
+    save_plan: "save a structured implementation plan",
+    doc_scan: "scan project documentation files and build an index manifest",
+    doc_extract: "extract actionable constraints from project documentation",
+    curator_analyze: "run curator phase analysis and optionally apply knowledge recommendations",
+    knowledge_add: "store a new lesson in the knowledge base",
+    knowledge_recall: "search the knowledge base for relevant past decisions",
+    knowledge_remove: "delete an outdated swarm knowledge entry by ID (swarm tier only)",
+    knowledge_query: "query swarm or hive knowledge with optional filters",
+    co_change_analyzer: "detect hidden couplings by analyzing git history",
+    check_gate_status: "check the gate status of a specific task",
+    completion_verify: "verify completed tasks have required evidence",
+    submit_council_verdicts: "submit pre-collected council member verdicts for synthesis (architect MUST dispatch critic/reviewer/sme/test_engineer/explorer as Agent tasks first; this tool synthesizes only, it does not contact members)",
+    submit_phase_council_verdicts: "submit pre-collected phase-level council member verdicts for holistic phase synthesis (architect MUST dispatch all 5 council members with phase-scoped context first; this tool synthesizes only, it does not contact members)",
+    declare_council_criteria: "pre-declare acceptance criteria for a task before the coder starts work; criteria are read back during council evaluation",
+    detect_domains: "detect which SME domains are relevant for a given text",
+    extract_code_blocks: "extract code blocks from text content and save them to files",
+    gitingest: "fetch a GitHub repository full content via gitingest.com",
+    retrieve_summary: "retrieve the full content of a stored tool output summary",
+    search: "Workspace-scoped ripgrep-style text search with structured JSON output. Supports literal and regex modes, glob filtering, and result limits. NOTE: This is text search, not structural AST search \u2014 use symbols and imports tools for structural queries.",
+    web_search: "External web search (Tavily or Brave) for architect-driven council research. Returns titled results with snippets and URLs. Config-gated on council.general.enabled; requires a search API key. Used by the architect in MODE: COUNCIL to gather a RESEARCH CONTEXT before dispatching council agents.",
+    convene_general_council: "Synthesize responses from a multi-model General Council. Accepts parallel member responses (Round 1, optionally Round 2), detects disagreements, and returns consensus points, persisting disagreements, and a structured synthesis. Architect-only. Config-gated on council.general.enabled.",
+    batch_symbols: "Batched symbol extraction across multiple files. Returns per-file symbol summaries with isolated error handling.",
+    suggest_patch: "Reviewer-safe structured patch suggestion tool. Produces context-anchored patch artifacts without file modification. Returns structured diagnostics on context mismatch.",
+    lint_spec: "validate .swarm/spec.md format and required fields",
+    get_approved_plan: "retrieve the last critic-approved immutable plan snapshot for baseline drift comparison",
+    repo_map: "query the repo code graph: importers, dependencies, blast radius, and localization context for structural awareness before refactoring",
+    get_qa_gate_profile: "retrieve the QA gate profile for the current plan: gates (reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, council_general_review, drift_check, final_council), lock state, and profile hash. Read-only.",
+    set_qa_gates: "configure the QA gate profile for the current plan. Architect-only. Ratchet-tighter only \u2014 rejected once the profile is locked after critic approval. Supports: reviewer, test_engineer, sme_enabled, critic_pre_plan, sast_enabled, council_mode, hallucination_guard, mutation_test, council_general_review, drift_check, final_council.",
+    req_coverage: "query requirement coverage status for tracked functional requirements",
+    skill_generate: "compile knowledge entries into a structured SKILL.md draft",
+    skill_list: "list generated skill files and their status",
+    skill_apply: "activate a draft skill proposal",
+    skill_inspect: "inspect the content and source entries of a skill file",
+    skill_improve: "run the skill_improver agent to review and refine skills",
+    spec_write: "author or update .swarm/spec.md for the current project",
+    knowledge_ack: "record an explicit KNOWLEDGE_APPLIED/IGNORED/VIOLATED acknowledgment",
+    lean_turbo_plan_lanes: "partition phase tasks into parallel lanes based on file-scope conflicts for Lean Turbo execution",
+    lean_turbo_acquire_locks: "acquire file locks for all files in a lane (all-or-nothing) before lane execution",
+    lean_turbo_runner_status: "read Lean Turbo run state from .swarm/turbo-state.json",
+    lean_turbo_review: "dispatch a read-only reviewer agent to evaluate a completed Lean Turbo phase",
+    lean_turbo_run_phase: "Execute a phase using Lean Turbo parallel lane execution. " + "Plans lanes, acquires file locks, and dispatches coder agents concurrently. " + "Use when Lean Turbo is active and you want to execute all tasks in a phase in parallel lanes.",
+    lean_turbo_status: "returns Lean Turbo configuration and active status for the current session"
+  };
   for (const [agentName, tools] of Object.entries(AGENT_TOOL_MAP)) {
     const invalidTools = tools.filter((tool) => !TOOL_NAME_SET.has(tool));
     if (invalidTools.length > 0) {
@@ -16607,7 +16694,7 @@ function getCanonicalAgentRole(agentName, generatedAgentNames) {
 function stripKnownSwarmPrefix(agentName) {
   return getCanonicalAgentRole(agentName);
 }
-var SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, CuratorConfigSchema, KnowledgeApplicationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, PluginConfigSchema;
+var SEPARATORS, CANONICAL_ROLES_LONGEST_FIRST, CANONICAL_ROLES_SET, AgentOverrideConfigSchema, SwarmConfigSchema, HooksConfigSchema, ScoringWeightsSchema, DecisionDecaySchema, TokenRatiosSchema, ScoringConfigSchema, ContextBudgetConfigSchema, EvidenceConfigSchema, GateFeatureSchema, PlaceholderScanConfigSchema, QualityBudgetConfigSchema, GateConfigSchema, PipelineConfigSchema, PhaseCompleteConfigSchema, SummaryConfigSchema, ReviewPassesConfigSchema, AdversarialDetectionConfigSchema, AdversarialTestingConfigSchemaBase, AdversarialTestingConfigSchema, IntegrationAnalysisConfigSchema, DocsConfigSchema, UIReviewConfigSchema, CompactionAdvisoryConfigSchema, LintConfigSchema, SecretscanConfigSchema, GuardrailsProfileSchema, DEFAULT_AGENT_PROFILES, DEFAULT_ARCHITECT_PROFILE, GuardrailsConfigSchema, WatchdogConfigSchema, SelfReviewConfigSchema, ToolFilterConfigSchema, PlanCursorConfigSchema, CheckpointConfigSchema, AutomationModeSchema, AutomationCapabilitiesSchema, AutomationConfigSchemaBase, AutomationConfigSchema, KnowledgeConfigSchema, CuratorConfigSchema, KnowledgeApplicationConfigSchema, SkillImproverConfigSchema, SpecWriterConfigSchema, SlopDetectorConfigSchema, IncrementalVerifyConfigSchema, CompactionConfigSchema, PrmConfigSchema, AgentAuthorityRuleSchema, AuthorityConfigSchema, GeneralCouncilMemberConfigSchema, GeneralCouncilConfigSchema, CouncilConfigSchema, ParallelizationConfigSchema, LeanTurboConfigSchema, StandardTurboConfigSchema, LeanTurboStrategyConfigSchema, TurboConfigSchema, PluginConfigSchema;
 var init_schema = __esm(() => {
   init_zod();
   init_constants();
@@ -17194,6 +17281,31 @@ var init_schema = __esm(() => {
     max_coders: exports_external.number().int().min(1).max(16).default(3),
     max_reviewers: exports_external.number().int().min(1).max(16).default(2)
   });
+  LeanTurboConfigSchema = exports_external.object({
+    max_parallel_coders: exports_external.number().int().min(1).max(6).default(4),
+    require_declared_scope: exports_external.boolean().default(true),
+    conflict_policy: exports_external.enum(["serialize", "degrade"]).default("serialize"),
+    degrade_on_risk: exports_external.boolean().default(true),
+    phase_reviewer: exports_external.boolean().default(true),
+    phase_critic: exports_external.boolean().default(true),
+    integrated_diff_required: exports_external.boolean().default(true),
+    allow_docs_only_without_reviewer: exports_external.boolean().default(false),
+    worktree_isolation: exports_external.boolean().default(false).refine((val) => val === false, {
+      message: "worktree_isolation: true is not yet implemented. Use false (the default) for in-repo parallel execution. Full worktree isolation will be available in a future release."
+    })
+  });
+  StandardTurboConfigSchema = exports_external.object({
+    strategy: exports_external.literal("standard"),
+    lean: LeanTurboConfigSchema.optional()
+  });
+  LeanTurboStrategyConfigSchema = exports_external.object({
+    strategy: exports_external.literal("lean"),
+    lean: LeanTurboConfigSchema
+  });
+  TurboConfigSchema = exports_external.discriminatedUnion("strategy", [
+    StandardTurboConfigSchema,
+    LeanTurboStrategyConfigSchema
+  ]);
   PluginConfigSchema = exports_external.object({
     agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
     default_agent: exports_external.string().optional().transform((v) => {
@@ -17253,6 +17365,7 @@ var init_schema = __esm(() => {
     prm: PrmConfigSchema.optional(),
     council: CouncilConfigSchema.optional(),
     parallelization: ParallelizationConfigSchema.optional(),
+    turbo: TurboConfigSchema.optional(),
     turbo_mode: exports_external.boolean().default(false).optional(),
     quiet: exports_external.boolean().default(true).optional(),
     version_check: exports_external.boolean().default(true).optional(),
@@ -19372,8 +19485,17 @@ function getLockFilePath(directory, filePath) {
   if (!pathOk) {
     throw new Error("Invalid file path: path traversal not allowed");
   }
-  const hash2 = Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
-  return path6.join(directory, LOCKS_DIR, `${hash2}.lock`);
+  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  const hash2 = Buffer.from(pathForHash).toString("base64").replace(/[/+=]/g, "_");
+  const lockPath = path6.join(directory, LOCKS_DIR, `${hash2}.lock`);
+  if (process.platform === "win32") {
+    const oldHash = Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
+    const oldLockPath = path6.join(directory, LOCKS_DIR, `${oldHash}.lock`);
+    if (fs3.existsSync(oldLockPath)) {
+      return oldLockPath;
+    }
+  }
+  return lockPath;
 }
 async function tryAcquireLock(directory, filePath, agent, taskId) {
   const lockPath = getLockFilePath(directory, filePath);
@@ -19408,10 +19530,14 @@ async function tryAcquireLock(directory, filePath, agent, taskId) {
   };
   return { acquired: true, lock };
 }
-var import_proper_lockfile, LOCKS_DIR = ".swarm/locks", LOCK_TIMEOUT_MS;
+var import_proper_lockfile, LOCKS_DIR = ".swarm/locks", LOCK_TIMEOUT_MS, _internals4;
 var init_file_locks = __esm(() => {
   import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
   LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+  _internals4 = {
+    tryAcquireLock,
+    writeFile: fs3.promises.writeFile
+  };
 });
 
 // src/evidence/lock.ts
@@ -19634,7 +19760,7 @@ async function loadEvidence(directory, taskId) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals4.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals5.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
@@ -19730,14 +19856,14 @@ async function checkRequirementCoverage(phase, directory) {
   }
 }
 async function archiveEvidence(directory, maxAgeDays, maxBundles) {
-  const taskIds = await _internals4.listEvidenceTaskIds(directory);
+  const taskIds = await _internals5.listEvidenceTaskIds(directory);
   const cutoffDate = new Date;
   cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
   const cutoffIso = cutoffDate.toISOString();
   const archived = [];
   const remainingBundles = [];
   for (const taskId of taskIds) {
-    const result = await _internals4.loadEvidence(directory, taskId);
+    const result = await _internals5.loadEvidence(directory, taskId);
     if (result.status !== "found") {
       continue;
     }
@@ -19765,7 +19891,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles) {
   }
   return archived;
 }
-var VALID_EVIDENCE_TYPES, sanitizeTaskId2, LEGACY_TASK_COMPLEXITY_MAP, _internals4;
+var VALID_EVIDENCE_TYPES, sanitizeTaskId2, LEGACY_TASK_COMPLEXITY_MAP, _internals5;
 var init_manager2 = __esm(() => {
   init_zod();
   init_evidence_schema();
@@ -19795,7 +19921,7 @@ var init_manager2 = __esm(() => {
     medium: "moderate",
     high: "complex"
   };
-  _internals4 = {
+  _internals5 = {
     wrapFlatRetrospective,
     loadEvidence,
     listEvidenceTaskIds
@@ -20006,7 +20132,7 @@ function getProfile(directory, planId) {
   return row ? rowToProfile(row) : null;
 }
 function getOrCreateProfile(directory, planId, projectType) {
-  const existing = _internals5.getProfile(directory, planId);
+  const existing = _internals6.getProfile(directory, planId);
   if (existing)
     return existing;
   const db = getProjectDb(directory);
@@ -20022,14 +20148,14 @@ function getOrCreateProfile(directory, planId, projectType) {
       throw err;
     }
   }
-  const after = _internals5.getProfile(directory, planId);
+  const after = _internals6.getProfile(directory, planId);
   if (!after) {
     throw new Error(`Failed to create or load QA gate profile for plan_id=${planId}`);
   }
   return after;
 }
 function setGates(directory, planId, gates) {
-  const current = _internals5.getProfile(directory, planId);
+  const current = _internals6.getProfile(directory, planId);
   if (!current) {
     throw new Error(`No QA gate profile found for plan_id=${planId} \u2014 call getOrCreateProfile first`);
   }
@@ -20053,7 +20179,7 @@ function setGates(directory, planId, gates) {
     JSON.stringify(merged),
     planId
   ]);
-  const updated = _internals5.getProfile(directory, planId);
+  const updated = _internals6.getProfile(directory, planId);
   if (!updated) {
     throw new Error(`Failed to re-read QA gate profile after update for plan_id=${planId}`);
   }
@@ -20075,10 +20201,10 @@ function getEffectiveGates(profile, sessionOverrides) {
   }
   return merged;
 }
-var _internals5, DEFAULT_QA_GATES;
+var _internals6, DEFAULT_QA_GATES;
 var init_qa_gate_profile = __esm(() => {
   init_project_db();
-  _internals5 = {
+  _internals6 = {
     getProfile,
     getOrCreateProfile,
     setGates,
@@ -20813,6 +20939,30 @@ function hasActiveTurboMode(sessionID) {
   }
   return false;
 }
+function hasActiveFullAuto(sessionID) {
+  if (sessionID) {
+    const session = swarmState.agentSessions.get(sessionID);
+    return session?.fullAutoMode === true;
+  }
+  for (const [_sessionId, session] of swarmState.agentSessions) {
+    if (session.fullAutoMode === true) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasActiveLeanTurbo(sessionID) {
+  if (sessionID) {
+    const session = swarmState.agentSessions.get(sessionID);
+    return session?.turboMode === true && session?.turboStrategy === "lean" && session?.leanTurboActive === true;
+  }
+  for (const [_sessionId, session] of swarmState.agentSessions) {
+    if (session.turboMode === true && session.turboStrategy === "lean" && session.leanTurboActive === true) {
+      return true;
+    }
+  }
+  return false;
+}
 var _rehydrationCache = null, _councilDisagreementWarned, _toolAggregates, defaultRunContext, _runContexts, swarmState;
 var init_state = __esm(() => {
   init_constants();
@@ -21440,8 +21590,8 @@ function getElementAtPath2(obj, path9) {
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
+  const promises2 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises2).then((results) => {
     const resolvedObj = {};
     for (let i = 0;i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -34401,7 +34551,7 @@ function resetToRemoteBranch(cwd, options) {
   const prunedBranches = [];
   try {
     const currentBranch = getCurrentBranch(cwd);
-    const defaultRemoteBranch = _internals6.detectDefaultRemoteBranch(cwd);
+    const defaultRemoteBranch = _internals7.detectDefaultRemoteBranch(cwd);
     if (!defaultRemoteBranch) {
       return {
         success: false,
@@ -34583,7 +34733,7 @@ function resetToRemoteBranch(cwd, options) {
 function resetToMainAfterMerge(cwd, options) {
   const warnings = [];
   try {
-    const defaultBranch = _internals6.detectDefaultRemoteBranch(cwd);
+    const defaultBranch = _internals7.detectDefaultRemoteBranch(cwd);
     if (!defaultBranch) {
       return {
         success: false,
@@ -34610,7 +34760,7 @@ function resetToMainAfterMerge(cwd, options) {
     }
     if (currentBranch === defaultBranch) {
       try {
-        const logOutput = _internals6.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
+        const logOutput = _internals7.gitExec(["log", `${targetBranch}..HEAD`, "--oneline"], cwd);
         if (logOutput.trim().length > 0) {
           return {
             success: false,
@@ -34625,11 +34775,11 @@ function resetToMainAfterMerge(cwd, options) {
       } catch {}
     } else {
       try {
-        _internals6.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
+        _internals7.gitExec(["rev-parse", "--abbrev-ref", `${currentBranch}@{upstream}`], cwd);
       } catch {
         try {
-          const localSha = _internals6.gitExec(["rev-parse", "HEAD"], cwd).trim();
-          const remoteSha = _internals6.gitExec(["rev-parse", targetBranch], cwd).trim();
+          const localSha = _internals7.gitExec(["rev-parse", "HEAD"], cwd).trim();
+          const remoteSha = _internals7.gitExec(["rev-parse", targetBranch], cwd).trim();
           if (localSha !== remoteSha) {
             return {
               success: false,
@@ -34655,7 +34805,7 @@ function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals6.gitExec(["fetch", "--prune", "origin"], cwd);
+      _internals7.gitExec(["fetch", "--prune", "origin"], cwd);
     } catch (err) {
       return {
         success: false,
@@ -34671,7 +34821,7 @@ function resetToMainAfterMerge(cwd, options) {
     let switchedBranch = false;
     if (currentBranch !== defaultBranch) {
       try {
-        _internals6.gitExec(["checkout", defaultBranch], cwd);
+        _internals7.gitExec(["checkout", defaultBranch], cwd);
         switchedBranch = true;
       } catch (err) {
         return {
@@ -34686,7 +34836,7 @@ function resetToMainAfterMerge(cwd, options) {
       }
     }
     try {
-      _internals6.gitExec(["reset", "--hard", targetBranch], cwd);
+      _internals7.gitExec(["reset", "--hard", targetBranch], cwd);
     } catch (err) {
       return {
         success: false,
@@ -34707,7 +34857,7 @@ function resetToMainAfterMerge(cwd, options) {
           while (Date.now() < endTime) {}
         }
         try {
-          _internals6.gitExec(["checkout", "--", "."], cwd);
+          _internals7.gitExec(["checkout", "--", "."], cwd);
           discardSucceeded = true;
           break;
         } catch {}
@@ -34718,18 +34868,18 @@ function resetToMainAfterMerge(cwd, options) {
       changesDiscarded = discardSucceeded;
     }
     try {
-      _internals6.gitExec(["clean", "-fd"], cwd);
+      _internals7.gitExec(["clean", "-fd"], cwd);
     } catch {
       warnings.push("Could not clean untracked files");
     }
     let branchDeleted = false;
     if (switchedBranch && previousBranch !== defaultBranch) {
       try {
-        const mergedOutput = _internals6.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals7.gitExec(["branch", "--merged", defaultBranch], cwd);
         const isMerged = mergedOutput.split(`
 `).some((line) => line.trim() === previousBranch || line.trim() === `* ${previousBranch}`);
         if (isMerged) {
-          _internals6.gitExec(["branch", "-d", previousBranch], cwd);
+          _internals7.gitExec(["branch", "-d", previousBranch], cwd);
           branchDeleted = true;
         } else {
           warnings.push(`Branch ${previousBranch} is not merged into ${defaultBranch} \u2014 keeping it`);
@@ -34740,7 +34890,7 @@ function resetToMainAfterMerge(cwd, options) {
     }
     if (options?.pruneBranches) {
       try {
-        const mergedOutput = _internals6.gitExec(["branch", "--merged", defaultBranch], cwd);
+        const mergedOutput = _internals7.gitExec(["branch", "--merged", defaultBranch], cwd);
         const mergedLines = mergedOutput.split(`
 `);
         for (const line of mergedLines) {
@@ -34749,7 +34899,7 @@ function resetToMainAfterMerge(cwd, options) {
             continue;
           }
           try {
-            _internals6.gitExec(["branch", "-d", trimmedLine], cwd);
+            _internals7.gitExec(["branch", "-d", trimmedLine], cwd);
           } catch {
             warnings.push(`Could not prune branch: ${trimmedLine}`);
           }
@@ -34779,10 +34929,10 @@ function resetToMainAfterMerge(cwd, options) {
     };
   }
 }
-var GIT_TIMEOUT_MS2 = 30000, _internals6;
+var GIT_TIMEOUT_MS2 = 30000, _internals7;
 var init_branch = __esm(() => {
   init_logger();
-  _internals6 = {
+  _internals7 = {
     gitExec: gitExec2,
     detectDefaultRemoteBranch,
     getDefaultBaseBranch,
@@ -35215,6 +35365,20 @@ function validateLesson(candidate, existingLessons, meta3) {
     severity: null
   };
 }
+function validateSkillPath(p) {
+  if (typeof p !== "string")
+    return false;
+  if (p.length === 0 || p.length > 256)
+    return false;
+  if (p.includes("\x00"))
+    return false;
+  if (path11.isAbsolute(p))
+    return false;
+  if (p.includes(".."))
+    return false;
+  const norm = p.replace(/\\/g, "/");
+  return ALLOWED_SKILL_PATH_PREFIXES.some((prefix) => norm.startsWith(prefix));
+}
 async function quarantineEntry(directory, entryId, reason, reportedBy) {
   if (!directory || directory.includes("..")) {
     warn("[knowledge-validator] quarantineEntry: directory traversal attempt blocked");
@@ -35325,7 +35489,7 @@ async function restoreEntry(directory, entryId) {
     }
   }
 }
-var import_proper_lockfile4, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, VALID_DIRECTIVE_PRIORITIES;
+var import_proper_lockfile4, DANGEROUS_COMMAND_PATTERNS, SECURITY_DEGRADING_PATTERNS, INVISIBLE_FORMAT_CHARS, INJECTION_PATTERNS, VALID_CATEGORIES, TECH_REFERENCE_WORDS, ACTION_VERB_WORDS, NEGATION_PAIRS, ALLOWED_SKILL_PATH_PREFIXES, VALID_DIRECTIVE_PRIORITIES;
 var init_knowledge_validator = __esm(() => {
   init_logger();
   init_knowledge_store();
@@ -35431,6 +35595,10 @@ var init_knowledge_validator = __esm(() => {
     ["use", "don't use"],
     ["recommended", "not recommended"]
   ];
+  ALLOWED_SKILL_PATH_PREFIXES = [
+    ".opencode/skills/generated/",
+    ".swarm/skills/proposals/"
+  ];
   VALID_DIRECTIVE_PRIORITIES = new Set([
     "low",
     "medium",
@@ -35967,7 +36135,7 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     existingEntries.push(entry);
   }
   await enforceKnowledgeCap(knowledgePath, config3.swarm_max_entries);
-  await _internals7.runAutoPromotion(directory, config3);
+  await _internals8.runAutoPromotion(directory, config3);
   return { stored, skipped, rejected };
 }
 async function runAutoPromotion(directory, config3) {
@@ -36048,7 +36216,7 @@ function createKnowledgeCuratorHook(directory, config3) {
       });
       const projectName2 = evidenceData.project_name ?? "unknown";
       const phaseNumber2 = typeof evidenceData.phase_number === "number" ? evidenceData.phase_number : 1;
-      await _internals7.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
+      await _internals8.curateAndStoreSwarm(lessons, projectName2, { phase_number: phaseNumber2 }, directory, config3);
       await updateRetrievalOutcome(directory, `Phase ${phaseNumber2}`, true);
       return;
     }
@@ -36071,19 +36239,19 @@ function createKnowledgeCuratorHook(directory, config3) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals7.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
+    await _internals8.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config3);
     await updateRetrievalOutcome(directory, `Phase ${phaseNumber}`, true);
   };
   return safeHook(handler);
 }
-var seenRetroSections, _internals7;
+var seenRetroSections, _internals8;
 var init_knowledge_curator = __esm(() => {
   init_knowledge_reader();
   init_knowledge_store();
   init_knowledge_validator();
   init_utils2();
   seenRetroSections = new Map;
-  _internals7 = {
+  _internals8 = {
     isWriteToEvidenceFile,
     curateAndStoreSwarm,
     runAutoPromotion,
@@ -36091,6 +36259,904 @@ var init_knowledge_curator = __esm(() => {
   };
 });
 
+// src/hooks/skill-improver-llm-factory.ts
+function resolveSkillImproverAgentName(sessionId) {
+  const suffix = "skill_improver";
+  const registeredNames = swarmState.skillImproverAgentNames;
+  if (registeredNames.length === 1)
+    return registeredNames[0];
+  if (registeredNames.length === 0)
+    return suffix;
+  const prefixMap = new Map;
+  for (const name of registeredNames) {
+    const prefix = name.endsWith(suffix) ? name.slice(0, name.length - suffix.length) : "";
+    prefixMap.set(prefix, name);
+  }
+  const matchForAgent = (agentName) => {
+    let bestPrefix = "";
+    let bestName = "";
+    for (const [prefix, name] of prefixMap) {
+      if (prefix && agentName.startsWith(prefix)) {
+        if (prefix.length > bestPrefix.length) {
+          bestPrefix = prefix;
+          bestName = name;
+        }
+      }
+    }
+    return bestName;
+  };
+  if (sessionId) {
+    const callingAgent = swarmState.activeAgent.get(sessionId);
+    if (callingAgent) {
+      const match = matchForAgent(callingAgent);
+      if (match)
+        return match;
+      const defaultAgent = prefixMap.get("");
+      if (defaultAgent)
+        return defaultAgent;
+    }
+  }
+  for (const activeAgentName of swarmState.activeAgent.values()) {
+    const match = matchForAgent(activeAgentName);
+    if (match)
+      return match;
+  }
+  return prefixMap.get("") ?? registeredNames[0];
+}
+function createSkillImproverLLMDelegate(directory, sessionId) {
+  const client = swarmState.opencodeClient;
+  if (!client)
+    return;
+  return async (systemPrompt, userInput, signal) => {
+    let ephemeralSessionId;
+    const cleanup = () => {
+      if (ephemeralSessionId) {
+        const id = ephemeralSessionId;
+        ephemeralSessionId = undefined;
+        client.session.delete({ path: { id } }).catch(() => {});
+      }
+    };
+    if (signal?.aborted) {
+      cleanup();
+      throw new Error("SKILL_IMPROVER_LLM_TIMEOUT");
+    }
+    signal?.addEventListener("abort", cleanup, { once: true });
+    try {
+      const createResult = await client.session.create({
+        query: { directory }
+      });
+      if (!createResult.data) {
+        throw new Error(`Failed to create skill_improver session: ${JSON.stringify(createResult.error)}`);
+      }
+      ephemeralSessionId = createResult.data.id;
+      if (signal?.aborted)
+        throw new Error("SKILL_IMPROVER_LLM_TIMEOUT");
+      const agentName = resolveSkillImproverAgentName(sessionId);
+      let promptResult;
+      try {
+        const prelude = systemPrompt ? `${systemPrompt}
+
+---
+
+${userInput}` : userInput;
+        promptResult = await client.session.prompt({
+          path: { id: ephemeralSessionId },
+          body: {
+            agent: agentName,
+            tools: { write: false, edit: false, patch: false },
+            parts: [{ type: "text", text: prelude }]
+          }
+        });
+      } catch (err) {
+        if (signal?.aborted)
+          throw new Error("SKILL_IMPROVER_LLM_TIMEOUT");
+        throw err;
+      }
+      if (!promptResult.data) {
+        throw new Error(`skill_improver LLM prompt failed: ${JSON.stringify(promptResult.error)}`);
+      }
+      const textParts = promptResult.data.parts.filter((p) => p.type === "text");
+      return textParts.map((p) => p.text).join(`
+`);
+    } finally {
+      signal?.removeEventListener("abort", cleanup);
+      cleanup();
+    }
+  };
+}
+var init_skill_improver_llm_factory = __esm(() => {
+  init_state();
+});
+
+// src/services/skill-generator.ts
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir5, readFile as readFile5, rename as rename3, writeFile as writeFile6 } from "fs/promises";
+import * as path14 from "path";
+function sanitizeSlug(input) {
+  const lc = input.toLowerCase().trim();
+  const mapped = lc.replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-");
+  const trimmed = mapped.replace(/^-+|-+$/g, "");
+  return trimmed.slice(0, 64);
+}
+function isValidSlug(slug) {
+  return SLUG_PATTERN.test(slug);
+}
+function proposalPath(directory, slug) {
+  return path14.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
+}
+function activePath(directory, slug) {
+  return path14.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
+}
+function activeRepoRelativePath(slug) {
+  return `.opencode/skills/generated/${slug}/SKILL.md`;
+}
+async function selectCandidateEntries(directory, opts) {
+  const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
+  const hivePath = resolveHiveKnowledgePath();
+  const hive = existsSync9(hivePath) ? await readKnowledge(hivePath) : [];
+  const all = [...swarm, ...hive];
+  return all.filter((e) => {
+    if (e.status === "archived")
+      return false;
+    if (e.confidence < opts.minConfidence)
+      return false;
+    const confirmations = (e.confirmed_by ?? []).length;
+    if (confirmations < opts.minConfirmations)
+      return false;
+    if (e.generated_skill_slug)
+      return false;
+    return true;
+  });
+}
+function clusterKey(e) {
+  const t = (e.triggers ?? []).map((s) => s.toLowerCase()).sort().join("|");
+  if (t)
+    return `trigger:${t}`;
+  const tools = (e.applies_to_tools ?? []).map((s) => s.toLowerCase()).sort();
+  const agents = (e.applies_to_agents ?? []).map((s) => s.toLowerCase()).sort();
+  if (tools.length > 0 || agents.length > 0) {
+    return `tool-agent:${tools.join("+")}::${agents.join("+")}`;
+  }
+  const tagSig = e.tags.slice(0, 3).map((s) => s.toLowerCase()).sort().join(",");
+  return `cat:${e.category}:${tagSig}`;
+}
+function clusterEntries(entries) {
+  const groups = new Map;
+  for (const e of entries) {
+    const k = clusterKey(e);
+    const arr = groups.get(k) ?? [];
+    arr.push(e);
+    groups.set(k, arr);
+  }
+  const clusters = [];
+  for (const [key, arr] of groups) {
+    const triggers = uniqueStrings(arr.flatMap((e) => e.triggers ?? []));
+    const required3 = uniqueStrings(arr.flatMap((e) => e.required_actions ?? []));
+    const forbidden = uniqueStrings(arr.flatMap((e) => e.forbidden_actions ?? []));
+    const agents = uniqueStrings(arr.flatMap((e) => e.applies_to_agents ?? []));
+    const checks5 = uniqueStrings(arr.flatMap((e) => e.verification_checks ?? []));
+    const avgConf = arr.reduce((s, e) => s + e.confidence, 0) / Math.max(1, arr.length);
+    const slugSeed = triggers[0] ?? required3[0] ?? arr[0]?.tags?.[0] ?? arr[0]?.category ?? "lesson";
+    const slug = sanitizeSlug(slugSeed);
+    const title = triggers[0] ?? required3[0] ?? `Lessons: ${arr[0]?.category ?? "general"} (${arr.length})`;
+    clusters.push({
+      slug: isValidSlug(slug) ? slug : sanitizeSlug(`cluster-${key.slice(0, 12)}`),
+      title,
+      entries: arr,
+      triggers,
+      required_actions: required3,
+      forbidden_actions: forbidden,
+      target_agents: agents,
+      verification_checks: checks5,
+      avgConfidence: avgConf
+    });
+  }
+  clusters.sort((a, b) => b.entries.length - a.entries.length || b.avgConfidence - a.avgConfidence || a.slug.localeCompare(b.slug));
+  return clusters;
+}
+function uniqueStrings(arr) {
+  return [...new Set(arr.filter((s) => typeof s === "string" && s.length > 0))];
+}
+function renderSkillMarkdown(cluster, mode = "active") {
+  const description = cluster.title.length > 200 ? `${cluster.title.slice(0, 197)}\u2026` : cluster.title;
+  const ids = cluster.entries.map((e) => `  - ${e.id}`).join(`
+`);
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${cluster.slug}`);
+  lines.push(`description: ${escapeYaml(description)}`);
+  lines.push("generated_from_knowledge:");
+  lines.push(ids);
+  lines.push(`confidence: ${cluster.avgConfidence.toFixed(2)}`);
+  lines.push(`status: ${mode === "active" ? "active" : "draft"}`);
+  lines.push("---");
+  lines.push("");
+  lines.push("<!-- generated by opencode-swarm skill-generator. Do not edit by hand; edits will be preserved on regeneration only with controlled update mode. -->");
+  lines.push("");
+  lines.push(`# ${escapeMarkdown(cluster.title)}`);
+  lines.push("");
+  lines.push("## Trigger");
+  lines.push("");
+  for (const t of cluster.triggers.length > 0 ? cluster.triggers : ["(no explicit trigger metadata; cluster derived from category/tags)"]) {
+    lines.push(`- ${escapeMarkdown(t)}`);
+  }
+  lines.push("");
+  lines.push("## Required Procedure");
+  lines.push("");
+  if (cluster.required_actions.length > 0) {
+    for (const r of cluster.required_actions)
+      lines.push(`- ${escapeMarkdown(r)}`);
+  } else {
+    lines.push("- Apply the lessons listed under Source Knowledge IDs.");
+  }
+  lines.push("");
+  lines.push("## Forbidden Shortcuts");
+  lines.push("");
+  if (cluster.forbidden_actions.length > 0) {
+    for (const f of cluster.forbidden_actions)
+      lines.push(`- ${escapeMarkdown(f)}`);
+  } else {
+    lines.push("- (none recorded)");
+  }
+  lines.push("");
+  lines.push("## Delegation Template");
+  lines.push("");
+  lines.push("When delegating a task affected by this skill, include:");
+  lines.push("");
+  lines.push("```");
+  lines.push(`SKILLS: file:.opencode/skills/generated/${cluster.slug}/SKILL.md`);
+  lines.push("```");
+  lines.push("");
+  lines.push("## Reviewer Checks");
+  lines.push("");
+  if (cluster.verification_checks.length > 0) {
+    for (const c of cluster.verification_checks)
+      lines.push(`- ${escapeMarkdown(c)}`);
+  } else {
+    lines.push("- Verify each required action above appears in the diff.");
+  }
+  lines.push("");
+  const needsTestEng = cluster.entries.some((e) => e.category === "testing" || (e.tags ?? []).includes("testing"));
+  if (needsTestEng) {
+    lines.push("## Test Engineer Checks");
+    lines.push("");
+    lines.push("- Add or update tests covering the trigger condition and the forbidden shortcut.");
+    lines.push("");
+  }
+  lines.push("## Source Knowledge IDs");
+  lines.push("");
+  for (const e of cluster.entries)
+    lines.push(`- ${e.id} \u2014 ${escapeMarkdown(e.lesson)}`);
+  lines.push("");
+  return lines.join(`
+`);
+}
+function escapeYaml(s) {
+  if (/[:#\n\r"']/.test(s)) {
+    return JSON.stringify(s);
+  }
+  return s;
+}
+function escapeMarkdown(s) {
+  return s.replace(/[\r\n]+/g, " ").slice(0, 280);
+}
+async function atomicWrite(p, content) {
+  await mkdir5(path14.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile6(tmp, content, "utf-8");
+  await rename3(tmp, p);
+}
+async function generateSkills(req) {
+  const minConfidence = req.minConfidence ?? 0.85;
+  const minConfirmations = req.minConfirmations ?? 2;
+  const candidates = await selectCandidateEntries(req.directory, {
+    minConfidence,
+    minConfirmations
+  });
+  let pool;
+  if (req.sourceKnowledgeIds && req.sourceKnowledgeIds.length > 0) {
+    const idSet = new Set(req.sourceKnowledgeIds);
+    const swarm = await readKnowledge(resolveSwarmKnowledgePath(req.directory));
+    const hivePath = resolveHiveKnowledgePath();
+    const hive = existsSync9(hivePath) ? await readKnowledge(hivePath) : [];
+    pool = [...swarm, ...hive].filter((e) => idSet.has(e.id) && e.status !== "archived");
+  } else {
+    pool = candidates;
+  }
+  const clusters = clusterEntries(pool);
+  const result = { written: [], skipped: [] };
+  for (let i = 0;i < clusters.length; i++) {
+    const cluster = clusters[i];
+    if (req.slug && i === 0) {
+      const overridden = sanitizeSlug(req.slug);
+      if (!isValidSlug(overridden)) {
+        result.skipped.push({
+          slug: req.slug,
+          reason: "slug rejected by sanitizer (path traversal or invalid chars)"
+        });
+        continue;
+      }
+      cluster.slug = overridden;
+    }
+    if (!isValidSlug(cluster.slug)) {
+      result.skipped.push({
+        slug: cluster.slug,
+        reason: "computed slug invalid"
+      });
+      continue;
+    }
+    const targetPath = req.mode === "active" ? activePath(req.directory, cluster.slug) : proposalPath(req.directory, cluster.slug);
+    const repoRel = path14.relative(req.directory, targetPath).replace(/\\/g, "/");
+    if (!validateSkillPath(repoRel)) {
+      result.skipped.push({
+        slug: cluster.slug,
+        reason: `target path ${repoRel} not under allowed prefixes (${ALLOWED_SKILL_PATH_PREFIXES.join(", ")})`
+      });
+      continue;
+    }
+    let preserved = false;
+    if (req.mode === "active" && existsSync9(targetPath) && !req.force) {
+      const existing = await readFile5(targetPath, "utf-8");
+      if (!existing.includes("generated by opencode-swarm skill-generator")) {
+        preserved = true;
+        result.skipped.push({
+          slug: cluster.slug,
+          reason: "manually edited skill exists at target path; rerun with force=true to overwrite"
+        });
+        continue;
+      }
+    }
+    const content = renderSkillMarkdown(cluster, req.mode);
+    await atomicWrite(targetPath, content);
+    if (req.mode === "active") {
+      await stampSourceEntries(req.directory, cluster.slug, cluster.entries.map((e) => e.id));
+    }
+    result.written.push({
+      slug: cluster.slug,
+      path: targetPath,
+      mode: req.mode,
+      sourceKnowledgeIds: cluster.entries.map((e) => e.id),
+      preserved
+    });
+  }
+  return result;
+}
+async function stampSourceEntries(directory, slug, ids) {
+  if (!ids || ids.length === 0)
+    return;
+  const swarmPath = resolveSwarmKnowledgePath(directory);
+  const swarm = await readKnowledge(swarmPath);
+  const idSet = new Set(ids);
+  let touched = false;
+  const repoRel = activeRepoRelativePath(slug);
+  for (const e of swarm) {
+    if (!idSet.has(e.id))
+      continue;
+    e.generated_skill_slug = slug;
+    e.generated_skill_path = repoRel;
+    e.updated_at = new Date().toISOString();
+    touched = true;
+  }
+  if (touched)
+    await rewriteKnowledge(swarmPath, swarm);
+  const hivePath = resolveHiveKnowledgePath();
+  if (!existsSync9(hivePath))
+    return;
+  const hive = await readKnowledge(hivePath);
+  let touchedHive = false;
+  for (const e of hive) {
+    if (!idSet.has(e.id))
+      continue;
+    e.generated_skill_slug = slug;
+    e.generated_skill_path = repoRel;
+    e.updated_at = new Date().toISOString();
+    touchedHive = true;
+  }
+  if (touchedHive)
+    await rewriteKnowledge(hivePath, hive);
+}
+async function listSkills(directory) {
+  const result = {
+    proposals: [],
+    active: []
+  };
+  const proposalsDir = path14.join(directory, ".swarm", "skills", "proposals");
+  const activeDir = path14.join(directory, ".opencode", "skills", "generated");
+  const fs7 = await import("fs/promises");
+  if (existsSync9(proposalsDir)) {
+    const entries = await fs7.readdir(proposalsDir);
+    for (const f of entries) {
+      if (!f.endsWith(".md"))
+        continue;
+      const slug = f.replace(/\.md$/, "");
+      result.proposals.push({
+        slug,
+        path: path14.join(proposalsDir, f)
+      });
+    }
+  }
+  if (existsSync9(activeDir)) {
+    const entries = await fs7.readdir(activeDir, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory())
+        continue;
+      const skillPath = path14.join(activeDir, e.name, "SKILL.md");
+      if (existsSync9(skillPath)) {
+        result.active.push({
+          slug: e.name,
+          path: skillPath
+        });
+      }
+    }
+  }
+  return result;
+}
+var SLUG_PATTERN;
+var init_skill_generator = __esm(() => {
+  init_knowledge_store();
+  init_knowledge_validator();
+  init_logger();
+  SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+});
+
+// src/services/skill-improver-quota.ts
+import { existsSync as existsSync10 } from "fs";
+import { mkdir as mkdir6, readFile as readFile6, rename as rename4, writeFile as writeFile7 } from "fs/promises";
+import * as path15 from "path";
+async function acquireLock(dir) {
+  const acquire = import_proper_lockfile5.default.lock(dir, LOCK_RETRY_OPTS);
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`SKILL_IMPROVER_QUOTA_LOCK_TIMEOUT: failed to acquire lock on ${dir} within ${LOCK_ACQUIRE_TIMEOUT_MS}ms`));
+    }, LOCK_ACQUIRE_TIMEOUT_MS);
+  });
+  try {
+    const release = await Promise.race([acquire, timeout]);
+    return release;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+function resolveQuotaPath(directory) {
+  return path15.join(directory, ".swarm", "skill-improver-quota.json");
+}
+function todayKey(window, now = new Date) {
+  if (window === "utc") {
+    return now.toISOString().slice(0, 10);
+  }
+  const yr = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${yr}-${m}-${d}`;
+}
+async function readState(filePath) {
+  if (!existsSync10(filePath))
+    return null;
+  try {
+    const raw = await readFile6(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.date !== "string" || typeof parsed.calls_used !== "number" || typeof parsed.max_calls !== "number" || parsed.window !== "utc" && parsed.window !== "local") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeState(filePath, state) {
+  await mkdir6(path15.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp-${process.pid}`;
+  await writeFile7(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await rename4(tmp, filePath);
+}
+async function getQuotaState(directory, opts) {
+  const filePath = resolveQuotaPath(directory);
+  const today = todayKey(opts.window, opts.now);
+  const existing = await readState(filePath);
+  if (!existing || existing.date !== today || existing.window !== opts.window) {
+    const fresh = {
+      date: today,
+      calls_used: 0,
+      max_calls: opts.maxCalls,
+      window: opts.window
+    };
+    await writeState(filePath, fresh);
+    return fresh;
+  }
+  return { ...existing, max_calls: opts.maxCalls };
+}
+async function reserveQuota(directory, opts) {
+  const filePath = resolveQuotaPath(directory);
+  await mkdir6(path15.dirname(filePath), { recursive: true });
+  let release = null;
+  try {
+    release = await acquireLock(path15.dirname(filePath));
+    const state = await getQuotaState(directory, opts);
+    if (state.calls_used + opts.nCalls > opts.maxCalls) {
+      return {
+        allowed: false,
+        state,
+        reason: `daily quota exhausted: used=${state.calls_used} requested=${opts.nCalls} max=${opts.maxCalls}`
+      };
+    }
+    const next = {
+      ...state,
+      calls_used: state.calls_used + opts.nCalls,
+      max_calls: opts.maxCalls,
+      last_run_at: (opts.now ?? new Date).toISOString()
+    };
+    await writeState(filePath, next);
+    return { allowed: true, state: next };
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+async function releaseQuota(directory, opts) {
+  const filePath = resolveQuotaPath(directory);
+  await mkdir6(path15.dirname(filePath), { recursive: true });
+  let release = null;
+  try {
+    release = await acquireLock(path15.dirname(filePath));
+    const state = await getQuotaState(directory, opts);
+    const next = {
+      ...state,
+      calls_used: Math.max(0, state.calls_used - opts.nCalls),
+      max_calls: opts.maxCalls
+    };
+    await writeState(filePath, next);
+    return next;
+  } finally {
+    if (release) {
+      try {
+        await release();
+      } catch {}
+    }
+  }
+}
+var import_proper_lockfile5, LOCK_ACQUIRE_TIMEOUT_MS = 1e4, LOCK_RETRY_OPTS;
+var init_skill_improver_quota = __esm(() => {
+  import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
+  LOCK_RETRY_OPTS = {
+    retries: {
+      retries: 30,
+      minTimeout: 50,
+      maxTimeout: 200,
+      factor: 1.5
+    },
+    stale: 5000
+  };
+});
+
+// src/services/skill-improver.ts
+import { existsSync as existsSync11 } from "fs";
+import { mkdir as mkdir7, rename as rename5, writeFile as writeFile8 } from "fs/promises";
+import * as path16 from "path";
+function timestampSlug(d) {
+  return d.toISOString().replace(/[:.]/g, "-");
+}
+async function atomicWrite2(p, content) {
+  await mkdir7(path16.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile8(tmp, content, "utf-8");
+  await rename5(tmp, p);
+}
+async function gatherInventory(directory) {
+  const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
+  const hivePath = resolveHiveKnowledgePath();
+  const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
+  const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
+  const skills = await listSkills(directory);
+  const matureCandidates = swarm.concat(hive).filter((e) => e.status !== "archived" && e.confidence >= 0.85 && !e.generated_skill_slug && (e.confirmed_by ?? []).length >= 2);
+  return {
+    knowledge: { swarm: swarm.length, hive: hive.length, archived },
+    skills: {
+      proposals: skills.proposals.length,
+      active: skills.active.length
+    },
+    highConfidenceClusters: matureCandidates.length,
+    matureCandidates
+  };
+}
+function buildSystemPrompt(targets, cfg) {
+  return `You are skill_improver. Targets: ${targets.join(", ")}. Mode: ${cfg.write_mode}.
+
+Output a single complete markdown proposal under 6000 chars. Sections required:
+1. ## Inventory snapshot
+2. ## Repeated ignored or violated directives (cite knowledge ids)
+3. ## Concrete recommendations
+4. ## Optional cluster suggestions for new draft skills (slug, title, source ids, target agents) \u2014 leave empty if none qualify
+5. ## Risks and known limitations
+
+Do NOT propose direct source-code edits. Do NOT call any tools. Return only the markdown body.`;
+}
+function buildUserPrompt(inv) {
+  const matureRows = inv.matureCandidates.slice(0, 25).map((e) => `- ${e.id} | conf=${e.confidence.toFixed(2)} | ${e.category} | "${e.lesson.slice(0, 140).replace(/\n/g, " ")}"`).join(`
+`);
+  return `INVENTORY
+swarm_entries: ${inv.knowledge.swarm}
+hive_entries: ${inv.knowledge.hive}
+archived: ${inv.knowledge.archived}
+draft_skills: ${inv.skills.proposals}
+active_skills: ${inv.skills.active}
+mature_uncompiled_clusters: ${inv.highConfidenceClusters}
+
+TOP MATURE CANDIDATES (first 25):
+${matureRows || "(none)"}
+`;
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.message === "skill_improver_aborted");
+}
+function throwIfAborted(signal) {
+  if (!signal?.aborted)
+    return;
+  const err = new Error("skill_improver_aborted");
+  err.name = "AbortError";
+  throw err;
+}
+function buildDeterministicProposal(args) {
+  const lines = [];
+  lines.push("---");
+  lines.push("source: deterministic_fallback");
+  lines.push(`generated_at: ${args.now.toISOString()}`);
+  lines.push(`targets: [${args.targets.join(", ")}]`);
+  lines.push(`model: ${args.model ?? "(none \u2014 deterministic body)"}`);
+  lines.push("---");
+  lines.push("");
+  lines.push("# Skill Improvement Proposal (deterministic fallback)");
+  lines.push("");
+  lines.push("> No OpenCode LLM client was available when this proposal was generated. The body below is a deterministic inventory summary, not an LLM-derived analysis. To produce a real LLM proposal, run `skill_improve` from a session where the OpenCode runtime has wired `swarmState.opencodeClient`, or set `skill_improver.allow_deterministic_fallback: false` to force a hard failure instead of this fallback.");
+  lines.push("");
+  lines.push("## Inventory snapshot");
+  lines.push(`- Knowledge entries: swarm=${args.inventory.knowledge.swarm}, hive=${args.inventory.knowledge.hive}, archived=${args.inventory.knowledge.archived}`);
+  lines.push(`- Generated skills: proposals=${args.inventory.skills.proposals}, active=${args.inventory.skills.active}`);
+  lines.push(`- High-confidence un-skill'd clusters: ${args.inventory.highConfidenceClusters}`);
+  lines.push("");
+  lines.push("## Recommendations");
+  if (args.inventory.highConfidenceClusters > 0) {
+    lines.push(`- Run \`skill_generate { mode: "draft" }\` to emit ${args.inventory.highConfidenceClusters} draft SKILL.md proposal(s).`);
+  }
+  if (args.targets.includes("architect_prompt")) {
+    lines.push("- Manually review architect prompt against current high-priority directives.");
+  }
+  if (args.targets.includes("spec")) {
+    lines.push("- Audit `.swarm/spec.md` for drift.");
+  }
+  if (args.targets.includes("knowledge")) {
+    lines.push("- Archive low-confidence (< 0.3) entries with applied_explicit_count == 0 and shown_count > 5.");
+  }
+  lines.push("");
+  return lines.join(`
+`);
+}
+function buildLLMProposalFrame(args) {
+  const lines = [];
+  lines.push("---");
+  lines.push("source: llm");
+  lines.push(`generated_at: ${args.now.toISOString()}`);
+  lines.push(`targets: [${args.targets.join(", ")}]`);
+  if (args.model)
+    lines.push(`model: ${args.model}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(args.body.trim());
+  lines.push("");
+  return lines.join(`
+`);
+}
+async function runSkillImprover(req) {
+  const cfg = req.config;
+  const now = req.now ?? new Date;
+  const targets = req.targets && req.targets.length > 0 ? req.targets : cfg.targets;
+  const writeMode = req.mode ?? cfg.write_mode;
+  const maxCalls = Math.max(1, Math.min(cfg.max_calls_per_day, req.maxCalls ?? 1));
+  const noQuota = {
+    date: now.toISOString().slice(0, 10),
+    calls_used: 0,
+    max_calls: cfg.max_calls_per_day
+  };
+  if (!cfg.enabled) {
+    return {
+      ran: false,
+      reason: "skill_improver.enabled is false",
+      quota: noQuota
+    };
+  }
+  if (req.signal?.aborted) {
+    return {
+      ran: false,
+      reason: "skill_improver aborted",
+      quota: noQuota
+    };
+  }
+  const delegate = req.delegate ?? createSkillImproverLLMDelegate(req.directory, req.sessionId);
+  if (!delegate && !cfg.allow_deterministic_fallback) {
+    return {
+      ran: false,
+      reason: "no_llm_client: skill_improver.allow_deterministic_fallback is false and no OpenCode client is wired. Run from a session where swarmState.opencodeClient is available, or enable allow_deterministic_fallback to use the offline path.",
+      quota: noQuota
+    };
+  }
+  const reservation = await reserveQuota(req.directory, {
+    nCalls: maxCalls,
+    maxCalls: cfg.max_calls_per_day,
+    window: cfg.quota_window,
+    now
+  });
+  if (!reservation.allowed) {
+    return {
+      ran: false,
+      reason: reservation.reason ?? "quota exhausted",
+      quota: {
+        date: reservation.state.date,
+        calls_used: reservation.state.calls_used,
+        max_calls: reservation.state.max_calls
+      }
+    };
+  }
+  let networkStarted = false;
+  let sideEffectsStarted = false;
+  const reservationQuota = {
+    date: reservation.state.date,
+    calls_used: reservation.state.calls_used,
+    max_calls: reservation.state.max_calls
+  };
+  const releaseReservedQuota = async () => {
+    const released = await releaseQuota(req.directory, {
+      nCalls: maxCalls,
+      maxCalls: cfg.max_calls_per_day,
+      window: cfg.quota_window,
+      now
+    }).catch(() => ({
+      ...reservation.state,
+      calls_used: Math.max(0, reservation.state.calls_used - maxCalls)
+    }));
+    return {
+      date: released.date,
+      calls_used: released.calls_used,
+      max_calls: released.max_calls
+    };
+  };
+  const abortResult = async () => ({
+    ran: false,
+    reason: "skill_improver aborted",
+    quota: networkStarted || sideEffectsStarted ? reservationQuota : await releaseReservedQuota()
+  });
+  let inventory;
+  try {
+    throwIfAborted(req.signal);
+    inventory = await gatherInventory(req.directory);
+    throwIfAborted(req.signal);
+  } catch (err) {
+    if (isAbortError(err)) {
+      return await abortResult();
+    }
+    await releaseQuota(req.directory, {
+      nCalls: maxCalls,
+      maxCalls: cfg.max_calls_per_day,
+      window: cfg.quota_window,
+      now
+    }).catch(() => {});
+    return {
+      ran: false,
+      reason: `inventory_failed: ${err instanceof Error ? err.message : String(err)}`,
+      quota: {
+        date: reservation.state.date,
+        calls_used: reservation.state.calls_used - maxCalls,
+        max_calls: reservation.state.max_calls
+      }
+    };
+  }
+  let body;
+  let source;
+  if (delegate) {
+    try {
+      throwIfAborted(req.signal);
+      networkStarted = true;
+      body = await delegate(buildSystemPrompt(targets, { ...cfg, write_mode: writeMode }), buildUserPrompt(inventory), req.signal);
+      throwIfAborted(req.signal);
+      if (!body || body.trim().length === 0) {
+        throw new Error("empty LLM response");
+      }
+      source = "llm";
+    } catch (err) {
+      if (isAbortError(err)) {
+        return await abortResult();
+      }
+      return {
+        ran: false,
+        reason: `llm_call_failed: ${err instanceof Error ? err.message : String(err)}`,
+        quota: {
+          date: reservation.state.date,
+          calls_used: reservation.state.calls_used,
+          max_calls: reservation.state.max_calls
+        }
+      };
+    }
+  } else {
+    try {
+      throwIfAborted(req.signal);
+    } catch (err) {
+      if (isAbortError(err)) {
+        return await abortResult();
+      }
+      throw err;
+    }
+    body = "";
+    source = "deterministic_fallback";
+  }
+  let draftSkillsWritten;
+  if (writeMode === "draft_skills" && inventory.matureCandidates.length > 0) {
+    try {
+      throwIfAborted(req.signal);
+    } catch (err) {
+      if (isAbortError(err)) {
+        return await abortResult();
+      }
+      throw err;
+    }
+    sideEffectsStarted = true;
+    const gen = await generateSkills({
+      directory: req.directory,
+      mode: "draft",
+      minConfidence: 0.85,
+      minConfirmations: 2
+    });
+    draftSkillsWritten = gen.written.map((w) => ({
+      slug: w.slug,
+      path: w.path,
+      sourceKnowledgeIds: w.sourceKnowledgeIds
+    }));
+  }
+  try {
+    throwIfAborted(req.signal);
+  } catch (err) {
+    if (isAbortError(err)) {
+      return await abortResult();
+    }
+    throw err;
+  }
+  const proposalDir = path16.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path16.join(proposalDir, `${timestampSlug(now)}.md`);
+  const finalBody = source === "llm" ? buildLLMProposalFrame({
+    body,
+    targets,
+    model: cfg.model,
+    now
+  }) : buildDeterministicProposal({
+    targets,
+    inventory,
+    model: cfg.model,
+    now
+  });
+  sideEffectsStarted = true;
+  await atomicWrite2(proposalFile, finalBody);
+  return {
+    ran: true,
+    proposalPath: proposalFile,
+    source,
+    quota: {
+      date: reservation.state.date,
+      calls_used: reservation.state.calls_used,
+      max_calls: reservation.state.max_calls
+    },
+    draftSkillsWritten,
+    model: cfg.model ?? undefined
+  };
+}
+var init_skill_improver = __esm(() => {
+  init_knowledge_store();
+  init_skill_improver_llm_factory();
+  init_skill_generator();
+  init_skill_improver_quota();
+});
+
 // src/tools/write-retro.ts
 async function executeWriteRetro(args, directory) {
   if (/^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(:|$)/i.test(directory)) {
@@ -36392,7 +37458,7 @@ async function executeWriteRetro(args, directory) {
     }, null, 2);
   }
 }
-var write_retro, _internals8;
+var write_retro, _internals9;
 var init_write_retro = __esm(() => {
   init_zod();
   init_evidence_schema();
@@ -36439,13 +37505,13 @@ var init_write_retro = __esm(() => {
           task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
           metadata: args.metadata
         };
-        return await _internals8.executeWriteRetro(writeRetroArgs, directory);
+        return await _internals9.executeWriteRetro(writeRetroArgs, directory);
       } catch {
         return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
       }
     }
   });
-  _internals8 = {
+  _internals9 = {
     executeWriteRetro,
     write_retro
   };
@@ -36453,7 +37519,40 @@ var init_write_retro = __esm(() => {
 
 // src/commands/close.ts
 import { promises as fs7 } from "fs";
-import path14 from "path";
+import path17 from "path";
+async function runAbortableSkillReview(req, timeoutMs) {
+  const controller = new AbortController;
+  let timeout;
+  const skillReviewPromise = runSkillImprover({
+    ...req,
+    signal: controller.signal
+  });
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      reject(new Error(`skill_review exceeded ${timeoutMs}ms budget`));
+      controller.abort();
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([skillReviewPromise, timeoutPromise]);
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+  }
+}
+function countSessionKnowledgeEntries(entries, sessionStart, fallbackCount) {
+  if (!sessionStart)
+    return fallbackCount;
+  const sessionStartMs = Date.parse(sessionStart);
+  if (!Number.isFinite(sessionStartMs))
+    return fallbackCount;
+  return entries.filter((entry) => {
+    if (typeof entry.created_at !== "string")
+      return false;
+    const createdAtMs = Date.parse(entry.created_at);
+    return Number.isFinite(createdAtMs) && createdAtMs >= sessionStartMs;
+  }).length;
+}
 function guaranteeAllPlansComplete(planData) {
   const closedPhaseIds = [];
   const closedTaskIds = [];
@@ -36474,12 +37573,12 @@ function guaranteeAllPlansComplete(planData) {
   }
   return { closedPhaseIds, closedTaskIds };
 }
-async function handleCloseCommand(directory, args) {
+async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
-  const swarmDir = path14.join(directory, ".swarm");
+  const swarmDir = path17.join(directory, ".swarm");
   let planExists = false;
   let planData = {
-    title: path14.basename(directory) || "Ad-hoc session",
+    title: path17.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
@@ -36498,6 +37597,7 @@ async function handleCloseCommand(directory, args) {
   const phases = planData.phases ?? [];
   const inProgressPhases = phases.filter((p) => p.status === "in_progress");
   const isForced = args.includes("--force");
+  const runSkillReview = args.includes("--skill-review");
   let planAlreadyDone = false;
   if (planExists) {
     planAlreadyDone = phases.length > 0 && phases.every((p) => p.status === "complete" || p.status === "completed" || p.status === "blocked" || p.status === "closed");
@@ -36585,7 +37685,7 @@ async function handleCloseCommand(directory, args) {
       warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path14.join(swarmDir, "close-lessons.md");
+  const lessonsFilePath = path17.join(swarmDir, "close-lessons.md");
   let explicitLessons = [];
   try {
     const lessonsText = await fs7.readFile(lessonsFilePath, "utf-8");
@@ -36594,11 +37694,11 @@ async function handleCloseCommand(directory, args) {
   } catch {}
   const retroLessons = [];
   try {
-    const evidenceDir = path14.join(swarmDir, "evidence");
+    const evidenceDir = path17.join(swarmDir, "evidence");
     const evidenceEntries = await fs7.readdir(evidenceDir);
     const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path14.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path17.join(evidenceDir, retroDir, "evidence.json");
       try {
         const content = await fs7.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -36617,8 +37717,9 @@ async function handleCloseCommand(directory, args) {
   } catch {}
   const allLessons = [...new Set([...explicitLessons, ...retroLessons])];
   let curationSucceeded = false;
+  let curationResult;
   try {
-    await curateAndStoreSwarm(allLessons, projectName, { phase_number: 0 }, directory, config3);
+    curationResult = await curateAndStoreSwarm(allLessons, projectName, { phase_number: 0 }, directory, config3);
     curationSucceeded = true;
   } catch (error93) {
     const msg = error93 instanceof Error ? error93.message : String(error93);
@@ -36648,6 +37749,44 @@ async function handleCloseCommand(directory, args) {
       warnings.push(`Hive promotion failed: ${msg}`);
     }
   }
+  const fallbackKnowledgeCreated = curationResult?.stored ?? 0;
+  let sessionKnowledgeCreated = fallbackKnowledgeCreated;
+  try {
+    const knowledgePath = resolveSwarmKnowledgePath(directory);
+    const entries = await readKnowledge(knowledgePath);
+    sessionKnowledgeCreated = countSessionKnowledgeEntries(entries, sessionStart, fallbackKnowledgeCreated);
+  } catch (knowledgeErr) {
+    const msg = knowledgeErr instanceof Error ? knowledgeErr.message : String(knowledgeErr);
+    warnings.push(`Knowledge session count failed: ${msg}`);
+  }
+  const knowledgeSkillHint = sessionKnowledgeCreated > 0 ? `${sessionKnowledgeCreated} knowledge entries created this session. Consider running skill_improve or skill_generate to compile mature entries into skills.` : "";
+  let skillReviewSummary = "";
+  if (runSkillReview) {
+    try {
+      const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
+      const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
+      const skillReviewResult = await runAbortableSkillReview({
+        directory,
+        config: skillImproverConfig,
+        targets: ["skills", "knowledge"],
+        mode: "proposal",
+        sessionId: options.sessionID
+      }, options.skillReviewTimeoutMs ?? CLOSE_SKILL_REVIEW_TIMEOUT_MS);
+      if (skillReviewResult.ran) {
+        const proposal = skillReviewResult.proposalPath ? ` Proposal: ${skillReviewResult.proposalPath}.` : "";
+        const source = skillReviewResult.source ? ` Source: ${skillReviewResult.source}.` : "";
+        skillReviewSummary = `Skill review proposal generated.${proposal}${source}`;
+      } else {
+        const reason = skillReviewResult.reason ?? "unknown reason";
+        skillReviewSummary = `Skill review skipped: ${reason}`;
+        warnings.push(skillReviewSummary);
+      }
+    } catch (skillReviewErr) {
+      const msg = skillReviewErr instanceof Error ? skillReviewErr.message : String(skillReviewErr);
+      skillReviewSummary = `Skill review failed: ${msg}`;
+      warnings.push(skillReviewSummary);
+    }
+  }
   if (planExists) {
     const guaranteeResult = guaranteeAllPlansComplete(planData);
     for (const phaseId of guaranteeResult.closedPhaseIds) {
@@ -36672,7 +37811,7 @@ async function handleCloseCommand(directory, args) {
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const suffix = Math.random().toString(36).slice(2, 8);
-  const archiveDir = path14.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
+  const archiveDir = path17.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
   let archiveResult = "";
   let archivedFileCount = 0;
   const archivedActiveStateFiles = new Set;
@@ -36680,8 +37819,8 @@ async function handleCloseCommand(directory, args) {
   try {
     await fs7.mkdir(archiveDir, { recursive: true });
     for (const artifact of ARCHIVE_ARTIFACTS) {
-      const srcPath = path14.join(swarmDir, artifact);
-      const destPath = path14.join(archiveDir, artifact);
+      const srcPath = path17.join(swarmDir, artifact);
+      const destPath = path17.join(archiveDir, artifact);
       try {
         await fs7.copyFile(srcPath, destPath);
         archivedFileCount++;
@@ -36691,22 +37830,22 @@ async function handleCloseCommand(directory, args) {
       } catch {}
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path14.join(swarmDir, dirName);
-      const destDir = path14.join(archiveDir, dirName);
+      const srcDir = path17.join(swarmDir, dirName);
+      const destDir = path17.join(archiveDir, dirName);
       try {
         const entries = await fs7.readdir(srcDir);
         if (entries.length > 0) {
           await fs7.mkdir(destDir, { recursive: true });
           for (const entry of entries) {
-            const srcEntry = path14.join(srcDir, entry);
-            const destEntry = path14.join(destDir, entry);
+            const srcEntry = path17.join(srcDir, entry);
+            const destEntry = path17.join(destDir, entry);
             try {
               const stat2 = await fs7.stat(srcEntry);
               if (stat2.isDirectory()) {
                 await fs7.mkdir(destEntry, { recursive: true });
                 const subEntries = await fs7.readdir(srcEntry);
                 for (const sub of subEntries) {
-                  await fs7.copyFile(path14.join(srcEntry, sub), path14.join(destEntry, sub)).catch(() => {});
+                  await fs7.copyFile(path17.join(srcEntry, sub), path17.join(destEntry, sub)).catch(() => {});
                 }
               } else {
                 await fs7.copyFile(srcEntry, destEntry);
@@ -36738,7 +37877,7 @@ async function handleCloseCommand(directory, args) {
         warnings.push(`Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path14.join(swarmDir, artifact);
+      const filePath = path17.join(swarmDir, artifact);
       try {
         await fs7.unlink(filePath);
         cleanedFiles.push(artifact);
@@ -36751,7 +37890,7 @@ async function handleCloseCommand(directory, args) {
     if (!archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path14.join(swarmDir, dirName);
+    const dirPath = path17.join(swarmDir, dirName);
     try {
       await fs7.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
@@ -36762,23 +37901,23 @@ async function handleCloseCommand(directory, args) {
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs7.unlink(path14.join(swarmDir, backup));
+        await fs7.unlink(path17.join(swarmDir, backup));
         configBackupsRemoved++;
       } catch {}
     }
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs7.unlink(path14.join(swarmDir, sibling));
+        await fs7.unlink(path17.join(swarmDir, sibling));
       } catch {}
     }
   } catch {}
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path14.join(directory, ".swarm", "SWARM_PLAN.json"),
-    path14.join(directory, ".swarm", "SWARM_PLAN.md"),
-    path14.join(directory, "SWARM_PLAN.json"),
-    path14.join(directory, "SWARM_PLAN.md")
+    path17.join(directory, ".swarm", "SWARM_PLAN.json"),
+    path17.join(directory, ".swarm", "SWARM_PLAN.md"),
+    path17.join(directory, "SWARM_PLAN.json"),
+    path17.join(directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
@@ -36786,12 +37925,12 @@ async function handleCloseCommand(directory, args) {
       swarmPlanFilesRemoved++;
     } catch (err) {
       if (err?.code !== "ENOENT") {
-        warnings.push(`Failed to remove ${path14.basename(candidate)}: ${err instanceof Error ? err.message : String(err)}`);
+        warnings.push(`Failed to remove ${path17.basename(candidate)}: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
   }
   clearAllScopes(directory);
-  const contextPath = path14.join(swarmDir, "context.md");
+  const contextPath = path17.join(swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -36864,6 +38003,12 @@ async function handleCloseCommand(directory, args) {
     "## Lessons Committed",
     allLessons.length > 0 ? `| # | Lesson |` : "_No lessons committed_",
     ...allLessons.length > 0 ? ["| --- | --- |", ...allLessons.map((l, i) => `| ${i + 1} | ${l} |`)] : [],
+    ...knowledgeSkillHint ? ["", knowledgeSkillHint] : [],
+    ...runSkillReview ? [
+      "",
+      "## Skill Review",
+      skillReviewSummary || "Skill review completed without details."
+    ] : [],
     "",
     "## Local Repo State",
     ...gitAlignResult ? [`- **Git:** ${gitAlignResult}`] : ["- Git alignment skipped"],
@@ -36894,11 +38039,13 @@ async function handleCloseCommand(directory, args) {
   const preservedFullAutoFlag = swarmState.fullAutoEnabledInConfig;
   const preservedCuratorInitNames = swarmState.curatorInitAgentNames;
   const preservedCuratorPhaseNames = swarmState.curatorPhaseAgentNames;
+  const preservedSkillImproverAgentNames = swarmState.skillImproverAgentNames;
   resetSwarmState();
   swarmState.opencodeClient = preservedClient;
   swarmState.fullAutoEnabledInConfig = preservedFullAutoFlag;
   swarmState.curatorInitAgentNames = preservedCuratorInitNames;
   swarmState.curatorPhaseAgentNames = preservedCuratorPhaseNames;
+  swarmState.skillImproverAgentNames = preservedSkillImproverAgentNames;
   const retroWarnings = warnings.filter((w) => w.includes("Retrospective write") || w.includes("retrospective write") || w.includes("Session retrospective"));
   const otherWarnings = warnings.filter((w) => !w.includes("Retrospective write") && !w.includes("retrospective write") && !w.includes("Session retrospective"));
   let warningMsg = "";
@@ -36919,19 +38066,26 @@ ${otherWarnings.map((w) => `- ${w}`).join(`
   const lessonSummary = curationSucceeded && allLessons.length > 0 ? `
 
 **Lessons Committed:** ${allLessons.length} lesson(s) committed to knowledge store` : "";
+  const knowledgeHintSummary = knowledgeSkillHint ? `
+
+**Knowledge Review:** ${knowledgeSkillHint}` : "";
+  const skillReviewOutput = skillReviewSummary ? `
+
+**Skill Review:** ${skillReviewSummary}` : "";
   if (planAlreadyDone) {
     return `\u2705 Session finalized. Plan was already in a terminal state \u2014 cleanup and archive applied.
 
 **Archive:** ${archiveResult}
-**Git:** ${gitAlignResult}${lessonSummary}${warningMsg}`;
+**Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${warningMsg}`;
   }
   return `\u2705 Swarm finalized. ${closedPhases.length} phase(s) closed, ${closedTasks.length} incomplete task(s) marked closed.
 
 **Archive:** ${archiveResult}
-**Git:** ${gitAlignResult}${lessonSummary}${warningMsg}`;
+**Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${warningMsg}`;
 }
-var ARCHIVE_ARTIFACTS, ACTIVE_STATE_TO_CLEAN, ACTIVE_STATE_DIRS_TO_CLEAN;
+var CLOSE_SKILL_REVIEW_TIMEOUT_MS = 120000, ARCHIVE_ARTIFACTS, ACTIVE_STATE_TO_CLEAN, ACTIVE_STATE_DIRS_TO_CLEAN;
 var init_close = __esm(() => {
+  init_config();
   init_schema();
   init_manager2();
   init_branch();
@@ -36940,6 +38094,7 @@ var init_close = __esm(() => {
   init_knowledge_store();
   init_utils2();
   init_scope_persistence();
+  init_skill_improver();
   init_state();
   init_write_retro();
   ARCHIVE_ARTIFACTS = [
@@ -36995,14 +38150,14 @@ var init_close = __esm(() => {
 
 // src/commands/config.ts
 import * as os4 from "os";
-import * as path15 from "path";
+import * as path18 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path15.join(os4.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path18.join(os4.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config3 = loadPluginConfig(directory);
-  const userConfigPath = path15.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path15.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path18.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path18.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -37128,8 +38283,8 @@ var init_curate = __esm(() => {
 // src/tools/co-change-analyzer.ts
 import * as child_process3 from "child_process";
 import { randomUUID } from "crypto";
-import { readdir, readFile as readFile5, stat as stat2 } from "fs/promises";
-import * as path16 from "path";
+import { readdir, readFile as readFile7, stat as stat2 } from "fs/promises";
+import * as path19 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process3.execFile);
@@ -37231,7 +38386,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dir, entry.name);
+      const fullPath = path19.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -37239,7 +38394,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path16.extname(entry.name);
+        const ext = path19.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -37253,7 +38408,7 @@ async function getStaticEdges(directory) {
   const sourceFiles = await scanSourceFiles(directory);
   for (const sourceFile of sourceFiles) {
     try {
-      const content = await readFile5(sourceFile, "utf-8");
+      const content = await readFile7(sourceFile, "utf-8");
       const importRegex = /(?:import|require)\s*(?:\(?\s*['"`]|.*?from\s+['"`])([^'"`]+)['"`]/g;
       for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
         const importPath = match[1].trim();
@@ -37261,8 +38416,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path16.dirname(sourceFile);
-          const resolvedPath = path16.resolve(sourceDir, importPath);
+          const sourceDir = path19.dirname(sourceFile);
+          const resolvedPath = path19.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -37287,8 +38442,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path16.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path16.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path19.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path19.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -37300,7 +38455,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path16.basename(filePath);
+    const base = path19.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -37310,16 +38465,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path16.basename(fileA) && baseA !== path16.basename(fileB);
+  return baseA === baseB && baseA !== path19.basename(fileA) && baseA !== path19.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path16.dirname(fileA);
-  const dirB = path16.dirname(fileB);
+  const dirA = path19.dirname(fileA);
+  const dirB = path19.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path16.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path16.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path19.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path19.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -37347,9 +38502,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals9.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals9.buildCoChangeMatrix(commitMap);
-  const staticEdges = await _internals9.getStaticEdges(directory);
+  const commitMap = await _internals10.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals10.buildCoChangeMatrix(commitMap);
+  const staticEdges = await _internals10.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -37373,8 +38528,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path16.basename(pair.fileA);
-    const baseB = path16.basename(pair.fileB);
+    const baseA = path19.basename(pair.fileA);
+    const baseB = path19.basename(pair.fileB);
     let lesson = `Files ${pair.fileA} and ${pair.fileB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
     if (lesson.length > 280) {
       lesson = `Files ${baseA} and ${baseB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
@@ -37429,7 +38584,7 @@ ${rows}
 These pairs likely share an architectural concern invisible to static analysis.
 Consider adding explicit documentation or extracting the shared concern.`;
 }
-var co_change_analyzer, _internals9;
+var co_change_analyzer, _internals10;
 var init_co_change_analyzer = __esm(() => {
   init_zod();
   init_create_tool();
@@ -37461,11 +38616,11 @@ var init_co_change_analyzer = __esm(() => {
         npmiThreshold,
         maxCommitsToAnalyze
       };
-      const pairs = await _internals9.detectDarkMatter(directory, options);
-      return _internals9.formatDarkMatterOutput(pairs);
+      const pairs = await _internals10.detectDarkMatter(directory, options);
+      return _internals10.formatDarkMatterOutput(pairs);
     }
   });
-  _internals9 = {
+  _internals10 = {
     parseGitLog,
     buildCoChangeMatrix,
     getStaticEdges,
@@ -37476,7 +38631,7 @@ var init_co_change_analyzer = __esm(() => {
 });
 
 // src/commands/dark-matter.ts
-import path17 from "path";
+import path20 from "path";
 async function handleDarkMatterCommand(directory, args) {
   const options = {};
   for (let i = 0;i < args.length; i++) {
@@ -37496,7 +38651,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals9.detectDarkMatter(directory, options);
+    pairs = await _internals10.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -37508,7 +38663,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path17.basename(path17.resolve(directory));
+      const projectName = path20.basename(path20.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -37645,67 +38800,67 @@ var init_deep_dive = __esm(() => {
 
 // src/config/cache-paths.ts
 import * as os5 from "os";
-import * as path18 from "path";
+import * as path21 from "path";
 function getPluginConfigDir() {
-  return path18.join(process.env.XDG_CONFIG_HOME || path18.join(os5.homedir(), ".config"), "opencode");
+  return path21.join(process.env.XDG_CONFIG_HOME || path21.join(os5.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path18.join(os5.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path21.join(os5.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path18.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path18.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path18.join(configDir, "node_modules", "opencode-swarm")
+    path21.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path21.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path21.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path18.join(os5.homedir(), "Library", "Caches");
-    paths.push(path18.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path18.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path21.join(os5.homedir(), "Library", "Caches");
+    paths.push(path21.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path21.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path18.join(os5.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path18.join(os5.homedir(), "AppData", "Roaming");
-    paths.push(path18.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path18.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path18.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path21.join(os5.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path21.join(os5.homedir(), "AppData", "Roaming");
+    paths.push(path21.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path21.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path21.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path18.join(os5.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path21.join(os5.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path18.join(cacheBase, "opencode", "bun.lock"),
-    path18.join(cacheBase, "opencode", "bun.lockb"),
-    path18.join(configDir, "package-lock.json")
+    path21.join(cacheBase, "opencode", "bun.lock"),
+    path21.join(cacheBase, "opencode", "bun.lockb"),
+    path21.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path18.join(os5.homedir(), "Library", "Caches");
-    paths.push(path18.join(libCaches, "opencode", "bun.lock"), path18.join(libCaches, "opencode", "bun.lockb"));
+    const libCaches = path21.join(os5.homedir(), "Library", "Caches");
+    paths.push(path21.join(libCaches, "opencode", "bun.lock"), path21.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path18.join(os5.homedir(), "AppData", "Local");
-    paths.push(path18.join(localAppData, "opencode", "bun.lock"), path18.join(localAppData, "opencode", "bun.lockb"));
+    const localAppData = process.env.LOCALAPPDATA || path21.join(os5.homedir(), "AppData", "Local");
+    paths.push(path21.join(localAppData, "opencode", "bun.lock"), path21.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
 }
 var init_cache_paths = () => {};
 
 // src/services/version-check.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join17 } from "path";
+import { join as join20 } from "path";
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join17(homedir5(), ".cache");
-  return join17(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join20(homedir5(), ".cache");
+  return join20(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join17(cacheDir(), "version-check.json");
+  return join20(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path19 = cacheFile();
-    if (!existsSync9(path19))
+    const path22 = cacheFile();
+    if (!existsSync12(path22))
       return null;
-    const raw = readFileSync5(path19, "utf-8");
+    const raw = readFileSync6(path22, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -37744,8 +38899,8 @@ var init_version_check = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync6 } from "fs";
-import path19 from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync6 } from "fs";
+import path22 from "path";
 import { fileURLToPath } from "url";
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
@@ -37978,7 +39133,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync10(directory) || !statSync6(directory).isDirectory()) {
+    if (!existsSync13(directory) || !statSync6(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -38042,8 +39197,8 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path19.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync10(configPath)) {
+  const configPath = path22.join(directory, ".opencode/opencode-swarm.json");
+  if (!existsSync13(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -38051,7 +39206,7 @@ async function checkConfigParseability(directory) {
     };
   }
   try {
-    const content = readFileSync6(configPath, "utf-8");
+    const content = readFileSync7(configPath, "utf-8");
     JSON.parse(content);
     return {
       name: "Config Parseability",
@@ -38071,7 +39226,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path19.join(thisDir, "..", "lang", "grammars") : path19.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path22.join(thisDir, "..", "lang", "grammars") : path22.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -38095,14 +39250,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path19.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path22.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync10(path19.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync13(path22.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync10(path19.join(grammarDir, file3))) {
+    if (!existsSync13(path22.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -38120,8 +39275,8 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path19.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync10(manifestPath)) {
+  const manifestPath = path22.join(directory, ".swarm/checkpoints.json");
+  if (!existsSync13(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -38129,7 +39284,7 @@ async function checkCheckpointManifest(directory) {
     };
   }
   try {
-    const content = readFileSync6(manifestPath, "utf-8");
+    const content = readFileSync7(manifestPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
       return {
@@ -38172,8 +39327,8 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path19.join(directory, ".swarm/events.jsonl");
-  if (!existsSync10(eventsPath)) {
+  const eventsPath = path22.join(directory, ".swarm/events.jsonl");
+  if (!existsSync13(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -38181,7 +39336,7 @@ async function checkEventStreamIntegrity(directory) {
     };
   }
   try {
-    const content = readFileSync6(eventsPath, "utf-8");
+    const content = readFileSync7(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     let malformedCount = 0;
@@ -38213,8 +39368,8 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path19.join(directory, ".swarm/events.jsonl");
-  if (!existsSync10(eventsPath)) {
+  const eventsPath = path22.join(directory, ".swarm/events.jsonl");
+  if (!existsSync13(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -38222,7 +39377,7 @@ async function checkSteeringDirectives(directory) {
     };
   }
   try {
-    const content = readFileSync6(eventsPath, "utf-8");
+    const content = readFileSync7(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     const directivesIssued = [];
@@ -38269,8 +39424,8 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path19.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync10(summaryPath)) {
+    const summaryPath = path22.join(directory, ".swarm/curator-summary.json");
+    if (!existsSync13(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -38278,7 +39433,7 @@ async function checkCurator(directory) {
       };
     }
     try {
-      const content = readFileSync6(summaryPath, "utf-8");
+      const content = readFileSync7(summaryPath, "utf-8");
       const parsed = JSON.parse(content);
       if (typeof parsed.schema_version !== "number" || parsed.schema_version !== 1) {
         return {
@@ -38435,8 +39590,8 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path19.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync10(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const evidenceDir = path22.join(directory, ".swarm", "evidence");
+    const snapshotFiles = existsSync13(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -38469,13 +39624,13 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync10(cachePath)) {
+      if (!existsSync13(cachePath)) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path19.join(cachePath, "package.json");
+      const pkgJsonPath = path22.join(cachePath, "package.json");
       try {
-        const raw = readFileSync6(pkgJsonPath, "utf-8");
+        const raw = readFileSync7(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
         const installedVersion = typeof parsed.version === "string" ? parsed.version : "?";
         cacheRows.push(`\u2705 ${cachePath} \u2014 v${installedVersion}`);
@@ -38561,13 +39716,13 @@ __export(exports_config_doctor, {
 import * as crypto3 from "crypto";
 import * as fs8 from "fs";
 import * as os6 from "os";
-import * as path20 from "path";
+import * as path23 from "path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path20.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path23.join(os6.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path20.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path20.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path23.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path23.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -38592,9 +39747,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path20.resolve(configPath);
-    const resolvedUser = path20.resolve(normalizedUser);
-    const resolvedProject = path20.resolve(normalizedProject);
+    const resolvedConfig = path23.resolve(configPath);
+    const resolvedUser = path23.resolve(normalizedUser);
+    const resolvedProject = path23.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -38634,12 +39789,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path20.join(directory, ".swarm");
+  const swarmDir = path23.join(directory, ".swarm");
   if (!fs8.existsSync(swarmDir)) {
     fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path20.join(swarmDir, backupFilename);
+  const backupPath = path23.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -38669,7 +39824,7 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path20.dirname(targetPath);
+    const targetDir = path23.dirname(targetPath);
     if (!fs8.existsSync(targetDir)) {
       fs8.mkdirSync(targetDir, { recursive: true });
     }
@@ -38700,9 +39855,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path21, value, _config) {
+function validateConfigKey(path24, value, _config) {
   const findings = [];
-  switch (path21) {
+  switch (path24) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -38949,27 +40104,27 @@ function validateConfigKey(path21, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path21, config3, findings) {
+function walkConfigAndValidate(obj, path24, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path21 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path21, obj, config3);
+  if (path24 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path24, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path21, obj, config3);
+    const keyFindings = validateConfigKey(path24, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path21}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path24}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path21 ? `${path21}.${key}` : key;
+    const newPath = path24 ? `${path24}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -39089,7 +40244,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path20.dirname(configPath);
+    const configDir = path23.dirname(configPath);
     if (!fs8.existsSync(configDir)) {
       fs8.mkdirSync(configDir, { recursive: true });
     }
@@ -39099,12 +40254,12 @@ function applySafeAutoFixes(directory, result) {
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path20.join(directory, ".swarm");
+  const swarmDir = path23.join(directory, ".swarm");
   if (!fs8.existsSync(swarmDir)) {
     fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path20.join(swarmDir, artifactFilename);
+  const artifactPath = path23.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -40151,7 +41306,7 @@ var init_profiles = __esm(() => {
 
 // src/lang/detector.ts
 import { access as access3, readdir as readdir2 } from "fs/promises";
-import { extname as extname2, join as join19 } from "path";
+import { extname as extname2, join as join22 } from "path";
 async function detectProjectLanguages(projectDir) {
   const detected = new Set;
   async function scanDir(dir) {
@@ -40167,7 +41322,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access3(join19(dir, detectFile));
+          await access3(join22(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -40188,7 +41343,7 @@ async function detectProjectLanguages(projectDir) {
     const topEntries = await readdir2(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        await scanDir(join19(projectDir, entry.name));
+        await scanDir(join22(projectDir, entry.name));
       }
     }
   } catch {}
@@ -40207,7 +41362,7 @@ var init_detector = __esm(() => {
 
 // src/build/discovery.ts
 import * as fs9 from "fs";
-import * as path21 from "path";
+import * as path24 from "path";
 function isCommandAvailable(command) {
   if (toolchainCache.has(command)) {
     return toolchainCache.get(command);
@@ -40239,11 +41394,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path21.join(dir, matches[0]);
+          return path24.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path21.join(workingDir, pattern);
+      const filePath = path24.join(workingDir, pattern);
       if (fs9.existsSync(filePath)) {
         return filePath;
       }
@@ -40252,7 +41407,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path21.join(workingDir, "package.json");
+  const packageJsonPath = path24.join(workingDir, "package.json");
   if (!fs9.existsSync(packageJsonPath)) {
     return [];
   }
@@ -40293,7 +41448,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path21.join(workingDir, pattern);
+        const filePath = path24.join(workingDir, pattern);
         if (fs9.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -40306,7 +41461,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path21.join(dir, entry.name);
+      const fullPath = path24.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -40329,7 +41484,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path21.join(workingDir, cmd.detectFile);
+        const detectFilePath = path24.join(workingDir, cmd.detectFile);
         if (!fs9.existsSync(detectFilePath)) {
           continue;
         }
@@ -40362,7 +41517,7 @@ async function discoverBuildCommands(workingDir, options) {
   const scope = options?.scope ?? "all";
   const changedFiles = options?.changedFiles ?? [];
   const _filesToCheck = filterByScope(workingDir, scope, changedFiles);
-  const profileResult = await _internals10.discoverBuildCommandsFromProfiles(workingDir);
+  const profileResult = await _internals11.discoverBuildCommandsFromProfiles(workingDir);
   const profileCommands = profileResult.commands;
   const profileSkipped = profileResult.skipped;
   const coveredEcosystems = new Set;
@@ -40425,7 +41580,7 @@ function clearToolchainCache() {
 function getEcosystems() {
   return ECOSYSTEMS.map((e) => e.ecosystem);
 }
-var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, _internals10, build_discovery;
+var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, _internals11, build_discovery;
 var init_discovery = __esm(() => {
   init_dist();
   init_detector();
@@ -40543,7 +41698,7 @@ var init_discovery = __esm(() => {
     php: ["php-composer"]
   };
   toolchainCache = new Map;
-  _internals10 = {
+  _internals11 = {
     isCommandAvailable,
     discoverBuildCommandsFromProfiles,
     discoverBuildCommands,
@@ -40569,7 +41724,7 @@ var init_discovery = __esm(() => {
 
 // src/services/tool-doctor.ts
 import * as fs10 from "fs";
-import * as path22 from "path";
+import * as path25 from "path";
 function extractRegisteredToolKeys(indexPath) {
   const registeredKeys = new Set;
   try {
@@ -40624,8 +41779,8 @@ function checkBinaryReadiness() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path22.resolve(import.meta.dir, "..", "..");
-  const indexPath = path22.join(resolvedPluginRoot, "src", "index.ts");
+  const resolvedPluginRoot = pluginRoot ?? path25.resolve(import.meta.dir, "..", "..");
+  const indexPath = path25.join(resolvedPluginRoot, "src", "index.ts");
   if (!fs10.existsSync(indexPath)) {
     return {
       findings: [
@@ -40795,7 +41950,7 @@ var exports_evidence_summary_service = {};
 __export(exports_evidence_summary_service, {
   isAutoSummaryEnabled: () => isAutoSummaryEnabled,
   buildEvidenceSummary: () => buildEvidenceSummary,
-  _internals: () => _internals11,
+  _internals: () => _internals12,
   REQUIRED_EVIDENCE_TYPES: () => REQUIRED_EVIDENCE_TYPES,
   EVIDENCE_SUMMARY_VERSION: () => EVIDENCE_SUMMARY_VERSION
 });
@@ -40833,14 +41988,14 @@ function getTaskStatus(task, bundle) {
   if (task?.status) {
     return task.status;
   }
-  const entries = _internals11.normalizeBundleEntries(bundle);
+  const entries = _internals12.normalizeBundleEntries(bundle);
   if (entries.length > 0) {
     return "completed";
   }
   return "pending";
 }
 function isEvidenceComplete(bundle) {
-  const entries = _internals11.normalizeBundleEntries(bundle);
+  const entries = _internals12.normalizeBundleEntries(bundle);
   if (entries.length === 0) {
     return {
       isComplete: false,
@@ -40876,10 +42031,10 @@ async function buildTaskSummary(directory, task, taskId) {
   const result = await loadEvidence(directory, taskId);
   const bundle = result.status === "found" ? result.bundle : null;
   const phase = task?.phase ?? 0;
-  const status = _internals11.getTaskStatus(task, bundle);
-  const evidenceCheck = _internals11.isEvidenceComplete(bundle);
-  const blockers = _internals11.getTaskBlockers(task, evidenceCheck, status);
-  const entries = _internals11.normalizeBundleEntries(bundle);
+  const status = _internals12.getTaskStatus(task, bundle);
+  const evidenceCheck = _internals12.isEvidenceComplete(bundle);
+  const blockers = _internals12.getTaskBlockers(task, evidenceCheck, status);
+  const entries = _internals12.normalizeBundleEntries(bundle);
   const hasReview = entries.some((e) => e.type === "review");
   const hasTest = entries.some((e) => e.type === "test");
   const hasApproval = entries.some((e) => e.type === "approval");
@@ -40908,12 +42063,12 @@ async function buildPhaseSummary(directory, phase) {
   const taskSummaries = [];
   const _taskMap = new Map(phase.tasks.map((t) => [t.id, t]));
   for (const task of phase.tasks) {
-    const summary = await _internals11.buildTaskSummary(directory, task, task.id);
+    const summary = await _internals12.buildTaskSummary(directory, task, task.id);
     taskSummaries.push(summary);
   }
   const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
   for (const taskId of extraTaskIds) {
-    const summary = await _internals11.buildTaskSummary(directory, undefined, taskId);
+    const summary = await _internals12.buildTaskSummary(directory, undefined, taskId);
     if (summary.phase === phase.id) {
       taskSummaries.push(summary);
     }
@@ -41014,7 +42169,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
   let totalTasks = 0;
   let completedTasks = 0;
   for (const phase of phasesToProcess) {
-    const summary = await _internals11.buildPhaseSummary(directory, phase);
+    const summary = await _internals12.buildPhaseSummary(directory, phase);
     phaseSummaries.push(summary);
     totalTasks += summary.totalTasks;
     completedTasks += summary.completedTasks;
@@ -41036,7 +42191,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
     overallBlockers,
     summaryText: ""
   };
-  artifact.summaryText = _internals11.generateSummaryText(artifact);
+  artifact.summaryText = _internals12.generateSummaryText(artifact);
   log("[EvidenceSummary] Summary built", {
     phases: phaseSummaries.length,
     totalTasks,
@@ -41055,7 +42210,7 @@ function isAutoSummaryEnabled(automationConfig) {
   }
   return automationConfig.capabilities?.evidence_auto_summaries === true;
 }
-var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals11;
+var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals12;
 var init_evidence_summary_service = __esm(() => {
   init_manager2();
   init_manager();
@@ -41069,7 +42224,7 @@ var init_evidence_summary_service = __esm(() => {
     "retrospective"
   ]);
   REQUIRED_EVIDENCE_TYPES = ["review", "test"];
-  _internals11 = {
+  _internals12 = {
     buildEvidenceSummary,
     isAutoSummaryEnabled,
     normalizeBundleEntries,
@@ -41316,12 +42471,12 @@ var init_export = __esm(() => {
 
 // src/full-auto/state.ts
 import * as fs11 from "fs";
-import * as path23 from "path";
+import * as path26 from "path";
 function nowISO() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path23.resolve(directory, ".swarm");
+  const swarmDir = path26.resolve(directory, ".swarm");
   if (!fs11.existsSync(swarmDir)) {
     fs11.mkdirSync(swarmDir, { recursive: true });
   }
@@ -41366,7 +42521,7 @@ function withStateLock(directory, fn) {
       fs11.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
     }
-    release = lockfile5.lockSync(lockTarget, {
+    release = lockfile6.lockSync(lockTarget, {
       retries: { retries: 5, minTimeout: 5, maxTimeout: 50 },
       stale: 5000
     });
@@ -41552,12 +42707,12 @@ function terminateFullAutoRun(directory, sessionID, reason) {
     return state;
   });
 }
-var import_proper_lockfile5, lockfile5, STATE_FILE = "full-auto-state.json", stateUnreadable = false, stateUnreadableReason = "";
+var import_proper_lockfile6, lockfile6, STATE_FILE = "full-auto-state.json", stateUnreadable = false, stateUnreadableReason = "";
 var init_state2 = __esm(() => {
   init_utils2();
   init_logger();
-  import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-  lockfile5 = import_proper_lockfile5.default;
+  import_proper_lockfile6 = __toESM(require_proper_lockfile(), 1);
+  lockfile6 = import_proper_lockfile6.default;
 });
 
 // src/commands/full-auto.ts
@@ -41672,7 +42827,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals12.validatePlanPhases(plan)) {
+  if (!_internals13.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -41814,9 +42969,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals12.parseSessionState(sessionContent);
+  const sessionState = _internals13.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals12.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals13.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -41835,8 +42990,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals12.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals12.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals13.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals13.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -42000,13 +43155,13 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals12;
+var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals13;
 var init_handoff_service = __esm(() => {
   init_utils2();
   init_manager();
   init_utils();
   RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
-  _internals12 = {
+  _internals13 = {
     getHandoffData,
     formatHandoffMarkdown,
     formatContinuationPrompt,
@@ -42022,7 +43177,7 @@ var init_handoff_service = __esm(() => {
 
 // src/session/snapshot-writer.ts
 import { mkdirSync as mkdirSync10, renameSync as renameSync6 } from "fs";
-import * as path24 from "path";
+import * as path27 from "path";
 function serializeAgentSession(s) {
   const gateLog = {};
   const rawGateLog = s.gateLog ?? new Map;
@@ -42112,7 +43267,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path24.dirname(resolvedPath);
+    const dir = path27.dirname(resolvedPath);
     mkdirSync10(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -42125,22 +43280,22 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals13.writeSnapshot(directory, swarmState), () => _internals13.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals14.writeSnapshot(directory, swarmState), () => _internals14.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals13.writeSnapshot(directory, swarmState), () => _internals13.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals14.writeSnapshot(directory, swarmState), () => _internals14.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _writeInFlight, _internals13;
+var _writeInFlight, _internals14;
 var init_snapshot_writer = __esm(() => {
   init_utils2();
   init_state();
   init_utils();
   init_bun_compat();
   _writeInFlight = Promise.resolve();
-  _internals13 = {
+  _internals14 = {
     writeSnapshot,
     createSnapshotWriterHook,
     flushPendingSnapshot
@@ -42561,9 +43716,9 @@ var init_issue = __esm(() => {
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
-import * as path25 from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync12 } from "fs";
+import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import * as path28 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
     migrated: false,
@@ -42574,10 +43729,10 @@ async function migrateKnowledgeToExternal(_directory, _config) {
   };
 }
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path25.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path25.join(directory, ".swarm", "context.md");
+  const sentinelPath = path28.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path28.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync15(sentinelPath)) {
+  if (existsSync18(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -42586,7 +43741,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync15(contextPath)) {
+  if (!existsSync18(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -42595,7 +43750,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await readFile6(contextPath, "utf-8");
+  const contextContent = await readFile8(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -42605,9 +43760,9 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals14.parseContextMd(contextContent);
+  const rawEntries = _internals15.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals14.writeSentinel(sentinelPath, 0, 0);
+    await _internals15.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -42618,10 +43773,10 @@ async function migrateContextToKnowledge(directory, config3) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals14.inferProjectName(directory);
+  const projectName = _internals15.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config3.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals14.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals15.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -42641,8 +43796,8 @@ async function migrateContextToKnowledge(directory, config3) {
     const entry = {
       id: randomUUID2(),
       tier: "swarm",
-      lesson: _internals14.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals14.inferCategoryFromText(raw.text),
+      lesson: _internals15.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals15.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -42665,7 +43820,7 @@ async function migrateContextToKnowledge(directory, config3) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals14.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals15.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -42675,7 +43830,7 @@ async function migrateContextToKnowledge(directory, config3) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals14.splitIntoSections(content);
+  const sections = _internals15.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -42691,7 +43846,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals14.extractBullets(section.body);
+    const bullets = _internals15.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -42700,9 +43855,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals14.truncateLesson(bullet),
+        text: _internals15.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals14.inferCategoryFromText(bullet)
+        categoryHint: _internals15.inferCategoryFromText(bullet)
       });
     }
   }
@@ -42771,16 +43926,16 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path25.join(directory, "package.json");
-  if (existsSync15(packageJsonPath)) {
+  const packageJsonPath = path28.join(directory, "package.json");
+  if (existsSync18(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync12(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         return pkg.name;
       }
     } catch {}
   }
-  return path25.basename(directory);
+  return path28.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -42792,15 +43947,15 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir5(path25.dirname(sentinelPath), { recursive: true });
-  await writeFile6(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await mkdir8(path28.dirname(sentinelPath), { recursive: true });
+  await writeFile9(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
-var _internals14;
+var _internals15;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
-  _internals14 = {
+  _internals15 = {
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
     parseContextMd,
@@ -42814,7 +43969,7 @@ var init_knowledge_migrator = __esm(() => {
 });
 
 // src/commands/knowledge.ts
-import { join as join23 } from "path";
+import { join as join26 } from "path";
 function resolveEntryByPrefix(entries, inputId) {
   const exact = entries.find((e) => e.id === inputId);
   if (exact)
@@ -42865,7 +44020,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join23(directory, ".swarm", "knowledge-quarantined.jsonl");
+    const quarantinePath = join26(directory, ".swarm", "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -43314,7 +44469,7 @@ var init_path_security = () => {};
 
 // src/tools/lint.ts
 import * as fs12 from "fs";
-import * as path26 from "path";
+import * as path29 from "path";
 function validateArgs(args) {
   if (typeof args !== "object" || args === null)
     return false;
@@ -43325,9 +44480,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path26.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path26.join(binDir, "biome.EXE") : path26.join(binDir, "biome");
-  const eslintBin = isWindows ? path26.join(binDir, "eslint.cmd") : path26.join(binDir, "eslint");
+  const binDir = path29.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path29.join(binDir, "biome.EXE") : path29.join(binDir, "biome");
+  const eslintBin = isWindows ? path29.join(binDir, "eslint.cmd") : path29.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -43343,7 +44498,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs12.existsSync(path26.join(cwd, gradlewName)) ? path26.join(cwd, gradlewName) : null;
+  const gradlew = fs12.existsSync(path29.join(cwd, gradlewName)) ? path29.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -43377,10 +44532,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs12.existsSync(path26.join(cwd, "ruff.toml")))
+  if (fs12.existsSync(path29.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path26.join(cwd, "pyproject.toml");
+    const pyproject = path29.join(cwd, "pyproject.toml");
     if (fs12.existsSync(pyproject)) {
       const content = fs12.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -43390,19 +44545,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs12.existsSync(path26.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs12.existsSync(path29.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs12.existsSync(path26.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs12.existsSync(path29.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs12.existsSync(path26.join(cwd, "pom.xml"));
-  const hasGradle = fs12.existsSync(path26.join(cwd, "build.gradle")) || fs12.existsSync(path26.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs12.existsSync(path26.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs12.existsSync(path29.join(cwd, "pom.xml"));
+  const hasGradle = fs12.existsSync(path29.join(cwd, "build.gradle")) || fs12.existsSync(path29.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs12.existsSync(path29.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs12.existsSync(path26.join(cwd, "build.gradle.kts")) || fs12.existsSync(path26.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs12.existsSync(path29.join(cwd, "build.gradle.kts")) || fs12.existsSync(path29.join(cwd, "build.gradle")) || (() => {
     try {
       return fs12.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -43421,11 +44576,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs12.existsSync(path26.join(cwd, "CMakeLists.txt"))) {
+  if (fs12.existsSync(path29.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path26.join(cwd, "src")];
+    const dirsToCheck = [cwd, path29.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs12.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -43439,13 +44594,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs12.existsSync(path26.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs12.existsSync(path29.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs12.existsSync(path26.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs12.existsSync(path29.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs12.existsSync(path26.join(cwd, "Gemfile")) || fs12.existsSync(path26.join(cwd, "gems.rb")) || fs12.existsSync(path26.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs12.existsSync(path29.join(cwd, "Gemfile")) || fs12.existsSync(path29.join(cwd, "gems.rb")) || fs12.existsSync(path29.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -43473,10 +44628,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path26.join(dir, "node_modules", ".bin", binName);
+    const candidate = path29.join(dir, "node_modules", ".bin", binName);
     if (fs12.existsSync(candidate))
       return candidate;
-    const parent = path26.dirname(dir);
+    const parent = path29.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -43485,10 +44640,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path26.delimiter)) {
+  for (const dir of searchPath.split(path29.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path26.join(dir, binName);
+    const candidate = path29.join(dir, binName);
     if (fs12.existsSync(candidate))
       return candidate;
   }
@@ -43501,13 +44656,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path26.join(projectDir, "node_modules", ".bin", "biome.EXE") : path26.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path26.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path26.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path29.join(projectDir, "node_modules", ".bin", "biome.EXE") : path29.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path29.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path29.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path26.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path26.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path29.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path29.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -43666,7 +44821,7 @@ async function runAdditionalLint(linter, mode, cwd) {
     };
   }
 }
-var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals15;
+var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals16;
 var init_lint = __esm(() => {
   init_zod();
   init_discovery();
@@ -43698,15 +44853,15 @@ var init_lint = __esm(() => {
       }
       const { mode } = args;
       const cwd = directory;
-      const linter = await _internals15.detectAvailableLinter(directory);
+      const linter = await _internals16.detectAvailableLinter(directory);
       if (linter) {
-        const result = await _internals15.runLint(linter, mode, directory);
+        const result = await _internals16.runLint(linter, mode, directory);
         return JSON.stringify(result, null, 2);
       }
-      const additionalLinter = _internals15.detectAdditionalLinter(cwd);
+      const additionalLinter = _internals16.detectAdditionalLinter(cwd);
       if (additionalLinter) {
         warn(`[lint] Using ${additionalLinter} linter for this project`);
-        const result = await _internals15.runAdditionalLint(additionalLinter, mode, cwd);
+        const result = await _internals16.runAdditionalLint(additionalLinter, mode, cwd);
         return JSON.stringify(result, null, 2);
       }
       const errorResult = {
@@ -43720,7 +44875,7 @@ For Rust: rustup component add clippy`
       return JSON.stringify(errorResult, null, 2);
     }
   });
-  _internals15 = {
+  _internals16 = {
     detectAvailableLinter,
     runLint,
     detectAdditionalLinter,
@@ -43730,7 +44885,7 @@ For Rust: rustup component add clippy`
 
 // src/tools/secretscan.ts
 import * as fs13 from "fs";
-import * as path27 from "path";
+import * as path30 from "path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
     return 0;
@@ -43778,7 +44933,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path27.join(scanDir, ".secretscanignore");
+  const ignorePath = path30.join(scanDir, ".secretscanignore");
   try {
     if (!fs13.existsSync(ignorePath))
       return [];
@@ -43801,7 +44956,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path27.matchesGlob(relPath, pattern))
+    if (path30.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -43822,7 +44977,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path27.extname(filePath).toLowerCase();
+  const ext = path30.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -43958,9 +45113,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path27.resolve(scanDir);
-  const resolvedRealPath = path27.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path27.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path30.resolve(scanDir);
+  const resolvedRealPath = path30.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path30.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -43986,8 +45141,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path27.join(dir, entry);
-    const relPath = path27.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path30.join(dir, entry);
+    const relPath = path30.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -44022,7 +45177,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path27.extname(fullPath).toLowerCase();
+      const ext = path30.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -44034,7 +45189,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 }
 async function runSecretscan(directory) {
   try {
-    const result = await _internals16.secretscan.execute({ directory }, {});
+    const result = await _internals17.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -44049,7 +45204,7 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS, O_NOFOLLOW, secretscan, _internals16;
+var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS, O_NOFOLLOW, secretscan, _internals17;
 var init_secretscan = __esm(() => {
   init_zod();
   init_path_security();
@@ -44282,7 +45437,7 @@ var init_secretscan = __esm(() => {
         }
       }
       try {
-        const _scanDirRaw = path27.resolve(directory);
+        const _scanDirRaw = path30.resolve(directory);
         const scanDir = (() => {
           try {
             return fs13.realpathSync(_scanDirRaw);
@@ -44421,7 +45576,7 @@ var init_secretscan = __esm(() => {
       }
     }
   });
-  _internals16 = {
+  _internals17 = {
     secretscan,
     runSecretscan
   };
@@ -44429,7 +45584,7 @@ var init_secretscan = __esm(() => {
 
 // src/test-impact/analyzer.ts
 import fs14 from "fs";
-import path28 from "path";
+import path31 from "path";
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -44450,8 +45605,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path28.resolve(fromDir, importPath);
-  if (path28.extname(resolved)) {
+  const resolved = path31.resolve(fromDir, importPath);
+  if (path31.extname(resolved)) {
     if (fs14.existsSync(resolved) && fs14.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -44496,12 +45651,12 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path28.join(dir, entry.name), visitedInodes);
+          walk(path31.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name = entry.name;
         if (/\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name)) {
-          testFiles.push(normalizePath(path28.join(dir, entry.name)));
+          testFiles.push(normalizePath(path31.join(dir, entry.name)));
         }
       }
     }
@@ -44539,7 +45694,7 @@ async function buildImpactMapInternal(cwd) {
       continue;
     }
     const imports = extractImports(content);
-    const testDir = path28.dirname(testFile);
+    const testDir = path31.dirname(testFile);
     for (const importPath of imports) {
       const resolvedSource = resolveRelativeImport(testDir, importPath);
       if (resolvedSource === null) {
@@ -44556,28 +45711,28 @@ async function buildImpactMapInternal(cwd) {
   return impactMap;
 }
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals17.buildImpactMapInternal(cwd);
-  await _internals17.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals18.buildImpactMapInternal(cwd);
+  await _internals18.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd) {
-  const cachePath = path28.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path31.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs14.existsSync(cachePath)) {
     try {
       const content = fs14.readFileSync(cachePath, "utf-8");
       const data = JSON.parse(content);
       const map3 = data.map;
       const generatedAt = new Date(data.generatedAt).getTime();
-      if (!_internals17.isCacheStale(map3, generatedAt)) {
+      if (!_internals18.isCacheStale(map3, generatedAt)) {
         return map3;
       }
     } catch {}
   }
-  return _internals17.buildImpactMap(cwd);
+  return _internals18.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  const cacheDir2 = path28.join(cwd, ".swarm", "cache");
-  const cachePath = path28.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path31.join(cwd, ".swarm", "cache");
+  const cachePath = path31.join(cacheDir2, "impact-map.json");
   if (!fs14.existsSync(cacheDir2)) {
     fs14.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -44599,11 +45754,11 @@ async function analyzeImpact(changedFiles, cwd) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals17.loadImpactMap(cwd);
+  const impactMap = await _internals18.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   for (const changedFile of validFiles) {
-    const normalizedChanged = normalizePath(path28.resolve(changedFile));
+    const normalizedChanged = normalizePath(path31.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -44640,13 +45795,13 @@ async function analyzeImpact(changedFiles, cwd) {
     impactMap
   };
 }
-var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, EXTENSIONS_TO_TRY, _internals17;
+var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, EXTENSIONS_TO_TRY, _internals18;
 var init_analyzer = __esm(() => {
   IMPORT_REGEX_ES = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
   IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
   EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
-  _internals17 = {
+  _internals18 = {
     normalizePath,
     isCacheStale,
     resolveRelativeImport,
@@ -44867,9 +46022,9 @@ var FLAKY_THRESHOLD = 0.3, MIN_RUNS_FOR_QUARANTINE = 5, MAX_HISTORY_RUNS = 20;
 
 // src/test-impact/history-store.ts
 import fs15 from "fs";
-import path29 from "path";
+import path32 from "path";
 function getHistoryPath(workingDir) {
-  return path29.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
+  return path32.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -44924,7 +46079,7 @@ function appendTestRun(record3, workingDir) {
     changedFiles: sanitizeChangedFiles(record3.changedFiles || [])
   };
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path29.dirname(historyPath);
+  const historyDir = path32.dirname(historyPath);
   if (!fs15.existsSync(historyDir)) {
     fs15.mkdirSync(historyDir, { recursive: true });
   }
@@ -45006,7 +46161,7 @@ var init_history_store = __esm(() => {
 
 // src/tools/resolve-working-directory.ts
 import * as fs16 from "fs";
-import * as path30 from "path";
+import * as path33 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -45026,15 +46181,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path30.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path30.sep);
+  const normalizedDir = path33.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path33.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path30.resolve(normalizedDir);
+  const resolvedDir = path33.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs16.statSync(resolvedDir);
@@ -45050,7 +46205,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path30.resolve(fallbackDirectory);
+  const resolvedFallback = path33.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs16.statSync(resolvedFallback);
@@ -45060,7 +46215,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path30.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path33.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -45082,7 +46237,7 @@ var init_resolve_working_directory = () => {};
 
 // src/tools/test-runner.ts
 import * as fs17 from "fs";
-import * as path31 from "path";
+import * as path34 from "path";
 function isAbsolutePath(str) {
   if (str.startsWith("/"))
     return true;
@@ -45147,14 +46302,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs17.existsSync(path31.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs17.existsSync(path34.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs17.existsSync(path31.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs17.existsSync(path34.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs17.existsSync(path31.join(cwd, "build.gradle")) || fs17.existsSync(path31.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs17.existsSync(path31.join(cwd, "gradlew")) || fs17.existsSync(path31.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs17.existsSync(path34.join(cwd, "build.gradle")) || fs17.existsSync(path34.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs17.existsSync(path34.join(cwd, "gradlew")) || fs17.existsSync(path34.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -45167,30 +46322,30 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs17.existsSync(path31.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs17.existsSync(path31.join(cwd, "CMakeCache.txt")) || fs17.existsSync(path31.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs17.existsSync(path34.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs17.existsSync(path34.join(cwd, "CMakeCache.txt")) || fs17.existsSync(path34.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs17.existsSync(path31.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs17.existsSync(path34.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs17.existsSync(path31.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs17.existsSync(path34.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs17.existsSync(path31.join(cwd, ".rspec"));
-  const hasGemfile = fs17.existsSync(path31.join(cwd, "Gemfile"));
-  const hasSpecDir = fs17.existsSync(path31.join(cwd, "spec"));
+  const hasRSpecFile = fs17.existsSync(path34.join(cwd, ".rspec"));
+  const hasGemfile = fs17.existsSync(path34.join(cwd, "Gemfile"));
+  const hasSpecDir = fs17.existsSync(path34.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs17.existsSync(path31.join(cwd, "test")) && (fs17.existsSync(path31.join(cwd, "Gemfile")) || fs17.existsSync(path31.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs17.existsSync(path34.join(cwd, "test")) && (fs17.existsSync(path34.join(cwd, "Gemfile")) || fs17.existsSync(path34.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path31.join(baseDir, "package.json");
+    const packageJsonPath = path34.join(baseDir, "package.json");
     if (fs17.existsSync(packageJsonPath)) {
       const content = fs17.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -45211,16 +46366,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs17.existsSync(path31.join(baseDir, "bun.lockb")) || fs17.existsSync(path31.join(baseDir, "bun.lock"))) {
+      if (fs17.existsSync(path34.join(baseDir, "bun.lockb")) || fs17.existsSync(path34.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path31.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path31.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path31.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path34.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path34.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path34.join(baseDir, "requirements.txt");
     if (fs17.existsSync(pyprojectTomlPath)) {
       const content = fs17.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -45240,7 +46395,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path31.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path34.join(baseDir, "Cargo.toml");
     if (fs17.existsSync(cargoTomlPath)) {
       const content = fs17.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -45251,9 +46406,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path31.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path31.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path31.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path34.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path34.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path34.join(baseDir, "tests.ps1");
     if (fs17.existsSync(pesterConfigPath) || fs17.existsSync(pesterConfigJsonPath) || fs17.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -45282,12 +46437,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path31.isAbsolute(file3) ? path31.resolve(file3) : path31.resolve(workingDir, file3);
+  return path34.isAbsolute(file3) ? path34.resolve(file3) : path34.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path31.relative(workingDir, absolutePath);
+  return path34.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -45324,18 +46479,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path31.dirname(relativePath);
+  const relativeDir = path34.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path31.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path31.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path34.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path34.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path31.join(workingDir, "src/test/java", path31.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path34.join(workingDir, "src/test/java", path34.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path31.join(workingDir, "src/test/kotlin", path31.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path34.join(workingDir, "src/test/kotlin", path34.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -45363,23 +46518,23 @@ function isLanguageSpecificTestFile(basename5) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename5 = path31.basename(filePath);
+  const basename5 = path34.basename(filePath);
   return hasCompoundTestExtension(basename5) || basename5.includes(".spec.") || basename5.includes(".test.") || isLanguageSpecificTestFile(basename5) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path31.relative(workingDir, absoluteFile);
-    const basename5 = path31.basename(absoluteFile);
-    const dirname13 = path31.dirname(absoluteFile);
-    const preferRelativeOutput = !path31.isAbsolute(file3);
+    const relativeFile = path34.relative(workingDir, absoluteFile);
+    const basename5 = path34.basename(absoluteFile);
+    const dirname16 = path34.dirname(absoluteFile);
+    const preferRelativeOutput = !path34.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename5.replace(/\.[^.]+$/, "");
-    const ext = path31.extname(basename5);
+    const ext = path34.extname(basename5);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -45388,7 +46543,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path31.join(dirname13, candidateName));
+    ].map((candidateName) => path34.join(dirname16, candidateName));
     const testDirectoryNames = [
       basename5,
       ...genericTestNames,
@@ -45397,8 +46552,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path31.join(dirname13, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path31.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path34.join(dirname16, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path34.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs17.existsSync(testFile)) {
@@ -45419,7 +46574,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs17.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path31.dirname(absoluteTestFile);
+      const testDir = path34.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -45427,8 +46582,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path31.resolve(testDir, importPath);
-          const existingExt = path31.extname(resolvedImport);
+          resolvedImport = path34.resolve(testDir, importPath);
+          const existingExt = path34.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -45448,12 +46603,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path31.basename(resolvedImport, path31.extname(resolvedImport));
-        const importDir = path31.dirname(resolvedImport);
+        const importBasename = path34.basename(resolvedImport, path34.extname(resolvedImport));
+        const importDir = path34.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path31.dirname(sourceFile);
-          const sourceBasename = path31.basename(sourceFile, path31.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path31.join(sourceDir, "__tests__") || importDir === path31.join(sourceDir, "tests") || importDir === path31.join(sourceDir, "test") || importDir === path31.join(sourceDir, "spec");
+          const sourceDir = path34.dirname(sourceFile);
+          const sourceBasename = path34.basename(sourceFile, path34.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path34.join(sourceDir, "__tests__") || importDir === path34.join(sourceDir, "tests") || importDir === path34.join(sourceDir, "test") || importDir === path34.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -45466,8 +46621,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path31.resolve(testDir, importPath);
-          const existingExt = path31.extname(resolvedImport);
+          let resolvedImport = path34.resolve(testDir, importPath);
+          const existingExt = path34.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -45484,12 +46639,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path31.dirname(resolvedImport);
-          const importBasename = path31.basename(resolvedImport, path31.extname(resolvedImport));
+          const importDir = path34.dirname(resolvedImport);
+          const importBasename = path34.basename(resolvedImport, path34.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path31.dirname(sourceFile);
-            const sourceBasename = path31.basename(sourceFile, path31.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path31.join(sourceDir, "__tests__") || importDir === path31.join(sourceDir, "tests") || importDir === path31.join(sourceDir, "test") || importDir === path31.join(sourceDir, "spec");
+            const sourceDir = path34.dirname(sourceFile);
+            const sourceBasename = path34.basename(sourceFile, path34.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path34.join(sourceDir, "__tests__") || importDir === path34.join(sourceDir, "tests") || importDir === path34.join(sourceDir, "test") || importDir === path34.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -45592,8 +46747,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs17.existsSync(path31.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs17.existsSync(path31.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs17.existsSync(path34.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs17.existsSync(path34.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -45610,7 +46765,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs17.existsSync(path31.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs17.existsSync(path34.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -46263,7 +47418,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path31.extname(file3).toLowerCase();
+          const ext = path34.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -46298,7 +47453,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path31.extname(f).toLowerCase();
+          const ext = path34.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -46325,7 +47480,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path31.extname(f).toLowerCase();
+          const ext = path34.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -46343,8 +47498,8 @@ var init_test_runner = __esm(() => {
           const impactResult = await analyzeImpact(sourceFiles, workingDir);
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path31.relative(workingDir, absPath);
-              return path31.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path34.relative(workingDir, absPath);
+              return path34.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -46420,7 +47575,7 @@ var init_test_runner = __esm(() => {
 
 // src/services/preflight-service.ts
 import * as fs18 from "fs";
-import * as path32 from "path";
+import * as path35 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -46428,8 +47583,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path32.normalize(dir);
-  const absolutePath = path32.isAbsolute(normalized) ? normalized : path32.resolve(normalized);
+  const normalized = path35.normalize(dir);
+  const absolutePath = path35.isAbsolute(normalized) ? normalized : path35.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -46452,7 +47607,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path32.join(dir, "package.json");
+    const packagePath = path35.join(dir, "package.json");
     if (fs18.existsSync(packagePath)) {
       const content = fs18.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -46463,7 +47618,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path32.join(dir, "CHANGELOG.md");
+    const changelogPath = path35.join(dir, "CHANGELOG.md");
     if (fs18.existsSync(changelogPath)) {
       const content = fs18.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -46477,7 +47632,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path32.join(dir, file3);
+    const filePath = path35.join(dir, file3);
     if (fs18.existsSync(filePath)) {
       try {
         const content = fs18.readFileSync(filePath, "utf-8").trim();
@@ -46493,9 +47648,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals18.getPackageVersion(dir);
-    const changelogVersion = _internals18.getChangelogVersion(dir);
-    const versionFileVersion = _internals18.getVersionFileVersion(dir);
+    const packageVersion = _internals19.getPackageVersion(dir);
+    const changelogVersion = _internals19.getChangelogVersion(dir);
+    const versionFileVersion = _internals19.getVersionFileVersion(dir);
     const versions3 = [];
     if (packageVersion)
       versions3.push(`package.json: ${packageVersion}`);
@@ -46804,7 +47959,7 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path32.join(dir, ".swarm", "spec.md");
+    const specPath = path35.join(dir, ".swarm", "spec.md");
     if (!fs18.existsSync(specPath)) {
       return {
         type: "req_coverage",
@@ -46845,7 +48000,7 @@ async function runPreflight(dir, phase, config3) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals18.validateDirectoryPath(dir);
+    validatedDir = _internals19.validateDirectoryPath(dir);
   } catch (error93) {
     return {
       id: reportId,
@@ -46865,7 +48020,7 @@ async function runPreflight(dir, phase, config3) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals18.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals19.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error93) {
     return {
       id: reportId,
@@ -46906,12 +48061,12 @@ async function runPreflight(dir, phase, config3) {
   });
   const checks5 = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals18.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals19.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks5.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals18.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals19.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks5.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -46923,7 +48078,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals18.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals19.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -46935,7 +48090,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals18.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals19.runEvidenceCheck(validatedDir);
     checks5.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -46946,12 +48101,12 @@ async function runPreflight(dir, phase, config3) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals18.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals19.runRequirementCoverageCheck(validatedDir, phase);
   checks5.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals18.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals19.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -47014,10 +48169,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals18.runPreflight(directory, phase);
-  return _internals18.formatPreflightMarkdown(report);
+  const report = await _internals19.runPreflight(directory, phase);
+  return _internals19.formatPreflightMarkdown(report);
 }
-var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals18;
+var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals19;
 var init_preflight_service = __esm(() => {
   init_manager2();
   init_manager();
@@ -47034,7 +48189,7 @@ var init_preflight_service = __esm(() => {
     testScope: "convention",
     linter: "biome"
   };
-  _internals18 = {
+  _internals19 = {
     runPreflight,
     formatPreflightMarkdown,
     handlePreflightCommand,
@@ -47921,7 +49076,7 @@ var init_manager3 = __esm(() => {
 
 // src/commands/reset.ts
 import * as fs19 from "fs";
-import * as path33 from "path";
+import * as path36 from "path";
 async function handleResetCommand(directory, args) {
   const hasConfirm = args.includes("--confirm");
   if (!hasConfirm) {
@@ -47961,7 +49116,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path33.join(directory, filename);
+      const rootPath = path36.join(directory, filename);
       if (fs19.existsSync(rootPath)) {
         fs19.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -48001,7 +49156,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs20 from "fs";
-import * as path34 from "path";
+import * as path37 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -48016,13 +49171,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path34.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path37.dirname(validateSwarmPath(directory, "session/state.json"));
     if (fs20.existsSync(sessionDir)) {
       const files = fs20.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path34.join(sessionDir, file3);
+        const filePath = path37.join(sessionDir, file3);
         if (fs20.lstatSync(filePath).isFile()) {
           fs20.unlinkSync(filePath);
           deletedCount++;
@@ -48054,7 +49209,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import * as path35 from "path";
+import * as path38 from "path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -48077,7 +49232,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path35.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path38.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -48140,7 +49295,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs21 from "fs";
-import * as path36 from "path";
+import * as path39 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -48205,8 +49360,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path36.join(checkpointDir, file3);
-    const dest = path36.join(swarmDir, file3);
+    const src = path39.join(checkpointDir, file3);
+    const dest = path39.join(swarmDir, file3);
     try {
       fs21.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -48225,12 +49380,12 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path36.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path39.join(swarmDir, "plan-ledger.jsonl");
   if (fs21.existsSync(existingLedgerPath)) {
     fs21.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path36.join(swarmDir, "plan.json");
+    const planJsonPath = path39.join(swarmDir, "plan.json");
     if (fs21.existsSync(planJsonPath)) {
       const planRaw = fs21.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -48291,7 +49446,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals9.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals10.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -48321,9 +49476,9 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs22 = await import("fs/promises");
-    const path37 = await import("path");
-    const reportPath = path37.join(directory, ".swarm", "simulate-report.md");
-    await fs22.mkdir(path37.dirname(reportPath), { recursive: true });
+    const path40 = await import("path");
+    const reportPath = path40.join(directory, ".swarm", "simulate-report.md");
+    await fs22.mkdir(path40.dirname(reportPath), { recursive: true });
     await fs22.writeFile(reportPath, report, "utf-8");
   } catch (err) {
     const writeErr = err instanceof Error ? err.message : String(err);
@@ -48345,6 +49500,158 @@ async function handleSpecifyCommand(_directory, args) {
   return "[MODE: SPECIFY] Please enter MODE: SPECIFY and generate a spec for this project.";
 }
 
+// src/turbo/lean/state.ts
+import * as fs22 from "fs";
+import * as path40 from "path";
+function nowISO2() {
+  return new Date().toISOString();
+}
+function ensureSwarmDir2(directory) {
+  const swarmDir = path40.resolve(directory, ".swarm");
+  if (!fs22.existsSync(swarmDir)) {
+    fs22.mkdirSync(swarmDir, { recursive: true });
+  }
+  return swarmDir;
+}
+function emptyCounters2() {
+  return {
+    lanesPlanned: 0,
+    lanesStarted: 0,
+    lanesCompleted: 0,
+    lanesFailed: 0,
+    tasksSerialized: 0,
+    tasksDegraded: 0
+  };
+}
+function emptyRunState(sessionID, maxParallelCoders) {
+  return {
+    status: "idle",
+    sessionID,
+    strategy: "lean",
+    maxParallelCoders,
+    lanes: [],
+    degradedTasks: [],
+    serializedTasks: [],
+    counters: emptyCounters2()
+  };
+}
+function emptyPersisted2() {
+  return {
+    version: 1,
+    updatedAt: nowISO2(),
+    sessions: {}
+  };
+}
+function isStateUnreadable(directory) {
+  return stateUnreadableMap.get(directory) ?? false;
+}
+function markStateUnreadable2(directory, reason) {
+  stateUnreadableMap.set(directory, true);
+  error(`[turbo/lean/state] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
+}
+function readPersisted2(directory) {
+  try {
+    const filePath = path40.join(directory, ".swarm", STATE_FILE2);
+    if (!fs22.existsSync(filePath)) {
+      const seed = emptyPersisted2();
+      try {
+        ensureSwarmDir2(directory);
+        fs22.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+`, "utf-8");
+      } catch {}
+      return seed;
+    }
+    const raw = fs22.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
+      markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
+      return null;
+    }
+    return {
+      version: 1,
+      updatedAt: parsed.updatedAt ?? nowISO2(),
+      sessions: parsed.sessions
+    };
+  } catch (error93) {
+    const reason = error93 instanceof Error ? error93.message : String(error93);
+    markStateUnreadable2(directory, reason);
+    return null;
+  }
+}
+function writePersisted2(directory, persisted) {
+  if (stateUnreadableMap.get(directory)) {
+    throw new Error(`Lean Turbo state is unreadable. Please repair .swarm/${STATE_FILE2} before continuing.`);
+  }
+  let filePath;
+  let tmpPath;
+  let payload;
+  try {
+    ensureSwarmDir2(directory);
+    filePath = path40.join(directory, ".swarm", STATE_FILE2);
+    tmpPath = `${filePath}.tmp.${Date.now()}`;
+    persisted.updatedAt = nowISO2();
+    payload = `${JSON.stringify(persisted, null, 2)}
+`;
+  } catch (error93) {
+    const msg = error93 instanceof Error ? error93.message : String(error93);
+    error(`[turbo/lean/state] Failed to prepare ${STATE_FILE2} write: ${msg}`);
+    throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
+  }
+  try {
+    fs22.writeFileSync(tmpPath, payload, "utf-8");
+    fs22.renameSync(tmpPath, filePath);
+  } catch (error93) {
+    const msg = error93 instanceof Error ? error93.message : String(error93);
+    error(`[turbo/lean/state] Failed to persist ${STATE_FILE2} atomically: ${msg}`);
+    try {
+      if (fs22.existsSync(tmpPath)) {
+        fs22.unlinkSync(tmpPath);
+      }
+    } catch {}
+    throw new Error(`Lean Turbo state persistence failed: ${msg}`);
+  }
+}
+function loadLeanTurboRunState(directory, sessionID) {
+  if (stateUnreadableMap.get(directory))
+    return null;
+  const persisted = readPersisted2(directory);
+  if (!persisted)
+    return null;
+  return persisted.sessions[sessionID] ?? null;
+}
+function saveLeanTurboRunState(directory, runState) {
+  if (stateUnreadableMap.get(directory)) {
+    throw new Error(`Lean Turbo state is unreadable for ${directory}. Please repair .swarm/${STATE_FILE2} before continuing.`);
+  }
+  const persisted = readPersisted2(directory);
+  if (!persisted) {
+    throw new Error(`Lean Turbo state is unreadable for ${directory}. Please repair .swarm/${STATE_FILE2} before continuing.`);
+  }
+  persisted.sessions[runState.sessionID] = runState;
+  writePersisted2(directory, persisted);
+}
+function pauseLeanTurboRun(directory, sessionID, reason) {
+  if (stateUnreadableMap.get(directory)) {
+    throw new Error(`Lean Turbo state is unreadable for ${directory}. Please repair .swarm/${STATE_FILE2} before continuing.`);
+  }
+  const persisted = readPersisted2(directory);
+  if (!persisted) {
+    throw new Error(`Lean Turbo state is unreadable for ${directory}. Please repair .swarm/${STATE_FILE2} before continuing.`);
+  }
+  const state = persisted.sessions[sessionID];
+  if (!state)
+    return;
+  state.status = "paused";
+  state.pauseReason = reason;
+  persisted.sessions[sessionID] = state;
+  writePersisted2(directory, persisted);
+}
+var STATE_FILE2 = "turbo-state.json", stateUnreadableMap;
+var init_state3 = __esm(() => {
+  init_logger();
+  stateUnreadableMap = new Map;
+});
+
 // src/services/compaction-service.ts
 function makeInitialState() {
   return {
@@ -48408,66 +49715,126 @@ var init_context_budget_service = __esm(() => {
 // src/services/status-service.ts
 async function getStatusData(directory, agents) {
   const plan = await loadPlan(directory);
+  let status;
   if (plan && plan.migration_status !== "migration_failed") {
-    const currentPhase2 = extractCurrentPhaseFromPlan(plan) || "Unknown";
-    let completedTasks2 = 0;
-    let totalTasks2 = 0;
+    const currentPhase = extractCurrentPhaseFromPlan(plan) || "Unknown";
+    let completedTasks = 0;
+    let totalTasks = 0;
     for (const phase of plan.phases) {
       for (const task of phase.tasks) {
-        totalTasks2++;
+        totalTasks++;
         if (task.status === "completed")
-          completedTasks2++;
+          completedTasks++;
       }
     }
-    const agentCount2 = Object.keys(agents).length;
-    const metrics2 = getCompactionMetrics();
-    return {
+    const agentCount = Object.keys(agents).length;
+    const metrics = getCompactionMetrics();
+    status = {
       hasPlan: true,
-      currentPhase: currentPhase2,
-      completedTasks: completedTasks2,
-      totalTasks: totalTasks2,
-      agentCount: agentCount2,
+      currentPhase,
+      completedTasks,
+      totalTasks,
+      agentCount,
       isLegacy: false,
       turboMode: hasActiveTurboMode(),
       contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
-      compactionCount: metrics2.compactionCount,
-      lastSnapshotAt: metrics2.lastSnapshotAt
+      compactionCount: metrics.compactionCount,
+      lastSnapshotAt: metrics.lastSnapshotAt
     };
+  } else {
+    const planContent = await readSwarmFileAsync(directory, "plan.md");
+    if (!planContent) {
+      const metrics = getCompactionMetrics();
+      status = {
+        hasPlan: false,
+        currentPhase: "Unknown",
+        completedTasks: 0,
+        totalTasks: 0,
+        agentCount: Object.keys(agents).length,
+        isLegacy: true,
+        turboMode: hasActiveTurboMode(),
+        contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
+        compactionCount: metrics.compactionCount,
+        lastSnapshotAt: metrics.lastSnapshotAt
+      };
+    } else {
+      const currentPhase = extractCurrentPhase(planContent) || "Unknown";
+      const completedTasks = (planContent.match(/^- \[x\]/gm) || []).length;
+      const incompleteTasks = (planContent.match(/^- \[ \]/gm) || []).length;
+      const totalTasks = completedTasks + incompleteTasks;
+      const agentCount = Object.keys(agents).length;
+      const metrics = getCompactionMetrics();
+      status = {
+        hasPlan: true,
+        currentPhase,
+        completedTasks,
+        totalTasks,
+        agentCount,
+        isLegacy: true,
+        turboMode: hasActiveTurboMode(),
+        contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
+        compactionCount: metrics.compactionCount,
+        lastSnapshotAt: metrics.lastSnapshotAt
+      };
+    }
   }
-  const planContent = await readSwarmFileAsync(directory, "plan.md");
-  if (!planContent) {
-    const metrics2 = getCompactionMetrics();
-    return {
-      hasPlan: false,
-      currentPhase: "Unknown",
-      completedTasks: 0,
-      totalTasks: 0,
-      agentCount: Object.keys(agents).length,
-      isLegacy: true,
-      turboMode: hasActiveTurboMode(),
-      contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
-      compactionCount: metrics2.compactionCount,
-      lastSnapshotAt: metrics2.lastSnapshotAt
-    };
+  return enrichWithLeanTurbo(status, directory);
+}
+function enrichWithLeanTurbo(status, directory) {
+  const turboMode = hasActiveTurboMode();
+  const leanActive = _internals20.hasActiveLeanTurbo();
+  let turboStrategy = "off";
+  if (leanActive) {
+    turboStrategy = "lean";
+  } else if (turboMode) {
+    turboStrategy = "standard";
   }
-  const currentPhase = extractCurrentPhase(planContent) || "Unknown";
-  const completedTasks = (planContent.match(/^- \[x\]/gm) || []).length;
-  const incompleteTasks = (planContent.match(/^- \[ \]/gm) || []).length;
-  const totalTasks = completedTasks + incompleteTasks;
-  const agentCount = Object.keys(agents).length;
-  const metrics = getCompactionMetrics();
-  return {
-    hasPlan: true,
-    currentPhase,
-    completedTasks,
-    totalTasks,
-    agentCount,
-    isLegacy: true,
-    turboMode: hasActiveTurboMode(),
-    contextBudgetPct: swarmState.lastBudgetPct > 0 ? swarmState.lastBudgetPct : null,
-    compactionCount: metrics.compactionCount,
-    lastSnapshotAt: metrics.lastSnapshotAt
-  };
+  status.turboStrategy = turboStrategy;
+  if (!leanActive) {
+    return status;
+  }
+  let leanSessionID = null;
+  for (const [sessionId, session] of swarmState.agentSessions) {
+    if (session.turboStrategy === "lean" && session.leanTurboActive === true) {
+      leanSessionID = sessionId;
+      break;
+    }
+  }
+  if (leanSessionID) {
+    const runState = _internals20.loadLeanTurboRunState(directory, leanSessionID);
+    if (runState) {
+      status.leanTurboPhase = runState.phase;
+      status.leanMaxParallelCoders = runState.maxParallelCoders;
+      status.leanPauseReason = runState.pauseReason;
+      if (!Array.isArray(runState.lanes)) {
+        runState.lanes = [];
+      }
+      let activeLanes = 0;
+      let completedLanes = 0;
+      for (const lane of runState.lanes) {
+        if (lane.status === "running")
+          activeLanes++;
+        if (lane.status === "completed")
+          completedLanes++;
+      }
+      status.leanActiveLaneCount = activeLanes;
+      status.leanCompletedLanes = completedLanes;
+      if (!Array.isArray(runState.degradedTasks)) {
+        runState.degradedTasks = [];
+        status.leanDegradedTasks = 0;
+      }
+      if (runState.degradedTasks.length > 0) {
+        status.leanDegradedTasks = runState.degradedTasks.length;
+        const summaryParts = [];
+        for (const dt of runState.degradedTasks) {
+          summaryParts.push(`${dt.taskId} (${dt.reason})`);
+        }
+        status.leanDegradationSummary = summaryParts.join("; ");
+      }
+    }
+  }
+  status.fullAutoActive = _internals20.hasActiveFullAuto();
+  return status;
 }
 function formatStatusMarkdown(status) {
   const lines = [
@@ -48477,8 +49844,36 @@ function formatStatusMarkdown(status) {
     `**Tasks**: ${status.completedTasks}/${status.totalTasks} complete`,
     `**Agents**: ${status.agentCount} registered`
   ];
-  if (status.turboMode) {
-    lines.push("", `**TURBO MODE**: active`);
+  if (status.turboStrategy && status.turboStrategy !== "off") {
+    lines.push("");
+    if (status.turboStrategy === "lean") {
+      const parts = ["lean"];
+      if (status.leanTurboPhase !== undefined) {
+        parts.push(`Phase ${status.leanTurboPhase}`);
+      }
+      if (status.leanActiveLaneCount !== undefined) {
+        const totalLanes = (status.leanActiveLaneCount ?? 0) + (status.leanCompletedLanes ?? 0);
+        parts.push(`${status.leanActiveLaneCount}/${totalLanes} lanes active`);
+      }
+      if (status.leanDegradedTasks !== undefined && status.leanDegradedTasks > 0) {
+        parts.push(`${status.leanDegradedTasks} degraded`);
+      }
+      lines.push(`**Turbo**: ${parts.join(", ")}`);
+      if (status.leanDegradationSummary) {
+        lines.push(`  - ${status.leanDegradationSummary}`);
+      }
+      if (status.leanPauseReason) {
+        lines.push(`**Lean paused**: ${status.leanPauseReason}`);
+      }
+    } else {
+      lines.push(`**Turbo**: standard`);
+    }
+    if (status.fullAutoActive) {
+      lines.push(`**Full-Auto**: active`);
+    }
+  } else if (status.turboStrategy === undefined && status.turboMode === true) {
+    lines.push("");
+    lines.push("**TURBO MODE**: active");
   }
   if (status.contextBudgetPct !== null && status.contextBudgetPct > 0) {
     const pct = status.contextBudgetPct.toFixed(1);
@@ -48502,13 +49897,20 @@ async function handleStatusCommand(directory, agents) {
   }
   return formatStatusMarkdown(statusData);
 }
+var _internals20;
 var init_status_service = __esm(() => {
   init_extractors();
   init_utils2();
   init_manager();
   init_state();
+  init_state3();
   init_compaction_service();
   init_context_budget_service();
+  _internals20 = {
+    loadLeanTurboRunState,
+    hasActiveLeanTurbo,
+    hasActiveFullAuto
+  };
 });
 
 // src/commands/status.ts
@@ -48544,7 +49946,7 @@ var init_sync_plan = __esm(() => {
 });
 
 // src/commands/turbo.ts
-async function handleTurboCommand(_directory, args, sessionID) {
+async function handleTurboCommand(directory, args, sessionID) {
   if (!sessionID || sessionID.trim() === "") {
     return "Error: No active session context. Turbo Mode requires an active session. Use /swarm turbo from within an OpenCode session, or start a session first.";
   }
@@ -48552,24 +49954,179 @@ async function handleTurboCommand(_directory, args, sessionID) {
   if (!session) {
     return "Error: No active session. Turbo Mode requires an active session to operate.";
   }
-  const arg = args[0]?.toLowerCase();
-  let newTurboMode;
-  let feedback;
-  if (arg === "on") {
-    newTurboMode = true;
-    feedback = "Turbo Mode enabled";
-  } else if (arg === "off") {
-    newTurboMode = false;
-    feedback = "Turbo Mode disabled";
+  const arg0 = args[0]?.toLowerCase();
+  const arg1 = args[1]?.toLowerCase();
+  if (arg0 === "status") {
+    return buildStatusMessage(session, directory, sessionID);
+  }
+  const isTurboOn = session.turboMode;
+  const isLeanActive = session.leanTurboActive === true;
+  const disableTurbo = (reason) => {
+    if (isLeanActive) {
+      try {
+        pauseLeanTurboRun(directory, sessionID, reason);
+      } catch (error93) {
+        error(`[turbo] pauseLeanTurboRun failed: ${error93 instanceof Error ? error93.message : String(error93)}`);
+      }
+    }
+    session.turboMode = false;
+    session.turboStrategy = undefined;
+    session.leanTurboActive = false;
+    session.leanTurboCurrentPhase = undefined;
+  };
+  if (arg0 === "off" || arg0 === "lean" && arg1 === "off") {
+    disableTurbo("/swarm turbo off");
+    return "Turbo Mode disabled";
+  }
+  if (arg0 === "standard" && arg1 === "off") {
+    disableTurbo("/swarm turbo standard off");
+    return "Turbo Mode disabled";
+  }
+  if (arg0 === undefined) {
+    if (isTurboOn) {
+      disableTurbo("/swarm turbo (toggle off)");
+      return "Turbo Mode disabled";
+    } else {
+      session.turboMode = true;
+      session.turboStrategy = "standard";
+      session.leanTurboActive = false;
+      session.leanTurboCurrentPhase = undefined;
+      return "Turbo Mode enabled";
+    }
+  }
+  if (arg0 === "on") {
+    let strategy = "standard";
+    try {
+      const { config: config3 } = loadPluginConfigWithMeta(directory);
+      if (config3.turbo?.strategy === "lean") {
+        strategy = "lean";
+      }
+    } catch (error93) {
+      warn(`[turbo] could not read config for strategy default: ${error93 instanceof Error ? error93.message : String(error93)}`);
+    }
+    if (strategy === "lean") {
+      return enableLeanTurbo(session, directory, sessionID);
+    }
+    if (isLeanActive) {
+      disableTurbo("/swarm turbo on (switching from lean)");
+    }
+    session.turboMode = true;
+    session.turboStrategy = "standard";
+    session.leanTurboActive = false;
+    session.leanTurboCurrentPhase = undefined;
+    return "Turbo Mode enabled";
+  }
+  if (arg0 === "standard" && arg1 === "on") {
+    if (isLeanActive) {
+      disableTurbo("/swarm turbo standard on (switching from lean)");
+    }
+    session.turboMode = true;
+    session.turboStrategy = "standard";
+    session.leanTurboActive = false;
+    session.leanTurboCurrentPhase = undefined;
+    return "Turbo Mode enabled (standard)";
+  }
+  if (arg0 === "lean" && arg1 === "on") {
+    return enableLeanTurbo(session, directory, sessionID);
+  }
+  if (arg0 === "lean" && arg1 === undefined) {
+    if (isLeanActive) {
+      disableTurbo("/swarm turbo lean (toggle off)");
+      return "Turbo Mode disabled";
+    } else {
+      return enableLeanTurbo(session, directory, sessionID);
+    }
+  }
+  if (isTurboOn) {
+    disableTurbo("/swarm turbo (toggle off via unknown arg)");
+    return "Turbo Mode disabled";
   } else {
-    newTurboMode = !session.turboMode;
-    feedback = newTurboMode ? "Turbo Mode enabled" : "Turbo Mode disabled";
+    session.turboMode = true;
+    session.turboStrategy = "standard";
+    session.leanTurboActive = false;
+    session.leanTurboCurrentPhase = undefined;
+    return "Turbo Mode enabled";
   }
-  session.turboMode = newTurboMode;
-  return feedback;
+}
+function enableLeanTurbo(session, directory, sessionID) {
+  let maxParallelCoders = 4;
+  let conflictPolicy = "serialize";
+  try {
+    const { config: config3 } = loadPluginConfigWithMeta(directory);
+    const leanConfig = config3.turbo?.lean;
+    if (leanConfig) {
+      maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
+      conflictPolicy = leanConfig.conflict_policy ?? "serialize";
+    }
+  } catch (error93) {
+    warn(`[turbo] could not read lean config: ${error93 instanceof Error ? error93.message : String(error93)}`);
+  }
+  let durableError;
+  try {
+    const state = emptyRunState(sessionID, maxParallelCoders);
+    state.status = "running";
+    saveLeanTurboRunState(directory, state);
+  } catch (error93) {
+    durableError = error93 instanceof Error ? error93.message : String(error93);
+    error(`[turbo] durable run-state write failed: ${durableError}`);
+  }
+  if (durableError) {
+    return [
+      "Error: Lean Turbo could NOT be enabled \u2014 durable run-state write failed.",
+      `Reason: ${durableError}.`,
+      "Inspect .swarm/ permissions and disk space, then retry."
+    ].join(" ");
+  }
+  const fullAutoActive = session.fullAutoMode;
+  session.turboMode = true;
+  session.turboStrategy = "lean";
+  session.leanTurboActive = true;
+  session.leanTurboCurrentPhase = undefined;
+  return [
+    "Lean Turbo enabled",
+    `(maxParallelCoders=${maxParallelCoders}, conflict_policy=${conflictPolicy},`,
+    `Full-Auto: ${fullAutoActive ? "active" : "inactive"})`
+  ].join(" ");
+}
+function buildStatusMessage(session, directory, sessionID) {
+  if (!session.turboMode) {
+    return "Turbo: off";
+  }
+  if (session.turboStrategy === "standard" || !session.leanTurboActive) {
+    return "Turbo: standard (turboMode=true)";
+  }
+  if (isStateUnreadable(directory)) {
+    return [
+      "Turbo: lean (turboMode=true, leanTurboActive=true)",
+      "WARNING: Durable state is unreadable \u2014 cannot report full status."
+    ].join(`
+`);
+  }
+  const state = loadLeanTurboRunState(directory, sessionID);
+  if (!state) {
+    return [
+      "Turbo: lean (turboMode=true, leanTurboActive=true)",
+      "WARNING: Durable state not found."
+    ].join(`
+`);
+  }
+  const phase = state.phase !== undefined ? `phase=${state.phase}` : "phase=unset";
+  const laneCount = state.lanes.length;
+  const degradedCount = state.degradedTasks.length;
+  const maxParallel = state.maxParallelCoders;
+  const fullAutoActive = session.fullAutoMode;
+  return [
+    `Turbo: lean (turboMode=true, leanTurboActive=true)`,
+    `Status: ${state.status}, ${phase}, lanes=${laneCount}, degraded=${degradedCount}`,
+    `maxParallelCoders=${maxParallel}, Full-Auto: ${fullAutoActive ? "active" : "inactive"}`
+  ].join(`
+`);
 }
 var init_turbo = __esm(() => {
+  init_config();
   init_state();
+  init_state3();
+  init_logger();
 });
 
 // src/commands/write-retro.ts
@@ -48693,8 +50250,8 @@ __export(exports_commands, {
   COMMAND_NAME_SET: () => COMMAND_NAME_SET,
   COMMAND_NAMES: () => COMMAND_NAMES
 });
-import fs22 from "fs";
-import path37 from "path";
+import fs23 from "fs";
+import path41 from "path";
 function buildHelpText() {
   const lines = ["## Swarm Commands", ""];
   const CATEGORIES = [
@@ -48797,11 +50354,11 @@ function createSwarmCommandHandler(directory, agents) {
       return;
     }
     let isFirstRun = false;
-    const sentinelPath = path37.join(directory, ".swarm", ".first-run-complete");
+    const sentinelPath = path41.join(directory, ".swarm", ".first-run-complete");
     try {
-      const swarmDir = path37.join(directory, ".swarm");
-      fs22.mkdirSync(swarmDir, { recursive: true });
-      fs22.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
+      const swarmDir = path41.join(directory, ".swarm");
+      fs23.mkdirSync(swarmDir, { recursive: true });
+      fs23.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
 `, { flag: "wx" });
       isFirstRun = true;
     } catch (_err) {}
@@ -48822,7 +50379,7 @@ function createSwarmCommandHandler(directory, agents) {
         const attemptedCommand = tokens[0] || "";
         const MAX_DISPLAY = 100;
         const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-        const similar = _internals19.findSimilarCommands(attemptedCommand);
+        const similar = _internals21.findSimilarCommands(attemptedCommand);
         const header = `Command \`/swarm ${displayCommand}\` not found.`;
         const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  \u2022 /swarm ${cmd}`).join(`
@@ -48929,7 +50486,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals19.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals21.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -48942,7 +50499,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals19.levenshteinDistance(qt, ct);
+          const dist = _internals21.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -48952,7 +50509,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals19.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals21.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -48984,11 +50541,11 @@ async function handleHelpCommand(ctx) {
     return buildHelpText2();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals19.resolveCommand(tokens);
+  const resolved = _internals21.resolveCommand(tokens);
   if (resolved) {
-    return _internals19.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals21.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals19.findSimilarCommands(targetCommand);
+  const similar = _internals21.findSimilarCommands(targetCommand);
   const { buildHelpText: fullHelp } = await Promise.resolve().then(() => (init_commands(), exports_commands));
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
@@ -49024,24 +50581,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path38 = [];
+      const path42 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path38.indexOf(current);
+          const cycleStart = path42.indexOf(current);
           const fullChain = [
             name,
-            ...path38.slice(0, cycleStart > 0 ? cycleStart : path38.length),
+            ...path42.slice(0, cycleStart > 0 ? cycleStart : path42.length),
             current
           ].join(" \u2192 ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path38.push(current);
+        path42.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -49082,7 +50639,7 @@ function resolveCommand(tokens) {
   }
   return null;
 }
-var COMMAND_REGISTRY, VALID_COMMANDS, _internals19, validation;
+var COMMAND_REGISTRY, VALID_COMMANDS, _internals21, validation;
 var init_registry = __esm(() => {
   init_acknowledge_spec_drift();
   init_agents();
@@ -49152,7 +50709,7 @@ var init_registry = __esm(() => {
       clashesWithNativeCcCommand: "/agents"
     },
     help: {
-      handler: (ctx) => _internals19.handleHelpCommand(ctx),
+      handler: (ctx) => _internals21.handleHelpCommand(ctx),
       description: "Show help for swarm commands",
       category: "core",
       args: "[command]",
@@ -49314,17 +50871,21 @@ var init_registry = __esm(() => {
       category: "diagnostics"
     },
     finalize: {
-      handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args),
+      handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args, {
+        sessionID: ctx.sessionID
+      }),
       description: "Use /swarm finalize to finalize the swarm project and archive evidence",
-      details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs safe git ff-only to main. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation.",
-      args: "--prune-branches",
+      details: "Idempotent 4-stage terminal finalization: (1) finalize writes retrospectives for in-progress phases, (2) archive creates timestamped bundle of swarm artifacts and evidence, (3) clean removes active-state files for a clean slate, (4) align performs safe git ff-only to main. Resets agent sessions and delegation chains. Reads .swarm/close-lessons.md for explicit lessons and runs curation. Use --skill-review to run the quota-bounded skill_improver in proposal mode.",
+      args: "--prune-branches, --skill-review",
       category: "core"
     },
     close: {
-      handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args),
+      handler: (ctx) => handleCloseCommand(ctx.directory, ctx.args, {
+        sessionID: ctx.sessionID
+      }),
       description: "Use /swarm close (deprecated alias) to finalize and archive swarm state",
       details: "Deprecated alias for /swarm finalize. Preserved for backward compatibility.",
-      args: "--prune-branches",
+      args: "--prune-branches, --skill-review",
       category: "core",
       aliasOf: "finalize",
       deprecated: true
@@ -49505,7 +51066,7 @@ var init_registry = __esm(() => {
     }
   };
   VALID_COMMANDS = Object.keys(COMMAND_REGISTRY);
-  _internals19 = {
+  _internals21 = {
     handleHelpCommand,
     validateAliases,
     resolveCommand,
@@ -49513,7 +51074,7 @@ var init_registry = __esm(() => {
     findSimilarCommands,
     buildDetailedHelp
   };
-  validation = _internals19.validateAliases();
+  validation = _internals21.validateAliases();
   if (!validation.valid) {
     throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
@@ -49531,68 +51092,68 @@ init_package();
 init_registry();
 init_cache_paths();
 init_constants();
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as os7 from "os";
-import * as path38 from "path";
+import * as path42 from "path";
 var { version: version4 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
-var OPENCODE_CONFIG_PATH = path38.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path38.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path38.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_CONFIG_PATH = path42.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path42.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path42.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
-  const resolved = path38.resolve(p);
-  const home = path38.resolve(os7.homedir());
+  const resolved = path42.resolve(p);
+  const home = path42.resolve(os7.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path38.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path42.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path38.basename(resolved);
+  const leaf = path42.basename(resolved);
   if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
     return false;
   }
-  const parent = path38.basename(path38.dirname(resolved));
+  const parent = path42.basename(path42.dirname(resolved));
   if (parent !== "packages" && parent !== "node_modules") {
     return false;
   }
-  const grandparent = path38.basename(path38.dirname(path38.dirname(resolved)));
+  const grandparent = path42.basename(path42.dirname(path42.dirname(resolved)));
   if (grandparent !== "opencode") {
     return false;
   }
   return true;
 }
 function isSafeLockFilePath(p) {
-  const resolved = path38.resolve(p);
-  const home = path38.resolve(os7.homedir());
+  const resolved = path42.resolve(p);
+  const home = path42.resolve(os7.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path38.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path42.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path38.basename(resolved);
+  const leaf = path42.basename(resolved);
   if (leaf !== "bun.lock" && leaf !== "bun.lockb" && leaf !== "package-lock.json") {
     return false;
   }
-  const parent = path38.basename(path38.dirname(resolved));
+  const parent = path42.basename(path42.dirname(resolved));
   if (parent !== "opencode") {
     return false;
   }
   return true;
 }
 function ensureDir(dir) {
-  if (!fs23.existsSync(dir)) {
-    fs23.mkdirSync(dir, { recursive: true });
+  if (!fs24.existsSync(dir)) {
+    fs24.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs23.readFileSync(filepath, "utf-8");
+    const content = fs24.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -49600,14 +51161,14 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs23.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs24.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path38.join(cwd, ".opencode");
-    const projectConfigPath = path38.join(opencodeDir, "opencode-swarm.json");
-    if (fs23.existsSync(projectConfigPath)) {
+    const opencodeDir = path42.join(cwd, ".opencode");
+    const projectConfigPath = path42.join(opencodeDir, "opencode-swarm.json");
+    if (fs24.existsSync(projectConfigPath)) {
       return;
     }
     ensureDir(opencodeDir);
@@ -49623,7 +51184,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path38.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path42.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);
@@ -49670,7 +51231,7 @@ async function install() {
     console.warn(`\u26A0 Could not clear opencode lock file \u2014 you may need to delete it manually:
   ${failed}`);
   }
-  if (!fs23.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs24.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: { ...DEFAULT_AGENT_CONFIGS },
       max_iterations: 5
@@ -49749,14 +51310,14 @@ function evictPluginCaches() {
   const cleared = [];
   const failed = [];
   for (const cachePath of OPENCODE_PLUGIN_CACHE_PATHS) {
-    if (!fs23.existsSync(cachePath))
+    if (!fs24.existsSync(cachePath))
       continue;
     if (!isSafeCachePath(cachePath)) {
       failed.push(`${cachePath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs23.rmSync(cachePath, { recursive: true, force: true });
+      fs24.rmSync(cachePath, { recursive: true, force: true });
       cleared.push(cachePath);
     } catch (err) {
       failed.push(`${cachePath} (${err instanceof Error ? err.message : String(err)})`);
@@ -49768,14 +51329,14 @@ function evictLockFiles() {
   const cleared = [];
   const failed = [];
   for (const lockPath of OPENCODE_PLUGIN_LOCK_FILE_PATHS) {
-    if (!fs23.existsSync(lockPath))
+    if (!fs24.existsSync(lockPath))
       continue;
     if (!isSafeLockFilePath(lockPath)) {
       failed.push(`${lockPath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs23.unlinkSync(lockPath);
+      fs24.unlinkSync(lockPath);
       cleared.push(lockPath);
     } catch (err) {
       const code = err?.code;
@@ -49794,7 +51355,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs23.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs24.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -49826,13 +51387,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs23.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs23.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs24.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs24.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs23.existsSync(PROMPTS_DIR)) {
-        fs23.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs24.existsSync(PROMPTS_DIR)) {
+        fs24.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }