opencode-swarm 7.99.4 → 7.99.6

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.99.4",
+    version: "7.99.6",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -17516,21 +17516,6 @@ var init_bundled_skills = __esm(() => {
   syncedProjectSkillTargets = new Set;
 });
 
-// src/utils/errors.ts
-var SwarmError;
-var init_errors3 = __esm(() => {
-  SwarmError = class SwarmError extends Error {
-    code;
-    guidance;
-    constructor(message, code, guidance) {
-      super(message);
-      this.name = "SwarmError";
-      this.code = code;
-      this.guidance = guidance;
-    }
-  };
-});
-
 // src/utils/logger.ts
 function isDebug() {
   return process.env.OPENCODE_SWARM_DEBUG === "1";
@@ -17573,6 +17558,21 @@ function error48(message, data) {
 }
 var init_logger = () => {};
 
+// src/utils/errors.ts
+var SwarmError;
+var init_errors3 = __esm(() => {
+  SwarmError = class SwarmError extends Error {
+    code;
+    guidance;
+    constructor(message, code, guidance) {
+      super(message);
+      this.name = "SwarmError";
+      this.code = code;
+      this.guidance = guidance;
+    }
+  };
+});
+
 // src/utils/regex.ts
 function escapeRegex2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -77880,6 +77880,21 @@ function emitObjectTypeMismatch(key, value, findings) {
     });
   }
 }
+function emitWorktreeIsolationLayeringAdvisory(config3, findings) {
+  const parallelization = config3.parallelization;
+  const worktreePolicy = config3.worktree?.policy ?? "auto";
+  if (parallelization?.enabled === true && (parallelization.maxConcurrentTasks ?? 1) > 1 && worktreePolicy !== "disabled") {
+    findings.push({
+      id: "worktree-isolation-baseline-active",
+      title: "Worktree isolation is already active for standard parallel coders",
+      description: "Standard parallel coders already use baseline worktree isolation through the parallel execution profile plus top-level worktree.policy. Lean Turbo and Epic are additive strategies, not requirements for obtaining worktree isolation.",
+      severity: "warn",
+      path: "worktree.policy",
+      currentValue: worktreePolicy,
+      autoFixable: false
+    });
+  }
+}
 function getUserConfigDir3() {
   return process.env.XDG_CONFIG_HOME || path69.join(os15.homedir(), ".config");
 }
@@ -78440,6 +78455,14 @@ function validateConfigKey(path70, value) {
       emitObjectTypeMismatch("summaries", value, findings);
       break;
     }
