@lazyingart/agintiflow 0.20.229 → 0.20.231

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.229",
+  "version": "0.20.231",
   "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/scripts/smoke-coding-tools.js

@@ -23,6 +23,7 @@ import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { readCodebaseMap } from "../src/codebase-map.js";
 import { classifyCommand, evaluateCommandPolicy } from "../src/command-policy.js";
+import { checkToolUse } from "../src/guardrails.js";
 import { shouldReviewToolResult } from "../src/scs-controller.js";
 import {
   engineeringGuidanceForTask,
@@ -36,6 +37,7 @@ import {
   buildFailedCommandAdvice,
   buildPermissionAdvice,
   isOptionalGeneratedPreviewCleanup,
+  isUnrequestedCleanupCommand,
 } from "../src/permission-advice.js";
 import { runJsonSpecialist } from "../src/json-specialist.js";
 import { SessionStore } from "../src/session-store.js";
@@ -1230,7 +1232,7 @@ try {
     "optional generated-preview cleanup should retain evidence and recover without pausing"
   );
   assert(
-    /leave the ignored preview files in place/i.test(optionalPreviewCleanupAdvice.instruction),
+    /leave every candidate file in place/i.test(optionalPreviewCleanupAdvice.instruction),
     "optional generated-preview cleanup advice did not tell the agent to retain evidence"
   );
   assert(
@@ -1239,6 +1241,65 @@ try {
     }),
     "a requested final artifact was misclassified as optional preview cleanup"
   );
