opencode-swarm 7.71.3 → 7.72.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.71.3",
+    version: "7.72.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -112,6 +112,7 @@ var init_package = __esm(() => {
       ".opencode/skills/pre-phase-briefing",
       ".opencode/skills/council",
       ".opencode/skills/deep-dive",
+      ".opencode/skills/deep-research",
       ".opencode/skills/codebase-review-swarm",
       ".opencode/skills/design-docs",
       ".opencode/skills/swarm-pr-review",
@@ -589,6 +590,10 @@ var init_tool_metadata = __esm(() => {
       description: "External web search (Tavily or Brave) for architect-driven council research, SME domain research, and skill-improver research. Returns titled results with snippets, URLs, normalized query metadata, temporal intent, freshness, and removed stale years. Config-gated on council.general.enabled in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides. Requires a search API key. Used by the architect in MODE: COUNCIL to gather a RESEARCH CONTEXT before dispatching council agents and by SME for opt-in external skill/source evaluation.",
       agents: ["architect", "sme", "skill_improver"]
     },
+    web_fetch: {
+      description: "Fetch the readable text of a single http(s) URL (architect-only). Returns decoded page text, document title, final URL after redirects, and an evidence reference. Reads primary sources that web_search only surfaces as snippets. Config-gated on council.general.enabled. Blocks private/loopback/link-local/metadata addresses (re-validated and re-pinned across redirects); enforces timeout and body size cap.",
+      agents: ["architect"]
+    },
     convene_general_council: {
       description: "Synthesize responses from a multi-model General Council. Accepts parallel member responses (Round 1, optionally Round 2), detects disagreements, and returns consensus points, persisting disagreements, and a structured synthesis. Architect-only. Config-gated on council.general.enabled in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project .opencode/opencode-swarm.json overrides.",
       agents: ["architect"]
@@ -17101,6 +17106,7 @@ var init_bundled_skills = __esm(() => {
     "pre-phase-briefing",
     "council",
     "deep-dive",
+    "deep-research",
     "codebase-review-swarm",
     "design-docs",
     "swarm-pr-review",
@@ -69353,6 +69359,119 @@ var init_deep_dive = __esm(() => {
   ]);
 });
 
+// src/commands/deep-research.ts
+function sanitizeQuestion2(raw) {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  const stripped = collapsed.replace(/\[\s*MODE\s*:[^\]]*\]/gi, "");
+  const normalized = stripped.replace(/\s+/g, " ").trim();
+  if (normalized.length <= MAX_QUESTION_LEN2)
+    return normalized;
+  return `${normalized.slice(0, MAX_QUESTION_LEN2)}…`;
+}
+function isBoundedInteger(raw, min, max) {
+  if (!raw || !/^\d+$/.test(raw))
+    return false;
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= min && n <= max;
+}
+function parseArgs4(args2) {
+  const result = {
+    depth: DEFAULT_DEPTH,
+    maxResearchers: DEFAULT_MAX_RESEARCHERS,
+    rounds: DEFAULT_ROUNDS,
+    output: "report",
+    rest: []
+  };
+  let i2 = 0;
+  while (i2 < args2.length) {
+    const token = args2[i2];
+    if (token === "--depth") {
+      if (i2 + 1 >= args2.length)
+        return { ...result, error: `Flag "${token}" requires a value` };
+      const value = args2[++i2];
+      if (!DEPTHS.has(value)) {
+        return {
+          ...result,
+          error: `Invalid depth "${value}". Must be one of: standard, exhaustive.`
+        };
+      }
+      result.depth = value;
+    } else if (token === "--max-researchers") {
+      if (i2 + 1 >= args2.length)
+        return { ...result, error: `Flag "${token}" requires a value` };
+      const value = args2[++i2];
+      if (!isBoundedInteger(value, 1, 6)) {
+        return {
+          ...result,
+          error: `Invalid --max-researchers value "${value}". Must be an integer between 1 and 6.`
+        };
+      }
+      result.maxResearchers = Number(value);
+      result.maxResearchersExplicit = true;
+    } else if (token === "--rounds") {
+      if (i2 + 1 >= args2.length)
+        return { ...result, error: `Flag "${token}" requires a value` };
+      const value = args2[++i2];
+      if (!isBoundedInteger(value, 1, 4)) {
+        return {
+          ...result,
+          error: `Invalid --rounds value "${value}". Must be an integer between 1 and 4.`
+        };
+      }
+      result.rounds = Number(value);
+      result.roundsExplicit = true;
+    } else if (token === "--brief") {
+      result.output = "brief";
+    } else if (token.startsWith("--")) {
+      return { ...result, error: `Unknown flag "${token}"` };
+    } else {
+      result.rest.push(token);
+    }
+    i2++;
+  }
+  return result;
+}
+async function handleDeepResearchCommand(_directory, args2) {
+  const parsed = parseArgs4(args2);
+  if (parsed.error) {
+    return `Error: ${parsed.error}
+
+${USAGE4}`;
+  }
+  const question = sanitizeQuestion2(parsed.rest.join(" "));
+  if (!question) {
+    return USAGE4;
+  }
+  if (parsed.depth === "exhaustive") {
+    if (!parsed.maxResearchersExplicit)
+      parsed.maxResearchers = EXHAUSTIVE_DEFAULT_MAX_RESEARCHERS;
+    if (!parsed.roundsExplicit)
+      parsed.rounds = EXHAUSTIVE_DEFAULT_ROUNDS;
+  }
+  return `[MODE: DEEP_RESEARCH depth=${parsed.depth} max_researchers=${parsed.maxResearchers} rounds=${parsed.rounds} output=${parsed.output}] ${question}`;
+}
+var MAX_QUESTION_LEN2 = 2000, DEPTHS, DEFAULT_DEPTH = "standard", DEFAULT_MAX_RESEARCHERS = 3, EXHAUSTIVE_DEFAULT_MAX_RESEARCHERS = 5, DEFAULT_ROUNDS = 2, EXHAUSTIVE_DEFAULT_ROUNDS = 3, USAGE4 = `Usage: /swarm deep-research <question> [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]
+
+Run a multi-source, fact-checked deep research pass and synthesize a cited report.
+
+Examples:
+  /swarm deep-research "What are the tradeoffs of WASM vs native plugins?"
+  /swarm deep research "current state of deep research agents" --depth exhaustive
+  /swarm deep-research "is Tavily or Brave better for our use case" --rounds 3 --brief
+
+Flags:
+  --depth <name>          standard (focused) or exhaustive (broader fan-out)
+  --max-researchers <N>   parallel synthesis workers per round, 1..6
+  --rounds <N>            max iterative research rounds, 1..4
+  --brief                 emit a short brief instead of a full cited report
+
+Requires council.general.enabled: true and a configured search API key (Tavily or Brave)
+in the resolved config: global ~/.config/opencode/opencode-swarm.json, then project
+.opencode/opencode-swarm.json overrides.`;
+var init_deep_research = __esm(() => {
+  DEPTHS = new Set(["standard", "exhaustive"]);
+});
+
 // src/commands/design-docs.ts
 function sanitizeDescription(raw) {
   const collapsed = raw.replace(/\s+/g, " ").trim();
@@ -69370,7 +69489,7 @@ function cleanFlagValue(raw) {
     return null;
   return raw;
 }
-function parseArgs4(args2) {
+function parseArgs5(args2) {
   const result = {
     out: "docs",
     lang: "auto",
@@ -69425,30 +69544,30 @@ function parseArgs4(args2) {
   return result;
 }
 async function handleDesignDocsCommand(directory, args2) {
-  const parsed = parseArgs4(args2);
+  const parsed = parseArgs5(args2);
   if (parsed.error) {
     return `Error: ${parsed.error}
 
-${USAGE4}`;
+${USAGE5}`;
   }
   try {
     const { config: config3 } = loadPluginConfigWithMeta(directory);
     if (config3.design_docs?.enabled !== true) {
       return "Error: design docs are disabled. Set `design_docs.enabled: true` in " + `opencode-swarm.json to enable the docs_design agent and this command.
 
-` + USAGE4;
+` + USAGE5;
     }
   } catch (configErr) {
     console.warn(`[design-docs] Could not read opencode-swarm.json (${String(configErr)}). ` + "Falling through — the architect will abort if docs_design is not registered.");
   }
   const description = sanitizeDescription(parsed.rest.join(" "));
   if (!description && !parsed.update) {
-    return USAGE4;
+    return USAGE5;
   }
   const header = `[MODE: DESIGN_DOCS out=${parsed.out} lang=${parsed.lang} update=${parsed.update}] ${description}`;
   return header.trimEnd();
 }
-var MAX_DESC_LEN = 2000, USAGE4 = `Usage: /swarm design-docs <description> [--out <dir>] [--lang <name>] [--update]
+var MAX_DESC_LEN = 2000, USAGE5 = `Usage: /swarm design-docs <description> [--out <dir>] [--lang <name>] [--update]
 
 Generate or sync language-agnostic design docs for the project under build:
   <out>/domain.md, <out>/technical-spec.md, <out>/behavior-spec.md,
@@ -75204,7 +75323,7 @@ function validateAndSanitizeUrl2(rawUrl) {
     return { error: "Invalid URL format" };
   }
 }
-function parseArgs5(args2) {
+function parseArgs6(args2) {
   const out2 = {
     plan: false,
     trace: false,
@@ -75278,24 +75397,24 @@ function detectGitRemote2() {
   }
 }
 function handleIssueCommand(_directory, args2) {
-  const parsed = parseArgs5(args2);
+  const parsed = parseArgs6(args2);
   const rawInput = parsed.rest.join(" ").trim();
   if (!rawInput) {
-    return USAGE5;
+    return USAGE6;
   }
   const isFullUrl = /^https?:\/\//i.test(rawInput);
   const issueInfo = parseIssueRef(isFullUrl ? sanitizeUrl2(rawInput) : rawInput);
   if (!issueInfo) {
     return `Error: Could not parse issue reference from "${rawInput}"
 
-${USAGE5}`;
+${USAGE6}`;
   }
   const issueUrl = `https://github.com/${issueInfo.owner}/${issueInfo.repo}/issues/${issueInfo.number}`;
   const result = validateAndSanitizeUrl2(issueUrl);
   if ("error" in result) {
     return `Error: ${result.error}
 
-${USAGE5}`;
+${USAGE6}`;
   }
   const flags2 = [];
   if (parsed.plan)
@@ -75307,10 +75426,10 @@ ${USAGE5}`;
   const flagsStr = flags2.length > 0 ? ` ${flags2.join(" ")}` : "";
   return `[MODE: ISSUE_INGEST issue="${result.sanitized}"${flagsStr}]`;
 }
-var MAX_URL_LEN2 = 2048, USAGE5;
+var MAX_URL_LEN2 = 2048, USAGE6;
 var init_issue = __esm(() => {
   init_pr_ref();
-  USAGE5 = [
+  USAGE6 = [
     "Usage: /swarm issue <url|owner/repo#N|N> [--plan] [--trace] [--no-repro]",
     "",
     "Ingest a GitHub issue into the swarm workflow.",
@@ -80579,7 +80698,7 @@ var init_pr_monitor_status = __esm(() => {
 });
 
 // src/commands/pr-review.ts
-function parseArgs6(args2) {
+function parseArgs7(args2) {
   const out2 = { council: false, rest: [] };
   for (const token of args2) {
     if (token === "--council") {
@@ -80598,29 +80717,29 @@ function parseArgs6(args2) {
   return out2;
 }
 function handlePrReviewCommand(directory, args2) {
-  const parsed = parseArgs6(args2);
+  const parsed = parseArgs7(args2);
   if (parsed.unknownFlag) {
     return `Error: Unknown flag "${parsed.unknownFlag}"
 
-${USAGE6}`;
+${USAGE7}`;
   }
   const resolved = resolvePrCommandInput(parsed.rest, directory);
   if (resolved === null) {
-    return USAGE6;
+    return USAGE7;
   }
   if ("error" in resolved) {
     return `Error: ${resolved.error}
 
-${USAGE6}`;
+${USAGE7}`;
   }
   const councilFlag = parsed.council ? "council=true" : "council=false";
   const signal = `[MODE: PR_REVIEW pr="${resolved.prUrl}" ${councilFlag}]`;
   return resolved.instructions ? `${signal} ${resolved.instructions}` : signal;
 }
-var USAGE6;
+var USAGE7;
 var init_pr_review = __esm(() => {
   init_pr_ref();
-  USAGE6 = [
+  USAGE7 = [
     "Usage: /swarm pr-review <url|owner/repo#N|N> [--council] [instructions...]",
     "",
     "Run a full swarm PR review on a GitHub pull request.",
@@ -87896,7 +88015,7 @@ var init_rollback = __esm(() => {
 });
 
 // src/commands/sdd.ts
-function parseArgs7(args2) {
+function parseArgs8(args2) {
   const parsed = { json: false, dryRun: false };
   for (let i2 = 0;i2 < args2.length; i2++) {
     const token = args2[i2];
@@ -87927,11 +88046,11 @@ function formatList(items) {
 `) : "- none";
 }
 async function handleSddStatusCommand(directory, args2) {
-  const parsed = parseArgs7(args2);
+  const parsed = parseArgs8(args2);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE7}`;
+${USAGE8}`;
   const status = loadSddStatusSync(directory);
   if (parsed.json)
     return JSON.stringify(status, null, 2);
@@ -87965,11 +88084,11 @@ ${formatList([
 `);
 }
 async function handleSddValidateCommand(directory, args2) {
-  const parsed = parseArgs7(args2);
+  const parsed = parseArgs8(args2);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE7}`;
+${USAGE8}`;
   const status = loadSddStatusSync(directory);
   const projection = buildOpenSpecProjectionSync(directory, {
     changeId: parsed.changeId
@@ -88007,11 +88126,11 @@ ${formatList(result.warnings)}` : ""
 `);
 }
 async function handleSddProjectCommand(directory, args2) {
-  const parsed = parseArgs7(args2);
+  const parsed = parseArgs8(args2);
   if (parsed.error)
     return `Error: ${parsed.error}
 
-${USAGE7}`;
+${USAGE8}`;
   const result = writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun
@@ -88031,7 +88150,7 @@ ${USAGE7}`;
     return [
       "SDD projection failed: no valid OpenSpec-compatible projection could be built.",
       "",
-      USAGE7
+      USAGE8
     ].join(`
 `);
   }
@@ -88048,9 +88167,9 @@ ${formatList(result.projection.warnings)}` : ""
 `);
 }
 async function handleSddCommand(_directory, _args) {
-  return USAGE7;
+  return USAGE8;
 }
-var USAGE7 = `Usage:
+var USAGE8 = `Usage:
   /swarm sdd status [--json]
   /swarm sdd validate [--json] [--change <id>]
   /swarm sdd project [--dry-run] [--json] [--change <id>]
@@ -89556,6 +89675,7 @@ __export(exports_commands, {
   handleEvidenceCommand: () => handleEvidenceCommand,
   handleDoctorCommand: () => handleDoctorCommand,
   handleDiagnoseCommand: () => handleDiagnoseCommand,
+  handleDeepResearchCommand: () => handleDeepResearchCommand,
   handleDeepDiveCommand: () => handleDeepDiveCommand,
   handleDarkMatterCommand: () => handleDarkMatterCommand,
   handleCurateCommand: () => handleCurateCommand,
@@ -89834,6 +89954,7 @@ var init_commands = __esm(() => {
   init_curate();
   init_dark_matter();
   init_deep_dive();
+  init_deep_research();
   init_diagnose();
   init_doctor();
   init_evidence();
@@ -90066,6 +90187,7 @@ var init_registry = __esm(() => {
   init_curate();
   init_dark_matter();
   init_deep_dive();
+  init_deep_research();
   init_design_docs();
   init_diagnose();
   init_doctor();
@@ -90461,6 +90583,20 @@ Subcommands:
       category: "agent",
       aliasOf: "deep-dive"
     },
+    "deep-research": {
+      handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepResearchCommand),
+      description: "Launch a multi-source, fact-checked deep research pass and synthesize a cited report [question]",
+      args: "<question> [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]",
+      details: "Runs the orchestrator-worker deep-research protocol: the architect decomposes the question into subtopics, gathers evidence with web_search and web_fetch across up to N iterative rounds, dispatches parallel sme synthesis workers, verifies every claim against cited sources with dual reviewers, challenges high-stakes claims with the critic, and presents a cited report in chat. Read-only — does not mutate source code, delegate to coder, or call declare_scope. Requires council.general.enabled and a search API key.",
+      category: "agent"
+    },
+    "deep research": {
+      handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleDeepResearchCommand),
+      description: "Alias for /swarm deep-research — launch a cited deep research pass",
+      args: "<question> [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]",
+      category: "agent",
+      aliasOf: "deep-research"
+    },
     "codebase-review": {
       handler: (ctx) => handleModeCommandWithBundledSkills(ctx, handleCodebaseReviewCommand),
       description: "Launch codebase-review-swarm for a quote-grounded full-repo or large-subsystem audit",
@@ -91957,6 +92093,22 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 - Explorers generate candidate findings only — reviewers verify or reject
 - Critics challenge only HIGH/CRITICAL findings — do NOT waste cycles on lower severity
 
+### MODE: DEEP_RESEARCH
+Activates when: architect receives \`[MODE: DEEP_RESEARCH depth=X max_researchers=N rounds=N output=report|brief] <question>\` signal from the deep-research command handler.
+
+Purpose: Orchestrator-worker deep research over external sources. Decompose the question into subtopics, gather evidence with \`web_search\` and \`web_fetch\` across up to \`rounds\` iterative rounds (re-planning gaps between rounds), dispatch parallel sme synthesis workers, verify every claim against cited sources with 2 reviewers, challenge high-stakes claims with the critic, and present a cited report in chat. This mode does NOT mutate source code, does NOT delegate to coder, and does NOT call declare_scope.
+
+ACTION: Load skill file:.opencode/skills/deep-research/SKILL.md immediately and follow its protocol.
+
+HARD CONSTRAINTS (apply regardless of skill load success):
+- Do NOT delegate to coder
+- Do NOT call declare_scope
+- Do NOT mutate source code or write any files outside .swarm/
+- You (architect) own \`web_search\` and \`web_fetch\`; sme workers receive gathered evidence in their dispatch message — do NOT expect sme to fetch
+- Every claim in the final report MUST cite a source from the gathered evidence; reviewers verify claim↔citation before a claim is reported
+- 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
+
 ### 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.
 
@@ -101144,7 +101296,7 @@ var init_design_doc_drift = __esm(() => {
 var exports_project_context = {};
 __export(exports_project_context, {
   buildProjectContext: () => buildProjectContext,
-  _internals: () => _internals103,
+  _internals: () => _internals104,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
 import * as fs136 from "node:fs";
@@ -101228,7 +101380,7 @@ function selectLintCommand(backend, directory) {
   return null;
 }
 async function buildProjectContext(directory) {
-  const backend = await _internals103.pickBackend(directory);
+  const backend = await _internals104.pickBackend(directory);
   if (!backend)
     return null;
   const ctx = emptyProjectContext();
@@ -101267,17 +101419,17 @@ async function buildProjectContext(directory) {
   if (backend.prompts.reviewerChecklist.length > 0) {
     ctx.REVIEWER_CHECKLIST = bulletList(backend.prompts.reviewerChecklist);
   }
-  const profiles = _internals103.pickedProfiles(directory);
+  const profiles = _internals104.pickedProfiles(directory);
   if (profiles.length > 1) {
     ctx.PROJECT_CONTEXT_SECONDARY_LANGUAGES = profiles.slice(1).map((p) => p.id).join(", ");
   }
   return ctx;
 }
-var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals103;
+var LANG_BACKEND_DETECTION_TIMEOUT_MS = 300, _internals104;
 var init_project_context = __esm(() => {
   init_dispatch();
   init_framework_detector();
-  _internals103 = {
+  _internals104 = {
     pickBackend,
     pickedProfiles
   };
@@ -140503,6 +140655,696 @@ var update_task_status = createSwarmTool({
   }
 });
 
+// src/tools/web-fetch.ts
+init_zod();
+init_loader();
+import { lookup } from "node:dns/promises";
+import * as http from "node:http";
+import * as https from "node:https";
+import { isIP } from "node:net";
+import { Readable } from "node:stream";
+import * as zlib from "node:zlib";
+
+// src/evidence/documents.ts
+init_utils2();
+init_redaction();
+import { createHash as createHash16 } from "node:crypto";
+import { appendFile as appendFile17, mkdir as mkdir31 } from "node:fs/promises";
+import * as path188 from "node:path";
+var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
+var MAX_EVIDENCE_TEXT_LENGTH = 4000;
+async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
+  const filePath = validateSwarmPath(directory, EVIDENCE_CACHE_FILE);
+  const capturedAt = now().toISOString();
+  const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
+  if (records.length > 0) {
+    await mkdir31(path188.dirname(filePath), { recursive: true });
+    await appendFile17(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
+`)}
+`, "utf-8");
+  }
+  return {
+    path: ".swarm/evidence-cache/documents.jsonl",
+    records,
+    refs: records.map((record3) => record3.ref)
+  };
+}
+function createEvidenceDocumentRecord(input, defaultCapturedAt) {
+  const text = normalizeEvidenceText(input.text ?? input.snippet ?? "");
+  if (!text)
+    return null;
+  const capturedAt = input.capturedAt ?? defaultCapturedAt;
+  const base = {
+    sourceType: input.sourceType,
+    query: normalizeOptional(input.query),
+    title: normalizeOptional(input.title),
+    url: normalizeOptional(input.url),
+    text
+  };
+  const id = createEvidenceDocumentId(base);
+  return {
+    id,
+    ref: `evidence-cache:${id}`,
+    ...base,
+    capturedAt,
+    createdBy: normalizeOptional(input.createdBy),
+    metadata: input.metadata ?? {}
+  };
+}
+function createEvidenceDocumentId(input) {
+  const hash4 = createHash16("sha256").update([
+    input.sourceType,
+    input.query ?? "",
+    input.title ?? "",
+    input.url ?? "",
+    input.text
+  ].join(`
+`)).digest("hex");
+  return `evd_${hash4.slice(0, 16)}`;
+}
+function normalizeEvidenceText(text) {
+  const normalized = redactSecrets(text.replace(/\s+/g, " ").trim());
+  return truncateEvidenceText(normalized, MAX_EVIDENCE_TEXT_LENGTH);
+}
+function truncateEvidenceText(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  const truncated = text.slice(0, maxLength);
+  const lastPlaceholderStart = truncated.lastIndexOf("[REDACTED:");
+  const lastPlaceholderEnd = truncated.lastIndexOf("]");
+  if (lastPlaceholderStart > lastPlaceholderEnd) {
+    return truncated.slice(0, lastPlaceholderStart).trimEnd();
+  }
+  return truncated;
+}
+function normalizeOptional(value) {
+  const normalized = value?.replace(/\s+/g, " ").trim();
+  return normalized ? redactSecrets(normalized) : undefined;
+}
+
+// src/tools/web-fetch.ts
+init_create_tool();
+init_resolve_working_directory();
+var DEFAULT_MAX_BYTES = 1e6;
+var MAX_BYTES_HARD_CAP = 5000000;
+var DEFAULT_TIMEOUT_MS4 = 15000;
+var MAX_TIMEOUT_MS2 = 30000;
+var MAX_REDIRECTS = 5;
+var MAX_TEXT_LENGTH2 = 50000;
+var ArgsSchema6 = exports_external.object({
+  url: exports_external.string().min(1).max(2048),
+  max_bytes: exports_external.number().int().min(1024).max(MAX_BYTES_HARD_CAP).optional(),
+  timeout_ms: exports_external.number().int().min(1000).max(MAX_TIMEOUT_MS2).optional(),
+  working_directory: exports_external.string().optional()
+});
+function isBlockedAddress(address) {
+  const family = isIP(address);
+  if (family === 4)
+    return isBlockedIPv4(address);
+  if (family === 6)
+    return isBlockedIPv6(address);
+  return true;
+}
+function isBlockedIPv4(address) {
+  const parts2 = address.split(".");
+  if (parts2.length !== 4)
+    return true;
+  const octets = parts2.map((p) => Number(p));
+  if (octets.some((o) => !Number.isInteger(o) || o < 0 || o > 255))
+    return true;
+  const [a, b] = octets;
+  if (a === 0)
+    return true;
+  if (a === 10)
+    return true;
+  if (a === 127)
+    return true;
+  if (a === 169 && b === 254)
+    return true;
+  if (a === 172 && b >= 16 && b <= 31)
+    return true;
+  if (a === 192 && b === 168)
+    return true;
+  if (a === 100 && b >= 64 && b <= 127)
+    return true;
+  if (a === 198 && (b === 18 || b === 19))
+    return true;
+  if (a === 192 && b === 0 && octets[2] === 0)
+    return true;
+  if (a === 192 && b === 0 && octets[2] === 2)
+    return true;
+  if (a === 198 && b === 51 && octets[2] === 100)
+    return true;
+  if (a === 203 && b === 0 && octets[2] === 113)
+    return true;
+  if (a === 192 && b === 88 && octets[2] === 99)
+    return true;
+  if (a >= 224)
+    return true;
+  return false;
+}
+function expandIPv6(input) {
+  let s = input.toLowerCase().split("%")[0];
+  if (!s)
+    return null;
+  if (s.includes(".")) {
+    const colon = s.lastIndexOf(":");
+    if (colon === -1)
+      return null;
+    const v4 = s.slice(colon + 1).split(".");
+    if (v4.length !== 4)
+      return null;
+    const o = v4.map((p) => Number(p));
+    if (o.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
+      return null;
+    const h1 = (o[0] << 8 | o[1]).toString(16);
+    const h2 = (o[2] << 8 | o[3]).toString(16);
+    s = `${s.slice(0, colon + 1)}${h1}:${h2}`;
+  }
+  const halves = s.split("::");
+  if (halves.length > 2)
+    return null;
+  const parseGroups = (part) => {
+    if (part === "")
+      return [];
+    const groups = part.split(":");
+    const out2 = [];
+    for (const g of groups) {
+      if (!/^[0-9a-f]{1,4}$/.test(g))
+        return null;
+      out2.push(Number.parseInt(g, 16));
+    }
+    return out2;
+  };
+  const head = parseGroups(halves[0]);
+  if (head === null)
+    return null;
+  if (halves.length === 2) {
+    const tail = parseGroups(halves[1]);
+    if (tail === null)
+      return null;
+    const missing = 8 - head.length - tail.length;
+    if (missing < 1)
+      return null;
+    return [...head, ...new Array(missing).fill(0), ...tail];
+  }
+  return head.length === 8 ? head : null;
+}
+function isBlockedIPv6(raw) {
+  const h = expandIPv6(raw);
+  if (!h)
+    return true;
+  if (h.every((x) => x === 0))
+    return true;
+  if (h.slice(0, 7).every((x) => x === 0) && h[7] === 1)
+    return true;
+  const mappedV4 = h.slice(0, 5).every((x) => x === 0) && h[5] === 65535;
+  const compatV4 = h.slice(0, 6).every((x) => x === 0) && !(h[6] === 0 && h[7] <= 1);
+  if (mappedV4 || compatV4) {
+    const v4 = `${h[6] >> 8}.${h[6] & 255}.${h[7] >> 8}.${h[7] & 255}`;
+    return isBlockedIPv4(v4);
+  }
+  const first = h[0];
+  if (first >= 64512 && first <= 65023)
+    return true;
+  if (first >= 65152 && first <= 65215)
+    return true;
+  if (first >= 65280)
+    return true;
+  return false;
+}
+async function validateFetchUrl(candidate, dnsLookup) {
+  let url3;
+  try {
+    url3 = new URL(candidate);
+  } catch {
+    return {
+      ok: false,
+      reason: "invalid_url",
+      message: `Not a valid URL: ${candidate}`
+    };
+  }
+  if (url3.protocol !== "http:" && url3.protocol !== "https:") {
+    return {
+      ok: false,
+      reason: "blocked_scheme",
+      message: `Only http and https URLs are allowed (got "${url3.protocol}").`
+    };
+  }
+  const host = url3.hostname.replace(/^\[|\]$/g, "");
+  if (isIP(host)) {
+    if (isBlockedAddress(host)) {
+      return {
+        ok: false,
+        reason: "blocked_host",
+        message: `Refusing to fetch a private, loopback, or reserved address: ${host}`
+      };
+    }
+    return { ok: true, url: url3, address: host };
+  }
+  let resolved;
+  try {
+    resolved = await dnsLookup(host, { all: true });
+  } catch (err3) {
+    return {
+      ok: false,
+      reason: "dns_failure",
+      message: `Could not resolve host "${host}": ${err3 instanceof Error ? err3.message : String(err3)}`
+    };
+  }
+  if (resolved.length === 0) {
+    return {
+      ok: false,
+      reason: "dns_failure",
+      message: `Host "${host}" resolved to no addresses.`
+    };
+  }
+  for (const { address } of resolved) {
+    if (isBlockedAddress(address)) {
+      return {
+        ok: false,
+        reason: "blocked_host",
+        message: `Host "${host}" resolves to a private, loopback, or reserved address (${address}).`
+      };
+    }
+  }
+  return { ok: true, url: url3, address: resolved[0].address };
+}
+function isAllowedContentType(contentType) {
+  if (!contentType)
+    return true;
+  const type = contentType.split(";")[0].trim().toLowerCase();
+  if (type.startsWith("text/"))
+    return true;
+  if (type === "application/json" || type === "application/xml")
+    return true;
+  if (type === "application/xhtml+xml" || type.endsWith("+json") || type.endsWith("+xml")) {
+    return true;
+  }
+  return false;
+}
+function extractTitle(html) {
+  const lower = html.toLowerCase();
+  const start2 = lower.indexOf("<title");
+  if (start2 === -1)
+    return;
+  const tagEnd = lower.indexOf(">", start2);
+  if (tagEnd === -1)
+    return;
+  const contentStart = tagEnd + 1;
+  const end = lower.indexOf("</title", contentStart);
+  if (end === -1)
+    return;
+  const content = html.slice(contentStart, end);
+  const title = decodeEntities(content.replace(/\s+/g, " ").trim());
+  return title || undefined;
+}
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'",
+  nbsp: " ",
+  "#39": "'"
+};
+function decodeEntities(text) {
+  return text.replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (whole, body2) => {
+    const key = body2.toLowerCase();
+    if (key in NAMED_ENTITIES)
+      return NAMED_ENTITIES[key];
+    if (body2.startsWith("#x") || body2.startsWith("#X")) {
+      const code = Number.parseInt(body2.slice(2), 16);
+      return Number.isFinite(code) ? safeFromCodePoint(code) : whole;
+    }
+    if (body2.startsWith("#")) {
+      const code = Number.parseInt(body2.slice(1), 10);
+      return Number.isFinite(code) ? safeFromCodePoint(code) : whole;
+    }
+    return whole;
+  });
+}
+function safeFromCodePoint(code) {
+  try {
+    return String.fromCodePoint(code);
+  } catch {
+    return "";
+  }
+}
+function stripSpans(input, open3, close) {
+  const lower = input.toLowerCase();
+  let out2 = "";
+  let i2 = 0;
+  while (i2 < input.length) {
+    const start2 = lower.indexOf(open3, i2);
+    if (start2 === -1) {
+      out2 += input.slice(i2);
+      break;
+    }
+    out2 += input.slice(i2, start2);
+    const end = lower.indexOf(close, start2 + open3.length);
+    if (end === -1)
+      break;
+    i2 = end + close.length;
+  }
+  return out2;
+}
+function htmlToText(html) {
+  let withoutScripts = stripSpans(html, "<script", "</script>");
+  withoutScripts = stripSpans(withoutScripts, "<style", "</style>");
+  withoutScripts = stripSpans(withoutScripts, "<noscript", "</noscript>");
+  withoutScripts = stripSpans(withoutScripts, "<!--", "-->");
+  const withBreaks = withoutScripts.replace(/<\/(p|div|li|h[1-6]|tr|section|article|header|footer)>/gi, `
+`).replace(/<br\s*\/?>/gi, `
+`);
+  const noTags = withBreaks.replace(/<[^>]+>/g, " ");
+  const decoded = decodeEntities(noTags);
+  return decoded.replace(/[ \t\f\v]+/g, " ").replace(/\s*\n\s*/g, `
+`).replace(/\n{3,}/g, `
+
+`).trim();
+}
+function makeAbortError() {
+  try {
+    return new DOMException("The operation was aborted", "AbortError");
+  } catch {
+    const err3 = new Error("The operation was aborted");
+    err3.name = "AbortError";
+    return err3;
+  }
+}
+function performHttpRequest(args2) {
+  const { url: url3, pinnedAddress, signal, headers } = args2;
+  const isHttps = url3.protocol === "https:";
+  const port = url3.port ? Number(url3.port) : isHttps ? 443 : 80;
+  const hostNoBrackets = url3.hostname.replace(/^\[|\]$/g, "");
+  const useSni = isHttps && isIP(hostNoBrackets) === 0;
+  const options = {
+    host: pinnedAddress,
+    port,
+    path: `${url3.pathname}${url3.search}`,
+    method: "GET",
+    headers: { Host: url3.host, ...headers }
+  };
+  if (useSni)
+    options.servername = url3.hostname;
+  return new Promise((resolve72, reject) => {
+    let req;
+    const onResponse = (res) => {
+      const normHeaders = {};
+      for (const [key, value] of Object.entries(res.headers)) {
+        normHeaders[key] = Array.isArray(value) ? value[0] : value;
+      }
+      res.on("error", () => {});
+      resolve72({
+        status: res.statusCode ?? 0,
+        headers: normHeaders,
+        body: res,
+        cancel: () => req.destroy()
+      });
+    };
+    req = isHttps ? https.request(options, onResponse) : http.request(options, onResponse);
+    const onAbort = () => req.destroy(makeAbortError());
+    if (signal.aborted)
+      req.destroy(makeAbortError());
+    else
+      signal.addEventListener("abort", onAbort, { once: true });
+    req.on("error", reject);
+    req.end();
+  });
+}
+async function boundedFetch(start2, maxBytes, timeoutMs, deps) {
+  let current = start2;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    for (let hop = 0;hop <= MAX_REDIRECTS; hop++) {
+      let raw;
+      try {
+        raw = await deps.httpRequest({
+          url: current.url,
+          pinnedAddress: current.address,
+          signal: controller.signal,
+          headers: {
+            Accept: "text/html,application/xhtml+xml,text/plain,application/json;q=0.9,*/*;q=0.5"
+          }
+        });
+      } catch (err3) {
+        if (controller.signal.aborted) {
+          return {
+            ok: false,
+            reason: "timeout",
+            message: `Fetch exceeded ${timeoutMs}ms for ${current.url.toString()}`
+          };
+        }
+        return {
+          ok: false,
+          reason: "network_error",
+          message: err3 instanceof Error ? err3.message : String(err3)
+        };
+      }
+      if (raw.status >= 300 && raw.status < 400) {
+        const location = raw.headers.location;
+        raw.cancel?.();
+        if (!location) {
+          return {
+            ok: false,
+            reason: "bad_redirect",
+            message: `Redirect ${raw.status} with no Location header.`
+          };
+        }
+        let next;
+        try {
+          next = new URL(location, current.url);
+        } catch {
+          return {
+            ok: false,
+            reason: "bad_redirect",
+            message: `Invalid redirect target: ${location}`
+          };
+        }
+        const revalidated = await validateFetchUrl(next.toString(), deps.dnsLookup);
+        if (!revalidated.ok)
+          return revalidated;
+        if (hop === MAX_REDIRECTS) {
+          return {
+            ok: false,
+            reason: "too_many_redirects",
+            message: `Exceeded ${MAX_REDIRECTS} redirect hops.`
+          };
+        }
+        current = { url: revalidated.url, address: revalidated.address };
+        continue;
+      }
+      if (raw.status < 200 || raw.status >= 300) {
+        raw.cancel?.();
+        return {
+          ok: false,
+          reason: "http_error",
+          message: `HTTP ${raw.status} for ${current.url.toString()}`
+        };
+      }
+      const contentType = raw.headers["content-type"] ?? null;
+      if (!isAllowedContentType(contentType)) {
+        raw.cancel?.();
+        return {
+          ok: false,
+          reason: "unsupported_content_type",
+          message: `Refusing to read non-text content type "${contentType}".`
+        };
+      }
+      let activeBody = raw.body;
+      if (raw.body !== null && raw.body instanceof Readable) {
+        const encoding = (raw.headers["content-encoding"] ?? "").toLowerCase();
+        let decoder = null;
+        if (encoding === "gzip" || encoding === "x-gzip")
+          decoder = raw.body.pipe(zlib.createGunzip());
+        else if (encoding === "deflate")
+          decoder = raw.body.pipe(zlib.createInflate());
+        else if (encoding === "br")
+          decoder = raw.body.pipe(zlib.createBrotliDecompress());
+        if (decoder) {
+          decoder.on("error", () => {});
+          activeBody = decoder;
+        }
+      }
+      let body2;
+      try {
+        body2 = await readBounded(activeBody, maxBytes);
+      } catch (err3) {
+        raw.cancel?.();
+        if (controller.signal.aborted) {
+          return {
+            ok: false,
+            reason: "timeout",
+            message: `Fetch exceeded ${timeoutMs}ms while reading the body of ${current.url.toString()}`
+          };
+        }
+        return {
+          ok: false,
+          reason: "network_error",
+          message: err3 instanceof Error ? err3.message : String(err3)
+        };
+      }
+      raw.cancel?.();
+      return {
+        ok: true,
+        outcome: {
+          status: raw.status,
+          finalUrl: current.url.toString(),
+          contentType,
+          bytes: body2.bytes,
+          truncated: body2.truncated
+        }
+      };
+    }
+    return {
+      ok: false,
+      reason: "too_many_redirects",
+      message: `Exceeded ${MAX_REDIRECTS} redirect hops.`
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function readBounded(body2, maxBytes) {
+  if (!body2)
+    return { bytes: new Uint8Array(0), truncated: false };
+  const chunks = [];
+  let received = 0;
+  let truncated = false;
+  for await (const value of body2) {
+    if (!value || value.byteLength === 0)
+      continue;
+    chunks.push(value);
+    received += value.byteLength;
+    if (received > maxBytes) {
+      truncated = true;
+      break;
+    }
+  }
+  const merged = new Uint8Array(Math.min(received, maxBytes));
+  let offset = 0;
+  for (const chunk of chunks) {
+    if (offset >= merged.length)
+      break;
+    const slice = chunk.subarray(0, merged.length - offset);
+    merged.set(slice, offset);
+    offset += slice.byteLength;
+  }
+  return { bytes: merged, truncated };
+}
+var web_fetch = createSwarmTool({
+  description: "Fetch the readable text of a single http(s) URL for architect-driven deep research (MODE: DEEP_RESEARCH). " + "Returns decoded page text (HTML stripped to plain text), the document title, the final URL after redirects, " + "and an evidence reference stored alongside web_search results. Use it to read primary sources that web_search " + "only surfaces as snippets. Config-gated on council.general.enabled; no search API key required. " + "Blocks private/loopback/link-local/metadata addresses (re-validated across redirects), enforces a timeout, " + "and caps the response body size.",
+  args: {
+    url: exports_external.string().min(1).max(2048).describe("Absolute http(s) URL to fetch (1–2048 chars)."),
+    max_bytes: exports_external.number().int().min(1024).max(MAX_BYTES_HARD_CAP).optional().describe(`Max decoded response bytes to read (1024..${MAX_BYTES_HARD_CAP}, default ${DEFAULT_MAX_BYTES}).`),
+    timeout_ms: exports_external.number().int().min(1000).max(MAX_TIMEOUT_MS2).optional().describe(`Request timeout in ms (1000..${MAX_TIMEOUT_MS2}, default ${DEFAULT_TIMEOUT_MS4}).`),
+    working_directory: exports_external.string().optional().describe("Project root for config resolution and evidence storage. Optional.")
+  },
+  execute: async (args2, directory) => {
+    const parsed = ArgsSchema6.safeParse(args2);
+    if (!parsed.success) {
+      const fail = {
+        success: false,
+        reason: "invalid_args",
+        message: parsed.error.issues.map((i2) => `${i2.path.join(".")}: ${i2.message}`).join("; ")
+      };
+      return JSON.stringify(fail, null, 2);
+    }
+    const dirResult = resolveWorkingDirectory(parsed.data.working_directory, directory);
+    if (!dirResult.success) {
+      const fail = {
+        success: false,
+        reason: "invalid_working_directory",
+        message: dirResult.message
+      };
+      return JSON.stringify(fail, null, 2);
+    }
+    const config3 = _internals102.loadPluginConfig(dirResult.directory);
+    const generalConfig = config3.council?.general;
+    if (!generalConfig || generalConfig.enabled !== true) {
+      const fail = {
+        success: false,
+        reason: "council_general_disabled",
+        message: "web_fetch is disabled - set council.general.enabled: true in the resolved config: global ~/.config/opencode/opencode-swarm.json or project .opencode/opencode-swarm.json."
+      };
+      return JSON.stringify(fail, null, 2);
+    }
+    const validated = await validateFetchUrl(parsed.data.url, _internals102.dnsLookup);
+    if (!validated.ok) {
+      const fail = {
+        success: false,
+        reason: validated.reason,
+        message: validated.message
+      };
+      return JSON.stringify(fail, null, 2);
+    }
+    const maxBytes = parsed.data.max_bytes ?? DEFAULT_MAX_BYTES;
+    const timeoutMs = parsed.data.timeout_ms ?? DEFAULT_TIMEOUT_MS4;
+    const result = await boundedFetch({ url: validated.url, address: validated.address }, maxBytes, timeoutMs, _internals102);
+    if (!result.ok) {
+      const fail = {
+        success: false,
+        reason: result.reason,
+        message: result.message
+      };
+      return JSON.stringify(fail, null, 2);
+    }
+    const { outcome } = result;
+    const raw = new TextDecoder("utf-8", { fatal: false }).decode(outcome.bytes);
+    const isHtml = (outcome.contentType ?? "").toLowerCase().includes("html") || /<html|<!doctype html/i.test(raw);
+    const title = isHtml ? extractTitle(raw) : undefined;
+    const bodyText = isHtml ? htmlToText(raw) : raw.replace(/\s*\n\s*/g, `
+`).trim();
+    const text = bodyText.length > MAX_TEXT_LENGTH2 ? `${bodyText.slice(0, MAX_TEXT_LENGTH2)}…` : bodyText;
+    const textTruncated = outcome.truncated || bodyText.length > MAX_TEXT_LENGTH2;
+    const evidence = await captureFetchEvidence(dirResult.directory, outcome.finalUrl, title, text);
+    const ok2 = {
+      success: true,
+      url: parsed.data.url,
+      finalUrl: outcome.finalUrl,
+      status: outcome.status,
+      contentType: outcome.contentType ?? undefined,
+      title,
+      text,
+      truncated: textTruncated,
+      bytesReturned: outcome.bytes.byteLength,
+      evidence
+    };
+    return JSON.stringify(ok2, null, 2);
+  }
+});
+async function captureFetchEvidence(directory, url3, title, text) {
+  try {
+    const written = await _internals102.writeEvidenceDocuments(directory, [
+      {
+        sourceType: "crawl",
+        url: url3,
+        title,
+        text,
+        createdBy: "web_fetch"
+      }
+    ]);
+    return {
+      stored: written.records.length > 0,
+      ref: written.refs[0],
+      path: written.path
+    };
+  } catch (err3) {
+    return {
+      stored: false,
+      error: err3 instanceof Error ? err3.message : String(err3)
+    };
+  }
+}
+var _internals102 = {
+  httpRequest: performHttpRequest,
+  dnsLookup: lookup,
+  loadPluginConfig,
+  writeEvidenceDocuments
+};
+
 // src/tools/web-search.ts
 init_zod();
 init_loader();
@@ -140699,88 +141541,11 @@ function createWebSearchProvider(config3) {
   }
 }
 
-// src/evidence/documents.ts
-init_utils2();
-init_redaction();
-import { createHash as createHash16 } from "node:crypto";
-import { appendFile as appendFile17, mkdir as mkdir31 } from "node:fs/promises";
-import * as path188 from "node:path";
-var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
-var MAX_EVIDENCE_TEXT_LENGTH = 4000;
-async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
-  const filePath = validateSwarmPath(directory, EVIDENCE_CACHE_FILE);
-  const capturedAt = now().toISOString();
-  const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
-  if (records.length > 0) {
-    await mkdir31(path188.dirname(filePath), { recursive: true });
-    await appendFile17(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
-`)}
-`, "utf-8");
-  }
-  return {
-    path: ".swarm/evidence-cache/documents.jsonl",
-    records,
-    refs: records.map((record3) => record3.ref)
-  };
-}
-function createEvidenceDocumentRecord(input, defaultCapturedAt) {
-  const text = normalizeEvidenceText(input.text ?? input.snippet ?? "");
-  if (!text)
-    return null;
-  const capturedAt = input.capturedAt ?? defaultCapturedAt;
-  const base = {
-    sourceType: input.sourceType,
-    query: normalizeOptional(input.query),
-    title: normalizeOptional(input.title),
-    url: normalizeOptional(input.url),
-    text
-  };
-  const id = createEvidenceDocumentId(base);
-  return {
-    id,
-    ref: `evidence-cache:${id}`,
-    ...base,
-    capturedAt,
-    createdBy: normalizeOptional(input.createdBy),
-    metadata: input.metadata ?? {}
-  };
-}
-function createEvidenceDocumentId(input) {
-  const hash4 = createHash16("sha256").update([
-    input.sourceType,
-    input.query ?? "",
-    input.title ?? "",
-    input.url ?? "",
-    input.text
-  ].join(`
-`)).digest("hex");
-  return `evd_${hash4.slice(0, 16)}`;
-}
-function normalizeEvidenceText(text) {
-  const normalized = redactSecrets(text.replace(/\s+/g, " ").trim());
-  return truncateEvidenceText(normalized, MAX_EVIDENCE_TEXT_LENGTH);
-}
-function truncateEvidenceText(text, maxLength) {
-  if (text.length <= maxLength)
-    return text;
-  const truncated = text.slice(0, maxLength);
-  const lastPlaceholderStart = truncated.lastIndexOf("[REDACTED:");
-  const lastPlaceholderEnd = truncated.lastIndexOf("]");
-  if (lastPlaceholderStart > lastPlaceholderEnd) {
-    return truncated.slice(0, lastPlaceholderStart).trimEnd();
-  }
-  return truncated;
-}
-function normalizeOptional(value) {
-  const normalized = value?.replace(/\s+/g, " ").trim();
-  return normalized ? redactSecrets(normalized) : undefined;
-}
-
 // src/tools/web-search.ts
 init_create_tool();
 init_resolve_working_directory();
 var MAX_RESULTS_HARD_CAP = 10;
-var ArgsSchema6 = exports_external.object({
+var ArgsSchema7 = exports_external.object({
   query: exports_external.string().min(1).max(500),
   max_results: exports_external.number().int().min(1).max(20).optional(),
   freshness: exports_external.enum(["auto", "none", "day", "week", "month", "year"]).default("auto"),
@@ -140795,7 +141560,7 @@ var web_search = createSwarmTool({
     working_directory: exports_external.string().optional().describe("Project root for config resolution. Optional.")
   },
   execute: async (args2, directory) => {
-    const parsed = ArgsSchema6.safeParse(args2);
+    const parsed = ArgsSchema7.safeParse(args2);
     if (!parsed.success) {
       const fail = {
         success: false,
@@ -140878,7 +141643,7 @@ var web_search = createSwarmTool({
 });
 async function captureSearchEvidence(directory, query, results) {
   try {
-    const written = await _internals102.writeEvidenceDocuments(directory, results.map((result) => ({
+    const written = await _internals103.writeEvidenceDocuments(directory, results.map((result) => ({
       sourceType: "web_search",
       query,
       title: result.title,
@@ -140906,7 +141671,7 @@ async function captureSearchEvidence(directory, query, results) {
     };
   }
 }
-var _internals102 = {
+var _internals103 = {
   writeEvidenceDocuments
 };
 
@@ -140937,7 +141702,7 @@ var KnowledgeRecommendationSchema2 = exports_external.object({
   confidence: exports_external.number().min(0).max(1).default(0.5),
   evidence_refs: exports_external.array(exports_external.string().min(1)).default([])
 });
-var ArgsSchema7 = exports_external.object({
+var ArgsSchema8 = exports_external.object({
   phase: exports_external.number().int().min(0).max(999),
   verdict: exports_external.enum(["APPROVE", "CONCERNS", "REJECT"]),
   findings: exports_external.array(FindingSchema2).default([]),
@@ -140958,7 +141723,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
     provenance_session_id: exports_external.string().min(1).optional().describe("Session ID of the agent that produced this evidence (optional provenance).")
   },
   execute: async (rawArgs, directory) => {
-    const parsed = ArgsSchema7.safeParse(rawArgs);
+    const parsed = ArgsSchema8.safeParse(rawArgs);
     if (!parsed.success) {
       return JSON.stringify({
         success: false,
@@ -141237,7 +142002,7 @@ var VerdictSchema3 = exports_external.object({
   criteriaUnmet: exports_external.array(exports_external.string()),
   durationMs: exports_external.number().nonnegative()
 });
-var ArgsSchema8 = exports_external.object({
+var ArgsSchema9 = exports_external.object({
   phase: exports_external.number().int().min(1),
   projectSummary: exports_external.string().min(1),
   roundNumber: exports_external.number().int().min(1).max(10).optional(),
@@ -141253,7 +142018,7 @@ function normalizeFinalVerdict(verdict, requiredFixesCount) {
   return requiredFixesCount > 0 ? "rejected" : "concerns";
 }
 async function executeWriteFinalCouncilEvidence(args2, directory) {
-  const parsed = ArgsSchema8.safeParse(args2);
+  const parsed = ArgsSchema9.safeParse(args2);
   if (!parsed.success) {
     return JSON.stringify({
       success: false,
@@ -141373,7 +142138,7 @@ var write_final_council_evidence = createSwarmTool({
     verdicts: exports_external.array(VerdictSchema3).min(1).max(5).describe("Collected CouncilMemberVerdict objects from critic, reviewer, sme, test_engineer, and explorer.")
   },
   execute: async (args2, directory) => {
-    const parsed = ArgsSchema8.safeParse(args2);
+    const parsed = ArgsSchema9.safeParse(args2);
     if (!parsed.success) {
       return JSON.stringify({
         success: false,
@@ -141707,6 +142472,7 @@ var TOOL_MANIFEST = defineHandlers({
   get_qa_gate_profile: () => get_qa_gate_profile,
   set_qa_gates: () => set_qa_gates,
   web_search: () => web_search,
+  web_fetch: () => web_fetch,
   convene_general_council: () => convene_general_council,
   write_final_council_evidence: () => write_final_council_evidence,
   skill_generate: () => skill_generate,
@@ -142389,6 +143155,10 @@ async function initializeOpenCodeSwarm(ctx) {
           template: "/swarm deep-dive $ARGUMENTS",
           description: "Use /swarm deep-dive to launch a read-only deep audit with parallel explorer waves, dual reviewers, and critic challenge"
         },
+        "swarm-deep-research": {
+          template: "/swarm deep-research $ARGUMENTS",
+          description: "Use /swarm deep-research <question> to run a multi-source, fact-checked deep research pass and synthesize a cited report [--depth standard|exhaustive] [--max-researchers 1..6] [--rounds 1..4] [--brief]"
+        },
         "swarm-codebase-review": {
           template: "/swarm codebase-review $ARGUMENTS",
           description: "Use /swarm codebase-review to launch codebase-review-swarm for a quote-grounded full-repo or large-subsystem audit"