@lazyingart/agintiflow 0.11.0 → 0.12.0

package/README.md

@@ -73,6 +73,10 @@ For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSee
 
 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.0",
   "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-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

@@ -37,6 +37,8 @@ const SLASH_COMMANDS = [
   "/resume",
   "/sessions",
   "/profile",
+  "/web-search",
+  "/scouts",
   "/routing",
   "/provider",
   "/model",
@@ -217,6 +219,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.",
@@ -350,7 +354,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 +439,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 +604,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 +715,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,