+  const mixedValidationCleanupArgs = {
+    command:
+      "python3 validate.py; rm -f output/page-*.png scratch-notes.md; git status --short",
+  };
+  assert(
+    isUnrequestedCleanupCommand(
+      "run_command",
+      mixedValidationCleanupArgs,
+      { goal: "Create and verify a clean document." },
+      {}
+    ),
+    "unrequested cleanup embedded after validation was not recognized as recoverable"
+  );
+  const mixedValidationCleanupAdvice = buildPermissionAdvice({
+    toolName: "run_command",
+    args: mixedValidationCleanupArgs,
+    guard: {
+      category: "destructive",
+      reason: "Destructive shell commands require Allow destructive actions.",
+    },
+    config: { ...dockerWorkspacePolicy, goal: "Create and verify a clean document." },
+    state: { sessionId: "coding-unrequested-cleanup-smoke" },
+  });
+  assert(
+    mixedValidationCleanupAdvice.autoRecover === true,
+    "unrequested cleanup should be skipped without pausing substantive work"
+  );
+  assert(
+    !isUnrequestedCleanupCommand(
+      "run_command",
+      { command: "rm -f output/obsolete.pdf" },
+      { goal: "Delete the obsolete PDF." },
+      {}
+    ),
+    "an explicitly requested deletion was incorrectly treated as optional housekeeping"
+  );
+  const documentPageBatchGuard = checkToolUse({
+    toolName: "read_image",
+    args: { imagePaths: ["build/verification/page-1.png", "build/verification/page-2.png"] },
+    snapshot: {},
+    config: { ...dockerWorkspacePolicy, allowFileTools: true, taskProfile: "word" },
+  });
+  assert(
+    documentPageBatchGuard.allowed === false &&
+      documentPageBatchGuard.category === "document-page-visual-batch",
+    "Word document review did not require one visual call per rendered page"
+  );
+  const documentPageBatchAdvice = buildPermissionAdvice({
+    toolName: "read_image",
+    args: { imagePaths: ["build/verification/page-1.png", "build/verification/page-2.png"] },
+    guard: documentPageBatchGuard,
+    config: { ...dockerWorkspacePolicy, taskProfile: "word" },
+    state: { sessionId: "coding-document-page-visual-batch-smoke" },
+  });
+  assert(
+    documentPageBatchAdvice.autoRecover === true &&
+      /once for each rendered page/i.test(documentPageBatchAdvice.instruction),
+    "Word document page batching did not recover into separate visual checks"
+  );
   const failedNetworkAdvice = buildFailedCommandAdvice({
     args: { command: "git clone https://github.com/lazyingart/AgInTiFlow.git" },
     commandPolicy: clonePolicy,

package/scripts/smoke-deep-research.js

@@ -48,6 +48,21 @@ async function main() {
   assert(!excessiveResearch.allowed, "deep_research accepted an excessive query/source budget");
 
   assert(hasExplicitDeepResearchIntent("literature review with primary papers"), "explicit research intent was not detected");
+  assert(
+    !hasExplicitDeepResearchIntent("Create a phone-friendly document from this folder.", [
+      {
+        role: "user",
+        content:
+          'Step 2/30. Latest runtime snapshot:\n{"pageText":"Web search and resumable deep research are available when current evidence is required."}',
+      },
+      {
+        role: "user",
+        content:
+          "The previous tool-call batch was rejected before dispatch. Tools offered in that turn: deep_research, finish.",
+      },
+    ]),
+    "runtime control prose was misclassified as genuine deep-research intent"
+  );
   assert(
     toolChoiceForProvider({ provider: "deepseek" }, []) === "auto",
     "provider-neutral research routing added an unsupported named tool_choice"

package/scripts/smoke-progressive-tool-selection.js

@@ -1475,6 +1475,49 @@ const explicitDeepResearchFollowup = selectProgressiveTools(allTools, {
 });
 assert(names(explicitDeepResearchFollowup).includes("web_search"), "deep-research follow-up did not restore targeted recovery tools");
 
+const documentRuntimeSnapshot =
+  'Step 1/30. Latest runtime snapshot:\n{"pageText":"Workspace file tools are ready. Web search and resumable deep research are available when current evidence is required."}';
+const localDocumentStarter = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek" },
+  goal: "Turn the files in this folder into an editable, phone-friendly handoff and finish it properly.",
+  profile: "word",
+  messages: [
+    { role: "user", content: "Turn the files in this folder into an editable, phone-friendly handoff and finish it properly." },
+    { role: "user", content: documentRuntimeSnapshot },
+  ],
+});
+assert(names(localDocumentStarter).includes("read_file"), "local document start omitted workspace reading tools");
+assert(names(localDocumentStarter).includes("write_file"), "local document start omitted workspace writing tools");
+assert(
+  !(names(localDocumentStarter).length === 2 && names(localDocumentStarter)[0] === "deep_research"),
+  "runtime snapshot prose forced a local document task into deep research"
+);
+
+const documentRepairAfterCompaction = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek" },
+  goal: "Turn the files in this folder into an editable, phone-friendly handoff and finish it properly.",
+  profile: "word",
+  messages: [
+    {
+      role: "user",
+      content:
+        "The runtime proactively compacted a long agent history before the provider context became inefficient or unstable. Authoritative current goal: create the document.",
+    },
+    {
+      role: "user",
+      content:
+        "The previous tool-call batch was rejected before dispatch. Reason code: TOOL_NOT_OFFERED. Rejected request: apply_patch. Tools offered in that turn: deep_research, finish.",
+    },
+    { role: "user", content: documentRuntimeSnapshot },
+  ],
+});
+assert(names(documentRepairAfterCompaction).includes("apply_patch"), "document repair after compaction omitted apply_patch");
+assert(names(documentRepairAfterCompaction).includes("run_command"), "document repair after compaction omitted build verification");
+assert(
+  !(names(documentRepairAfterCompaction).length === 2 && names(documentRepairAfterCompaction)[0] === "deep_research"),
+  "post-failure runtime scaffolding regressed a local document repair into deep research"
+);
+
 const scopedArtifactPrompt = `You are a persistent workspace agent. The surrounding policy mentions an evidence review.
 AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create one plain-text artifact and verify it."}
 Repository evidence to consult as relevant: literature review, evidence review, research report.`;

package/src/guardrails.js

