@lazyingart/agintiflow 0.20.189 → 0.20.191

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.189",
+  "version": "0.20.191",
   "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,28 @@ This note records the working publication route for AgInTiFlow so future release
 
 Latest verified release:
 
+- Version: `0.20.190`
+- Commit: `f192f8e`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26736284533`
+- Workflow result: success
+- npm registry check: `npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org` returned `0.20.190`.
+- Installed verification: `npm install -g @lazyingart/agintiflow@0.20.190` then `aginti --version` returned `0.20.190`.
+- Webapp verification: `aginti webapp restart --port 3210` then `curl -fsS http://127.0.0.1:3210/health` returned `version":"0.20.190"` from the global npm package path.
+- Feature verification: `aginti --provider mock --routing manual --model mock-agent --no-shell --allow-file-tools --scs off "hello"` returned a direct greeting and did not create `hello.py`.
+
+Previous 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/references/lazyedit-publish-skill-installation-2026-06-03.md

@@ -0,0 +1,88 @@
+# LazyEdit Publish Skill Installation
+
+Date: 2026-06-03
+
+## Installed Skill
+
+Skill id:
+
+- `lazyedit-publish-workflow`
+
+Source skill:
+
+- `/home/lachlan/.codex/skills/lazyedit-publish-workflow/SKILL.md`
+
+AgInTiFlow project-local copy:
+
+- `/home/lachlan/ProjectsLFS/Agent/AgInTiFlow/.aginti/skills/lazyedit-publish-workflow/SKILL.md`
+
+Global AgInTiFlow custom copy:
+
+- Skill Mesh storage under `/home/lachlan/.agintiflow/skillmesh/skills/lazyedit-publish-workflow/`
+- Installed as a local-reviewed enabled Skill Mesh skill.
+
+## Why Both Copies Exist
+
+The project-local `.aginti/skills/` copy documents the skill in the AgInTiFlow repository and lets local development sessions load it as `source=project-local`.
+
+The Skill Mesh copy makes the same skill available from other working directories such as LALACHAN, RARACHAN, LazyEdit, or Agent without requiring the user to start AgInTiFlow from the AgInTiFlow repo.
+
+## Verification
+
+Project-local loader:
+
+```bash
+node -e "import { listSkills, selectSkillsForGoal } from './src/skill-library.js'; const skill=listSkills({projectRoot:process.cwd(), includeBody:true}).find(s=>s.id==='lazyedit-publish-workflow'); if(!skill) throw new Error('missing'); console.log(skill.source);"
+```
+
+Expected result:
+
+```text
+project-local
+```
+
+Global Skill Mesh install:
+
+```bash
+node bin/aginti-cli.js skillmesh export lazyedit-publish-workflow --out /tmp/lazyedit-publish-workflow.skillpack.json
+node bin/aginti-cli.js skillmesh import /tmp/lazyedit-publish-workflow.skillpack.json --enable
+node bin/aginti-cli.js skillmesh status
+```
+
+Expected result includes:
+
+```text
+enabled  lazyedit-publish-workflow: LazyEdit Publish Workflow
+```
+
+Cross-directory discovery:
+
+```bash
+cd /home/lachlan/ProjectsLFS/Agent
+aginti skills lazyedit
+
+cd /home/lachlan/ProjectsLFS/LALACHAN
+node /home/lachlan/ProjectsLFS/Agent/AgInTiFlow/bin/aginti-cli.js skills lazyedit
+```
+
+Expected result:
+
+```text
+lazyedit-publish-workflow ... source=skillmesh
+```
+
+Selection check:
+
+```bash
+node -e "import { selectSkillsForGoal } from '/home/lachlan/ProjectsLFS/Agent/AgInTiFlow/src/skill-library.js'; const selected=selectSkillsForGoal('publish latest LALACHAN generated video through LazyEdit to Shipinhao YouTube Instagram with corrected subtitles', {projectRoot:'/home/lachlan/ProjectsLFS/LALACHAN', includeBody:true}).map(s=>s.id); console.log(selected); if(!selected.includes('lazyedit-publish-workflow')) throw new Error('not selected');"
+```
+
+Expected result:
+
+- `lazyedit-publish-workflow` appears in the selected skill list.
+
+## Operational Notes
+
+The skill is prompt guidance, not a privileged tool. LazyEdit publishing still runs through normal AgInTiFlow permission policy and shell/tmux safeguards.
+
+The subtitle correction rule is preserved: generated video scripts/stories are reference context for correcting ASR recognition errors, not verbatim targets. The agent should compare ASR output against the script, infer intended wording, preserve timing/line structure, and avoid blindly copying script text when the audio differs.

package/references/paper-revision-skill-installation-2026-06-03.md

