@lazyingart/agintiflow 0.10.0 → 0.12.0

package/README.md

@@ -71,7 +71,11 @@ Inside chat, type normal requests such as `write a small Python CLI app with tes
 
 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. This 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).
+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).
 

package/docs/large-codebase-engineering.md

@@ -10,6 +10,8 @@ Local agent references informed the design:
 - Copilot-style SDK surfaces: structured tools, session persistence, plan/history/workspace APIs, and explicit permission hooks.
 - Claude/Claw-style safety: project-local status, container-first execution, read-only operations by default, and clear failure recovery.
 - Gemini/Qwen-style extensibility: capability discovery through profiles and tools rather than hardcoding one model behavior.
+- Claw-style `doctor` discipline: check health and environment before treating system symptoms as code bugs.
+- Claude/Codex-style context discipline: read instructions, manifests, entry points, and failing tests before touching broad files.
 
 ## Skill vs Tool
 
@@ -47,3 +49,54 @@ aginti --profile large-codebase "fix the failing tests"
 or choose **Large codebase engineering** in the web task-profile dropdown.
 
 Smart routing sends this profile to DeepSeek v4 pro even when the user prompt is short.
+
+## Auto Profile Behavior
+
+The web app still defaults to **Auto**. Auto does not mean weak. When the prompt mentions a large repo, system bug, failing tests, setup, install, migration, or a known language stack, AgInTiFlow adds engineering guidance and raises the step budget automatically.
+
+Examples:
+
+```bash
+aginti "debug this Python project system bug and fix failing tests"
+aginti "fix the Rust workspace build"
+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:
+
+- JS/TS: inspect package scripts and lockfiles, then run focused `node`, `tsc`, or test commands.
+- Python: inspect `pyproject.toml` or requirements, prefer project-local venv/conda/Docker, then run focused pytest/module checks.
+- Rust/Go/JVM/C/C++: inspect native manifests, format only touched files when possible, and start with narrow build/test targets.
+- R/Stan/LaTeX: keep toolchains project-local or Docker-backed, compile from the right directory, and publish useful artifacts to canvas.
+- System tasks: diagnose first, capture versions/logs, write reversible scripts, use Docker for installs, and avoid silent host-level changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.10.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");
@@ -775,12 +781,25 @@ function renderTaskProfiles(selected = "auto") {
   taskProfileField.value = profiles.some((profile) => profile.id === selected) ? selected : "auto";
 }
 