@@ -245,6 +245,14 @@ export function checkToolUse({ toolName, args, snapshot, config }) {
       .map((item) => String(item || "").trim())
       .filter(Boolean);
     if (values.length === 0) return { allowed: false, reason: "At least one image path or URL is required.", category: "perception-tools" };
+    if (String(config.taskProfile || "").toLowerCase() === "word" && values.length > 1) {
+      return {
+        allowed: false,
+        reason:
+          "Word-document page review requires one rendered page per image call so clipping, orphaned headings, sparse spill pages, and other page-specific defects cannot be averaged away.",
+        category: "document-page-visual-batch",
+      };
+    }
     if (values.length > 4) return { allowed: false, reason: "Too many images. Maximum is 4.", category: "perception-tools" };
     for (const value of values) {
       if (/^https?:\/\//i.test(value)) {

package/src/permission-advice.js

@@ -67,6 +67,23 @@ export function isOptionalGeneratedPreviewCleanup(toolName = "", args = {}) {
   );
 }
 
+function goalRequestsDeletion(config = {}, state = {}) {
+  const goal = String(config.goal || state.goal || state.meta?.goalContract?.current || "");
+  return /\b(?:delete|remove|clean\s+up|cleanup|purge|erase|discard|drop)\b|删除|刪除|移除|清理|清除|删掉|刪掉|削除|消去/i.test(
+    goal
+  );
+}
+
+export function isUnrequestedCleanupCommand(toolName = "", args = {}, config = {}, state = {}) {
+  const goal = String(config.goal || state.goal || state.meta?.goalContract?.current || "").trim();
+  if (!goal || toolName !== "run_command" || goalRequestsDeletion(config, state)) return false;
+  const command = String(args.command || args.text || "");
+  return command
+    .split(/(?:&&|;|\n)/)
+    .map((segment) => segment.trim())
+    .some((segment) => /^(?:command\s+)?rm\s+(?:-[A-Za-z]*[fr][A-Za-z]*\s+|--force\s+)/.test(segment));
+}
+
 function quoteShell(value = "") {
   const text = String(value || "");
   return `'${text.replace(/'/g, `'\\''`)}'`;
@@ -180,6 +197,22 @@ function adviceForCategory(category = "", { toolName = "", args = {}, config = {
     };
   }
 
+  if (category === "document-page-visual-batch") {
+    return {
+      ...base,
+      autoRecover: true,
+      summary:
+        "The document review batched multiple rendered pages, so page-specific visual defects could be missed.",
+      instruction:
+        "Continue automatically by calling read_image once for each rendered page. Evaluate clipping, overflow, orphaned headings, sparse spill pages, table splits, margins, and hierarchy on that page before moving to the next one.",
+      options: [
+        "Review page 1 alone, repair any defect, and rebuild before reviewing later pages.",
+        "Review each remaining page in a separate read_image call.",
+        "Finish only after every page has its own accepted visual evidence.",
+      ],
+    };
+  }
+
   if (category === "workspace-write") {
     return {
       ...base,
@@ -258,14 +291,17 @@ function adviceForCategory(category = "", { toolName = "", args = {}, config = {
   }
 
   if (category === "destructive") {
-    if (isOptionalGeneratedPreviewCleanup(toolName, args)) {
+    if (
+      isOptionalGeneratedPreviewCleanup(toolName, args) ||
+      isUnrequestedCleanupCommand(toolName, args, config, state)
+    ) {
       return {
         ...base,
         autoRecover: true,
         summary:
-          "Optional generated-preview cleanup was blocked safely; the verification evidence can remain ignored and the task should continue.",
+          "Unrequested cleanup was blocked safely; generated or verification files can remain ignored and the substantive task should continue.",
         instruction:
-          "Do not retry, rename, or seek approval for this cleanup. Leave the ignored preview files in place, run any remaining read-only checks in a separate call, and finish the requested task when its substantive evidence passes.",
+          "Do not retry, rename, or seek approval for this cleanup. Leave every candidate file in place, run any remaining read-only checks in a separate call, and finish the requested task when its substantive evidence passes.",
         options: [
           "Retain the generated previews as private verification evidence.",
           "Run source hashes, artifact checks, and git status separately without a delete command.",

package/src/research-routing.js

@@ -6,11 +6,36 @@ function messageText(content) {
   return content.map((part) => part?.text || part?.content || "").filter(Boolean).join("\n");
 }
 
+const RUNTIME_USER_MESSAGE_PATTERNS = Object.freeze([
+  /^Step \d+\/\d+\b.*Latest runtime snapshot:/i,
+  /^Retained runtime tool evidence\./i,
+  /^The runtime proactively compacted a long agent history/i,
+  /^A previous agent-step model request timed out/i,
+  /^Continue from this compacted, valid transcript/i,
+  /^Previous assistant response retained as compacted history/i,
+  /^Highest-priority retained state:/i,
+  /^Bounded failed-test evidence packet(?: v\d+)?\./i,
+  /^Verification is still failing,/i,
+  /^The previous tool-call batch was rejected before dispatch\./i,
+  /^Loop guard:/i,
+  /^Runtime phase transition:/i,
+]);
+
+function isRuntimeUserMessage(content = "") {
+  const text = String(content || "").trim();
+  return RUNTIME_USER_MESSAGE_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+function genuineUserMessages(messages = []) {
+  return messages.filter(
+    (message) => message?.role === "user" && !isRuntimeUserMessage(messageText(message.content))
+  );
+}
+
 export function hasExplicitDeepResearchIntent(goal = "", messages = []) {
   const recent = hasAgintiEvidenceScope(goal)
     ? ""
-    : messages
-        .filter((message) => message?.role === "user")
+    : genuineUserMessages(messages)
         .slice(-4)
         .map((message) => scopedChatopsEvidenceGoal(messageText(message.content)))
         .join("\n");
@@ -24,12 +49,19 @@ export function hasExplicitDeepResearchIntent(goal = "", messages = []) {
 }
 
 export function toolWasRequested(messages = [], toolName = "") {
-  return messages.some(
-    (message) =>
+  return messages.some((message) => {
+    if (
       message?.role === "assistant" &&
       Array.isArray(message.tool_calls) &&
       message.tool_calls.some((call) => call?.function?.name === toolName)
-  );
+    ) {
+      return true;
+    }
+    if (message?.role !== "user") return false;
+    const content = messageText(message.content);
+    if (!/^Retained runtime tool evidence\./i.test(content.trim())) return false;
+    return new RegExp(`^Tool:\\s*${String(toolName).replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`, "im").test(content);
+  });
 }
 
 export function shouldStartWithDeepResearch(goal = "", messages = []) {

package/src/task-profiles.js

@@ -276,7 +276,7 @@ export const TASK_PROFILES = {
     id: "word",
     label: "Word documents",
     prompt:
-      "Bias toward Word/docx/document workflows while still using writing, conversion, LaTeX, or scripts when useful. Preserve source material byte-for-byte and synthesize a reader-facing document from the authoritative current facts instead of concatenating notes, logs, schemas, task IDs, private paths, or delivery instructions. Reconcile conflicting or superseded source facts before drafting; publish only the current state unless history is explicitly requested or necessary to explain a live decision. Prefer mature editable-document tooling already available in the workspace, such as python-docx, pandoc, or LibreOffice, over hand-written OOXML; when direct OOXML is genuinely necessary, validate its package parts and openability. Keep one maintainable source of truth and a reproducible project-local build command. Verify the DOCX is structurally editable, compile the PDF, run pdftotext or an equivalent extraction check that rejects replacement characters and unexpected control glyphs, and render every PDF page to a separate image under an ignored build/verification directory. Inspect every rendered page individually and repair orphaned headings, near-empty spill pages, awkward table or paragraph breaks, overlaps, clipping, excessive whitespace, weak hierarchy, and inconsistent number formatting before finishing. Retain ignored verification renders as evidence; optional cleanup must never block completion. Use clear descriptive filenames, exclude caches and generated debris from commits, inspect git status/diff before committing, and report success only after the editable source, reader-facing current-state content, visual layout, searchable text, and requested artifacts all pass.",
+      "Bias toward Word/docx/document workflows while still using writing, conversion, LaTeX, or scripts when useful. Preserve source material byte-for-byte and synthesize a reader-facing document from the authoritative current facts instead of concatenating notes, logs, schemas, task IDs, private paths, or delivery instructions. Reconcile conflicting or superseded source facts before drafting: values labeled corrected, replaced, earlier, old, prior, cancelled, or no longer selected identify what to discard, and those discarded literals must not appear in the final document unless the user explicitly requests history or the history is necessary to explain a live decision. Before finishing, extract the final text and search for every superseded literal found in the sources. Prefer mature editable-document tooling already available in the workspace, such as python-docx, pandoc, or LibreOffice, over hand-written OOXML; when direct OOXML is genuinely necessary, validate its package parts and openability. Keep one maintainable source of truth and a reproducible project-local build command. Verify the DOCX is structurally editable, compile the PDF, run pdftotext or an equivalent extraction check that rejects replacement characters and unexpected control glyphs, and verify PDF text bounding boxes remain inside a readable page margin. Render every PDF page to a separate image under an ignored build/verification directory. Inspect one rendered page per read_image call, never batch pages into one vision call, and repair orphaned headings, near-empty spill pages, awkward table or paragraph breaks, overlaps, clipping, excessive whitespace, weak hierarchy, and inconsistent number formatting before finishing. Retain ignored verification renders as evidence; optional cleanup must never block completion. Use clear descriptive filenames, exclude caches and generated debris from commits, inspect git status/diff before committing, and report success only after the editable source, reader-facing current-state content, visual layout, searchable text, and requested artifacts all pass.",
     tools: ["files", "shell", "canvas", "sandbox"],
   },
   latex: {