@lazyingart/agintiflow 0.11.0 → 0.12.1

package/README.md

@@ -67,12 +67,16 @@ aginti
 aginti chat
 ```
 
-Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
+Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, while Enter sends the message. Assistant responses render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, and tables. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
 
 For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSeek v4 pro by default and exposes `apply_patch` as a deterministic workspace tool. It supports exact replacements, Codex-style patch envelopes, and unified diffs, with preflight checks, path guardrails, hashes, and compact per-file diffs. See [docs/patch-tools.md](docs/patch-tools.md).
 
 For larger repositories, use `--profile large-codebase` or choose **Large codebase engineering** in the web UI. The web default stays **Auto**, and Auto now escalates codebase/system/debugging prompts to the same engineering loop when needed. Complex work routes to DeepSeek v4 pro, starts with `inspect_project`, then uses search/read/patch/check loops inspired by Codex, Copilot SDK, Claude Code, Gemini CLI, Qwen, and Claw Code. See [docs/large-codebase-engineering.md](docs/large-codebase-engineering.md).
 
+AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. Scouts run independently for architecture, implementation, review, and research risks, then the main agent uses those notes while still doing the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..4`.
+
+For current docs, install errors, package/toolchain setup, and source discovery, the agent has a guarded `web_search` tool. It returns compact search results without browser search-engine loops and respects configured domain allowlists. Disable with `--no-web-search`.
+
 For raster image work, AgInTiFlow has an optional `image_generation` skill backed by the `generate_image` tool and a local `GRSAI` key. The skill tells DeepSeek when image generation is appropriate; the tool calls GRS AI Nano Banana, saves manifests/images under `artifacts/images`, and sends the result to the canvas. See [docs/auxiliary-image-generation.md](docs/auxiliary-image-generation.md).
 
 Launch the local web UI from an installed package:

package/docs/large-codebase-engineering.md

@@ -64,6 +64,33 @@ aginti "repair the Docker setup and run the Node tests"
 
 These route to DeepSeek v4 pro when the complexity score is high enough.
 
+## Parallel Scout Mode
+
+DeepSeek calls are cheap enough that complex tasks can use several short advisory calls before the main executor starts. When enabled, AgInTiFlow runs bounded scouts in parallel:
+
+- Architect: decomposes the task and identifies first files/logs/commands.
+- Implementer: predicts patch boundaries and focused checks.
+- Reviewer: looks for missing tests, risks, and instruction-compliance failures.
+- Researcher: suggests `web_search` queries when current information may matter.
+
+Scout output is injected as advisory context only. The main agent still owns execution and must use real tools to inspect, edit, run commands, and finish. CLI flags:
+
+```bash
+aginti --parallel-scouts --scout-count 4 "fix this complicated repo bug"
+aginti --no-parallel-scouts "run a cheap short task"
+```
+
+The web app exposes the same toggle and scout count.
+
+## Web Search
+
+Use `web_search` for current docs, package/toolchain errors, install instructions, and source discovery. It returns compact titles, URLs, and snippets, and should be preferred over opening a search engine in the browser. Specific result pages can still be opened later with `open_url`.
+
+```bash
+aginti --web-search "look up the current pytest config docs and update this project"
+aginti --no-web-search "work fully offline"
+```
+
 ## Cross-Language Playbook
 
 AgInTiFlow gives DeepSeek stack-specific reminders without hardcoding a solution:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",

package/public/app.js

