@lazyingart/agintiflow 0.10.0 → 0.11.0

package/README.md

@@ -71,7 +71,7 @@ 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).
 
 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,27 @@ 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.
+
+## 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.11.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

@@ -775,12 +775,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) {
@@ -1966,11 +1979,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 +2057,7 @@ form.addEventListener("submit", async (event) => {
     setLogs(t("goalRequired"), "empty");
     return;
   }
+  ensureRecommendedMaxStepsForCurrentTask();
 
   const payload = {
     ...formPayload(),

package/scripts/smoke-coding-tools.js

@@ -5,6 +5,7 @@ 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 { SessionStore } from "../src/session-store.js";
 import { executeWorkspaceTool } from "../src/workspace-tools.js";
@@ -93,6 +94,24 @@ 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");
 
   await fs.mkdir(path.join(workspace, "src"), { recursive: true });
   await fs.mkdir(path.join(workspace, "test"), { recursive: true });
@@ -264,6 +283,8 @@ try {
           "deepseek_history_repair",
           "deepseek_pro_patch_route",
           "large_profile_pro_route",
+          "auto_system_pro_route",
+          "auto_engineering_guidance",
           "inspect_project",
           "mock_inspect_project",
           "write_file",

package/src/agent-runner.js

@@ -18,6 +18,7 @@ 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";
 
 const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "open_workspace_file", "preview_workspace", "click", "type", "scroll", "press", "back"]);
@@ -233,6 +234,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,
@@ -283,6 +285,7 @@ function createInitialState(config, sessionId) {
                 .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.",
           `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.",
@@ -321,6 +324,7 @@ function createInitialState(config, sessionId) {
                 .join(" ")}`
             : "",
           `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 +414,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 +441,7 @@ function applyContinuationPrompt(state, config, observers) {
         ? `Agent wrappers: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
         : "",
       `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
+      engineeringGuidance,
     ]
       .filter(Boolean)
       .join("\n"),

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";
@@ -256,7 +257,12 @@ function agentDefaults(args) {
     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

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/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");
@@ -673,6 +674,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,
@@ -688,7 +696,7 @@ async function runPrompt(prompt, state, packageDir) {
       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") {
@@ -173,6 +174,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.",
@@ -212,6 +214,7 @@ export async function createPlan(client, config, state) {
                 .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.",
           `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.",

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/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 = 5;
 
 function defaultPreferences(baseDir) {
   const presets = getModelPresets();
@@ -95,6 +95,9 @@ export class WebDatabase {
         if (!Number.isFinite(Number(parsed.maxSteps)) || Number(parsed.maxSteps) < 24) {
           preferences.maxSteps = 24;
         }
+        if ((parsed.preferencesSchemaVersion || 1) < 5) {
+          preferences.taskProfile = "auto";
+        }
         this.savePreferences(preferences);
       }
       return preferences;