@@ -0,0 +1,62 @@
+# Paper Revision Skill Installation
+
+Date: 2026-06-03
+
+Source repository:
+
+- `/home/lachlan/ProjectsLFS/paper-revision-skill`
+- `https://github.com/lachlanchen/paper-revision-skill`
+
+Purpose:
+
+- Add plan-gated academic manuscript revision as a reusable skill.
+- Keep manuscript-specific revision policy in the skill, not in AgInTiFlow core.
+- Let Codex, AgInTiFlow, Claude, Gemini, and Copilot consume the same workflow guidance with tool-specific entry files.
+
+AgInTiFlow integration:
+
+- The repository's root `SKILL.md` is Codex-style and uses `name:` plus `description:`.
+- AgInTiFlow SkillMesh now accepts that dialect by normalizing `name:` to native `id:` and deriving `label:` when missing.
+- Install the root `SKILL.md` as a reviewed local SkillMesh skill and enable it.
+
+Suggested install command from the AgInTiFlow repository:
+
+```bash
+node --input-type=module - <<'NODE'
+import fs from "node:fs/promises";
+import {
+  buildSkillPackFromMarkdown,
+  enableSkillMeshSkill,
+  installSkillPack,
+} from "./src/skillmesh.js";
+
+const content = await fs.readFile("/home/lachlan/ProjectsLFS/paper-revision-skill/SKILL.md", "utf8");
+const pack = await buildSkillPackFromMarkdown(content, { valueScore: 95 });
+await installSkillPack(pack, { enabled: true });
+await enableSkillMeshSkill("paper-revision-skill", true);
+console.log(JSON.stringify({ ok: true, installedSkills: pack.skills.map((skill) => skill.id), packHash: pack.packHash }, null, 2));
+NODE
+```
+
+Validation:
+
+```bash
+node scripts/smoke-skillmesh.js
+node --input-type=module - <<'NODE'
+import { selectSkillsForGoal } from "./src/skill-library.js";
+const selected = selectSkillsForGoal(
+  "Use the paper revision workflow to answer reviewer comments before editing LaTeX.",
+  { limit: 8, includeBody: false }
+);
+console.log(JSON.stringify(selected.map((skill) => ({ id: skill.id, source: skill.source })), null, 2));
+if (!selected.some((skill) => skill.id === "paper-revision-skill")) {
+  throw new Error("paper-revision-skill was not selected");
+}
+NODE
+```
+
+Boundary:
+
+- Do not move manuscript-revision details into AgInTiFlow core.
+- Improve AgInTiFlow core only when the issue is general skill compatibility, skill discovery, SkillMesh validation, evidence tracking, PDF/build tooling, or tool invocation reliability.
+- Keep the skill's plan-first, edit-second, PDF-verified revision workflow in the skill repository.

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-skillmesh.js

