@lazyingart/agintiflow 0.20.228 → 0.20.230

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.228",
+  "version": "0.20.230",
   "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,
@@ -32,7 +33,12 @@ import {
 import { createPlan } from "../src/model-client.js";
 import { selectModelRoute } from "../src/model-routing.js";
 import { listParallelScouts, runParallelScouts, shouldRunParallelScouts } from "../src/parallel-scouts.js";
-import { buildFailedCommandAdvice, buildPermissionAdvice } from "../src/permission-advice.js";
+import {
+  buildFailedCommandAdvice,
+  buildPermissionAdvice,
+  isOptionalGeneratedPreviewCleanup,
+  isUnrequestedCleanupCommand,
+} from "../src/permission-advice.js";
 import { runJsonSpecialist } from "../src/json-specialist.js";
 import { SessionStore } from "../src/session-store.js";
 import { getTaskProfile } from "../src/task-profiles.js";
@@ -1203,6 +1209,97 @@ try {
     destructiveAdvice.destructiveApprovalCommand.includes("--allow-destructive"),
     "destructive advice did not provide an explicit approval command"
   );
+  const optionalPreviewCleanupArgs = {
+    command:
+      "rm -f build/verification/page-1.png build/verification/page-2.png; git status --short",
+  };
+  assert(
+    isOptionalGeneratedPreviewCleanup("run_command", optionalPreviewCleanupArgs),
+    "bounded generated verification-preview cleanup was not recognized"
+  );
+  const optionalPreviewCleanupAdvice = buildPermissionAdvice({
+    toolName: "run_command",
+    args: optionalPreviewCleanupArgs,
+    guard: {
+      category: "destructive",
+      reason: "Destructive shell commands require Allow destructive actions.",
+    },
+    config: dockerWorkspacePolicy,
+    state: { sessionId: "coding-optional-preview-cleanup-smoke" },
+  });
+  assert(
+    optionalPreviewCleanupAdvice.autoRecover === true,
+    "optional generated-preview cleanup should retain evidence and recover without pausing"
+  );
+  assert(
+    /leave every candidate file in place/i.test(optionalPreviewCleanupAdvice.instruction),
+    "optional generated-preview cleanup advice did not tell the agent to retain evidence"
+  );
+  assert(
+    !isOptionalGeneratedPreviewCleanup("run_command", {
+      command: "rm -f output/final-report.pdf",
+    }),
+    "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-scs-evidence-visibility.js

@@ -270,8 +270,8 @@ const wordDocumentContract = deriveScsTaskContract({
 });
 assert.deepEqual(
   wordDocumentContract.requiredEvidence.map((item) => item.category).sort(),
-  ["artifact", "command", "file"],
-  "Word document production must require written files, validation, and durable artifacts"
+  ["artifact", "command", "file", "visual"],
+  "Word document production must require written files, validation, durable artifacts, and visual evidence"
 );
 
 const groundingRoot = fs.mkdtempSync(path.join(os.tmpdir(), "aginti-source-grounding-"));

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

@@ -23,6 +23,67 @@ const DOCKER_WORKSPACE_PATH_FAILURE_PATTERNS = [
   /cannot statx? ['"][^'"]+['"]:\s+No such file or directory/i,
 ];
 
+function unquoteShellToken(value = "") {
+  const text = String(value || "").trim();
+  if (
+    text.length >= 2 &&
+    ((text.startsWith("'") && text.endsWith("'")) ||
+      (text.startsWith('"') && text.endsWith('"')))
+  ) {
+    return text.slice(1, -1);
+  }
+  return text;
+}
+
+function isGeneratedVerificationPreviewPath(value = "") {
+  const target = unquoteShellToken(value).replace(/\\/g, "/");
+  if (
+    !target ||
+    target.startsWith("/") ||
+    target.includes("..") ||
+    /[*?\[\]{}$`]/.test(target)
+  ) {
+    return false;
+  }
+  return (
+    /^(?:build|artifacts)\/verification\/[A-Za-z0-9._/-]+\.(?:png|jpe?g|webp)$/i.test(target) ||
+    /^output\/preview[-_][A-Za-z0-9._-]+\.(?:png|jpe?g|webp)$/i.test(target)
+  );
+}
+
+export function isOptionalGeneratedPreviewCleanup(toolName = "", args = {}) {
+  if (toolName !== "run_command") return false;
+  const firstSegment = String(args.command || args.text || "")
+    .trim()
+    .split(/(?:&&|;|\n)/, 1)[0]
+    .trim();
+  const match = firstSegment.match(/^rm\s+-f\s+(.+)$/);
+  if (!match) return false;
+  const targets = match[1].trim().split(/\s+/).filter(Boolean);
+  return (
+    targets.length > 0 &&
+    targets.length <= 20 &&
+    targets.every((target) => isGeneratedVerificationPreviewPath(target))
+  );
+}
+
+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, `'\\''`)}'`;
@@ -136,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,
@@ -214,6 +291,24 @@ function adviceForCategory(category = "", { toolName = "", args = {}, config = {
   }
 
   if (category === "destructive") {
+    if (
+      isOptionalGeneratedPreviewCleanup(toolName, args) ||
+      isUnrequestedCleanupCommand(toolName, args, config, state)
+    ) {
+      return {
+        ...base,
+        autoRecover: true,
+        summary:
+          "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 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.",
+          "Continue to a real content or layout repair if validation still reports a defect.",
+        ],
+      };
+    }
     return {
       ...base,
       summary:

package/src/scs-evidence.js

@@ -259,7 +259,7 @@ const PROFILE_REQUIREMENTS = {
   design: ["artifact", "visual"],
   image: ["artifact", "visual"],
   slides: ["artifact"],
-  word: ["file", "command", "artifact"],
+  word: ["file", "command", "artifact", "visual"],
   data: ["file", "command", "artifact"],
   qa: ["command"],
   review: ["command"],

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 current corrected facts instead of concatenating notes, logs, schemas, task IDs, private paths, or delivery instructions. 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, render or convert it for visual inspection, compile the PDF, inspect every rendered page, and run pdftotext or an equivalent extraction check that rejects replacement characters and unexpected control glyphs. Resolve stale-versus-current facts explicitly, 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 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: {