@lazyingart/agintiflow 0.20.313 → 0.20.315

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.313",
+  "version": "0.20.315",
   "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-dynamic-step-budget.js

@@ -6030,13 +6030,86 @@ try {
       sandboxMode: "host",
     }
   );
+  const scopedCompoundTestLogCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: [
+        `cd ${JSON.stringify(workspace)}`,
+        `LOG=${JSON.stringify(path.join(scopedTaskRoot, "document-reader-test.log"))}`,
+        'echo "RUN_MARKER=now" > "$LOG"',
+        'python3 -m unittest discover -s tests -p \'test_reader.py\' -v >> "$LOG" 2>&1',
+        'echo "EXIT=0" >> "$LOG"',
+        'cat "$LOG"',
+      ].join(" && "),
+    },
+    projectMutationPaths: [],
+    stdout: "Ran 7 tests\nOK\nEXIT=0\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    scopedCompoundTestLogCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  const nullRedirectValidationCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command: [
+        `cd ${JSON.stringify(workspace)}`,
+        `python3 -m json.tool ${JSON.stringify(
+          path.join(scopedTaskRoot, "agent-result.json")
+        )} > /dev/null`,
+        'echo "JSON_VALID"',
+        `grep -c '^## [0-9]' ${JSON.stringify(
+          path.join(scopedTaskRoot, "source-intake-audit.md")
+        )}`,
+      ].join(" && "),
+    },
+    projectMutationPaths: [],
+    stdout: "JSON_VALID\n5\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(
+    scopedTaskState,
+    nullRedirectValidationCommand,
+    {
+      commandCwd: workspace,
+      taskProfile: "auto",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
   assert(
     requestedOutputRevision === 1 &&
       scopedTaskState.meta.projectVerification?.mutationRevision === 1 &&
       readOnlyArtifactValidation.readOnlyArtifactValidation === true &&
       scopedManifestCommand.scopedTaskArtifactWrite === true &&
-      pythonScopedManifestCommand.scopedTaskArtifactWrite === true,
-    "task-scoped delivery bookkeeping invalidated requested artifact evidence"
+      pythonScopedManifestCommand.scopedTaskArtifactWrite === true &&
+      scopedCompoundTestLogCommand.scopedTaskArtifactWrite === true &&
+      nullRedirectValidationCommand.readOnlyArtifactValidation === true,
+    `task-scoped delivery bookkeeping invalidated requested artifact evidence: ${JSON.stringify({
+      requestedOutputRevision,
+      mutationRevision:
+        scopedTaskState.meta.projectVerification?.mutationRevision,
+      readOnlyArtifactValidation:
+        readOnlyArtifactValidation.readOnlyArtifactValidation,
+      scopedManifestCommand: scopedManifestCommand.scopedTaskArtifactWrite,
+      pythonScopedManifestCommand:
+        pythonScopedManifestCommand.scopedTaskArtifactWrite,
+      scopedCompoundTestLogCommand:
+        scopedCompoundTestLogCommand.scopedTaskArtifactWrite,
+      nullRedirectValidationCommand:
+        nullRedirectValidationCommand.readOnlyArtifactValidation,
+    })}`
   );
   const mutatingInlinePython = {
     toolName: "run_command",

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

@@ -33,6 +33,19 @@ const groupBriefingContract = deriveScsTaskContract({
   ].join(" "),
   taskProfile: "research",
 });
+const sourceIntakeAuditContract = deriveScsTaskContract({
+  goal: [
+    "Create one concise coherent Markdown report with exactly five numbered cases:",
+    "(1) a bare video has no publication;",
+    "(2) a current same-chat publish request authorizes only the exact referenced video through autopublish-video plus LazyEdit, while this audit performs no external action;",
+    "(3) Finder recovery remains evidence-limited;",
+    "(4) mp.weixin recovery never asks for browser verification;",
+    "(5) PDF/archive intake uses the guarded document reader.",
+    "Run only the focused existing unit test and write agent-result.json.",
+    "Do not send, publish, submit, upload, alter queues, or open a GUI.",
+  ].join(" "),
+  taskProfile: "auto",
+});
 const scopedReadThenWriteRoot = fs.mkdtempSync(
   path.join(os.tmpdir(), "aginti-scoped-read-then-write-")
 );
@@ -83,6 +96,16 @@ assert.deepEqual(
   ["format:.pdf"],
   "an ordinary chat answer was incorrectly converted into a separate answer-key artifact"
 );
+assert.deepEqual(
+  sourceIntakeAuditContract.requiredArtifactKinds.map((item) => item.id),
+  ["format:.md"],
+  "a Markdown-only audit inferred PDF from a described PDF intake case"
+);
+assert.equal(
+  sourceIntakeAuditContract.requiredEvidence.some((item) => item.category === "publish"),
+  false,
+  "a read-only audit of a publish contract fabricated a publish action obligation"
+);
 assert.deepEqual(
   educationArtifactContract.requiredArtifactKinds.map((item) => item.id).sort(),
   [

package/src/agent-runner.js

@@ -12762,31 +12762,85 @@ function safePatchContextEvidencePath(value = "", state = {}, config = {}) {
 function commandWritesOnlyEvidenceMatching(command = "", pathMatches = () => false) {
   const normalized = String(command || "").trim();
   if (!normalized) return false;
+  const assignments = new Map();
+  for (const match of normalized.matchAll(
+    /(?:^|[\s;&|])([A-Za-z_]\w*)\s*=\s*("[^"\n]+"|'[^'\n]+'|[^\s;&|]+)/g
+  )) {
+    assignments.set(
+      match[1],
+      String(match[2] || "").replace(/^["']|["']$/g, "")
+    );
+  }
+  const resolveTarget = (value = "") => {
+    const target = String(value || "")
+      .trim()
+      .replace(/^["']|["']$/g, "");
+    const variable = target.match(/^\$(?:\{([A-Za-z_]\w*)\}|([A-Za-z_]\w*))$/);
+    return variable
+      ? String(assignments.get(variable[1] || variable[2]) || "")
+      : target;
+  };
   const tokens = tokenizeShellWords(normalized);
   if (tokens[0] === "tee") {
     let index = 1;
     if (["-a", "--append"].includes(tokens[index])) index += 1;
     if (tokens[index] === "--") index += 1;
-    const targets = tokens.slice(index);
+    const targets = tokens.slice(index).map(resolveTarget);
     return targets.length > 0 && targets.every(pathMatches);
   }
   if (tokens[0] === "mkdir") {
-    const targets = tokens.slice(1).filter((token) => token !== "-p" && token !== "--");
+    const targets = tokens
+      .slice(1)
+      .filter((token) => token !== "-p" && token !== "--")
+      .map(resolveTarget);
     return targets.length > 0 && targets.every(pathMatches);
   }
 
   let strippedEvidenceRedirect = false;
+  let rejectedRedirect = false;
   const withoutEvidenceRedirects = normalized.replace(
     /(^|\s)(?:\d*>>?|&>>?)\s*("[^"]+"|'[^']+'|[^\s;&|]+)/g,
     (match, prefix, target) => {
-      if (!pathMatches(target)) return match;
+      const resolvedTarget = resolveTarget(target);
+      if (/^(?:&\d+|\/dev\/null)$/u.test(resolvedTarget)) return prefix;
+      if (!resolvedTarget || !pathMatches(resolvedTarget)) {
+        rejectedRedirect = true;
+        return match;
+      }
       strippedEvidenceRedirect = true;
       return prefix;
     }
   ).trim();
-  if (!strippedEvidenceRedirect || !withoutEvidenceRedirects) return false;
-  const underlyingPolicy = classifyCommand(withoutEvidenceRedirects);
-  return underlyingPolicy.writesWorkspace !== true && underlyingPolicy.mayMutateProject !== true;
+  if (rejectedRedirect || !strippedEvidenceRedirect || !withoutEvidenceRedirects) {
+    return false;
+  }
+  const sequence = parseTopLevelShellSequence(withoutEvidenceRedirects);
+  if (sequence.openQuote || sequence.trailingEscape || sequence.trailingSeparator) {
+    return false;
+  }
+  return sequence.commands.every((segment) => {
+    const withoutAssignments = String(segment || "")
+      .trim()
+      .replace(
+        /^(?:[A-Za-z_]\w*=(?:"[^"\n]*"|'[^'\n]*'|[^\s;&|]+)\s*)+/u,
+        ""
+      )
+      .trim();
+    if (!withoutAssignments) return true;
+    const commandTokens = tokenizeShellWords(withoutAssignments);
+    if (
+      ["cat", "cd", "head", "ls", "stat", "tail", "wc"].includes(
+        String(commandTokens[0] || "")
+      )
+    ) {
+      return true;
+    }
+    const underlyingPolicy = classifyCommand(withoutAssignments);
+    return (
+      underlyingPolicy.writesWorkspace !== true &&
+      underlyingPolicy.mayMutateProject !== true
+    );
+  });
 }
 
 function commandWritesOnlyPrivateVerificationEvidence(command = "") {
@@ -12833,15 +12887,20 @@ function commandIsBoundedReadOnlyArtifactValidation(command = "") {
   const normalized = String(command || "").trim();
   if (!normalized) return false;
   if (
-    !/\bassert\b|\bjson\.(?:load|loads)\s*\(|\bJSON\.parse\s*\(|\bjq\b|\bsha256sum\b|\bmd5sum\b|\b(?:valid|pass|verified?)\b/i.test(
+    !/\bassert\b|\bjson\.(?:load|loads|tool)\b|\bJSON\.parse\s*\(|\bjq\b|\bsha256sum\b|\bmd5sum\b|\b(?:valid|pass|verified?)\b/i.test(
       normalized
     )
   ) {
     return false;
   }
+  const withoutNullRedirects = normalized.replace(
+    /(^|\s)(?:\d*>>?|&>>?)\s*(?:"\/dev\/null"|'\/dev\/null'|\/dev\/null)/g,
+    "$1"
+  );
   // Heredoc input (`<<`) is compatible with read-only validation. Any output
-  // redirection or known mutator keeps conservative project revision tracking.
-  if (/(^|[^<])>{1,2}(?!=)/m.test(normalized)) return false;
+  // redirection outside /dev/null or known mutator keeps conservative project
+  // revision tracking.
+  if (/(^|[^<])>{1,2}(?!=)/m.test(withoutNullRedirects)) return false;
   if (
     /\b(?:cp|install|mkdir|mv|rm|rmdir|tee|touch|truncate)\b|\bsed\s+-i\b|\bperl\s+-pi\b/i.test(
       normalized

package/src/scs-evidence.js

@@ -583,6 +583,7 @@ const REQUESTED_ARTIFACT_FORMATS = [
   { extension: ".pptx", pattern: /\b(?:pptx|powerpoint)\b/i, description: "editable PowerPoint deck" },
   { extension: ".odp", pattern: /\b(?:odp|open(?:office|document) presentation)\b/i, description: "editable ODP deck" },
   { extension: ".pdf", pattern: /\bpdf\b/i, description: "PDF document" },
+  { extension: ".md", pattern: /(?:\bmarkdown\b|\.md\b)/i, description: "Markdown document" },
   {
     extension: ".tex",
     pattern: /(?:\b(?:editable\s+)?(?:latex|tex)\s+source\b|\.tex\b)/i,
@@ -594,6 +595,64 @@ const REQUESTED_ARTIFACT_FORMATS = [
   { extension: ".svg", pattern: /\bsvg\b/i, description: "editable SVG image" },
 ];
 
+function requestedArtifactFormatHasOutputIntent(source = "", format = {}) {
+  const extension = String(format.extension || "").toLocaleLowerCase("en-US");
+  if (!extension || !format.pattern) return false;
+  if (
+    inferExactOutputPaths(source).some(
+      (candidate) => path.extname(candidate).toLocaleLowerCase("en-US") === extension
+    )
+  ) {
+    return true;
+  }
+
+  const matcher = new RegExp(
+    format.pattern.source,
+    format.pattern.flags.includes("g") ? format.pattern.flags : `${format.pattern.flags}g`
+  );
+  const outputAction =
+    /\b(?:compile|convert|create|deliver|export|generate|keep|make|output|prepare|preserve|produce|provide|render|retain|return|reuse|save|send|write)\b/i;
+  const directRequest =
+    /\b(?:can|could|would|will)\s+you\b|\b(?:i|we)\s+(?:also\s+)?(?:need|want|would\s+like|request)\b|\b(?:please|kindly)\b/i;
+  for (const match of source.matchAll(matcher)) {
+    const index = Number(match.index || 0);
+    const clauseStart = Math.max(
+      source.lastIndexOf(".", index - 1),
+      source.lastIndexOf("!", index - 1),
+      source.lastIndexOf("?", index - 1),
+      source.lastIndexOf(";", index - 1),
+      source.lastIndexOf("。", index - 1),
+      source.lastIndexOf("！", index - 1),
+      source.lastIndexOf("？", index - 1),
+      source.lastIndexOf("；", index - 1),
+      source.lastIndexOf("\n", index - 1)
+    );
+    const nextBoundaries = [".", "!", "?", ";", "。", "！", "？", "；", "\n"]
+      .map((delimiter) => source.indexOf(delimiter, index + String(match[0] || "").length))
+      .filter((candidate) => candidate >= 0);
+    const clauseEnd = nextBoundaries.length ? Math.min(...nextBoundaries) : source.length;
+    const clause = source.slice(clauseStart + 1, clauseEnd);
+    const matchOffset = index - clauseStart - 1;
+    const before = clause.slice(Math.max(0, matchOffset - 180), matchOffset);
+    const after = clause.slice(matchOffset + String(match[0] || "").length, matchOffset + 120);
+    if (outputAction.test(before) || directRequest.test(before)) return true;
+    if (
+      /\b(?:as|into|to)\s+(?:an?\s+)?$/i.test(before) &&
+      /\b(?:compile|convert|export|render|save)\b/i.test(clause)
+    ) {
+      return true;
+    }
+    if (
+      /^\s*(?:output|deliverable|file|document|report|version|copy)\b/i.test(after) &&
+      outputAction.test(clause)
+    ) {
+      return true;
+    }
+    if (/^\s*(?:please|required|requested)\b/i.test(after)) return true;
+  }
+  return false;
+}
+
 function artifactRequestHasOutputIntent(goal = "", taskProfile = "") {
   const source = stripForbiddenLanguage(String(goal || ""));
   return Boolean(
@@ -622,7 +681,7 @@ export function inferRequestedArtifactRequirements(goal = "", taskProfile = "")
   };
 
   for (const format of REQUESTED_ARTIFACT_FORMATS) {
-    if (!format.pattern.test(source)) continue;
+    if (!requestedArtifactFormatHasOutputIntent(source, format)) continue;
     add({
       id: `format:${format.extension}`,
       kind: "format",
@@ -1456,6 +1515,41 @@ function requiresSourceGrounding(goal = "") {
   );
 }
 
+function goalRequestsPublishAction(goal = "") {
+  const text = normalizedText(stripCompletedWorkNarration(stripForbiddenLanguage(goal)));
+  const action =
+    "(?:publish|deploy|submit|upload\\s+to|generate\\s+(?:a\\s+)?video|npm\\s+publish)";
+  const release =
+    "(?:release|ship)(?:\\s+(?:(?:the|this|that|a|an)\\s+)?(?:package|version|build|app|application|software|library|plugin|extension|product)|\\s+(?:to|on|via|through))|cut\\s+(?:a\\s+)?release";
+  const clauses = text
+    .split(/[\n.!?;，；。！？]+/u)
+    .map((clause) => clause.trim())
+    .filter(Boolean);
+  for (const clause of clauses) {
+    if (
+      new RegExp(
+        `^(?:(?:and|also|then|next|finally|please|kindly)\\s+)*(?:${action}|${release})\\b`,
+        "i"
+      ).test(clause)
+    ) {
+      return true;
+    }
+    if (
+      new RegExp(
+        `\\b(?:(?:can|could|would|will)\\s+you|(?:i|we)\\s+(?:need|want|would\\s+like)\\s+(?:you\\s+)?to|you\\s+(?:must|should|need\\s+to|have\\s+to)|please|kindly|then|next|finally)\\b[^.\\n;]{0,140}\\b(?:${action}|${release})\\b`,
+        "i"
+      ).test(clause)
+    ) {
+      return true;
+    }
+  }
+  return (
+    /(?:请|請|需要|必须|必須|帮我|幫我|立即|现在|現在)[^。；\n]{0,100}(?:发布|發布|部署|提交|上传|上傳|生成视频|生成影片)/u.test(
+      text
+    ) || /^(?:发布|發布|部署|提交|上传|上傳|生成视频|生成影片)/u.test(text)
+  );
+}
+
 function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCriteria = []) {
   const positiveGoal = stripForbiddenLanguage(goal);
   const text = normalizedText(positiveGoal);
@@ -1531,16 +1625,7 @@ function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCrite
   ) {
     categories.add("visual");
   }
-  const explicitPublishAction =
-    textHas(
-      text,
-      /\b(?:publish|deploy|submit|upload to|generate video|external service|npm publish)\b/
-    ) ||
-    textHas(
-      text,
-      /\b(?:release|ship)\s+(?:(?:the|this|that|a|an)\s+)?(?:package|version|build|app|application|software|library|plugin|extension|product)\b|\b(?:release|ship)\s+(?:to|on|via|through)\b|\bcut\s+(?:a\s+)?release\b/
-    ) ||
-    /发布|部署|提交|生成视频|外部服务/.test(text);
+  const explicitPublishAction = goalRequestsPublishAction(positiveGoal);
   if (explicitPublishAction) {
     categories.add("publish");
   }