@@ -69,6 +69,9 @@ const translations = {
     shellToolLabel: "Enable shell tool",
     fileToolLabel: "Enable file tools",
     auxiliaryToolLabel: "Enable auxiliary skills",
+    webSearchLabel: "Enable web search",
+    parallelScoutsLabel: "Parallel DeepSeek scouts",
+    parallelScoutCountLabel: "Scout count",
     wrapperToolLabel: "Enable agent wrappers",
     preferredWrapperLabel: "Preferred wrapper",
     dockerSandboxLabel: "Use Docker sandbox",
@@ -650,6 +653,9 @@ const runMetaEl = document.querySelector("#run-meta");
 const stopRunButton = document.querySelector("#stop-run");
 const keyStatusEl = document.querySelector("#key-status");
 const allowAuxiliaryToolsField = document.querySelector("#allowAuxiliaryTools");
+const allowWebSearchField = document.querySelector("#allowWebSearch");
+const allowParallelScoutsField = document.querySelector("#allowParallelScouts");
+const parallelScoutCountField = document.querySelector("#parallelScoutCount");
 const allowWrapperToolsField = document.querySelector("#allowWrapperTools");
 const preferredWrapperField = document.querySelector("#preferredWrapper");
 const wrapperStatusEl = document.querySelector("#wrapper-status");
@@ -1003,6 +1009,9 @@ function formPayload() {
     allowShellTool: document.querySelector("#allowShellTool").checked,
     allowFileTools: document.querySelector("#allowFileTools").checked,
     allowAuxiliaryTools: allowAuxiliaryToolsField?.checked ?? true,
+    allowWebSearch: allowWebSearchField?.checked ?? true,
+    allowParallelScouts: allowParallelScoutsField?.checked ?? true,
+    parallelScoutCount: Number(parallelScoutCountField?.value) || 3,
     allowWrapperTools: allowWrapperToolsField.checked,
     preferredWrapper: preferredWrapperField.value,
     taskProfile: taskProfileField?.value || "auto",
@@ -2196,6 +2205,9 @@ async function loadConfig() {
   document.querySelector("#allowShellTool").checked = prefs.allowShellTool ?? true;
   document.querySelector("#allowFileTools").checked = prefs.allowFileTools ?? true;
   if (allowAuxiliaryToolsField) allowAuxiliaryToolsField.checked = prefs.allowAuxiliaryTools ?? true;
+  if (allowWebSearchField) allowWebSearchField.checked = prefs.allowWebSearch ?? true;
+  if (allowParallelScoutsField) allowParallelScoutsField.checked = prefs.allowParallelScouts ?? true;
+  if (parallelScoutCountField) parallelScoutCountField.value = String(prefs.parallelScoutCount || 3);
   allowWrapperToolsField.checked = prefs.allowWrapperTools ?? false;
   preferredWrapperField.value = prefs.preferredWrapper || "codex";
   document.querySelector("#dockerSandboxImage").value = prefs.dockerSandboxImage || "agintiflow-sandbox:latest";

package/public/index.html

@@ -181,6 +181,16 @@
               <span class="switch" aria-hidden="true"></span>
               <span data-i18n="auxiliaryToolLabel">Enable auxiliary skills</span>
             </label>
+            <label class="switch-label">
+              <input id="allowWebSearch" name="allowWebSearch" type="checkbox" checked />
+              <span class="switch" aria-hidden="true"></span>
+              <span data-i18n="webSearchLabel">Enable web search</span>
+            </label>
+            <label class="switch-label">
+              <input id="allowParallelScouts" name="allowParallelScouts" type="checkbox" checked />
+              <span class="switch" aria-hidden="true"></span>
+              <span data-i18n="parallelScoutsLabel">Parallel DeepSeek scouts</span>
+            </label>
             <label class="switch-label">
               <input id="allowPasswords" name="allowPasswords" type="checkbox" />
               <span class="switch" aria-hidden="true"></span>
@@ -193,6 +203,11 @@
             </label>
           </div>
 
+          <label>
+            <span data-i18n="parallelScoutCountLabel">Scout count</span>
+            <input id="parallelScoutCount" name="parallelScoutCount" type="number" min="1" max="4" value="3" />
+          </label>
+
           <div class="grid wrapper-controls">
             <label class="switch-label switch-card">
               <input id="allowWrapperTools" name="allowWrapperTools" type="checkbox" />

package/scripts/smoke-cli-chat.js

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { stripMarkdown } from "../src/interactive-cli.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-cli-chat-"));
@@ -52,6 +53,23 @@ function runCli(args, inputText) {
 }
 
 try {
+  const renderedMarkdown = stripMarkdown(
+    [
+      "**Docker status**",
+      "",
+      "| Check | Result |",
+      "| --- | --- |",
+      "| `/.dockerenv` | **Present** |",
+      "| Hostname | `abc123` |",
+    ].join("\n")
+  );
+  if (renderedMarkdown.includes("**") || renderedMarkdown.includes("| --- |")) {
+    throw new Error("terminal markdown renderer left raw markdown syntax");
+  }
+  if (!renderedMarkdown.includes("Check") || !renderedMarkdown.includes("Present")) {
+    throw new Error("terminal markdown renderer dropped table content");
+  }
+
   const result = await runChat("Create notes/interactive.md with a short CLI chat smoke message\n/exit\n");
   const written = await fs.readFile(path.join(tempRoot, "notes/interactive.md"), "utf8");
   if (!written.includes("Created by AgInTiFlow mock mode.")) {
@@ -74,7 +92,7 @@ try {
       {
         ok: true,
         projectRoot: tempRoot,
-        checks: ["interactive-chat", "mock-file-write", "run-status", "resume-latest"],
+        checks: ["markdown-render", "interactive-chat", "mock-file-write", "run-status", "resume-latest"],
       },
       null,
       2

package/scripts/smoke-coding-tools.js

@@ -7,7 +7,9 @@ import { repairModelMessageHistory, runAgent } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { engineeringGuidanceForTask, recommendedMaxStepsForTask } from "../src/engineering-guidance.js";
 import { selectModelRoute } from "../src/model-routing.js";
+import { shouldRunParallelScouts } from "../src/parallel-scouts.js";
 import { SessionStore } from "../src/session-store.js";
+import { searchWeb } from "../src/web-search.js";
 import { executeWorkspaceTool } from "../src/workspace-tools.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -112,6 +114,24 @@ try {
   const guidance = engineeringGuidanceForTask("debug this Python project system bug and fix failing tests", "auto");
   assert(guidance.includes("Python:"), "engineering guidance did not include Python stack advice");
   assert(guidance.includes("System/shell:"), "engineering guidance did not include system stack advice");
+  assert(
+    shouldRunParallelScouts(
+      {
+        provider: "deepseek",
+        allowParallelScouts: true,
+        routeComplexityScore: autoSystemRoute.complexityScore,
+        taskProfile: "auto",
+        goal: "debug this Python project system bug and fix failing tests",
+      },
+      { meta: {}, goal: "debug this Python project system bug and fix failing tests" }
+    ),
+    "parallel scouts did not enable for complex auto task"
+  );
+  const drySearch = await searchWeb(
+    { query: "AgInTiFlow web_search smoke", maxResults: 2 },
+    { allowWebSearch: true, webSearchDryRun: true }
+  );
+  assert(drySearch.ok && drySearch.results.length === 1, "web_search dry-run did not return deterministic result");
 
   await fs.mkdir(path.join(workspace, "src"), { recursive: true });
   await fs.mkdir(path.join(workspace, "test"), { recursive: true });
@@ -285,6 +305,8 @@ try {
           "large_profile_pro_route",
           "auto_system_pro_route",
           "auto_engineering_guidance",
+          "parallel_scout_trigger",
+          "web_search_dry_run",
           "inspect_project",
           "mock_inspect_project",
           "write_file",

package/src/agent-runner.js

@@ -19,6 +19,8 @@ import { normalizeCanvasPayload } from "./artifact-tunnel.js";
 import { getTaskProfile } from "./task-profiles.js";
 import { generateImage, listAuxiliarySkills } from "./auxiliary-tools.js";
 import { engineeringGuidanceForTask } from "./engineering-guidance.js";
+import { searchWeb } from "./web-search.js";
+import { runParallelScouts, shouldRunParallelScouts } from "./parallel-scouts.js";
 
 const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "open_workspace_file", "preview_workspace", "click", "type", "scroll", "press", "back"]);
@@ -284,6 +286,12 @@ function createInitialState(config, sessionId) {
                 .map((skill) => `${skill.id} via ${skill.toolName} (${skill.available ? "key available" : `needs ${skill.keyName}`})`)
                 .join(", ")}. Use generate_image for real raster image/photo/illustration/cover/poster/logo requests when appropriate; if the key is missing, ask the user to run /auxilliary grsai or aginti login grsai.`
             : "Auxiliary skills are disabled for this run.",
+          config.allowWebSearch
+            ? "web_search is available for current information, docs, package/toolchain errors, and source discovery. Prefer web_search over browser search-engine navigation."
+            : "web_search is disabled.",
+          config.allowParallelScouts
+            ? `Parallel DeepSeek scouts may run before complex execution. Scout count: ${config.parallelScoutCount}.`
+            : "Parallel scouts are disabled.",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           engineeringGuidance,
           "A frontend canvas/artifacts tunnel exists. Use send_to_canvas when important markdown, diffs, screenshots, images, or workspace files should be highlighted in the UI. It is optional and ordinary final text can still go directly to finish.",
@@ -323,6 +331,8 @@ function createInitialState(config, sessionId) {
                 .map((skill) => `${skill.id}:${skill.available ? "available" : "missing-key"}`)
                 .join(" ")}`
             : "",
+          config.allowWebSearch ? "Web search tool: enabled." : "Web search tool: disabled.",
+          config.allowParallelScouts ? `Parallel scouts: enabled count=${config.parallelScoutCount}.` : "Parallel scouts: disabled.",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           engineeringGuidance,
           "Canvas/artifacts tunnel: available through send_to_canvas for optional frontend rendering.",
@@ -746,6 +756,13 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
       case "open_url":
         await abortable(browserState.page.goto(String(args.url), { waitUntil: "domcontentloaded" }), config.abortSignal);
         break;
+      case "web_search": {
+        const result = await searchWeb(args, config);
+        const eventResult = sanitizeToolResult(result);
+        await store.appendEvent(result.ok ? "tool.completed" : "tool.failed", eventResult);
+        observers.event(result.ok ? "tool.completed" : "tool.failed", eventResult);
+        return result;
+      }
       case "open_workspace_file": {
         const target = resolveWorkspacePath(config, args.path || args.file || ".");
         const stat = await fs.stat(target.absolutePath);
@@ -1111,6 +1128,40 @@ export async function runAgent(config) {
       observers.event("plan.created", { plan });
     }
 
+    if (shouldRunParallelScouts(config, state)) {
+      const scouts = await runParallelScouts(client, config, state);
+      state.meta.parallelScoutsCompleted = true;
+      state.meta.parallelScouts = {
+        model: scouts.model,
+        requested: scouts.requested,
+        completed: scouts.completed,
+      };
+      state.messages.push({
+        role: "user",
+        content: scouts.summary,
+      });
+      await store.appendEvent("parallel_scouts.completed", {
+        model: scouts.model,
+        requested: scouts.requested,
+        completed: scouts.completed,
+        scouts: scouts.scouts.map((scout) => ({
+          name: scout.name,
+          model: scout.model,
+          content: scout.content || "",
+          error: scout.error || "",
+        })),
+      });
+      await store.saveState(state);
+      observers.event("parallel_scouts.completed", {
+        model: scouts.model,
+        requested: scouts.requested,
+        completed: scouts.completed,
+      });
+      emitConsole(config, `Parallel scouts: ${scouts.completed}/${scouts.requested} completed using ${scouts.model}`, {
+        kind: "meta",
+      });
+    }
+
     const repair = repairModelMessageHistory(state, config);
     if (repair.changed) {
       await store.appendEvent("history.repaired", repair);
@@ -1129,6 +1180,9 @@ export async function runAgent(config) {
       allowShellTool: config.allowShellTool,
       allowWrapperTools: config.allowWrapperTools,
       preferredWrapper: normalizeWrapperName(config.preferredWrapper),
+      allowWebSearch: config.allowWebSearch,
+      allowParallelScouts: config.allowParallelScouts,
+      parallelScoutCount: config.parallelScoutCount,
       wrappers: config.allowWrapperTools ? wrapperStatusText() : "",
       workspaceFileTools: summarizeWorkspaceTools(config),
       shellSandbox: config.useDockerSandbox ? "docker" : "host",
@@ -1198,6 +1252,8 @@ export async function runAgent(config) {
           agentWrappersAvailable: config.allowWrapperTools,
           preferredWrapper: normalizeWrapperName(config.preferredWrapper),
           agentWrappers: config.allowWrapperTools ? wrapperStatusText() : "",
+          webSearchAvailable: config.allowWebSearch !== false,
+          parallelScouts: state.meta.parallelScouts || null,
           shellSandbox: config.useDockerSandbox ? "docker" : "host",
           sandboxMode: config.sandboxMode,
           packageInstallPolicy: config.packageInstallPolicy,

package/src/capabilities.js

@@ -207,6 +207,11 @@ export async function buildCapabilityReport(projectRoot, packageVersion, config)
         toolName: skill.toolName,
         available: skill.available,
       })),
+      orchestration: {
+        webSearch: config.allowWebSearch !== false,
+        parallelScouts: config.allowParallelScouts !== false,
+        parallelScoutCount: Number(config.parallelScoutCount) || 3,
+      },
     },
     checks,
     maintenancePolicy: maintenancePolicyChecks(config),

package/src/cli.js

@@ -46,6 +46,9 @@ export function parseArgs(argv) {
     allowFileTools: undefined,
     allowWrapperTools: undefined,
     allowAuxiliaryTools: undefined,
+    allowWebSearch: undefined,
+    allowParallelScouts: undefined,
+    parallelScoutCount: undefined,
     allowDestructive: undefined,
     preferredWrapper: "",
     taskProfile: "",
@@ -183,6 +186,27 @@ export function parseArgs(argv) {
       result.allowAuxiliaryTools = false;
       continue;
     }
+    if (arg === "--web-search") {
+      result.allowWebSearch = true;
+      continue;
+    }
+    if (arg === "--no-web-search") {
+      result.allowWebSearch = false;
+      continue;
+    }
+    if (arg === "--parallel-scouts") {
+      result.allowParallelScouts = true;
+      continue;
+    }
+    if (arg === "--no-parallel-scouts") {
+      result.allowParallelScouts = false;
+      continue;
+    }
+    if (arg === "--scout-count") {
+      result.parallelScoutCount = Number(readOption(argv, i));
+      i += 1;
+      continue;
+    }
     if (arg === "--allow-wrappers") {
       result.allowWrapperTools = true;
       continue;
@@ -237,7 +261,7 @@ export function parseArgs(argv) {
 
 function printUsage() {
   console.log(
-    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti login deepseek|openai|grsai OR aginti resume [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti login deepseek|openai|grsai OR aginti resume [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-file-tools|--no-file-tools] [--web-search|--no-web-search] [--parallel-scouts|--no-parallel-scouts --scout-count 3] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
   );
 }
 
@@ -254,6 +278,9 @@ function agentDefaults(args) {
     allowShellTool: args.allowShellTool ?? true,
     allowFileTools: args.allowFileTools ?? true,
     allowAuxiliaryTools: args.allowAuxiliaryTools ?? true,
+    allowWebSearch: args.allowWebSearch ?? true,
+    allowParallelScouts: args.allowParallelScouts ?? true,
+    parallelScoutCount: args.parallelScoutCount || 3,
     sandboxMode: args.sandboxMode || "docker-workspace",
     packageInstallPolicy: args.packageInstallPolicy || "allow",
     useDockerSandbox: args.useDockerSandbox ?? true,

package/src/config.js

@@ -90,6 +90,12 @@ export function resolveRuntimeConfig(args, overrides = {}) {
       overrides.allowAuxiliaryTools ?? args.allowAuxiliaryTools ?? process.env.ALLOW_AUXILIARY_TOOLS,
       true
     ),
+    allowWebSearch: parseBoolean(overrides.allowWebSearch ?? args.allowWebSearch ?? process.env.ALLOW_WEB_SEARCH, true),
+    allowParallelScouts: parseBoolean(
+      overrides.allowParallelScouts ?? args.allowParallelScouts ?? process.env.AGINTI_PARALLEL_SCOUTS,
+      true
+    ),
+    parallelScoutCount: parseNumber(overrides.parallelScoutCount ?? args.parallelScoutCount ?? process.env.AGINTI_SCOUT_COUNT, 3),
     preferredWrapper: normalizeWrapperName(
       overrides.preferredWrapper ?? args.preferredWrapper ?? process.env.PREFERRED_WRAPPER ?? process.env.AGENT_WRAPPER
     ),

package/src/guardrails.js

@@ -72,6 +72,18 @@ export function checkToolUse({ toolName, args, snapshot, config }) {
     return { allowed: true };
   }
 
+  if (toolName === "web_search") {
+    if (config.allowWebSearch === false) {
+      return { allowed: false, reason: "Web search is disabled for this run.", category: "web-search" };
+    }
+    const query = String(args.query || "").trim();
+    if (!query) return { allowed: false, reason: "Search query is required.", category: "web-search" };
+    if (Buffer.byteLength(query, "utf8") > 500) {
+      return { allowed: false, reason: "Search query is too large.", category: "web-search" };
+    }
+    return { allowed: true };
+  }
+
   if (toolName === "open_workspace_file" || toolName === "preview_workspace") {
     if (!config.allowFileTools) {
       return { allowed: false, reason: "Workspace preview tools require file tools to be enabled.", category: "workspace-tools" };

package/src/interactive-cli.js

@@ -18,6 +18,9 @@ const ansi = {
   green: "\x1b[32m",
   yellow: "\x1b[33m",
   red: "\x1b[31m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  faint: "\x1b[2m",
   clearLine: "\x1b[2K",
   cursorHide: "\x1b[?25l",
   cursorShow: "\x1b[?25h",
@@ -37,6 +40,8 @@ const SLASH_COMMANDS = [
   "/resume",
   "/sessions",
   "/profile",
+  "/web-search",
+  "/scouts",
   "/routing",
   "/provider",
   "/model",
@@ -62,6 +67,26 @@ function label(name, bgCode) {
   return color(` ${name} `, bgCode, ansi.bold);
 }
 
+function terminalWidth() {
+  return Math.max(Number(output.columns) || 80, 40);
+}
+
+function visualLength(value) {
+  return stripAnsi(value).length;
+}
+
+function padVisible(value, width) {
+  const padding = Math.max(width - visualLength(value), 0);
+  return `${value}${" ".repeat(padding)}`;
+}
+
+function panelLine(content = "", bgCode = ansi.systemBg) {
+  const width = terminalWidth();
+  if (!useColor) return padVisible(content, width);
+  const padded = padVisible(content, width).replaceAll(ansi.reset, `${ansi.reset}${bgCode}`);
+  return `${bgCode}${padded}${ansi.reset}`;
+}
+
 function userPrompt() {
   return `\n${label("user>", ansi.userBg)} ${color("|", ansi.userBg)} `;
 }
@@ -88,12 +113,13 @@ function commandSuggestions(line = "") {
   return SLASH_COMMANDS.filter((command) => command.startsWith(trimmed)).slice(0, 8);
 }
 
-function stripMarkdown(text) {
+export function stripMarkdown(text) {
   const lines = String(text || "").split(/\r?\n/);
   let inFence = false;
   const rendered = [];
 
-  for (const rawLine of lines) {
+  for (let index = 0; index < lines.length; index += 1) {
+    const rawLine = lines[index];
     let line = rawLine;
     if (/^\s*```/.test(line)) {
       inFence = !inFence;
@@ -117,6 +143,12 @@ function stripMarkdown(text) {
       if (/^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line)) {
         continue;
       }
+      const table = parseMarkdownTable(lines, index);
+      if (table) {
+        rendered.push(...renderMarkdownTable(table));
+        index += table.rawLineCount - 1;
+        continue;
+      }
       line = line.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)");
       line = line.replace(/\*\*([^*]+)\*\*/g, (_, value) => color(value, ansi.bold));
       line = line.replace(/__([^_]+)__/g, (_, value) => color(value, ansi.bold));
@@ -135,6 +167,75 @@ function stripMarkdown(text) {
   return rendered.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
 }
 
+function splitMarkdownTableRow(line = "") {
+  const trimmed = String(line || "").trim();
+  if (!trimmed.includes("|")) return null;
+  const normalized = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  const cells = normalized.split("|").map((cell) => cell.trim());
+  return cells.length >= 2 ? cells : null;
+}
+
+function isMarkdownTableSeparator(line = "") {
+  const cells = splitMarkdownTableRow(line);
+  return Boolean(cells?.length) && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+}
+
+function parseMarkdownTable(lines, startIndex) {
+  const header = splitMarkdownTableRow(lines[startIndex]);
+  if (!header || !isMarkdownTableSeparator(lines[startIndex + 1] || "")) return null;
+  const rows = [];
+  let index = startIndex + 2;
+  while (index < lines.length) {
+    const row = splitMarkdownTableRow(lines[index]);
+    if (!row) break;
+    rows.push(row);
+    index += 1;
+  }
+  return {
+    header,
+    rows,
+    rawLineCount: Math.max(index - startIndex, 2),
+  };
+}
+
+function renderMarkdownTable(table) {
+  const allRows = [table.header, ...table.rows];
+  const columnCount = Math.max(...allRows.map((row) => row.length));
+  const widths = Array.from({ length: columnCount }, (_unused, column) =>
+    Math.min(
+      Math.max(
+        ...allRows.map((row) => visualLength(stripMarkdownInline(row[column] || ""))),
+        3
+      ),
+      36
+    )
+  );
+  const formatRow = (row, header = false) =>
+    widths
+      .map((width, column) => {
+        const value = stripMarkdownInline(row[column] || "");
+        return padVisible(value, width);
+      })
+      .join(color("  │  ", ansi.dim));
+  const separator = widths.map((width) => "─".repeat(width)).join(color("──┼──", ansi.dim));
+  return [
+    color(formatRow(table.header, true), ansi.bold, ansi.cyan),
+    color(separator, ansi.dim),
+    ...table.rows.map((row) => formatRow(row)),
+  ];
+}
+
+function stripMarkdownInline(value = "") {
+  return String(value)
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)")
+    .replace(/\*\*([^*]+)\*\*/g, (_, text) => color(text, ansi.bold))
+    .replace(/__([^_]+)__/g, (_, text) => color(text, ansi.bold))
+    .replace(/`([^`]+)`/g, (_, text) => color(text, ansi.yellow))
+    .replace(/~~([^~]+)~~/g, "$1")
+    .replace(/\*([^*]+)\*/g, "$1")
+    .replace(/_([^_]+)_/g, "$1");
+}
+
 function rolePrefix(name, bgCode) {
   return `${label(name, bgCode)} ${color("|", bgCode)} `;
 }
@@ -181,7 +282,10 @@ async function renderLaunchHeader(packageVersion = "") {
   const title = "AgInTi Flow";
   const subtitle = "web-first agent workspace";
   const version = packageVersion ? `v${packageVersion}` : "";
-  const line = "+--------------------------------------------------+";
+  const width = Math.min(Math.max(terminalWidth() - 2, 58), 82);
+  const top = `╭${"─".repeat(width)}╮`;
+  const mid = `├${"─".repeat(width)}┤`;
+  const bottom = `╰${"─".repeat(width)}╯`;
 
   if (!useColor || process.env.AGINTIFLOW_NO_ANIMATION === "1") {
     console.log(` AgInTiFlow ${packageVersion || ""}`.trim());
@@ -196,11 +300,15 @@ async function renderLaunchHeader(packageVersion = "") {
   output.write(`\r${ansi.clearLine}`);
   output.write(ansi.cursorShow);
 
-  console.log(color(line, "\x1b[38;5;45m"));
-  console.log(`${color("|", "\x1b[38;5;45m")} ${shimmerText(title, 2)} ${color(version.padStart(36 - title.length), ansi.dim)} ${color("|", "\x1b[38;5;45m")}`);
-  console.log(`${color("|", "\x1b[38;5;45m")} ${color(subtitle.padEnd(48), ansi.dim)} ${color("|", "\x1b[38;5;45m")}`);
-  console.log(`${color("|", "\x1b[38;5;45m")} ${color("browser + shell + files + docker + canvas".padEnd(48), ansi.cyan)} ${color("|", "\x1b[38;5;45m")}`);
-  console.log(color(line, "\x1b[38;5;45m"));
+  const border = "\x1b[38;5;45m";
+  const titleLine = `${shimmerText(title, 2)} ${color(version, ansi.dim)}`;
+  const tagline = "browser + shell + files + docker + web search + scouts";
+  console.log(color(top, border));
+  console.log(`${color("│", border)} ${padVisible(titleLine, width - 2)} ${color("│", border)}`);
+  console.log(`${color("│", border)} ${color(padVisible(subtitle, width - 2), ansi.dim)} ${color("│", border)}`);
+  console.log(color(mid, border));
+  console.log(`${color("│", border)} ${color(padVisible(tagline, width - 2), ansi.cyan)} ${color("│", border)}`);
+  console.log(color(bottom, border));
 }
 
 function printHelp() {
@@ -217,6 +325,8 @@ function printHelp() {
       "  /resume <session-id>      Continue a saved session.",
       "  /sessions                 List recent sessions in this project.",
       "  /profile <name>           Set task profile, e.g. code, website, latex, maintenance.",
+      "  /web-search on|off        Enable or disable the web_search tool.",
+      "  /scouts on|off|<1-4>      Enable parallel DeepSeek scouts and set scout count.",
       "  /routing <mode>           Set routing: smart, fast, complex, manual.",
       "  /provider <name>          Set provider: deepseek, openai, mock.",
       "  /model <name>             Set an explicit model, or /model auto.",
@@ -243,12 +353,17 @@ function renderPromptBuffer(buffer, previousLineCount = 0) {
   const lines = String(buffer || "").split("\n");
   const suggestions = commandSuggestions(lines[0] || "");
   const rendered = [];
-  rendered.push(`${userPrompt().replace(/^\n/, "")}${lines[0] || ""}`);
-  for (const line of lines.slice(1)) {
-    rendered.push(`${promptGutter()}${line}`);
+  const firstPrefix = " user ";
+  const nextPrefix = "  ... ";
+  const emptyHint = color("type a request, /help, Enter to send, Ctrl+J for newline", ansi.faint);
+  const cursor = color("▌", ansi.bold);
+  rendered.push(panelLine(`${firstPrefix}${lines[0] || emptyHint}${lines.length === 1 ? cursor : ""}`, ansi.userBg));
+  for (const [index, line] of lines.slice(1).entries()) {
+    const isLast = index === lines.length - 2;
+    rendered.push(panelLine(`${nextPrefix}${line}${isLast ? cursor : ""}`, ansi.userBg));
   }
   if (suggestions.length > 0) {
-    rendered.push(`${promptGutter()}${color(`suggest: ${suggestions.join("  ")}`, ansi.dim)}`);
+    rendered.push(panelLine(` hint  ${color(suggestions.join("  "), ansi.dim)}`, ansi.systemBg));
   }
   output.write(rendered.join("\n"));
   return rendered.length;
@@ -292,7 +407,7 @@ function readTtyPrompt() {
         reject(createAbortError());
         return;
       }
-      if ((key.ctrl && key.name === "j") || (key.sequence === "\n" && key.name !== "return" && key.name !== "enter")) {
+      if ((key.ctrl && key.name === "j") || key.sequence === "\n") {
         buffer += "\n";
         redraw();
         return;
@@ -350,7 +465,7 @@ function printStatus(state) {
   printSystemLine(`provider=${state.provider || "auto"} routing=${state.routingMode} model=${state.model || "auto"}`);
   printSystemLine(`profile=${state.taskProfile} maxSteps=${state.maxSteps}`);
   printSystemLine(
-    `shell=${state.allowShellTool} files=${state.allowFileTools} auxiliary=${state.allowAuxiliaryTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
+    `shell=${state.allowShellTool} files=${state.allowFileTools} webSearch=${state.allowWebSearch} scouts=${state.allowParallelScouts}:${state.parallelScoutCount} auxiliary=${state.allowAuxiliaryTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
   );
   if (state.sandboxMode !== "host") {
     printSystemLine(`dockerWorkspace=/workspace -> ${state.commandCwd || process.cwd()}`);
@@ -435,6 +550,9 @@ function createState(args = {}) {
     allowShellTool: args.allowShellTool ?? true,
     allowFileTools: args.allowFileTools ?? true,
     allowAuxiliaryTools: args.allowAuxiliaryTools ?? true,
+    allowWebSearch: args.allowWebSearch ?? true,
+    allowParallelScouts: args.allowParallelScouts ?? true,
+    parallelScoutCount: args.parallelScoutCount || 3,
     allowWrapperTools: args.allowWrapperTools ?? false,
     allowDestructive: args.allowDestructive ?? false,
     preferredWrapper: args.preferredWrapper || "codex",
@@ -597,6 +715,22 @@ async function handleCommand(line, state, packageDir) {
     printSystemLine(`profile=${state.taskProfile}`);
     return true;
   }
+  if (command === "web-search") {
+    state.allowWebSearch = value !== "off";
+    printSystemLine(`webSearch=${state.allowWebSearch ? "on" : "off"}`);
+    return true;
+  }
+  if (command === "scouts") {
+    if (value === "off") {
+      state.allowParallelScouts = false;
+    } else {
+      state.allowParallelScouts = true;
+      const count = Number(value);
+      if (Number.isFinite(count) && count > 0) state.parallelScoutCount = Math.min(Math.max(count, 1), 4);
+    }
+    printSystemLine(`parallelScouts=${state.allowParallelScouts ? "on" : "off"} count=${state.parallelScoutCount}`);
+    return true;
+  }
   if (command === "routing") {
     state.routingMode = value || "smart";
     printSystemLine(`routing=${state.routingMode}`);
@@ -692,6 +826,9 @@ async function runPrompt(prompt, state, packageDir) {
       allowShellTool: state.allowShellTool,
       allowFileTools: state.allowFileTools,
       allowAuxiliaryTools: state.allowAuxiliaryTools,
+      allowWebSearch: state.allowWebSearch,
+      allowParallelScouts: state.allowParallelScouts,
+      parallelScoutCount: state.parallelScoutCount,
       allowWrapperTools: state.allowWrapperTools,
       allowDestructive: state.allowDestructive,
       preferredWrapper: state.preferredWrapper,

package/src/model-client.js

@@ -122,6 +122,16 @@ function mockWorkspaceToolForGoal(goal = "") {
   return null;
 }
 
+function mockWebSearchToolForGoal(goal = "") {
+  const text = String(goal || "");
+  if (!/\b(web search|search web|search the web|look up|current|latest|recent|docs|documentation|online)\b/i.test(text)) return null;
+  const query = text.replace(/\s+/g, " ").slice(0, 180);
+  return mockToolCall("web_search", {
+    query,
+    maxResults: 3,
+  });
+}
+
 function mockPreviewToolForGoal(goal = "") {
   const text = String(goal).toLowerCase();
   if (!/(open|preview|view|browser|website|web\s*site)/.test(text)) return null;
@@ -213,6 +223,12 @@ export async function createPlan(client, config, state) {
                 .map((skill) => `${skill.id} via ${skill.toolName} (${skill.available ? "key available" : `needs ${skill.keyName}`})`)
                 .join(", ")}. For raster image generation requests, plan to use generate_image when a GRSAI key is available; otherwise ask the user to run /auxilliary grsai or aginti login grsai.`
             : "Auxiliary skills are disabled for this run.",
+          config.allowWebSearch
+            ? "web_search is available for current information, docs, install errors, package/toolchain questions, and source discovery. Prefer web_search over opening a search engine in the browser."
+            : "web_search is disabled for this run.",
+          config.allowParallelScouts
+            ? `Parallel scout notes may be injected before execution for complex tasks. Scout count: ${config.parallelScoutCount}.`
+            : "Parallel scouts are disabled.",
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           engineeringGuidance,
           "A canvas/artifacts tunnel is available through send_to_canvas. Use it when an output should be highlighted visually, such as screenshots, image files, important markdown, diffs, or generated artifact paths. It is optional for ordinary text answers.",
@@ -362,6 +378,26 @@ export async function requestNextStep(client, config, messages) {
     },
   ];
 
+  if (config.allowWebSearch !== false) {
+    tools.splice(-1, 0, {
+      type: "function",
+      function: {
+        name: "web_search",
+        description:
+          "Search the public web for current information, documentation, install errors, package/toolchain guidance, and source discovery. Returns compact result titles, URLs, and snippets. Prefer this over browser search-engine navigation; open specific results only when needed.",
+        parameters: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query. Do not include secrets or tokens." },
+            maxResults: { type: "integer", description: "Number of results, 1 to 10. Defaults to 5." },
+          },
+          required: ["query"],
+          additionalProperties: false,
+        },
+      },
+    });
+  }
+
   if (config.allowFileTools) {
     tools.splice(
       0,
@@ -637,6 +673,9 @@ export async function requestNextStep(client, config, messages) {
         Array.isArray(toolPayload.recommendedReads) && toolPayload.recommendedReads.length
           ? `Recommended reads: ${toolPayload.recommendedReads.join(", ")}`
           : "",
+        Array.isArray(toolPayload.results) && toolPayload.results.length
+          ? `Results:\n${toolPayload.results.map((item, index) => `${index + 1}. ${item.title} ${item.url}`).join("\n")}`
+          : "",
         toolPayload.path ? `Path: ${toolPayload.path}` : "",
         Array.isArray(toolPayload.changes)
           ? toolPayload.changes
@@ -677,6 +716,13 @@ export async function requestNextStep(client, config, messages) {
       }
     }
 
+    if (config.allowWebSearch !== false) {
+      const webSearchTool = mockWebSearchToolForGoal(config.goal);
+      if (webSearchTool) {
+        return mockChatResponse("Mock mode will exercise the web search tool.", [webSearchTool]);
+      }
+    }
+
     const canvasTool = mockCanvasToolForGoal(config.goal);
     if (canvasTool) {
       return mockChatResponse("Mock mode will publish a canvas artifact for the UI tunnel.", [canvasTool]);

package/src/parallel-scouts.js

@@ -0,0 +1,126 @@
+import { engineeringGuidanceForTask } from "./engineering-guidance.js";
+import { getModelPresets } from "./model-routing.js";
+import { getTaskProfile, normalizeTaskProfile } from "./task-profiles.js";
+import { redactSensitiveText } from "./redaction.js";
+
+const SCOUTS = [
+  {
+    name: "architect",
+    prompt:
+      "Decompose the task into independent workstreams. Identify the first files, manifests, logs, or commands the executor should inspect. Keep it actionable.",
+  },
+  {
+    name: "implementer",
+    prompt:
+      "Predict the most likely implementation path across languages/toolchains. Suggest patch boundaries and focused checks. Avoid writing full code.",
+  },
+  {
+    name: "reviewer",
+    prompt:
+      "Find instruction-compliance risks, missing tests, system/environment pitfalls, and stop conditions. Suggest how to avoid loops.",
+  },
+  {
+    name: "researcher",
+    prompt:
+      "If current external information may matter, suggest exact web_search queries and source types. Otherwise say no web search needed.",
+  },
+];
+
+function shouldUseComplexScouts(config, state) {
+  const profile = normalizeTaskProfile(config.taskProfile);
+  const goal = String(config.goal || state.goal || "");
+  return (
+    Number(config.routeComplexityScore || 0) >= 3 ||
+    ["large-codebase", "maintenance", "code"].includes(profile) ||
+    /\b(large|complex|complicated|debug|bug|failing|system|install|setup|codebase|repo|multi[- ]file|architecture|refactor|migration)\b/i.test(
+      goal
+    )
+  );
+}
+
+export function shouldRunParallelScouts(config, state) {
+  if (config.allowParallelScouts === false) return false;
+  if (config.provider === "mock") return false;
+  if (state?.meta?.parallelScoutsCompleted) return false;
+  return shouldUseComplexScouts(config, state || {});
+}
+
+function scoutModel(config) {
+  if (config.provider === "deepseek") return getModelPresets().fast.model;
+  return config.model;
+}
+
+function scoutMessages(config, state, scout) {
+  const profile = getTaskProfile(config.taskProfile);
+  const guidance = engineeringGuidanceForTask(config.goal || state.goal || "", config.taskProfile);
+  return [
+    {
+      role: "system",
+      content:
+        "You are a parallel scout for AgInTiFlow. Your answer is advisory only: do not claim work is done, do not ask questions, do not use tools, and keep under 180 words.",
+    },
+    {
+      role: "user",
+      content: [
+        `Scout role: ${scout.name}`,
+        scout.prompt,
+        `Goal: ${config.goal || state.goal || ""}`,
+        `Task profile: ${profile.label}. ${profile.prompt}`,
+        guidance,
+        `Workspace: ${config.commandCwd}`,
+        `Sandbox: ${config.sandboxMode}; package policy: ${config.packageInstallPolicy}`,
+        `Current plan:\n${state.plan || "(none yet)"}`,
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    },
+  ];
+}
+
+export async function runParallelScouts(client, config, state) {
+  const count = Math.min(Math.max(Number(config.parallelScoutCount) || 3, 1), SCOUTS.length);
+  const selected = SCOUTS.slice(0, count);
+  const model = scoutModel(config);
+  const settled = await Promise.allSettled(
+    selected.map(async (scout) => {
+      const response = await client.chat.completions.create(
+        {
+          model,
+          temperature: 0,
+          messages: scoutMessages(config, state, scout),
+        },
+        config.abortSignal ? { signal: config.abortSignal } : undefined
+      );
+      return {
+        name: scout.name,
+        model,
+        content: redactSensitiveText(response.choices[0]?.message?.content || "").trim(),
+      };
+    })
+  );
+
+  const scouts = settled.map((item, index) => {
+    if (item.status === "fulfilled") return item.value;
+    return {
+      name: selected[index]?.name || `scout-${index + 1}`,
+      model,
+      error: redactSensitiveText(item.reason instanceof Error ? item.reason.message : String(item.reason)),
+    };
+  });
+  const completed = scouts.filter((scout) => scout.content).length;
+  const summary = [
+    "Parallel scout notes. Treat these as advisory, not completed work.",
+    ...scouts.map((scout) =>
+      scout.content ? `\n## ${scout.name}\n${scout.content}` : `\n## ${scout.name}\nScout failed: ${scout.error || "unknown error"}`
+    ),
+  ].join("\n");
+
+  return {
+    ok: completed > 0,
+    model,
+    requested: selected.length,
+    completed,
+    scouts,
+    summary,
+  };
+}

package/src/web-db.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { getModelPresets } from "./model-routing.js";
 
-const PREFERENCES_SCHEMA_VERSION = 5;
+const PREFERENCES_SCHEMA_VERSION = 6;
 
 function defaultPreferences(baseDir) {
   const presets = getModelPresets();
@@ -19,6 +19,10 @@ function defaultPreferences(baseDir) {
     commandCwd: path.resolve(baseDir),
     allowShellTool: true,
     allowFileTools: true,
+    allowAuxiliaryTools: true,
+    allowWebSearch: true,
+    allowParallelScouts: true,
+    parallelScoutCount: 3,
     allowWrapperTools: false,
     preferredWrapper: "codex",
     wrapperTimeoutMs: 120000,
@@ -98,6 +102,11 @@ export class WebDatabase {
         if ((parsed.preferencesSchemaVersion || 1) < 5) {
           preferences.taskProfile = "auto";
         }
+        if ((parsed.preferencesSchemaVersion || 1) < 6) {
+          preferences.allowWebSearch = true;
+          preferences.allowParallelScouts = true;
+          preferences.parallelScoutCount = 3;
+        }
         this.savePreferences(preferences);
       }
       return preferences;

package/src/web-search.js

@@ -0,0 +1,111 @@
+import { isDomainAllowed } from "./guardrails.js";
+import { redactSensitiveText } from "./redaction.js";
+
+const MAX_QUERY_BYTES = 500;
+const MAX_RESULTS = 10;
+
+function decodeHtml(value = "") {
+  return String(value)
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&#x27;/g, "'")
+    .replace(/<[^>]+>/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalizeDuckDuckGoHref(href = "") {
+  const decoded = decodeHtml(href);
+  try {
+    const parsed = new URL(decoded, "https://duckduckgo.com");
+    const uddg = parsed.searchParams.get("uddg");
+    if (uddg) return decodeURIComponent(uddg);
+    if (/^https?:\/\//i.test(decoded)) return decoded;
+    return parsed.href;
+  } catch {
+    return decoded;
+  }
+}
+
+function parseDuckDuckGoHtml(html, maxResults, allowedDomains = []) {
+  const results = [];
+  const blocks = String(html || "").split(/<div class="result\b/i).slice(1);
+  for (const block of blocks) {
+    const anchor = block.match(/<a[^>]+class="[^"]*result__a[^"]*"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+    if (!anchor) continue;
+    const url = normalizeDuckDuckGoHref(anchor[1]);
+    if (!/^https?:\/\//i.test(url)) continue;
+    if (!isDomainAllowed(url, allowedDomains)) continue;
+    const snippet = block.match(/<a[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>/i) ||
+      block.match(/<div[^>]+class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/div>/i);
+    results.push({
+      title: decodeHtml(anchor[2]).slice(0, 220),
+      url,
+      snippet: snippet ? decodeHtml(snippet[1]).slice(0, 420) : "",
+    });
+    if (results.length >= maxResults) break;
+  }
+  return results;
+}
+
+export async function searchWeb(args = {}, config = {}) {
+  const query = String(args.query || "").trim();
+  if (!query) return { ok: false, toolName: "web_search", error: "Search query is required." };
+  if (Buffer.byteLength(query, "utf8") > MAX_QUERY_BYTES) {
+    return { ok: false, toolName: "web_search", error: "Search query is too large." };
+  }
+
+  const maxResults = Math.min(Math.max(Number(args.maxResults) || 5, 1), MAX_RESULTS);
+  const searchUrl = `https://duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+  if (config.webSearchDryRun) {
+    return {
+      ok: true,
+      toolName: "web_search",
+      query,
+      provider: "duckduckgo-html",
+      searchUrl,
+      dryRun: true,
+      results: [
+        {
+          title: `Dry-run search result for ${query}`,
+          url: "https://example.com/agintiflow-web-search-smoke",
+          snippet: "Deterministic web_search dry-run result.",
+        },
+      ].slice(0, maxResults),
+    };
+  }
+
+  try {
+    const response = await fetch(searchUrl, {
+      signal: config.abortSignal || AbortSignal.timeout(Number(args.timeoutMs) || 12000),
+      headers: {
+        "User-Agent": "AgInTiFlow/1.0 (+https://flow.lazying.art)",
+        Accept: "text/html,application/xhtml+xml",
+      },
+    });
+    const html = await response.text();
+    const results = parseDuckDuckGoHtml(html, maxResults, config.allowedDomains || []);
+    return {
+      ok: true,
+      toolName: "web_search",
+      query: redactSensitiveText(query),
+      provider: "duckduckgo-html",
+      status: response.status,
+      searchUrl,
+      results,
+      note: results.length ? "" : "No results parsed. The search URL is included as fallback.",
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      toolName: "web_search",
+      query: redactSensitiveText(query),
+      provider: "duckduckgo-html",
+      searchUrl,
+      error: redactSensitiveText(error instanceof Error ? error.message : String(error)),
+    };
+  }
+}

package/web.js

@@ -118,6 +118,7 @@ function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
   const providerDefaults = getProviderDefaults(provider);
   const parsedMaxSteps = Number(body.maxSteps);
   const parsedWrapperTimeoutMs = Number(body.wrapperTimeoutMs);
+  const parsedParallelScoutCount = Number(body.parallelScoutCount);
   const sandboxMode = normalizeSandboxMode(body.sandboxMode || current.sandboxMode || "docker-workspace");
 
   return {
@@ -143,6 +144,14 @@ function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
     allowFileTools: typeof body.allowFileTools === "boolean" ? body.allowFileTools : current.allowFileTools !== false,
     allowAuxiliaryTools:
       typeof body.allowAuxiliaryTools === "boolean" ? body.allowAuxiliaryTools : current.allowAuxiliaryTools !== false,
+    allowWebSearch:
+      typeof body.allowWebSearch === "boolean" ? body.allowWebSearch : current.allowWebSearch !== false,
+    allowParallelScouts:
+      typeof body.allowParallelScouts === "boolean" ? body.allowParallelScouts : current.allowParallelScouts !== false,
+    parallelScoutCount:
+      Number.isFinite(parsedParallelScoutCount) && parsedParallelScoutCount > 0
+        ? Math.min(Math.max(parsedParallelScoutCount, 1), 4)
+        : Number(current.parallelScoutCount) || 3,
     allowWrapperTools:
       typeof body.allowWrapperTools === "boolean" ? body.allowWrapperTools : Boolean(current.allowWrapperTools),
     preferredWrapper: normalizeWrapperName(body.preferredWrapper || current.preferredWrapper || "codex"),
@@ -221,6 +230,9 @@ function buildRunConfig(body, overrides = {}) {
       allowShellTool: merged.allowShellTool,
       allowFileTools: merged.allowFileTools,
       allowAuxiliaryTools: merged.allowAuxiliaryTools,
+      allowWebSearch: merged.allowWebSearch,
+      allowParallelScouts: merged.allowParallelScouts,
+      parallelScoutCount: merged.parallelScoutCount,
       allowWrapperTools: merged.allowWrapperTools,
       preferredWrapper: merged.preferredWrapper,
       wrapperTimeoutMs: merged.wrapperTimeoutMs,