opencode-swarm 7.99.5 → 7.99.7

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.99.5",
+    version: "7.99.7",
     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, "\\$&");
@@ -18141,6 +18141,9 @@ var init_swarm_artifact_cache = __esm(() => {
 // src/hooks/utils.ts
 import * as fs4 from "node:fs";
 import * as path5 from "node:path";
+function isFailClosedHandler(value) {
+  return typeof value === "function" && Object.hasOwn(value, "__failClosed") && value.__failClosed === true;
+}
 function safeHook(fn2) {
   return async (input, output) => {
     try {
@@ -18162,6 +18165,9 @@ function composeHandlers(...fns) {
   }
   return async (input, output) => {
     for (const fn2 of fns) {
+      if (isFailClosedHandler(fn2)) {
+        throw new Error("composeHandlers cannot wrap fail-closed handlers; use composeBlockingHandlers or await them directly");
+      }
       const safeFn = _internals3.safeHook(fn2);
       await safeFn(input, output);
     }
@@ -43377,6 +43383,10 @@ function createToolBeforeHandler(ctx) {
       return;
     const executor = await getExecutor();
     if (!executor || !executor.isAvailable()) {
+      if (!hasWarnedSandboxUnavailable) {
+        hasWarnedSandboxUnavailable = true;
+        warn("[guardrails] sandbox executor unavailable; shell commands will run unsandboxed");
+      }
       appendGuardrailDecision({
         type: "sandbox_skip",
         ts: new Date().toISOString(),
@@ -43875,6 +43885,15 @@ function createToolBeforeHandler(ctx) {
     handleDelegatedWriteTracking(input.sessionID, input.tool, output.args);
     handleLoopDetection(input.sessionID, input.tool, output.args);
     handleTestSuiteBlocking(input.tool, output.args);
+    const agentNameForSandbox = (() => {
+      const rawAgent = swarmState.activeAgent.get(input.sessionID);
+      return rawAgent ? stripKnownSwarmPrefix(rawAgent) : "unknown";
+    })();
+    const rawShellCommand = (() => {
+      const bashArgs = output.args;
+      return typeof bashArgs?.command === "string" ? bashArgs.command : "";
+    })();
+    await applySandboxExecution(input.sessionID, input.tool, output.args, agentNameForSandbox, rawShellCommand, shellAuditPath, shellAuditEnabled);
     const normalizedAuditTool = normalizeToolName(input.tool).toLowerCase();
     if (normalizedAuditTool === "bash" || normalizedAuditTool === "shell") {
       appendGuardrailDecision({
@@ -44221,17 +44240,10 @@ function createToolBeforeHandler(ctx) {
       elapsedMinutes,
       repetitionCount
     });
-    await applySandboxExecution(input.sessionID, input.tool, output.args, (() => {
-      const rawAgent = swarmState.activeAgent.get(input.sessionID);
-      return rawAgent ? stripKnownSwarmPrefix(rawAgent) : "unknown";
-    })(), (() => {
-      const bashArgs = output.args;
-      const rawCmd = typeof bashArgs?.command === "string" ? bashArgs.command : "";
-      return rawCmd;
-    })(), shellAuditPath, shellAuditEnabled);
     setStoredInputArgs(input.callID, output.args);
   };
 }
+var hasWarnedSandboxUnavailable = false;
 var init_tool_before = __esm(() => {
   init_tool_policy();
   init_constants();
@@ -76654,26 +76666,45 @@ function writeVersionCache(entry) {
     writeFileSync13(cacheFile(), JSON.stringify(entry, null, 2), "utf-8");
   } catch {}
 }
+function parseVersion(version3) {
+  const trimmed = version3.trim();
+  const match = SEMVER_REGEX.exec(trimmed);
+  if (!match)
+    return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: match[4] ?? null
+  };
+}
+function normalizeVersionCandidate(version3) {
+  if (typeof version3 !== "string")
+    return null;
+  const trimmed = version3.trim();
+  return SEMVER_REGEX.test(trimmed) ? trimmed : null;
+}
 function compareVersions(a, b) {
-  const [aBase, aPre] = a.split("-", 2);
-  const [bBase, bPre] = b.split("-", 2);
-  const aParts = aBase.split(".").map((n) => Number.parseInt(n, 10) || 0);
-  const bParts = bBase.split(".").map((n) => Number.parseInt(n, 10) || 0);
-  const len = Math.max(aParts.length, bParts.length);
-  for (let i = 0;i < len; i++) {
-    const av = aParts[i] ?? 0;
-    const bv = bParts[i] ?? 0;
-    if (av > bv)
-      return 1;
-    if (av < bv)
-      return -1;
+  const aParsed = parseVersion(a);
+  const bParsed = parseVersion(b);
+  if (!aParsed || !bParsed)
+    return 0;
+  if (aParsed.major !== bParsed.major) {
+    return aParsed.major > bParsed.major ? 1 : -1;
   }
-  if (aPre && !bPre)
+  if (aParsed.minor !== bParsed.minor) {
+    return aParsed.minor > bParsed.minor ? 1 : -1;
+  }
+  if (aParsed.patch !== bParsed.patch) {
+    return aParsed.patch > bParsed.patch ? 1 : -1;
+  }
+  if (aParsed.prerelease && !bParsed.prerelease)
     return -1;
-  if (!aPre && bPre)
+  if (!aParsed.prerelease && bParsed.prerelease)
     return 1;
-  if (aPre && bPre)
-    return aPre < bPre ? -1 : aPre > bPre ? 1 : 0;
+  if (aParsed.prerelease && bParsed.prerelease) {
+    return aParsed.prerelease < bParsed.prerelease ? -1 : aParsed.prerelease > bParsed.prerelease ? 1 : 0;
+  }
   return 0;
 }
 async function fetchLatestVersion(signal) {
@@ -76731,7 +76762,8 @@ async function runVersionCheck(runningVersion, emitWarning, now, fetchImpl) {
   const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
   let npmLatest = null;
   try {
-    npmLatest = await fetchImpl(controller.signal);
+    const fetchedVersion = await fetchImpl(controller.signal);
+    npmLatest = normalizeVersionCandidate(fetchedVersion);
   } finally {
     clearTimeout(timeout);
   }
@@ -76745,9 +76777,10 @@ function maybeWarn(runningVersion, npmLatest, emitWarning) {
     emitWarning(`[opencode-swarm] Update available: ${runningVersion} → ${npmLatest}. ` + "OpenCode caches plugins indefinitely. Run `bunx opencode-swarm update` to refresh.");
   }
 }
-var NPM_REGISTRY_URL = "https://registry.npmjs.org/opencode-swarm/latest", CHECK_INTERVAL_MS, FETCH_TIMEOUT_MS = 5000, MAX_RESPONSE_BYTES, STRICT_SEMVER, _checkLatched = false, _internals43;
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/opencode-swarm/latest", CHECK_INTERVAL_MS, FETCH_TIMEOUT_MS = 5000, SEMVER_REGEX, MAX_RESPONSE_BYTES, STRICT_SEMVER, _checkLatched = false, _internals43;
 var init_version_check = __esm(() => {
   CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+  SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
   MAX_RESPONSE_BYTES = 256 * 1024;
   STRICT_SEMVER = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
   _internals43 = {
@@ -101085,6 +101118,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}`, "");
@@ -101219,6 +101259,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();
@@ -102147,6 +102188,7 @@ Subcommands:
     handleHelpCommand,
     validateAliases,
     validateToolPolicy,
+    emitValidationWarnings,
     resolveCommand,
     levenshteinDistance: levenshteinDistance2,
     findSimilarCommands,
@@ -102158,20 +102200,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}`);
   }
 });
 
@@ -116575,6 +116609,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)
@@ -116705,6 +116740,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 = "";
@@ -116897,6 +116990,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 ["*"];
@@ -117023,44 +117138,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);
@@ -117111,6 +117308,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) {
@@ -117141,7 +117342,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);
@@ -117163,6 +117369,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
     skippedFiles: 0,
     truncated: false
   };
+  const diagnostics = createEmptyDiagnostics();
   const sourceFiles = await findSourceFilesAsync(absoluteRoot, stats2, {
     walkBudgetMs,
     maxFiles,
@@ -117183,6 +117390,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 {
@@ -117223,6 +117431,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" : ""));
   }
@@ -117264,7 +117473,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(/^(?:\.\/)+/, "");
@@ -117363,6 +117576,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)
@@ -117951,7 +118297,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;
@@ -118076,7 +118422,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" });
@@ -123102,9 +123448,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;
@@ -123128,11 +123474,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 = {};
@@ -129968,7 +130314,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";
@@ -130006,7 +130352,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 () => {
@@ -130042,7 +130388,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,
@@ -130050,7 +130396,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)}`);
@@ -130407,7 +130753,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(),
@@ -130419,17 +130765,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 {
@@ -149644,7 +149990,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;
@@ -149708,7 +150055,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",
@@ -149722,8 +150069,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".'),
@@ -149758,6 +150106,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;
@@ -153111,7 +153468,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: {
@@ -153138,8 +153495,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;
@@ -153148,14 +153505,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
           });
         }
@@ -153163,7 +153520,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");
@@ -153176,7 +153533,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);
@@ -158389,14 +158746,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 }) => {
@@ -158412,9 +158761,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 {}
         }
@@ -158957,7 +159316,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) => {
@@ -158975,7 +159336,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, {