@lazyingart/agintiflow 0.20.189 → 0.20.190

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.189",
+  "version": "0.20.190",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/references/agintiflow-intent-routing-overpatch-audit-2026-06-01.md

@@ -0,0 +1,74 @@
+# AgInTiFlow Intent Routing Overpatch Audit
+
+Date: 2026-06-01
+
+## Problem
+
+A bare user message, `hello`, was handled as an execution task. In the observed run, AgInTiFlow planned to inspect the workspace, created `hello.py`, and then stopped without a natural chat answer. That is the wrong default behavior for a general agent UI: a greeting should be answered directly, not converted into a workspace mutation.
+
+## Evidence
+
+Observed session:
+
+- Session: `/home/lachlan/.agintiflow/sessions/web-agent-f798c7cc-b3c2-439f-b2be-2a2746b4944d/state.json`
+- Provider/model: `deepseek/deepseek-v4-flash`
+- Goal: `hello`
+- Task profile: `auto`
+- Selected skills: `[]`
+- Outcome shown by user: AgInTiFlow wrote `hello.py` with `print("Hello from agent!")`
+
+The selected skills list was empty, so this was not caused by a custom skill. The behavior came from the core runtime prompt and the lack of a direct-answer lane.
+
+## Root Cause
+
+The runtime had one dominant path:
+
+1. Create a plan.
+2. Continue with tools until completion.
+3. Prefer real workspace edits/checks over advice-only answers.
+
+The strongest prompt pressure was in:
+
+- `src/agent-runner.js`: system prompt said the plan is not final and the agent should actively use tools until complete.
+- `src/model-client.js`: planner prompt said to prefer real workspace edits/checks over advice-only answers.
+- `src/task-profiles.js`: the `auto` profile told the agent to infer task type and choose a tool mix, but did not define a no-tool conversational mode.
+
+That design is useful for real tasks, but over-applies tool use to short social turns.
+
+## Design Fix
+
+Add a deterministic pre-plan goal-intent classifier:
+
+- Greetings, thanks, and explicit greeting requests finish directly.
+- Explicit create/edit/run/read/search/download/build/test/coding/file/command requests remain agentic.
+- File paths, file extensions, and command-looking inputs remain agentic.
+- The direct path runs before planning, SCS, surgical context, snapshots, browser, shell, canvas, or file tools.
+
+This keeps the fix general. It does not special-case `hello.py`, mock mode, DeepSeek, or a single UI path.
+
+The prompts were also softened:
+
+- Tool use is required only when the user actually asks for workspace/browser/shell/web/canvas/image/MCP/specialist work.
+- Greetings and simple conversational turns should finish directly.
+- Canvas should not be used for ordinary chat replies.
+
+## Regression Contract
+
+Required behavior:
+
+- `hello` returns a direct greeting.
+- `hello` does not create a plan.
+- `hello` does not call tools.
+- `hello` does not create `hello.py`.
+- `create hello.py` still requires tools.
+- `write a hello-world Python script and run it` still requires tools.
+
+## Product Lesson
+
+AgInTiFlow should solve problems at the correct layer:
+
+- Core system flaw: no conversational/direct-answer lane. Fix in runtime intent routing.
+- Core general skill incompleteness: missing reusable task classifier. Add deterministic classifier and tests.
+- Custom skill issue: not applicable here because no skill was selected.
+
+Avoid overpatching by not making every short input a file task and not routing every interaction through heavyweight planning/SCS/tool execution.

package/references/agintiflow-npm-publication-memory.md

@@ -2,7 +2,7 @@
 
 Date: 2026-05-20
 
-Updated: 2026-05-31
+Updated: 2026-06-01
 
 This note records the working publication route for AgInTiFlow so future release work does not get blocked by stale local npm tokens or repeated discussion about why direct `npm publish` failed.
 
@@ -10,6 +10,17 @@ This note records the working publication route for AgInTiFlow so future release
 
 Latest verified release:
 