@@ -64,6 +64,28 @@ assert(!listSkills({ includeBody: false }).some((skill) => skill.id === "mesh-an
 await setSkillMeshMode("share");
 const config = await loadSkillMeshConfig();
 assert(config.mode === "share", "share mode should persist");
+
+const codexStyleMarkdown = [
+  "---",
+  "name: paper-revision-skill",
+  "description: Plan-gated academic manuscript revision workflow for LaTeX papers, reviewer responses, proof corrections, redlines, PDF-backed audits, and submission packaging.",
+  "---",
+  "",
+  "Plan first, edit second, verify from compiled PDFs, and keep revision evidence under references/.",
+  "",
+].join("\n");
+const codexPack = await buildSkillPackFromMarkdown(codexStyleMarkdown, { valueScore: 90 });
+assert(codexPack.skills[0].id === "paper-revision-skill", "Codex-style name should become SkillMesh id");
+assert(codexPack.skills[0].content.includes("id: paper-revision-skill"), "Codex-style skill should be normalized with id");
+assert(codexPack.skills[0].content.includes("label: Paper Revision Skill"), "Codex-style skill should receive a label");
+await installSkillPack(codexPack, { enabled: true });
+assert(
+  selectSkillsForGoal("use the paper revision workflow to answer reviewer comments before editing latex", { limit: 8 }).some(
+    (skill) => skill.id === "paper-revision-skill"
+  ),
+  "Codex-style imported skill should be selectable"
+);
+
 const serviceUnit = buildSkillMeshServiceUnit({
   dataDir: path.join(tempRoot, "relay-service"),
   runScript: path.join(tempRoot, "relay-service", "aginti-skill-relay.run.sh"),
@@ -120,6 +142,7 @@ console.log(
         "metadata-sync",
         "soft-unreachable-node",
         "systemd-service-unit",
+        "codex-style-skill-import",
       ],
     },
     null,

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/skill-library.js

@@ -100,15 +100,19 @@ function normalizeExternalTools(value) {
 export function loadSkillFile(filePath) {
   const text = fs.readFileSync(filePath, "utf8");
   const { meta, body } = parseFrontmatter(text, filePath);
-  for (const field of ["id", "label", "description"]) {
-    if (typeof meta[field] !== "string" || !meta[field].trim()) {
-      throw new Error(`${filePath}: ${field} must be a non-empty string`);
-    }
+  const id = String(meta.id || meta.name || "").trim();
+  if (!id) {
+    throw new Error(`${filePath}: id or name must be a non-empty string`);
+  }
+  const label = String(meta.label || titleCaseSkillId(id)).trim();
+  const description = String(meta.description || "").trim();
+  if (!description) {
+    throw new Error(`${filePath}: description must be a non-empty string`);
   }
   return {
-    id: meta.id.trim(),
-    label: meta.label.trim(),
-    description: meta.description.trim(),
+    id,
+    label,
+    description,
     triggers: normalizeList(meta.triggers),
     tools: normalizeList(meta.tools),
     body,

package/src/skillmesh.js

@@ -321,6 +321,60 @@ function canonicalSkillContent(content = "") {
   return String(content || "").replace(/\r\n/g, "\n").trim();
 }
 
+function titleCaseSkillId(id = "") {
+  return String(id || "")
+    .split(/[-_\s/]+/)
+    .filter(Boolean)
+    .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+    .join(" ");
+}
+
+function parseSkillMarkdownContent(content = "", context = "SKILL.md") {
+  const text = String(content || "");
+  if (!text.trim()) throw new Error(`${context}: empty skill`);
+  if (Buffer.byteLength(text, "utf8") > MAX_SKILL_BYTES) throw new Error(`${context}: skill is too large`);
+  if (redactSensitiveText(text) !== text) throw new Error(`${context}: contains token-like secret text`);
+  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) throw new Error(`${context}: missing YAML frontmatter`);
+  const frontmatter = match[1].replace(/\r\n/g, "\n");
+  const fields = {};
+  const passthrough = [];
+  for (const line of frontmatter.split(/\n/)) {
+    const scalar = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (scalar) {
+      const key = scalar[1];
+      const value = scalar[2].trim().replace(/^['"]|['"]$/g, "");
+      if (value) fields[key] = value;
+      if (["id", "name", "label", "description"].includes(key)) continue;
+    }
+    passthrough.push(line);
+  }
+  const id = fields.id || fields.name || "";
+  if (!id) throw new Error(`${context}: id or name is required`);
+  if (!safeSkillId(id)) throw new Error(`${context}: invalid skill id ${id}`);
+  const description = fields.description || "";
+  if (!description) throw new Error(`${context}: description is required`);
+  const label = fields.label || titleCaseSkillId(id);
+  return {
+    fields: { ...fields, id, label, description },
+    body: text.slice(match[0].length).trim(),
+    passthrough: passthrough.join("\n").trim(),
+  };
+}
+
+function normalizeSkillMarkdownForSkillMesh(content = "", context = "SKILL.md") {
+  const parsed = parseSkillMarkdownContent(content, context);
+  const frontmatter = [
+    "---",
+    `id: ${parsed.fields.id}`,
+    `label: ${parsed.fields.label}`,
+    `description: ${parsed.fields.description}`,
+    parsed.passthrough,
+    "---",
+  ].filter((line) => line !== "");
+  return `${frontmatter.join("\n")}\n\n${parsed.body}`.trim();
+}
+
 function canonicalPackForSignature(pack) {
   const copy = { ...pack };
   delete copy.signature;
@@ -382,25 +436,7 @@ function verifyPackSignature(pack) {
 }
 
 function validateSkillMarkdownContent(content = "", context = "SKILL.md") {
-  const text = String(content || "");
-  if (!text.trim()) throw new Error(`${context}: empty skill`);
-  if (Buffer.byteLength(text, "utf8") > MAX_SKILL_BYTES) throw new Error(`${context}: skill is too large`);
-  if (redactSensitiveText(text) !== text) throw new Error(`${context}: contains token-like secret text`);
-  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  if (!match) throw new Error(`${context}: missing YAML frontmatter`);
-  const frontmatter = match[1];
-  const fields = {};
-  for (const line of frontmatter.split(/\r?\n/)) {
-    const scalar = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
-    if (!scalar) continue;
-    const value = scalar[2].trim().replace(/^['"]|['"]$/g, "");
-    if (value) fields[scalar[1]] = value;
-  }
-  for (const field of ["id", "label", "description"]) {
-    if (!fields[field]) throw new Error(`${context}: ${field} is required`);
-  }
-  if (!safeSkillId(fields.id)) throw new Error(`${context}: invalid skill id ${fields.id}`);
-  return fields;
+  return parseSkillMarkdownContent(content, context).fields;
 }
 
 function builtInSkillIds() {
@@ -420,7 +456,7 @@ export async function buildSkillPack(skillId, { home = agintiflowHome(), author
 export async function buildSkillPackFromMarkdown(content, { home = agintiflowHome(), author = "local-user", valueScore = 80 } = {}) {
   const fields = validateSkillMarkdownContent(content, "SKILL.md");
   const id = fields.id;
-  const normalized = canonicalSkillContent(content);
+  const normalized = normalizeSkillMarkdownForSkillMesh(content, "SKILL.md");
   const entry = {
     id,
     path: `skills/${id}/SKILL.md`,

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: {