-function recommendedMaxStepsForProfile(profile = "auto") {
+const COMPLEX_ENGINEERING_HINT = /\b(large|complex|complicated|monorepo|codebase|repository|repo-wide|multi[- ]file|cross[- ]file|architecture|refactor|migration|regression|root cause|failing tests?|fix build|system bug|debug|performance|security)\b/i;
+
+function recommendedMaxStepsForProfile(profile = "auto", goal = "") {
   if (profile === "large-codebase") return 36;
   if (profile === "latex") return 30;
+  if (COMPLEX_ENGINEERING_HINT.test(goal || "")) return 36;
+  if (/\b(latex|tex|pdflatex|latexmk|pdf|website|app|docker|system|install|setup|debug)\b/i.test(goal || "")) return 30;
   return 24;
 }
 
+function ensureRecommendedMaxStepsForCurrentTask() {
+  const maxStepsField = document.querySelector("#maxSteps");
+  const goalField = document.querySelector("#goal");
+  const recommended = recommendedMaxStepsForProfile(taskProfileField?.value || "auto", goalField?.value || "");
+  if (maxStepsField && Number(maxStepsField.value || 0) < recommended) {
+    maxStepsField.value = String(recommended);
+  }
+}
+
 function renderWrapperStatus(wrappers = lastWrappers) {
   lastWrappers = wrappers || [];
   if (lastWrappers.length === 0) {
@@ -990,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",
@@ -1966,11 +1988,7 @@ packageInstallPolicyField.addEventListener("change", updatePackageWarning);
 allowWrapperToolsField.addEventListener("change", () => renderWrapperStatus());
 preferredWrapperField.addEventListener("change", () => renderWrapperStatus());
 taskProfileField?.addEventListener("change", () => {
-  const maxStepsField = document.querySelector("#maxSteps");
-  const recommended = recommendedMaxStepsForProfile(taskProfileField.value);
-  if (maxStepsField && Number(maxStepsField.value || 0) < recommended) {
-    maxStepsField.value = String(recommended);
-  }
+  ensureRecommendedMaxStepsForCurrentTask();
   schedulePreferenceSave();
 });
 
@@ -2048,6 +2066,7 @@ form.addEventListener("submit", async (event) => {
     setLogs(t("goalRequired"), "empty");
     return;
   }
+  ensureRecommendedMaxStepsForCurrentTask();
 
   const payload = {
     ...formPayload(),
@@ -2186,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

@@ -5,8 +5,11 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 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)), "..");
@@ -93,6 +96,42 @@ try {
     taskProfile: "large-codebase",
   });
   assert(/pro/i.test(largeProfileRoute.model), "large-codebase profile did not route to DeepSeek pro");
+  const autoSystemRoute = selectModelRoute({
+    routingMode: "smart",
+    provider: "deepseek",
+    goal: "debug this Python project system bug and fix failing tests",
+    taskProfile: "auto",
+  });
+  assert(/pro/i.test(autoSystemRoute.model), "auto system/code problem did not route to DeepSeek pro");
+  assert(
+    recommendedMaxStepsForTask({
+      goal: "debug this Python project system bug and fix failing tests",
+      taskProfile: "auto",
+      complexityScore: autoSystemRoute.complexityScore,
+    }) >= 36,
+    "auto system/code problem did not get engineering step budget"
+  );
+  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 });
@@ -264,6 +303,10 @@ try {
           "deepseek_history_repair",
           "deepseek_pro_patch_route",
           "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

@@ -18,6 +18,9 @@ import { executeWorkspaceTool, resolveWorkspacePath, summarizeWorkspaceTools, WO
 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"]);
@@ -233,6 +236,7 @@ export function repairModelMessageHistory(state, config = {}) {
 function createInitialState(config, sessionId) {
   const now = new Date().toISOString();
   const taskProfile = getTaskProfile(config.taskProfile);
+  const engineeringGuidance = engineeringGuidanceForTask(config.goal, config.taskProfile);
   return {
     sessionId,
     createdAt: now,
@@ -282,7 +286,14 @@ 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.",
           "For visual-output requests such as draw, plot, graph, chart, diagram, figure, image, or visualization, proactively publish a canvas artifact even when the user does not mention canvas. If workspace file tools are enabled, prefer creating a small SVG or markdown artifact and call send_to_canvas with selected=true.",
           "Work like a practical coding agent: orient with inspect_project/search/read, patch code with apply_patch, run safe checks when they add confidence, iterate on failures, and keep outputs inside the workspace.",
@@ -320,7 +331,10 @@ 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.",
           "Visual-output requests should produce a canvas artifact without requiring the user to ask for canvas explicitly.",
           "Use file, shell, browser, canvas, and wrapper tools when they are useful; choose the workflow from the user's request. For complicated engineering tasks, keep a tight loop: inspect, choose minimal files, patch, run focused checks, repair, then summarize.",
@@ -410,6 +424,7 @@ function applyContinuationPrompt(state, config, observers) {
   if (!config.resume || !config.goal) return;
 
   const taskProfile = getTaskProfile(config.taskProfile);
+  const engineeringGuidance = engineeringGuidanceForTask(config.goal, config.taskProfile);
   ensureChatState(state);
   state.goal = config.goal;
   state.provider = config.provider;
@@ -436,6 +451,7 @@ function applyContinuationPrompt(state, config, observers) {
         ? `Agent wrappers: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
         : "",
       `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
+      engineeringGuidance,
     ]
       .filter(Boolean)
       .join("\n"),
@@ -740,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);
@@ -1105,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);
@@ -1123,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",
@@ -1192,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

@@ -14,7 +14,8 @@ import {
   setProviderKey,
   showProjectSession,
 } from "./project.js";
-import { defaultMaxStepsForProfile, listTaskProfiles } from "./task-profiles.js";
+import { listTaskProfiles } from "./task-profiles.js";
+import { recommendedMaxStepsForTask } from "./engineering-guidance.js";
 import { promptAndSaveDeepSeekKey, promptHidden, shouldPromptForDeepSeek } from "./auth-onboarding.js";
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -45,6 +46,9 @@ export function parseArgs(argv) {
     allowFileTools: undefined,
     allowWrapperTools: undefined,
     allowAuxiliaryTools: undefined,
+    allowWebSearch: undefined,
+    allowParallelScouts: undefined,
+    parallelScoutCount: undefined,
     allowDestructive: undefined,
     preferredWrapper: "",
     taskProfile: "",
@@ -182,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;
@@ -236,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"'
   );
 }
 
@@ -253,10 +278,18 @@ 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,
-    maxSteps: args.maxSteps || defaultMaxStepsForProfile(args.taskProfile || (args.latex ? "latex" : "auto")),
+    maxSteps:
+      args.maxSteps ||
+      recommendedMaxStepsForTask({
+        goal: args.goal || "",
+        taskProfile: args.taskProfile || (args.latex ? "latex" : "auto"),
+      }),
   };
 
   if (defaults.sandboxMode === "host") {

package/src/config.js

@@ -4,7 +4,8 @@ import { getProviderDefaults, normalizeRoutingMode, selectModelRoute } from "./m
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
 import { normalizeWrapperName } from "./tool-wrappers.js";
 import { loadProjectEnv, resolveProjectRoot } from "./project.js";
-import { defaultMaxStepsForProfile, normalizeTaskProfile } from "./task-profiles.js";
+import { normalizeTaskProfile } from "./task-profiles.js";
+import { recommendedMaxStepsForTask } from "./engineering-guidance.js";
 
 function parseBoolean(value, fallback) {
   if (value === undefined) return fallback;
@@ -43,6 +44,11 @@ export function resolveRuntimeConfig(args, overrides = {}) {
   });
 
   const defaults = getProviderDefaults(route.provider);
+  const defaultMaxSteps = recommendedMaxStepsForTask({
+    goal: args.goal || "",
+    taskProfile,
+    complexityScore: route.complexityScore,
+  });
   const packageDir = path.resolve(overrides.packageDir || process.env.AGINTIFLOW_PACKAGE_DIR || baseDir);
   const dockerRequested = parseBoolean(overrides.useDockerSandbox ?? args.useDockerSandbox ?? process.env.USE_DOCKER_SANDBOX, true);
   const requestedSandboxMode =
@@ -67,7 +73,7 @@ export function resolveRuntimeConfig(args, overrides = {}) {
     apiKey: overrides.apiKey || defaults.apiKey,
     baseURL: overrides.baseURL || defaults.baseURL,
     model: route.model || defaults.model,
-    maxSteps: parseNumber(overrides.maxSteps ?? args.maxSteps ?? process.env.MAX_STEPS, defaultMaxStepsForProfile(taskProfile)),
+    maxSteps: parseNumber(overrides.maxSteps ?? args.maxSteps ?? process.env.MAX_STEPS, defaultMaxSteps),
     headless: parseBoolean(overrides.headless ?? args.headless ?? process.env.HEADLESS, false),
     allowedDomains: Array.isArray(overrides.allowedDomains)
       ? overrides.allowedDomains
@@ -84,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/engineering-guidance.js

@@ -0,0 +1,102 @@
+import { defaultMaxStepsForProfile, normalizeTaskProfile } from "./task-profiles.js";
+
+const LANGUAGE_HINTS = [
+  {
+    id: "javascript-typescript",
+    pattern: /\b(node|npm|pnpm|yarn|bun|javascript|typescript|react|vue|svelte|next\.?js|vite|express)\b/i,
+    text:
+      "JS/TS: inspect package.json and lockfiles, identify package manager, use npm/pnpm/yarn scripts before inventing commands, prefer targeted node --check/tsc/test runs before broad builds.",
+  },
+  {
+    id: "python",
+    pattern: /\b(python|pytest|pip|uv|poetry|conda|venv|jupyter|fastapi|django|flask|pandas|numpy)\b/i,
+    text:
+      "Python: inspect pyproject/requirements, prefer project-local venv/uv/conda or Docker, run python -m pytest or focused module checks, avoid global package installs on host.",
+  },
+  {
+    id: "rust",
+    pattern: /\b(rust|cargo|crate|clippy|rustfmt|tokio|actix)\b/i,
+    text:
+      "Rust: inspect Cargo.toml/workspace crates, run cargo fmt/check/test on the narrowest crate first, preserve Cargo.lock discipline, avoid broad workspace runs until focused checks pass.",
+  },
+  {
+    id: "go",
+    pattern: /\b(golang|go test|go mod|goroutine|gin|grpc)\b/i,
+    text:
+      "Go: inspect go.mod, use go test ./pkg-or-target first, run gofmt on touched files, avoid changing module paths unless required.",
+  },
+  {
+    id: "java-jvm",
+    pattern: /\b(java|kotlin|gradle|maven|spring|junit|jvm)\b/i,
+    text:
+      "JVM: inspect pom.xml/build.gradle/settings.gradle, use focused Maven/Gradle test targets, keep generated build outputs out of source patches.",
+  },
+  {
+    id: "c-cpp",
+    pattern: /\b(c\+\+|cpp|cmake|makefile|gcc|clang|native|segfault|asan|valgrind)\b/i,
+    text:
+      "C/C++: inspect CMake/Make/build scripts, prefer out-of-tree builds, run compile-only or narrow tests first, use sanitizers only when available and safe.",
+  },
+  {
+    id: "shell-system",
+    pattern: /\b(shell|bash|zsh|system|systemd|docker|linux|ubuntu|debian|apt|yum|dnf|brew|service|permission denied|port|network)\b/i,
+    text:
+      "System/shell: diagnose first with read-only commands, capture versions/logs, make reversible scripts, use Docker for installs/toolchains, and only use host-level changes when policy explicitly allows them.",
+  },
+  {
+    id: "r-stats",
+    pattern: /\b(rstats|r language|cmdstanr|stan|renv|tidyverse|shiny)\b/i,
+    text:
+      "R/Stan: inspect renv/DESCRIPTION and project notes, prefer project-local libraries or Docker, validate scripts with non-interactive Rscript commands when available.",
+  },
+  {
+    id: "latex",
+    pattern: /\b(latex|tex|pdflatex|latexmk|bibtex|biber|pdf)\b/i,
+    text:
+      "LaTeX: keep source/figures together, compile from the document directory, run enough passes for refs/bibliography, publish PDF/source artifacts to canvas.",
+  },
+];
+
+const COMPLEX_ENGINEERING_PATTERN =
+  /\b(large|complex|complicated|monorepo|codebase|repository|repo-wide|multi[- ]file|cross[- ]file|architecture|refactor|migration|regression|root cause|failing tests?|fix build|system bug|debug|performance|security)\b/i;
+
+export function engineeringGuidanceForTask(goal = "", taskProfile = "auto") {
+  const normalizedProfile = normalizeTaskProfile(taskProfile);
+  const text = String(goal || "");
+  const matched = LANGUAGE_HINTS.filter((hint) => hint.pattern.test(text));
+  const wantsComplex =
+    normalizedProfile === "large-codebase" ||
+    normalizedProfile === "maintenance" ||
+    COMPLEX_ENGINEERING_PATTERN.test(text) ||
+    text.length > 500;
+
+  if (!wantsComplex && matched.length === 0) return "";
+
+  const lines = [
+    "Engineering operating mode:",
+    "Use the proven coding-agent loop: inspect_project, read instructions/manifests, search exact symbols/errors, patch small coherent batches, run focused checks, repair failures, then summarize changed files and residual risks.",
+    "Keep CLI and web behavior equivalent: use the same workspace, sessions, profiles, file tools, shell policy, Docker mounts, and canvas artifacts.",
+    "For large repositories, preserve context by reading fewer but more relevant files; prefer deterministic tools and diffs over long model memory.",
+    "For system repair, act like a doctor: gather evidence first, avoid silent destructive host changes, prefer Docker or project-local scripts for installs, and make every stronger action explicit in logs.",
+  ];
+
+  if (matched.length > 0) {
+    lines.push("Stack-specific checks:");
+    for (const hint of matched.slice(0, 5)) lines.push(`- ${hint.text}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function recommendedMaxStepsForTask({ goal = "", taskProfile = "auto", complexityScore = 0 } = {}) {
+  const normalizedProfile = normalizeTaskProfile(taskProfile);
+  const profileDefault = defaultMaxStepsForProfile(normalizedProfile);
+  const text = String(goal || "");
+  if (normalizedProfile === "large-codebase" || complexityScore >= 3 || COMPLEX_ENGINEERING_PATTERN.test(text)) {
+    return Math.max(profileDefault, 36);
+  }
+  if (/\b(latex|tex|pdflatex|latexmk|pdf|website|app|docker|system|install|setup|debug)\b/i.test(text)) {
+    return Math.max(profileDefault, 30);
+  }
+  return profileDefault;
+}

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

@@ -6,6 +6,7 @@ import { loadConfig } from "./config.js";
 import { initProject, listProjectSessions, providerKeyStatus, setProviderKey } from "./project.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
 import { defaultMaxStepsForProfile, normalizeTaskProfile } from "./task-profiles.js";
+import { recommendedMaxStepsForTask } from "./engineering-guidance.js";
 import { promptAndSaveDeepSeekKey, promptHidden, shouldPromptForDeepSeek } from "./auth-onboarding.js";
 
 const useColor = Boolean(input.isTTY && output.isTTY && process.env.AGINTIFLOW_NO_COLOR !== "1");
@@ -36,6 +37,8 @@ const SLASH_COMMANDS = [
   "/resume",
   "/sessions",
   "/profile",
+  "/web-search",
+  "/scouts",
   "/routing",
   "/provider",
   "/model",
@@ -216,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.",
@@ -349,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()}`);
@@ -434,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",
@@ -596,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}`);
@@ -673,6 +697,13 @@ async function handleCommand(line, state, packageDir) {
 
 async function runPrompt(prompt, state, packageDir) {
   const controller = new AbortController();
+  const runMaxSteps = Math.max(
+    state.maxSteps,
+    recommendedMaxStepsForTask({
+      goal: prompt,
+      taskProfile: state.taskProfile,
+    })
+  );
   const config = loadConfig(
     {
       provider: state.provider,
@@ -684,11 +715,14 @@ 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,
       taskProfile: state.taskProfile,
-      maxSteps: state.maxSteps,
+      maxSteps: runMaxSteps,
       headless: state.headless,
       resume: state.sessionId,
       goal: prompt,

package/src/model-client.js

@@ -2,6 +2,7 @@ import OpenAI from "openai";
 import { normalizeWrapperName, wrapperStatusText } from "./tool-wrappers.js";
 import { getTaskProfile } from "./task-profiles.js";
 import { listAuxiliarySkills } from "./auxiliary-tools.js";
+import { engineeringGuidanceForTask } from "./engineering-guidance.js";
 
 export function createClient(config) {
   if (config.provider === "mock") {
@@ -121,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;
@@ -173,6 +184,7 @@ function mockChatResponse(content, toolCalls = []) {
 
 export async function createPlan(client, config, state) {
   const taskProfile = getTaskProfile(config.taskProfile);
+  const engineeringGuidance = engineeringGuidanceForTask(state.goal, config.taskProfile);
   if (client.mock) {
     return [
       "1. Inspect the request and prefer the local shell when available.",
@@ -211,7 +223,14 @@ 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.",
           "Work like a practical coding agent: inspect when useful, edit with file tools, run safe checks when they add confidence, and keep outputs inside the workspace.",
           "For large apps, websites, LaTeX documents, Python/C/shell projects, or system tasks, plan a coherent minimal implementation, then use tools to create files, run checks, and publish artifacts.",
@@ -359,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,
@@ -634,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
@@ -674,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/model-routing.js

@@ -29,12 +29,35 @@ const COMPLEXITY_KEYWORDS = [
   "docker",
   "ci",
   "github",
+  "system",
+  "systemd",
+  "permission denied",
+  "install",
+  "setup",
+  "toolchain",
+  "conda",
+  "venv",
+  "kubernetes",
+  "nginx",
+  "postgres",
+  "redis",
+  "segfault",
+  "typescript",
+  "python",
+  "rust",
+  "cargo",
+  "golang",
+  "cmake",
+  "gradle",
+  "maven",
 ];
 
 const COMPLEX_ROUTE_HINTS = [
   /\b(large|big|complex|complicated)\s+(repo|repository|codebase|project|task)\b/i,
   /\b(multi[- ]file|cross[- ]file|repo[- ]wide|workspace[- ]wide)\b/i,
   /\b(root cause|regression|failing tests?|fix the build|make it pass)\b/i,
+  /\b(system bug|system problem|permission denied|service failed|daemon|systemd|toolchain|install|setup)\b/i,
+  /\b(conda|venv|python|node|typescript|rust|cargo|golang|java|gradle|maven|cmake|c\+\+)\b.*\b(project|app|tests?|build|compile|fix)\b/i,
   /\blatex\b/i,
   /\btexlive\b/i,
   /\bpdflatex\b/i,

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/task-profiles.js

@@ -3,15 +3,15 @@ export const TASK_PROFILES = {
     id: "auto",
     label: "Auto",
     prompt:
-      "Infer the task type from the user request. Prefer the smallest safe tool sequence that actually completes the work, preserve workspace files, run useful checks, and summarize what changed.",
-    tools: ["browser", "shell", "files", "canvas"],
+      "Infer the task type from the user request. For short tasks, use the smallest safe tool sequence that completes the work. For codebase, system, debugging, migration, or multi-language tasks, switch into the engineering loop: inspect, read/search exact context, patch incrementally, run focused checks, repair failures, and summarize changed files plus residual risks.",
+    tools: ["browser", "shell", "files", "canvas", "inspect_project"],
   },
   code: {
     id: "code",
     label: "Code writing",
     prompt:
-      "Act like a coding agent: understand the request, edit workspace files, run useful safe checks, iterate on failures, and report changed files and residual risks.",
-    tools: ["files", "shell", "sandbox"],
+      "Act like a coding agent across languages: inspect project manifests and conventions, edit workspace files with patches, run useful focused checks, iterate on failures, and report changed files and residual risks.",
+    tools: ["inspect_project", "files", "shell", "sandbox"],
   },
   "large-codebase": {
     id: "large-codebase",
@@ -87,8 +87,8 @@ export const TASK_PROFILES = {
     id: "maintenance",
     label: "System maintenance",
     prompt:
-      "For system maintenance, diagnose first, use Docker for broad installs when available, and follow the configured trust/package policy for host-level changes.",
-    tools: ["shell", "sandbox", "files"],
+      "For system maintenance and system bugs, diagnose first with read-only evidence, use Docker for broad installs/toolchains when available, generate reversible project-local scripts, follow the configured trust/package policy for host-level changes, and stop with clear next actions if stronger permission is needed.",
+    tools: ["shell", "sandbox", "files", "inspect_project"],
   },
 };
 

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 = 4;
+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,
@@ -95,6 +99,14 @@ export class WebDatabase {
         if (!Number.isFinite(Number(parsed.maxSteps)) || Number(parsed.maxSteps) < 24) {
           preferences.maxSteps = 24;
         }
+        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,