+    case "auto_review": {
+      emitObjectTypeMismatch("auto_review", value, findings);
+      break;
+    }
+    case "repo_graph": {
+      emitObjectTypeMismatch("repo_graph", value, findings);
+      break;
+    }
     case "review_passes": {
       emitObjectTypeMismatch("review_passes", value, findings);
       break;
@@ -78516,6 +78539,10 @@ function validateConfigKey(path70, value) {
       emitObjectTypeMismatch("skill_improver", value, findings);
       break;
     }
+    case "skills": {
+      emitObjectTypeMismatch("skills", value, findings);
+      break;
+    }
     case "spec_writer": {
       emitObjectTypeMismatch("spec_writer", value, findings);
       break;
@@ -78701,6 +78728,7 @@ function walkConfigAndValidate(obj, path70, findings, visited = new WeakSet) {
 function runConfigDoctor(config3, directory) {
   const findings = [];
   walkConfigAndValidate(config3, "", findings);
+  emitWorktreeIsolationLayeringAdvisory(config3, findings);
   const summary = {
     info: findings.filter((f) => f.severity === "info").length,
     warn: findings.filter((f) => f.severity === "warn").length,
@@ -101057,6 +101085,13 @@ function findSimilarCommands(query) {
   scored.sort((a, b) => a.score - b.score);
   return scored.slice(0, 3).map((s) => s.cmd);
 }
+function emitValidationWarnings(prefix, warnings) {
+  if (warnings.length === 0)
+    return;
+  warn(`${prefix}:
+${warnings.join(`
+`)}`);
+}
 function buildDetailedHelp(commandName, entry) {
   const lines = [];
   lines.push(`## /swarm ${commandName}`, "");
@@ -101191,6 +101226,7 @@ function resolveCommand(tokens) {
 var COMMAND_REGISTRY, VALID_COMMANDS, _internals15, validation;
 var init_registry = __esm(() => {
   init_bundled_skills();
+  init_logger();
   init_acknowledge_spec_drift();
   init_agents();
   init_archive();
@@ -101693,7 +101729,7 @@ Subcommands:
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handlePrReviewCommand),
       description: "Launch deep PR review with multi-lane analysis [url] [--council]",
       args: "<pr-url|owner/repo#N|N> [--council]",
-      details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, runs 6 parallel explorer lanes through the deterministic dispatch_lanes join barrier (correctness, security, dependencies, docs-intent-vs-actual, tests, performance-architecture), validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, synthesizes structured report. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
+      details: "Launches a structured PR review: reconstructs PR intent via obligation extraction cascade, launches all 6 fixed base explorer lanes through dispatch_lanes_async while the architect keeps doing non-dependent work, polls collect_lane_results incrementally, runs every triggered micro-lane, validates findings through independent reviewer confirmation, applies critic challenge to HIGH/CRITICAL findings, then synthesizes only after coverage is closed. If lane tools cannot close coverage, Task-tool dispatch is the final verified-equivalent fallback; if equivalence cannot be proven, the review is BLOCKED rather than degraded. --council variant fires adversarial multi-model review. Supports full GitHub URL, owner/repo#N shorthand, or bare PR number (resolves against origin remote).",
       category: "agent",
       toolPolicy: "none"
     },
@@ -102119,6 +102155,7 @@ Subcommands:
     handleHelpCommand,
     validateAliases,
     validateToolPolicy,
+    emitValidationWarnings,
     resolveCommand,
     levenshteinDistance: levenshteinDistance2,
     findSimilarCommands,
@@ -102130,20 +102167,12 @@ Subcommands:
 ${validation.errors.join(`
 `)}`);
   }
-  if (validation.warnings.length > 0) {
-    console.warn(`COMMAND_REGISTRY alias warnings:
-${validation.warnings.join(`
-`)}`);
-  }
+  _internals15.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
   try {
     const toolPolicyValidation = _internals15.validateToolPolicy();
-    if (toolPolicyValidation.warnings.length > 0) {
-      console.warn(`COMMAND_REGISTRY toolPolicy warnings:
-${toolPolicyValidation.warnings.join(`
-`)}`);
-    }
+    _internals15.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
   } catch (e) {
-    console.warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
+    warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
   }
 });
 
@@ -102726,6 +102755,8 @@ If a tool modifies a file, it is a CODER tool. Delegate.
 2. ONE agent per message. Send, STOP, wait for response.
    Exception: Stage B reviewer/test_engineer gate agents for the SAME completed coder task may be dispatched together before waiting when both gates are required. This exception NEVER applies to coder delegations. Preserve ONE task per coder call.
    Separate parallel-mode exception (distinct from the Stage B exception above, and the ONLY case where more than one coder may be dispatched before waiting): when an active \`[PARALLEL EXECUTION PROFILE]\` directive is present in your context (parallelization_enabled=true), you MAY dispatch multiple {{AGENT_PREFIX}}coder agents in a single message — up to the stated max_concurrent_tasks — but ONLY for distinct, dependency-ready tasks whose declared file scopes do NOT overlap. Each coder still requires its own \`declare_scope\` call and carries exactly ONE task (Rule 3 still holds: never batch multiple objectives into one coder). Parallel coders each run in an isolated git worktree, so their writes never collide and are merged back automatically. If no \`[PARALLEL EXECUTION PROFILE]\` directive is present, dispatch coders one at a time.
+
+    > **WORKTREE ISOLATION IS BASELINE.** Standard parallel coders use isolated git worktrees by default; this is governed by the top-level \`worktree.policy\` setting (default \`auto\`) in \`PluginConfig\` — a sibling of \`parallelization:\`, not nested under it — and is active whenever the plan's \`parallelization_enabled=true\`. \`turbo.lean.worktree_isolation\` is a separate, Lean-Turbo-internal flag (default \`false\`); it is one possible SOURCE but NOT the recommended one. Do NOT recommend Lean Turbo (or Epic) SOLELY to obtain worktree isolation; recommend them only for what they add beyond baseline (Lean Turbo: lane planning, file locks, phase reviewer, integrated diff; Epic: co-change awareness + auto-decide). Lean Turbo users can also enable isolation via \`turbo.lean.worktree_isolation: true\`, but this is the secondary/legacy path — the recommended path is \`worktree.policy\`.
    Read-only advisory-lane exception (NON-BLOCKING; distinct from both exceptions above): the "Send, STOP, wait" rule governs MUTATION delegations (coder, and the test_engineer/reviewer Stage B completion gates). It does NOT govern read-only advisory exploration/review lanes. When you dispatch read-only advisory lanes — \`{{AGENT_PREFIX}}explorer\`, \`{{AGENT_PREFIX}}sme\`, \`{{AGENT_PREFIX}}researcher\`, the council members (\`council_generalist\`/\`council_skeptic\`/\`council_domain_expert\`), or an advisory \`{{AGENT_PREFIX}}critic\` lane — use the NON-BLOCKING path so you keep working while they run. Dispatch PROMPTLY: emit the \`dispatch_lanes_async\` call EARLY with compact lane prompts — do not accumulate long planning prose or build oversized inline prompts first, or the tool call can be truncated out of your message and the lanes never launch (a real failure mode on smaller models). The lane mechanism is a SINGLE \`dispatch_lanes_async\` call carrying all lane specs — NOT a per-agent Task/run-in-background pattern. Call \`dispatch_lanes_async\` with all lane specs in one call, record the returned \`batch_id\`, then IMMEDIATELY continue non-dependent architect work (refine the plan/obligation ledger, inspect metadata, prepare the synthesis/reviewer structure, run deterministic read-only tools). Poll incrementally with \`collect_lane_results\` without \`wait\` (or with \`wait: false\`) to harvest lanes as they settle; process completed lane output immediately while other lanes remain pending/running, then continue independent work between polls. Do NOT sit idle waiting on running lanes, and do NOT synthesize findings from still-running lanes. Join later by calling \`collect_lane_results\` with \`wait: true\` as the explicit barrier immediately before you synthesize. Use blocking \`dispatch_lanes\` only when \`dispatch_lanes_async\`/promptAsync is unavailable. Keep each lane prompt compact: send large shared context (PR diff, ledger, scope) ONCE via the \`common_prompt\` field, or have lanes read it from a file by absolute path, instead of inlining the same blob into every lane prompt — inlining large context into many lanes is what produces malformed or truncated tool-call JSON and forces clumsy file workarounds. This non-blocking exception applies ONLY to read-only advisory lanes; it NEVER applies to coder delegations, to the test_engineer/reviewer Stage B completion gates, or to the critic PLAN-review gate, which all still follow "Send, STOP, wait" (or the Stage B parallel-dispatch exception above).
 3. ONE task per {{AGENT_PREFIX}}coder call. Never batch.
 3a. PRE-DELEGATION SCOPE CALL (required): BEFORE every {{AGENT_PREFIX}}coder delegation, you MUST call \`declare_scope\` with { taskId, files } listing the exact file(s) this task will modify (including generated/lockfile paths). No \`declare_scope\` call → no coder delegation. See Rule 1a.
@@ -103331,6 +103362,7 @@ ACTION: Load skill file:.opencode/skills/pre-phase-briefing/SKILL.md immediately
 
 HARD CONSTRAINTS:
 - Complete the codebase reality report before spec finalization, plan generation, plan ingestion, declare_scope, or starting/resuming phase implementation. Dispatching the reality-check lanes asynchronously is allowed and preferred; settling all lanes before any of that downstream work is not optional.
+- When reality-check lanes are dispatched asynchronously, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 
 ### MODE: COUNCIL
 Activates when the user invokes /swarm council or requests a council-style decision review.
@@ -103341,6 +103373,7 @@ ACTION: Load skill file:.opencode/skills/council/SKILL.md immediately. Follow th
 
 HARD CONSTRAINTS:
 - Provide research context up front and synthesize only from returned council member responses.
+- For async council lanes, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 
 ### MODE: DEEP_DIVE
 Activates when: architect receives \`[MODE: DEEP_DIVE profile=X max_explorers=N output=X update_main=X allow_dirty=X] <scope>\` signal from the deep-dive command handler.
@@ -103357,6 +103390,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - No final finding may appear in the report without reviewer verification
 - Explorers generate candidate findings only — reviewers verify or reject
 - Critics challenge only HIGH/CRITICAL findings — do NOT waste cycles on lower severity
+- For async explorer waves, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 
 ### MODE: LOOP
 Activates when: architect receives \`[MODE: LOOP max_cycles=N autonomy=checkpoint|auto depth=standard|exhaustive resume=true|false] <objective>\` signal from the loop command handler.
@@ -103390,6 +103424,8 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Critics challenge only high-stakes / contested claims — do NOT waste cycles on well-supported ones
 - If council.general.enabled is false or no search API key is configured, surface that and STOP — do not produce ungrounded research
 
+- For async synthesis lanes, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
+
 ### MODE: CODEBASE_REVIEW
 Activates when: architect receives \`[MODE: CODEBASE_REVIEW mode=X output=X update_main=X allow_dirty=X tracks="..." continue_run="..."] scope="..."\` signal from the codebase-review command handler.
 
@@ -103409,6 +103445,8 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Every repo-derived factual claim needs quote-grounded evidence with file path and line/range
 - Final report is forbidden until selected-track coverage is closed and final critic passes
 
+- For async inventory or candidate-generation lanes, record the \`batch_id\`, keep doing non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
+
 ### MODE: DESIGN_DOCS
 Activates when: architect receives \`[MODE: DESIGN_DOCS out=X lang=X update=X] <description>\` signal from the design-docs command handler (issue #1080).
 
@@ -103440,9 +103478,11 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - No finding may appear as CONFIRMED in the final report without reviewer validation provenance
 - Test execution, explorer lanes, reviewer dispatch, and critic challenge are all permitted within this mode
 - Quality is the only metric — time, tokens, and agent dispatches are irrelevant to correctness
-- FOLLOW THE SKILL EXACTLY: execute every phase of the loaded SKILL.md in order with no shortcuts, no phase-skipping, and no premature synthesis. If a phase cannot complete, state the limitation explicitly and continue — do not silently skip it.
+- FOLLOW THE SKILL EXACTLY: execute every phase of the loaded SKILL.md in order with no shortcuts, no phase-skipping, and no premature synthesis. If a required coverage phase cannot complete, apply the skill's coverage gate (retry or verified equivalent alternative). If the gap still cannot be closed, stop and surface the lane failure to the user as BLOCKED; do not produce a degraded review, partial verdict, or final synthesis.
 - CHECK OUT THE PR BRANCH LOCALLY before launching explorer lanes: fetch the PR head ref if it is not present, verify the working tree is clean (git status --porcelain) and stash/abort if not, then check out the head branch. Explorers read the working-tree filesystem (Read/Glob/Grep), so without a checkout they read the base branch and produce invalid candidates. Always pass the base..head commit range in explorer delegations.
-- RUN THE TRIGGERED MICRO-LANES: after the base explorer lanes start, inspect the context pack risk triggers and launch every matching Swarm plugin micro-lane from the skill's risk-trigger map (launch only triggered lanes, never irrelevant ones). Do not skip micro-lanes that match the diff.
+- RUN ALL BASE LANES: the default PR_REVIEW path always launches the fixed six base check-type lanes from the skill (correctness, security, dependencies/deployment, docs/intent, tests, performance/architecture). Do not collapse, omit, or scale down the base lanes for a small, docs-only, or CI-only PR.
+- USE ASYNC DISPATCH WITHOUT IDLING: launch the base lanes with one \`dispatch_lanes_async\` call when available, record the \`batch_id\`, then keep doing non-dependent architect work while they run. Poll with \`collect_lane_results\` without \`wait\` (or \`wait: false\`) to process settled lanes and continue independent work between polls; use \`wait: true\` only as the final join when no independent work remains.
+- RUN THE TRIGGERED MICRO-LANES: after the base explorer lanes settle, inspect the context pack risk triggers and launch every matching Swarm plugin micro-lane from the skill's risk-trigger map (launch only triggered lanes, never irrelevant ones). Do not skip micro-lanes that match the diff; when multiple micro-lanes are needed, dispatch them with \`dispatch_lanes_async\` and the same non-idling incremental collection pattern.
 - Honor any free-text instructions that follow the closing bracket of the signal as additional reviewer focus, without weakening the validation ladder above.
 
 ### MODE: PR_FEEDBACK
@@ -103457,6 +103497,7 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - CHECK OUT THE PR BRANCH LOCALLY before verifying feedback or making fixes: fetch the PR head ref if absent, verify the working tree is clean (git status --porcelain) and stash/abort if not, then check out the head branch. Feedback verification and fix validation require the PR branch in the working tree.
 - Do NOT run a fresh broad PR review — inspect adjacent code only as needed to verify reachability, dependencies, shared root causes, regression risk, or sibling changes for a confirmed item.
 - Treat every review comment, CI failure, bot summary, and pasted note as a CLAIM until source evidence proves it; classify each ledger item (CONFIRMED, DISPROVED, PRE_EXISTING, or NEEDS_USER_DECISION) and never silently drop, defer, or mark items out of scope.
+- For async verification lanes, record the \`batch_id\`, keep doing ledger-safe non-dependent architect work, poll with \`collect_lane_results\` without \`wait\`, process settled lanes immediately, and use \`wait: true\` only when no independent work remains.
 - Patch only confirmed items plus the tests/docs they require; report closure status for every ledger item including disproved ones.
 - Do NOT resolve or mark GitHub review threads resolved unless the user explicitly instructs it.
 - Honor any free-text instructions that follow the closing bracket of the signal as additional scope, without dropping any ledger item.
@@ -116535,6 +116576,7 @@ var SUPPORTED_EXTENSIONS = new Set(LANGUAGE_REGISTRY.getAll().filter((p) => !p.p
 var DEFAULT_WALK_FILE_CAP = 1e4;
 var DEFAULT_WALK_BUDGET_MS = 5000;
 var ASYNC_WALK_YIELD_INTERVAL = 200;
+var MAX_DIAGNOSTIC_ENTRIES = 200;
 var EXTENSION_TO_LANGUAGE = {};
 for (const profile of LANGUAGE_REGISTRY.getAll()) {
   if (profile.parserOnly)
@@ -116665,6 +116707,64 @@ function isRefusedWorkspaceRoot(target) {
   }
   return refused.has(resolved);
 }
+function createEmptyDiagnostics() {
+  return {
+    extractionFailures: [],
+    unresolvedImports: [],
+    oversizedFiles: [],
+    unsupportedFiles: [],
+    binaryFiles: [],
+    unreadableFiles: [],
+    lowConfidenceEdgeCount: 0
+  };
+}
+function diagnosticsHaveEntries(diagnostics) {
+  return (diagnostics.extractionFailures?.length ?? 0) > 0 || (diagnostics.unresolvedImports?.length ?? 0) > 0 || (diagnostics.oversizedFiles?.length ?? 0) > 0 || (diagnostics.unsupportedFiles?.length ?? 0) > 0 || (diagnostics.binaryFiles?.length ?? 0) > 0 || (diagnostics.unreadableFiles?.length ?? 0) > 0 || (diagnostics.lowConfidenceEdgeCount ?? 0) > 0;
+}
+function pushCapped(target, value) {
+  if (target.length < MAX_DIAGNOSTIC_ENTRIES) {
+    target.push(value);
+  }
+}
+function mergeDiagnostics(target, source) {
+  if (!source)
+    return;
+  for (const entry of source.extractionFailures ?? []) {
+    pushCapped(target.extractionFailures, entry);
+  }
+  for (const entry of source.unresolvedImports ?? []) {
+    pushCapped(target.unresolvedImports, entry);
+  }
+  for (const entry of source.oversizedFiles ?? []) {
+    pushCapped(target.oversizedFiles, entry);
+  }
+  for (const entry of source.unsupportedFiles ?? []) {
+    pushCapped(target.unsupportedFiles, entry);
+  }
+  for (const entry of source.binaryFiles ?? []) {
+    pushCapped(target.binaryFiles, entry);
+  }
+  for (const entry of source.unreadableFiles ?? []) {
+    pushCapped(target.unreadableFiles, entry);
+  }
+  target.lowConfidenceEdgeCount += source.lowConfidenceEdgeCount ?? 0;
+}
+function isRelativeImportSpecifier(specifier) {
+  return specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+}
+function unresolvedRelativeImportsFor(parsedImports, filePath, absoluteRoot) {
+  const unresolved = [];
+  const moduleName = toModuleName(filePath, absoluteRoot);
+  for (const parsed of parsedImports) {
+    if (!isRelativeImportSpecifier(parsed.specifier))
+      continue;
+    const resolvedTarget = resolveModuleSpecifier(absoluteRoot, filePath, parsed.specifier);
+    if (resolvedTarget === null) {
+      unresolved.push({ file: moduleName, specifier: parsed.specifier });
+    }
+  }
+  return unresolved;
+}
 var REGEX_ALLOWED_AFTER = new Set("(,=:[!&|?{};*+-~^<>%".split(""));
 function stripComments2(content) {
   let out = "";
@@ -116857,6 +116957,28 @@ function computeUsedSymbols(strippedContent, bindings) {
   }
   return [...used].sort((a, b) => a.localeCompare(b));
 }
+function usedSymbolsForImport(parsed, strippedContent) {
+  if (parsed.importType === "namespace" || parsed.importType === "sideeffect" || parsed.importType === "require") {
+    return;
+  }
+  if (parsed.reExport) {
+    return [...new Set(parsed.bindings.map((b) => b.imported))].sort((a, b) => a.localeCompare(b));
+  }
+  return computeUsedSymbols(strippedContent, parsed.bindings);
+}
+function collectExports(symbols2) {
+  const exported = symbols2.filter((s) => s.exported);
+  const exports = exported.map((s) => s.signature === `default ${s.name}` ? "default" : s.name);
+  const exportLines = {};
+  for (let i = 0;i < exported.length; i++) {
+    const s = exported[i];
+    const name = exports[i];
+    if (typeof s.line === "number" && Number.isFinite(s.line) && exportLines[name] === undefined) {
+      exportLines[name] = s.line;
+    }
+  }
+  return { exports, exportLines };
+}
 function parseImportedSymbols(matchedString, importType) {
   if (importType === "namespace")
     return ["*"];
@@ -116983,44 +117105,126 @@ function isBinaryContent(content) {
   }
   return false;
 }
+function scanFile(filePath, absoluteRoot, maxFileSize) {
+  let content;
+  let fileStats;
+  try {
+    fileStats = fsSync8.statSync(filePath);
+    if (fileStats.size > maxFileSize) {
+      return { node: null, edges: [] };
+    }
+    content = fsSync8.readFileSync(filePath, "utf-8");
+  } catch {
+    return { node: null, edges: [] };
+  }
+  if (isBinaryContent(content)) {
+    return { node: null, edges: [] };
+  }
+  const ext = path134.extname(filePath).toLowerCase();
+  let exports = [];
+  let exportLines = {};
+  try {
+    if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
+      const relativePath = path134.relative(absoluteRoot, filePath);
+      ({ exports, exportLines } = collectExports(_internals82.extractTSSymbols(relativePath, absoluteRoot)));
+    } else if (ext === ".py") {
+      const relativePath = path134.relative(absoluteRoot, filePath);
+      ({ exports, exportLines } = collectExports(_internals82.extractPythonSymbols(relativePath, absoluteRoot)));
+    }
+    const parsedImports = _internals82.parseFileImports(content);
+    const strippedForUsage = parsedImports.length > 0 ? _internals82.stripComments(content) : "";
+    const moduleName = toModuleName(filePath, absoluteRoot);
+    const node = {
+      filePath,
+      moduleName,
+      exports,
+      ...Object.keys(exportLines).length > 0 ? { exportLines } : {},
+      imports: parsedImports.map((p) => p.specifier),
+      language: getLanguage(filePath),
+      mtime: fileStats.mtime.toISOString(),
+      ontology: _internals82.extractFileOntology({
+        moduleName,
+        filePath,
+        content,
+        language: getLanguage(filePath),
+        exports,
+        imports: parsedImports.map((p) => p.specifier)
+      })
+    };
+    const edges = [];
+    const sortedImports = [...parsedImports].sort((a, b) => a.specifier.localeCompare(b.specifier));
+    for (const parsed of sortedImports) {
+      const resolvedTarget = resolveModuleSpecifier(absoluteRoot, filePath, parsed.specifier);
+      if (resolvedTarget !== null) {
+        const usedSymbols = usedSymbolsForImport(parsed, strippedForUsage);
+        edges.push({
+          source: filePath,
+          target: resolvedTarget,
+          importSpecifier: parsed.specifier,
+          importType: parsed.importType,
+          importedSymbols: parsed.importedSymbols,
+          ...usedSymbols !== undefined ? { usedSymbols } : {}
+        });
+      }
+    }
+    return { node, edges };
+  } catch {
+    return { node: null, edges: [] };
+  }
+}
 async function scanFileAsync(filePath, absoluteRoot, maxFileSize) {
   let content;
   let fileStats;
   try {
     fileStats = fsSync8.statSync(filePath);
     if (fileStats.size > maxFileSize) {
-      return { node: null, edges: [], symbolEdges: [] };
+      return {
+        node: null,
+        edges: [],
+        symbolEdges: [],
+        diagnostics: { oversizedFiles: [toModuleName(filePath, absoluteRoot)] }
+      };
     }
     content = fsSync8.readFileSync(filePath, "utf-8");
   } catch {
-    return { node: null, edges: [], symbolEdges: [] };
+    return {
+      node: null,
+      edges: [],
+      symbolEdges: [],
+      diagnostics: { unreadableFiles: [toModuleName(filePath, absoluteRoot)] }
+    };
   }
   if (isBinaryContent(content)) {
-    return { node: null, edges: [], symbolEdges: [] };
+    return {
+      node: null,
+      edges: [],
+      symbolEdges: [],
+      diagnostics: { binaryFiles: [toModuleName(filePath, absoluteRoot)] }
+    };
   }
   const grammarId = getLanguage(filePath);
   const facts = await _internals82.extractFileSymbols(grammarId, content);
   if (facts === null) {
-    const moduleName2 = toModuleName(filePath, absoluteRoot);
+    const fallback = scanFile(filePath, absoluteRoot, maxFileSize);
+    let parsedImports = [];
+    try {
+      parsedImports = _internals82.parseFileImports(content);
+    } catch {
+      parsedImports = [];
+    }
     return {
-      node: {
-        filePath,
-        moduleName: moduleName2,
-        exports: [],
-        imports: [],
-        language: grammarId,
-        mtime: fileStats.mtime.toISOString(),
-        ontology: _internals82.extractFileOntology({
-          moduleName: moduleName2,
-          filePath,
-          content,
-          language: grammarId,
-          exports: [],
-          imports: []
-        })
-      },
-      edges: [],
-      symbolEdges: []
+      ...fallback,
+      symbolEdges: [],
+      diagnostics: {
+        extractionFailures: [
+          {
+            file: toModuleName(filePath, absoluteRoot),
+            language: grammarId,
+            reason: "symbol_extraction_failed"
+          }
+        ],
+        unresolvedImports: unresolvedRelativeImportsFor(parsedImports, filePath, absoluteRoot)
+      }
     };
   }
   const exportedDefs = facts.defs.filter((d) => d.exported);
@@ -117071,6 +117275,10 @@ async function scanFileAsync(filePath, absoluteRoot, maxFileSize) {
       });
     }
   }
+  const unresolvedImports = sortedImports.filter((imp) => isRelativeImportSpecifier(imp.specifier)).filter((imp) => resolveModuleSpecifier(absoluteRoot, filePath, imp.specifier) === null).map((imp) => ({
+    file: moduleName,
+    specifier: imp.specifier
+  }));
   const symbolEdges = [];
   const localToImported = new Map;
   for (const imp of facts.imports) {
@@ -117101,7 +117309,12 @@ async function scanFileAsync(filePath, absoluteRoot, maxFileSize) {
       toSymbol: mapping.imported
     });
   }
-  return { node, edges, symbolEdges };
+  return {
+    node,
+    edges,
+    symbolEdges,
+    diagnostics: unresolvedImports.length > 0 ? { unresolvedImports } : undefined
+  };
 }
 async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   validateWorkspace(workspaceRoot);
@@ -117123,6 +117336,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
     skippedFiles: 0,
     truncated: false
   };
+  const diagnostics = createEmptyDiagnostics();
   const sourceFiles = await findSourceFilesAsync(absoluteRoot, stats2, {
     walkBudgetMs,
     maxFiles,
@@ -117143,6 +117357,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   let processedSinceYield = 0;
   for (const filePath of sourceFiles) {
     const result = await scanFileAsync(filePath, absoluteRoot, maxFileSize);
+    mergeDiagnostics(diagnostics, result.diagnostics);
     if (result.node) {
       let appended = false;
       try {
@@ -117183,6 +117398,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   if (allSymbolEdges.length > 0) {
     graph.symbolEdges = allSymbolEdges;
   }
+  graph.diagnostics = diagnosticsHaveEntries(diagnostics) ? diagnostics : createEmptyDiagnostics();
   if (stats2.skippedFiles > 0 || stats2.skippedDirs > 0 || stats2.truncated) {
     log(`[repo-graph] Scan stats: ${stats2.filesScanned} files scanned, ` + `${stats2.skippedFiles} files skipped, ${stats2.skippedDirs} dirs skipped` + (stats2.truncated ? ", TRUNCATED" : ""));
   }
@@ -117224,7 +117440,11 @@ import * as fsPromises7 from "node:fs/promises";
 import * as path138 from "node:path";
 
 // src/tools/repo-graph/query.ts
+init_path_security();
+import * as fsSync9 from "node:fs";
 import * as path136 from "node:path";
+var GRAPH_HEALTH_OUTPUT_LIMIT = 50;
+var MAX_HEALTH_PATH_LENGTH = 500;
 var cachedReverseIndex = null;
 function normalizeLookupPath(input) {
   return normalizeGraphPath(input).replace(/^(?:\.\/)+/, "");
@@ -117323,6 +117543,139 @@ function isGraphFresh(graph, maxAgeMs = 5 * 60 * 1000) {
     return false;
   return Date.now() - built <= maxAgeMs;
 }
+function isSafeHealthPath(value) {
+  if (typeof value !== "string")
+    return false;
+  if (value.length === 0 || value.length > MAX_HEALTH_PATH_LENGTH)
+    return false;
+  if (containsControlChars(value) || containsPathTraversal(value))
+    return false;
+  if (path136.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value))
+    return false;
+  return true;
+}
+function isSafeHealthText(value) {
+  if (typeof value !== "string")
+    return false;
+  if (value.length === 0 || value.length > MAX_HEALTH_PATH_LENGTH)
+    return false;
+  if (containsControlChars(value))
+    return false;
+  return true;
+}
+function cap(entries) {
+  return entries.slice(0, GRAPH_HEALTH_OUTPUT_LIMIT);
+}
+function sanitizeExtractionFailures(value) {
+  if (!Array.isArray(value))
+    return [];
+  const entries = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const entry = raw;
+    if (isSafeHealthPath(entry.file) && isSafeHealthText(entry.language) && isSafeHealthText(entry.reason)) {
+      entries.push({
+        file: entry.file,
+        language: entry.language,
+        reason: entry.reason
+      });
+    }
+  }
+  return cap(entries);
+}
+function sanitizeUnresolvedImports(value) {
+  if (!Array.isArray(value))
+    return [];
+  const entries = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const entry = raw;
+    if (isSafeHealthPath(entry.file) && isSafeHealthText(entry.specifier)) {
+      entries.push({ file: entry.file, specifier: entry.specifier });
+    }
+  }
+  return cap(entries);
+}
+function sanitizePathList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return cap(value.filter(isSafeHealthPath));
+}
+function getStaleFiles(graph, workspaceRoot) {
+  const built = Date.parse(graph.metadata.generatedAt);
+  if (!Number.isFinite(built))
+    return [];
+  const root = workspaceRoot ?? graph.workspaceRoot;
+  const stale = [];
+  for (const node of Object.values(graph.nodes)) {
+    const moduleName = normalizeGraphPath(node.moduleName);
+    if (!isSafeHealthPath(moduleName))
+      continue;
+    const filePath = path136.join(root, moduleName);
+    try {
+      if (fsSync9.statSync(filePath).mtimeMs > built) {
+        stale.push(moduleName);
+        if (stale.length >= GRAPH_HEALTH_OUTPUT_LIMIT)
+          break;
+      }
+    } catch {}
+  }
+  return stale;
+}
+function getGraphHealth(graph, workspaceRoot) {
+  if (!graph) {
+    return {
+      schemaVersion: null,
+      fresh: false,
+      staleFiles: [],
+      extractionFailures: [],
+      unresolvedImports: [],
+      oversizedFiles: [],
+      unsupportedFiles: [],
+      binaryFiles: [],
+      unreadableFiles: [],
+      lowConfidenceEdgeCount: 0,
+      notes: [
+        'No repo graph found at .swarm/repo-graph.json. Run repo_map with action="build" first.'
+      ]
+    };
+  }
+  const diagnostics = graph.diagnostics;
+  const fresh = isGraphFresh(graph);
+  const staleFiles = getStaleFiles(graph, workspaceRoot);
+  const notes = [];
+  if (!fresh || staleFiles.length > 0) {
+    notes.push('Graph is stale. Run repo_map with action="build" to refresh.');
+  }
+  if (!diagnostics) {
+    notes.push('Graph has no recorded diagnostics. Rebuild with repo_map action="build" to collect health details.');
+  }
+  const binaryFiles = sanitizePathList(diagnostics?.binaryFiles);
+  const binaryCount = binaryFiles.length;
+  if (binaryCount > 0) {
+    notes.push(`${binaryCount} binary files skipped during last build.`);
+  }
+  const unreadableFiles = sanitizePathList(diagnostics?.unreadableFiles);
+  const unreadableCount = unreadableFiles.length;
+  if (unreadableCount > 0) {
+    notes.push(`${unreadableCount} unreadable files skipped during last build.`);
+  }
+  return {
+    schemaVersion: graph.schema_version,
+    fresh,
+    staleFiles,
+    extractionFailures: sanitizeExtractionFailures(diagnostics?.extractionFailures),
+    unresolvedImports: sanitizeUnresolvedImports(diagnostics?.unresolvedImports),
+    oversizedFiles: sanitizePathList(diagnostics?.oversizedFiles),
+    unsupportedFiles: sanitizePathList(diagnostics?.unsupportedFiles),
+    binaryFiles,
+    unreadableFiles,
+    lowConfidenceEdgeCount: typeof diagnostics?.lowConfidenceEdgeCount === "number" && Number.isFinite(diagnostics.lowConfidenceEdgeCount) && diagnostics.lowConfidenceEdgeCount > 0 ? Math.floor(diagnostics.lowConfidenceEdgeCount) : 0,
+    notes
+  };
+}
 function getImporters(graph, filePath) {
   const node = getGraphNode(graph, filePath);
   if (!node)
@@ -117911,7 +118264,7 @@ function buildOntologyPreflightPacket(graph, filePaths = [], options = {}) {
 init_utils2();
 init_logger();
 init_path_security();
-import { constants as constants5, existsSync as existsSync77, readFileSync as readFileSync53, statSync as statSync27 } from "node:fs";
+import { constants as constants5, existsSync as existsSync77, readFileSync as readFileSync53, statSync as statSync28 } from "node:fs";
 import * as fsPromises6 from "node:fs/promises";
 import * as path137 from "node:path";
 var WINDOWS_RENAME_MAX_RETRIES2 = 5;
@@ -118036,7 +118389,7 @@ function loadGraphSync(workspace) {
     const graphPath = getGraphPath(workspace);
     if (!existsSync77(graphPath))
       return null;
-    const stats2 = statSync27(graphPath);
+    const stats2 = statSync28(graphPath);
     const content = readFileSync53(graphPath, "utf-8");
     if (content.includes("\x00") || content.includes("�")) {
       throw Object.assign(new Error("repo-graph.json contains null bytes or invalid encoding"), { code: "CORRUPTION" });
@@ -123062,9 +123415,9 @@ function parseDelegateDirectiveBlock(text) {
 }
 async function injectForDelegate(params) {
   const { directory, agent, taskTitle, sessionId, config: config3 } = params;
-  const cap = config3.delegate_max_inject_count ?? 8;
+  const cap2 = config3.delegate_max_inject_count ?? 8;
   const expectedTools = params.expectedTools && params.expectedTools.length > 0 ? params.expectedTools : defaultExpectedToolsForAgent(agent);
-  if (cap <= 0)
+  if (cap2 <= 0)
     return { entries: [], trace_id: "" };
   const role = stripKnownSwarmPrefix(agent).toLowerCase();
   const firstTool = expectedTools.length > 0 ? expectedTools[0] : undefined;
@@ -123088,11 +123441,11 @@ async function injectForDelegate(params) {
       tier: "all",
       applyScopeFilter: true,
       applyRoleScope: false,
-      maxResults: Math.max(40, cap * 4),
+      maxResults: Math.max(40, cap2 * 4),
       emitEvent: false
     });
     const scoped = search.results.filter((e) => matchesDelegateScope(e, role, expectedTools));
-    const capped = scoped.slice(0, cap);
+    const capped = scoped.slice(0, cap2);
     if (capped.length > 0) {
       const ranks = {};
       const scores = {};
@@ -129928,7 +130281,7 @@ ${body}`);
 init_zod();
 init_task_file();
 import { appendFileSync as appendFileSync18, existsSync as existsSync95, mkdirSync as mkdirSync42, readFileSync as readFileSync64 } from "node:fs";
-import { join as join131 } from "node:path";
+import { join as join132 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
@@ -129966,7 +130319,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   if (!VALID_TASK_ID.test(synthesis.taskId)) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
-  const dir = join131(workingDir, EVIDENCE_DIR2);
+  const dir = join132(workingDir, EVIDENCE_DIR2);
   mkdirSync42(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals96.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
@@ -130002,7 +130355,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
     await atomicWriteFile(filePath, JSON.stringify(updated, null, 2));
   });
   try {
-    const councilDir = join131(workingDir, ".swarm", "council");
+    const councilDir = join132(workingDir, ".swarm", "council");
     mkdirSync42(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
@@ -130010,7 +130363,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
       timestamp: synthesis.timestamp,
       vetoedBy: synthesis.vetoedBy
     });
-    appendFileSync18(join131(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
+    appendFileSync18(join132(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
 `);
   } catch (auditError) {
     console.warn(`writeCouncilEvidence: failed to append round-history audit log: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
@@ -130367,7 +130720,7 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 init_zod();
 init_task_file();
 import { existsSync as existsSync96, mkdirSync as mkdirSync43, readFileSync as readFileSync65 } from "node:fs";
-import { join as join132 } from "node:path";
+import { join as join133 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 var CouncilCriteriaSchema = exports_external.object({
   taskId: exports_external.string(),
@@ -130379,17 +130732,17 @@ var CouncilCriteriaSchema = exports_external.object({
   declaredAt: exports_external.string()
 });
 async function writeCriteria(workingDir, taskId, criteria) {
-  const dir = join132(workingDir, COUNCIL_DIR);
+  const dir = join133(workingDir, COUNCIL_DIR);
   mkdirSync43(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
     declaredAt: new Date().toISOString()
   };
-  await atomicWriteFile(join132(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  await atomicWriteFile(join133(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
-  const filePath = join132(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
+  const filePath = join133(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
   if (!existsSync96(filePath))
     return null;
   try {
@@ -149604,7 +149957,8 @@ var VALID_ACTIONS = [
   "preflight_packet",
   "callers",
   "dead_exports",
-  "context_pack"
+  "context_pack",
+  "graph_health"
 ];
 var MAX_FILE_PATH_LENGTH3 = 500;
 var MAX_SYMBOL_LENGTH2 = 256;
@@ -149668,7 +150022,7 @@ async function loadOrError(directory, action) {
   }
 }
 var repo_map = createSwarmTool({
-  description: "Query the repository code graph for structural awareness before editing. " + 'Actions: "build" (build/refresh .swarm/repo-graph.json), "importers" (who imports a file), ' + '"dependencies" (what a file imports), "blast_radius" (transitive dependents + risk), ' + '"localization" (compact context block for a target file), "key_files" (top-N most-imported files), ' + '"ontology" (file roles/routes/data/security/findings), "package_boundaries" (inferred package/layer boundaries), ' + '"preflight_packet" (bounded ontology packet for planning), ' + '"callers" (files that reference an exported symbol, call-site granularity; needs file+symbol), ' + '"dead_exports" (advisory: exported symbols with no detected in-repo reference; results are review candidates, not delete directives), ' + '"context_pack" (token-budgeted slice of source spans for a target symbol — definition + transitive callers/callees; advisory/conservative; needs file+symbol; uses max_depth for traversal depth, top_n for span cap). ' + "Use this before refactoring shared modules to avoid breaking unseen consumers. " + 'Note: "callers"/"dead_exports"/"context_pack" use conservative regex analysis (TS/JS/Python) and cannot see ' + 'dynamic dispatch or namespace/barrel re-export usage; "dead_exports" results are review candidates, not delete directives.',
+  description: "Query the repository code graph for structural awareness before editing. " + 'Actions: "build" (build/refresh .swarm/repo-graph.json), "importers" (who imports a file), ' + '"dependencies" (what a file imports), "blast_radius" (transitive dependents + risk), ' + '"localization" (compact context block for a target file), "key_files" (top-N most-imported files), ' + '"ontology" (file roles/routes/data/security/findings), "package_boundaries" (inferred package/layer boundaries), ' + '"preflight_packet" (bounded ontology packet for planning), ' + '"callers" (files that reference an exported symbol, call-site granularity; needs file+symbol), ' + '"dead_exports" (advisory: exported symbols with no detected in-repo reference; results are review candidates, not delete directives), ' + '"context_pack" (token-budgeted slice of source spans for a target symbol — definition + transitive callers/callees; advisory/conservative; needs file+symbol; uses max_depth for traversal depth, top_n for span cap), ' + '"graph_health" (freshness and bounded extraction diagnostics; no file required). ' + "Use this before refactoring shared modules to avoid breaking unseen consumers. " + 'Note: "callers"/"dead_exports"/"context_pack" use conservative regex analysis (TS/JS/Python) and cannot see ' + 'dynamic dispatch or namespace/barrel re-export usage; "dead_exports" results are review candidates, not delete directives.',
   args: {
     action: exports_external.enum([
       "build",
@@ -149682,8 +150036,9 @@ var repo_map = createSwarmTool({
       "preflight_packet",
       "callers",
       "dead_exports",
-      "context_pack"
-    ]).describe('Query action: "build" | "importers" | "dependencies" | "blast_radius" | "localization" | "key_files" | "ontology" | "package_boundaries" | "preflight_packet" | "callers" | "dead_exports" | "context_pack"'),
+      "context_pack",
+      "graph_health"
+    ]).describe('Query action: "build" | "importers" | "dependencies" | "blast_radius" | "localization" | "key_files" | "ontology" | "package_boundaries" | "preflight_packet" | "callers" | "dead_exports" | "context_pack" | "graph_health"'),
     file: exports_external.string().optional().describe("Target file (workspace-relative or absolute). Required for importers/dependencies/localization/ontology. Optional for preflight_packet."),
     files: exports_external.array(exports_external.string()).optional().describe("Multiple target files for blast_radius/preflight_packet. If omitted, falls back to `file`."),
     symbol: exports_external.string().optional().describe('Exported symbol name. Restricts consumers on action="importers"; required for action="callers"/"context_pack".'),
@@ -149718,6 +150073,15 @@ var repo_map = createSwarmTool({
         return err(action, `build failed: ${message}`);
       }
     }
+    if (action === "graph_health") {
+      try {
+        const graph2 = await loadGraph(directory);
+        return ok(action, { ...getGraphHealth(graph2, directory) });
+      } catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        return err(action, `failed to load repo graph: ${message}`);
+      }
+    }
     const loaded = await loadOrError(directory, action);
     if (!loaded.ok)
       return loaded.response;
@@ -153071,7 +153435,7 @@ init_skill_generator();
 init_create_tool();
 import { existsSync as existsSync119 } from "node:fs";
 import { readdir as readdir12, readFile as readFile33 } from "node:fs/promises";
-import { join as join166 } from "node:path";
+import { join as join167 } from "node:path";
 var run_stale_reconciliation = createSwarmTool({
   description: "Reconcile skills against the knowledge store. clear=false: mark skills stale when source knowledge is archived or deleted. clear=true: clear stale.marker on affected active skills (proposal files under .swarm/skills/proposals are scanned but not modified — they are drafts, not yet active skills).",
   args: {
@@ -153098,8 +153462,8 @@ var run_stale_reconciliation = createSwarmTool({
     } catch {}
     const skillEntries = [];
     for (const dir of [
-      join166(directory, ".opencode", "skills", "generated"),
-      join166(directory, ".swarm", "skills", "proposals")
+      join167(directory, ".opencode", "skills", "generated"),
+      join167(directory, ".swarm", "skills", "proposals")
     ]) {
       if (!_internals125.existsSync(dir))
         continue;
@@ -153108,14 +153472,14 @@ var run_stale_reconciliation = createSwarmTool({
         if (entry.isDirectory()) {
           skillEntries.push({
             slug: entry.name,
-            path: join166(dir, entry.name),
+            path: join167(dir, entry.name),
             isProposal: false
           });
         } else if (entry.name.endsWith(".md")) {
           const slug = entry.name.replace(/\.md$/, "");
           skillEntries.push({
             slug,
-            path: join166(dir, entry.name),
+            path: join167(dir, entry.name),
             isProposal: true
           });
         }
@@ -153123,7 +153487,7 @@ var run_stale_reconciliation = createSwarmTool({
     }
     const results = [];
     for (const { slug, path: path210, isProposal } of skillEntries) {
-      const skillMdPath = isProposal ? path210 : join166(path210, "SKILL.md");
+      const skillMdPath = isProposal ? path210 : join167(path210, "SKILL.md");
       if (!_internals125.existsSync(skillMdPath))
         continue;
       const content = await _internals125.readFile(skillMdPath, "utf-8");
@@ -153136,7 +153500,7 @@ var run_stale_reconciliation = createSwarmTool({
         continue;
       if (args2.clear) {
         if (!isProposal) {
-          const markerPath = join166(path210, "stale.marker");
+          const markerPath = join167(path210, "stale.marker");
           if (_internals125.existsSync(markerPath)) {
             try {
               await _internals125.clearSkillStale(path210);
@@ -158349,14 +158713,6 @@ async function initializeOpenCodeSwarm(ctx) {
     prEventCleanup?.();
   };
   process.on("exit", cleanupAutomation);
-  process.once("SIGINT", () => {
-    cleanupAutomation();
-    process.exit(130);
-  });
-  process.once("SIGTERM", () => {
-    cleanupAutomation();
-    process.exit(143);
-  });
   if (shouldRunOnStartup(automationConfig)) {
     const enableAutofix = automationConfig.capabilities?.config_doctor_autofix === true;
     Promise.resolve().then(() => (init_config_doctor(), exports_config_doctor)).then(({ runConfigDoctorWithFixes: runConfigDoctorWithFixes2 }) => {
@@ -158372,9 +158728,19 @@ async function initializeOpenCodeSwarm(ctx) {
           try {
             const autoFixableCount = doctorResult.result.findings.filter((f) => f.autoFixable).length;
             if (!enableAutofix && autoFixableCount > 0) {
-              console.warn(`[opencode-swarm] Config Doctor found ${autoFixableCount} auto-fixable issue(s). Run /swarm config doctor --fix to apply.`);
+              const msg = `[opencode-swarm] Config Doctor found ${autoFixableCount} auto-fixable issue(s). Run /swarm config doctor --fix to apply.`;
+              if (!config3.quiet) {
+                console.warn(msg);
+              } else {
+                addDeferredWarning(msg);
+              }
             } else if (enableAutofix && doctorResult.appliedFixes.length > 0) {
-              console.warn(`[opencode-swarm] Config Doctor applied ${doctorResult.appliedFixes.length} fix(es) automatically.`);
+              const msg = `[opencode-swarm] Config Doctor applied ${doctorResult.appliedFixes.length} fix(es) automatically.`;
+              if (!config3.quiet) {
+                console.warn(msg);
+              } else {
+                addDeferredWarning(msg);
+              }
             }
           } catch {}
         }
@@ -158917,7 +159283,9 @@ async function initializeOpenCodeSwarm(ctx) {
                 argsRecord.prompt = `SKILLS: none
 
 ${promptRaw}`;
-                console.warn("[skill-propagation-gate] No skills above threshold 0.5 — injected SKILLS: none");
+                if (!config3.quiet) {
+                  console.warn("[skill-propagation-gate] No skills above threshold 0.5 — injected SKILLS: none");
+                }
               } else {
                 const topSkills = qualified.slice(0, 5);
                 const skillPaths = topSkills.map((s) => {
@@ -158935,7 +159303,9 @@ ${promptRaw}`;
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
                 const skillNames = topSkills.map((s) => `${path225.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
-                console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
+                if (!config3.quiet) {
+                  console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
+                }
                 for (const skill of topSkills) {
                   try {
                     appendSkillUsageEntry(ctx.directory, {