+- Version: `0.20.189`
+- Commit: `0095284`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26734901522`
+- Workflow result: success
+- npm registry check: `npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org` returned `0.20.189`.
+- Installed verification: `npm install -g @lazyingart/agintiflow@0.20.189` then `aginti --version` returned `0.20.189`.
+- Webapp verification: `aginti webapp restart --port 3210` then `curl -fsS http://127.0.0.1:3210/health` returned `version":"0.20.189"` from the global npm package path.
+- Feature verification: `npm run smoke:model-roles` covered `OPENAI_BASE_URL`, provider-default reasoning, OpenAI chat `reasoning_effort`, and retry-without-reasoning for OpenAI-compatible gateways.
+
+Previous verified release:
+
 - Version: `0.20.188`
 - Commit: `939e2ec`
 - GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26705729544`

package/scripts/smoke-coding-tools.js

@@ -939,6 +939,23 @@ try {
     "surgical context message was not injected into model history"
   );
 
+  const helloRun = await runMock("hello", "coding-direct-hello");
+  assert(helloRun.result.result.includes("Hello"), "bare hello did not finish with a direct greeting");
+  assert(!helloRun.state?.plan, "bare hello should not create an execution plan");
+  assert(
+    helloRun.events.some((event) => event.type === "session.finished" && event.data?.mode === "direct-answer"),
+    "bare hello did not finish through the direct-answer path"
+  );
+  assert(
+    !helloRun.events.some((event) => event.type === "tool.started" || event.type === "tool.completed"),
+    "bare hello should not call tools"
+  );
+  const helloPyExists = await fs
+    .stat(path.join(workspace, "hello.py"))
+    .then(() => true)
+    .catch(() => false);
+  assert(!helloPyExists, "bare hello should not create hello.py");
+
   const writeRun = await runMock("Create notes/hello.md with a short coding smoke message.", "coding-write");
   const written = await fs.readFile(path.join(workspace, "notes/hello.md"), "utf8");
   assert(written.includes("Created by AgInTiFlow mock mode."), "mock write did not create expected file");
@@ -1214,6 +1231,7 @@ try {
           "scout_blackboard",
           "surgical_context_pack",
           "mock_inspect_project",
+          "direct_greeting_no_tools",
           "write_file",
           "duplicate_write_failed",
           "resume_session_write",

package/scripts/smoke-model-roles.js

@@ -23,6 +23,7 @@ import {
 } from "../src/scs-controller.js";
 import { buildScsEvidenceLedger, deriveScsTaskContract, evaluateScsEvidence } from "../src/scs-evidence.js";
 import { resolveRuntimeConfig } from "../src/config.js";
+import { classifyGoalIntent, isDirectAnswerIntent } from "../src/goal-intent.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -127,6 +128,14 @@ for (const [key, value] of Object.entries(envSnapshot)) {
   else process.env[key] = value;
 }
 
+const helloIntent = classifyGoalIntent("hello");
+assert(isDirectAnswerIntent(helloIntent), "bare hello should be classified as direct conversational intent");
+assert(helloIntent.requiresTools === false, "bare hello should not require tools");
+assert(classifyGoalIntent("你好").directAnswer.includes("你好"), "Chinese greeting should get a direct Chinese reply");
+assert(classifyGoalIntent("say hello in Japanese").directAnswer.includes("こんにちは"), "Japanese greeting request should answer directly");
+assert(classifyGoalIntent("create hello.py").requiresTools, "explicit file creation should remain agentic");
+assert(classifyGoalIntent("write a hello-world Python script and run it").requiresTools, "explicit coding task should require tools");
+
 const complexRoute = selectModelRoute({
   routingMode: "complex",
   provider: "deepseek",
@@ -732,6 +741,7 @@ console.log(
         "openai-base-url",
         "provider-default-reasoning",
         "openai-chat-reasoning-payload",
+        "goal-intent-direct-answer",
         "route-overrides",
         "provider-groups",
         "auxiliary-catalog",

package/scripts/smoke-web-ui.js

@@ -204,10 +204,11 @@ try {
   });
   await page.fill("#maxSteps", "4");
   await page.selectOption("#dynamicSteps", "off");
-  await page.fill("#chat-input", "Say hello from the web UI composer in one concise sentence.");
+  const composerGoal = "Create notes/web-ui-smoke.md with one concise sentence from the web UI composer.";
+  await page.fill("#chat-input", composerGoal);
   await page.click("#chat-submit");
   const firstPayload = JSON.parse(runPayloads.at(-1) || "{}");
-  if (firstPayload.goal !== "Say hello from the web UI composer in one concise sentence.") {
+  if (firstPayload.goal !== composerGoal) {
     throw new Error("composer text was not used as the first run goal");
   }
   if (firstPayload.enableScs !== "off" || firstPayload.taskProfile !== "auto") {

package/src/agent-runner.js

@@ -42,6 +42,7 @@ import { summarizeMcpConfig } from "./mcp/config.js";
 import { isMcpBridgeTool } from "./mcp/policy.js";
 import { executeMcpBridgeTool } from "./mcp/tool-bridge.js";
 import { longJobStatus, startLongJob } from "./long-job-tools.js";
+import { classifyGoalIntent, isDirectAnswerIntent } from "./goal-intent.js";
 import {
   DEFAULT_SCS_MODE,
   buildSupervisorInstruction,
@@ -589,11 +590,11 @@ async function createInitialState(config, sessionId) {
         content: [
           "You are a careful browser and shell agent with a small tool surface.",
           "Use only the provided tools.",
-          "The execution plan is not the final answer. After planning, actively use tools until the requested task is complete or genuinely blocked.",
+          "The execution plan is not the final answer. After planning, actively use tools until the requested task is complete or genuinely blocked. If the user only sends a greeting, thanks, or another simple conversational turn, finish directly without creating files, running shell commands, opening browsers, or sending canvas artifacts.",
           "If the shell tool can satisfy a local task, prefer it before opening a browser.",
           "Do not open a browser page just because a start URL exists. Treat it as a suggestion only.",
           "Only reference element ids from the latest browser snapshot.",
-          "Prefer short, deliberate actions over guessing.",
+          "Prefer short, deliberate actions over guessing. Use tools only when the request actually needs workspace, browser, shell, web, canvas, image, MCP, or specialist work.",
           browserStateReconciliationGuidance(),
           "Never navigate outside the allowed domains when an allowlist exists.",
           "Avoid destructive actions, purchases, account changes, and sensitive workflows.",
@@ -645,7 +646,7 @@ async function createInitialState(config, sessionId) {
           `Task profile: ${taskProfile.label}. ${taskProfile.prompt}`,
           skillContext,
           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. File paths sent to canvas are copied into session artifacts for durable preview, but user-requested outputs should also remain in a clear workspace path unless the user asked only for a temporary preview.",
+          "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. File paths sent to canvas are copied into session artifacts for durable preview, but user-requested outputs should also remain in a clear workspace path unless the user asked only for a temporary preview. Do not use canvas for ordinary greetings or short chat replies.",
           "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.",
           "For large projects, decompose into useful files and milestones, identify entry points/tests/contracts first, implement a coherent minimal version, then iterate with checks rather than only describing what you would do.",
@@ -1107,6 +1108,40 @@ function appendChatEntry(state, role, content) {
   });
 }
 
+async function finishWithDirectAnswer({ config, state, store, observers, sessionId, intent }) {
+  const result = redactSensitiveText(intent.directAnswer || "I'm here. How can I help?");
+  state.meta = state.meta || {};
+  state.meta.goalIntent = intent;
+  state.updatedAt = new Date().toISOString();
+  state.messages.push({
+    role: "assistant",
+    content: result,
+  });
+  appendChatEntry(state, "assistant", result);
+  await store.saveState(state);
+  await store.appendEvent("intent.classified", intent);
+  await store.appendEvent("session.finished", {
+    result,
+    mode: "direct-answer",
+    intent: {
+      kind: intent.kind,
+      reason: intent.reason,
+      requiresTools: intent.requiresTools,
+    },
+  });
+  observers.event("intent.classified", intent);
+  observers.event("session.finished", {
+    result,
+    sessionId,
+    mode: "direct-answer",
+  });
+  emitConsole(config, result, { kind: "assistant", markdown: true });
+  return {
+    sessionId,
+    result,
+  };
+}
+
 async function applyContinuationPrompt(state, config, observers) {
   if (!config.resume || !config.goal) return;
 
@@ -2360,6 +2395,16 @@ export async function runAgent(config) {
 
   try {
     throwIfAborted(config);
+    const goalIntent = classifyGoalIntent(config.goal);
+    const canFinishDirectly =
+      !config.resume && !state.plan && Number(state.stepsCompleted || 0) === 0 && isDirectAnswerIntent(goalIntent);
+    if (canFinishDirectly) {
+      return await finishWithDirectAnswer({ config, state, store, observers, sessionId, intent: goalIntent });
+    }
+
+    state.meta = state.meta || {};
+    state.meta.goalIntent = goalIntent;
+
     const scoutsWillRun = shouldRunParallelScouts(config, state);
     if (!scoutsWillRun) {
       await maybePrepareSurgicalContext(config, state, store, observers);

package/src/goal-intent.js

@@ -0,0 +1,101 @@
+const GREETING_PATTERNS = [
+  /^(hi|hello|hey|hiya|yo|sup|howdy|good\s+(morning|afternoon|evening))[\s!.。！]*$/i,
+  /^(你好|您好|嗨|哈喽|哈啰|早上好|下午好|晚上好)[\s!.。！]*$/i,
+  /^(こんにちは|こんばんは|おはよう|おはようございます|やあ|もしもし)[\s!.。！]*$/i,
+  /^(안녕하세요|안녕|여보세요)[\s!.。！]*$/i,
+  /^(bonjour|salut|hola|hallo|ciao|olá|ola|namaste)[\s!.。！]*$/i,
+];
+
+const THANKS_PATTERNS = [
+  /^(thanks|thank\s+you|thx|ty|much\s+appreciated)[\s!.。！]*$/i,
+  /^(谢谢|多谢|感谢|辛苦了)[\s!.。！]*$/i,
+  /^(ありがとう|ありがとうございます|助かりました)[\s!.。！]*$/i,
+];
+
+const TOOL_INTENT_RE =
+  /\b(create|write|edit|update|fix|patch|modify|delete|remove|rename|move|copy|save|generate|draw|plot|build|compile|run|execute|test|debug|install|download|upload|clone|commit|push|publish|deploy|open|browse|search|read|inspect|analyze|analyse|summarize|summarise|convert|extract|classify|compare|review)\b/i;
+
+const FILE_OR_COMMAND_HINT_RE =
+  /(^|\s)(\.{0,2}\/|~\/|[A-Za-z]:\\|[\w.-]+\.(js|ts|jsx|tsx|py|md|tex|json|csv|tsv|txt|yaml|yml|html|css|svg|png|jpg|jpeg|pdf|zip|tar|gz|sh|bash|zsh|rs|go|java|c|cpp|h|hpp|sql)\b|npm\s|node\s|python\s|pip\s|git\s|curl\s|wget\s|docker\s|tmux\s)/i;
+
+function normalizedGoal(goal = "") {
+  return String(goal || "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function directGreetingAnswer(goal) {
+  const text = normalizedGoal(goal);
+  if (/谢谢|多谢|感谢|辛苦了/.test(text)) return "不用谢。";
+  if (/ありがとう|ありがとうございます|助かりました/.test(text)) return "どういたしまして。";
+  if (/안녕|감사/.test(text)) return "천만에요.";
+  if (/你好|您好|嗨|哈喽|哈啰|早上好|下午好|晚上好/.test(text)) return "你好，我在。";
+  if (/こんにちは|こんばんは|おはよう|もしもし/.test(text)) return "こんにちは。";
+  if (/bonjour|salut/i.test(text)) return "Bonjour.";
+  if (/hola/i.test(text)) return "Hola.";
+  return "Hello. How can I help?";
+}
+
+function looksLikeDirectGreetingRequest(text) {
+  return /^(say|reply|respond)\s+(hi|hello|hey)\b/i.test(text) && !TOOL_INTENT_RE.test(text.replace(/^(say|reply|respond)\s+/i, ""));
+}
+
+export function classifyGoalIntent(goal, options = {}) {
+  const text = normalizedGoal(goal);
+  if (!text) {
+    return {
+      kind: "empty",
+      requiresTools: false,
+      directAnswer: "",
+      reason: "empty-input",
+    };
+  }
+
+  if (FILE_OR_COMMAND_HINT_RE.test(text) || TOOL_INTENT_RE.test(text)) {
+    return {
+      kind: "agentic",
+      requiresTools: true,
+      directAnswer: "",
+      reason: FILE_OR_COMMAND_HINT_RE.test(text) ? "file-or-command-hint" : "tool-intent-keyword",
+    };
+  }
+
+  if (GREETING_PATTERNS.some((pattern) => pattern.test(text)) || THANKS_PATTERNS.some((pattern) => pattern.test(text))) {
+    return {
+      kind: "casual",
+      requiresTools: false,
+      directAnswer: directGreetingAnswer(text),
+      reason: "short-social-turn",
+    };
+  }
+
+  if (looksLikeDirectGreetingRequest(text)) {
+    return {
+      kind: "direct-answer",
+      requiresTools: false,
+      directAnswer: /japanese|日本語|日语|日文/i.test(text) ? "こんにちは。" : directGreetingAnswer(text),
+      reason: "explicit-greeting-answer",
+    };
+  }
+
+  const shortQuestion = text.length <= 160 && /[?？]$/.test(text);
+  if (shortQuestion && options.allowQuestionDirectAnswers) {
+    return {
+      kind: "direct-answer",
+      requiresTools: false,
+      directAnswer: "",
+      reason: "short-question",
+    };
+  }
+
+  return {
+    kind: "agentic",
+    requiresTools: true,
+    directAnswer: "",
+    reason: "default-agentic",
+  };
+}
+
+export function isDirectAnswerIntent(intent = {}) {
+  return Boolean(intent && intent.requiresTools === false && (intent.kind === "casual" || intent.kind === "direct-answer"));
+}

package/src/model-client.js

@@ -742,7 +742,7 @@ export async function createPlan(client, config, state) {
       {
         role: "system",
         content:
-          `You are planning a browser, shell, workspace, and coding-agent task. The plan is only a launchpad: after planning, the runtime will continue with tools until the task is complete or genuinely blocked. Prefer real workspace edits/checks over advice-only answers. If a local shell command can satisfy the goal, prefer that before browser actions. Treat any suggested start URL as optional. ${browserStateReconciliationGuidance()} ${formatBehaviorContractForPrompt({ mode: "plan" })} Write a concise execution plan with 3 to 6 steps. Mention risks or blockers when relevant. Keep it short and practical.`,
+          `You are planning a browser, shell, workspace, and coding-agent task. The plan is only a launchpad: after planning, the runtime will continue with tools until the task is complete or genuinely blocked. Use tools only when the user actually asks for workspace, browser, shell, web, canvas, image, MCP, or specialist work. For greetings, thanks, or simple conversational turns, finish directly; never invent file creation or shell work for them. Prefer real workspace edits/checks over advice-only answers only when the request is an explicit task or deliverable. If a local shell command can satisfy a local task, prefer that before browser actions. Treat any suggested start URL as optional. ${browserStateReconciliationGuidance()} ${formatBehaviorContractForPrompt({ mode: "plan" })} Write a concise execution plan with 3 to 6 steps only for requests that need execution. Mention risks or blockers when relevant. Keep it short and practical.`,
       },
       {
         role: "user",

package/src/task-profiles.js

@@ -3,7 +3,7 @@ export const TASK_PROFILES = {
     id: "auto",
     label: "Auto",
     prompt:
-      "Act as the general-purpose AgInTiFlow agent. Infer the task type from the request, then choose the right mix of browser, shell, files, web search, canvas, and sandbox tools. For short tasks, use the smallest safe tool sequence that completes the work. For browser form/composer workflows, reconcile toward the requested state: inspect, set missing controls, verify, then submit when requested. For codebase, writing, website, LaTeX, system, debugging, migration, data cleanup, reporting, or multi-language tasks, automatically borrow the relevant specialized profile habits without becoming narrowly constrained. When you create or repair a deliverable, verify the produced output and polish obvious noise, duplicates, broken formatting, stale filenames, or misleading summaries before finalizing.",
+      "Act as the general-purpose AgInTiFlow agent. Infer the task type from the request, then choose the right mix of browser, shell, files, web search, canvas, and sandbox tools only when tools are actually needed. For greetings, thanks, or simple conversational turns, answer directly without creating files, running commands, opening browsers, or sending canvas artifacts. For short explicit tasks, use the smallest safe tool sequence that completes the work. For browser form/composer workflows, reconcile toward the requested state: inspect, set missing controls, verify, then submit when requested. For codebase, writing, website, LaTeX, system, debugging, migration, data cleanup, reporting, or multi-language tasks, automatically borrow the relevant specialized profile habits without becoming narrowly constrained. When you create or repair a deliverable, verify the produced output and polish obvious noise, duplicates, broken formatting, stale filenames, or misleading summaries before finalizing.",
     tools: ["browser", "shell", "files", "canvas", "inspect_project"],
   },
   code: {