@lazyingart/agintiflow 0.20.227 → 0.20.229

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.227",
+  "version": "0.20.229",
   "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

@@ -32,7 +32,11 @@ 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,
+} 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";
@@ -1115,6 +1119,27 @@ try {
   assert(cdWorkspacePolicy.allowed, "cd /workspace should be allowed in docker-workspace mode");
   const gitCleanDryRunPolicy = evaluateCommandPolicy("git clean -nd reports", dockerWorkspacePolicy);
   assert(gitCleanDryRunPolicy.allowed, "git clean dry-run should be allowed as read-only inspection evidence");
+  const gitRmCachedPolicy = evaluateCommandPolicy(
+    "git rm --cached -q build/__pycache__/content.cpython-312.pyc",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(gitRmCachedPolicy.allowed, "bounded git rm --cached should preserve the working tree and remain allowed");
+  assert(gitRmCachedPolicy.category === "git-workflow", "bounded git rm --cached should be a git workflow command");
+  const gitRmCachedRecursivePolicy = evaluateCommandPolicy(
+    "git rm --cached -r build",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(!gitRmCachedRecursivePolicy.allowed, "recursive git rm --cached should remain guarded");
+  const gitRmCachedGlobPolicy = evaluateCommandPolicy(
+    "git rm --cached 'build/**/*.pyc'",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(!gitRmCachedGlobPolicy.allowed, "globbed git rm --cached should remain guarded");
+  const gitRmWorkingTreePolicy = evaluateCommandPolicy(
+    "git rm build/content.py",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(!gitRmWorkingTreePolicy.allowed, "git rm without --cached must remain guarded");
   const localGitInitPolicy = evaluateCommandPolicy("git init", dockerWorkspaceNoInstallsPolicy);
   assert(localGitInitPolicy.allowed, "local git init should be allowed without package installs");
   assert(localGitInitPolicy.category === "git-workflow", "local git init should be classified as git-workflow");
@@ -1182,6 +1207,38 @@ 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 the ignored preview files 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 failedNetworkAdvice = buildFailedCommandAdvice({
     args: { command: "git clone https://github.com/lazyingart/AgInTiFlow.git" },
     commandPolicy: clonePolicy,

package/scripts/smoke-scs-evidence-visibility.js

@@ -264,6 +264,16 @@ assert(
   "excluding output filenames also removed a real required text term"
 );
 
+const wordDocumentContract = deriveScsTaskContract({
+  goal: "Create an editable DOCX and a phone-friendly PDF, then verify both outputs.",
+  taskProfile: "word",
+});
+assert.deepEqual(
+  wordDocumentContract.requiredEvidence.map((item) => item.category).sort(),
+  ["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-"));
 try {
   const reportPath = path.join(groundingRoot, "READINESS.md");

package/src/command-policy.js

@@ -1226,6 +1226,48 @@ function classifyGitCleanDryRun(normalized) {
   };
 }
 
+function classifyGitRmCached(normalized) {
+  if (!/^git\s+rm\b/.test(normalized) || hasActiveShellExpansion(normalized)) return null;
+  const tokens = tokenizeShellWords(normalized);
+  if (tokens[0] !== "git" || tokens[1] !== "rm") return null;
+
+  let cached = false;
+  const paths = [];
+  let afterOptions = false;
+  for (const token of tokens.slice(2)) {
+    if (!afterOptions && token === "--") {
+      afterOptions = true;
+      continue;
+    }
+    if (!afterOptions && ["--cached"].includes(token)) {
+      cached = true;
+      continue;
+    }
+    if (!afterOptions && ["-q", "--quiet"].includes(token)) continue;
+    if (!afterOptions && token.startsWith("-")) return null;
+    paths.push(token);
+  }
+  if (!cached || !paths.length || paths.length > 20) return null;
+  if (
+    paths.some(
+      (target) =>
+        target === "." ||
+        /[*?\[\]{}]/.test(target) ||
+        !isSafeRelativeDir(target)
+    )
+  ) {
+    return null;
+  }
+  return {
+    category: "git-workflow",
+    needsNetwork: false,
+    writesWorkspace: true,
+    gitOnly: true,
+    reason:
+      "Git rm --cached removes only bounded literal workspace paths from the index; working-tree files are preserved.",
+  };
+}
+
 function classifyGitClone(normalized) {
   const match = normalized.match(
     /^git\s+clone(?:\s+--depth\s+\d+)?(?:\s+--branch\s+[-\w./]+)?\s+(https:\/\/\S+)(?:\s+([-\w./]+))?$/
@@ -1305,6 +1347,8 @@ function classifySimpleCommand(normalized) {
   }
   const gitCleanDryRun = classifyGitCleanDryRun(normalized);
   if (gitCleanDryRun) return gitCleanDryRun;
+  const gitRmCached = classifyGitRmCached(normalized);
+  if (gitRmCached) return gitRmCached;
   const scopedReadOnlyGitProbe = classifyScopedReadOnlyGitProbe(normalized);
   if (scopedReadOnlyGitProbe) return scopedReadOnlyGitProbe;
   const gitWorkflowClassification = classifyGitWorkflow(normalized);

package/src/permission-advice.js

@@ -23,6 +23,50 @@ 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 quoteShell(value = "") {
   const text = String(value || "");
   return `'${text.replace(/'/g, `'\\''`)}'`;
@@ -214,6 +258,21 @@ function adviceForCategory(category = "", { toolName = "", args = {}, config = {
   }
 
   if (category === "destructive") {
+    if (isOptionalGeneratedPreviewCleanup(toolName, args)) {
+      return {
+        ...base,
+        autoRecover: true,
+        summary:
+          "Optional generated-preview cleanup was blocked safely; the verification evidence can remain ignored and the 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.",
+        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: ["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 originals, create clear output filenames, use available local tools such as pandoc/libreoffice/python packages when present, and verify generated documents exist before reporting success.",
+      "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.",
     tools: ["files", "shell", "canvas", "sandbox"],
   },
   latex: {