@lazyingart/agintiflow 0.20.319 → 0.20.321

package/package.json

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

@@ -4615,6 +4615,46 @@ try {
       mutatingPipedTestResult.nonAuthoritativeTestOutputPipeline !== true,
     "a source mutation appended to an unsafe test pipeline escaped revision tracking"
   );
+  const workspaceCdWrappedTestCommand =
+    `cd ${workspace} && PYTHONPATH=src python -m pytest tests/test_wechat_document_reader.py -v; echo "EXIT=$?"`;
+  assert(
+    isSubstantiveTestCommand(workspaceCdWrappedTestCommand, {
+      commandCwd: workspace,
+    }),
+    "a safe explicit-status test wrapper lost test identity behind a workspace cd"
+  );
+  const workspaceCdWrappedTestState = {
+    meta: { goalContract: { revision: 1 } },
+  };
+  const workspaceCdWrappedTestResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: workspaceCdWrappedTestCommand },
+    stdout: "7 passed in 0.06s\nEXIT=0\n",
+    stderr: "",
+    projectMutationPaths: [],
+    commandPolicy: classifyCommand(workspaceCdWrappedTestCommand),
+  };
+  recordProjectVerificationOutcome(
+    workspaceCdWrappedTestState,
+    workspaceCdWrappedTestResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "qa",
+      allowShellTool: true,
+      sandboxMode: "host",
+    }
+  );
+  assert(
+    workspaceCdWrappedTestResult.projectTest?.passed === true &&
+      workspaceCdWrappedTestState.meta.projectVerification?.testRuns?.length === 1,
+    `a successful workspace-cd status wrapper did not produce one passing test run: ${JSON.stringify({
+      projectTest: workspaceCdWrappedTestResult.projectTest,
+      testRuns:
+        workspaceCdWrappedTestState.meta.projectVerification?.testRuns,
+    })}`
+  );
   const pipedUnittestCommand =
     "python3 -m unittest discover -s tests -p 'test_wechat_document_reader.py' -v 2>&1 | tail -14; echo \"EXIT=${PIPESTATUS[0]}\"";
   assert(

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

@@ -167,6 +167,53 @@ assert.equal(
 );
 fs.rmSync(educationWorkspace, { recursive: true, force: true });
 
+const crowdedWorkspace = fs.mkdtempSync(
+  path.join(os.tmpdir(), "aginti-crowded-scoped-artifact-")
+);
+const crowdedArtifactRoot = path.join(crowdedWorkspace, "output", "task-artifacts");
+const crowdedReportDir = path.join(crowdedArtifactRoot, "reports", "final");
+fs.mkdirSync(crowdedReportDir, { recursive: true });
+for (let index = 0; index < 3005; index += 1) {
+  fs.writeFileSync(
+    path.join(crowdedWorkspace, `unrelated-${String(index).padStart(4, "0")}.txt`),
+    "noise\n",
+    "utf8"
+  );
+}
+fs.writeFileSync(
+  path.join(crowdedReportDir, "wecom-external-group-ai-bot-capabilities.md"),
+  "# Source-grounded report\n",
+  "utf8"
+);
+const crowdedScopedContract = deriveScsTaskContract({
+  goal: [
+    "Save one concise source-grounded Markdown report under the task artifact directory.",
+    `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+      mode: "task",
+      request:
+        "Save one concise source-grounded Markdown report under the task artifact directory.",
+      artifact_root: crowdedArtifactRoot,
+    })}`,
+  ].join("\n"),
+  taskProfile: "research",
+});
+const crowdedScopedArtifacts = evaluateRequestedArtifactRequirements(
+  crowdedScopedContract,
+  { commandCwd: crowdedWorkspace, state: {} }
+);
+assert.equal(
+  crowdedScopedArtifacts.ok,
+  true,
+  `a valid scoped Markdown report was hidden by unrelated workspace files: ${crowdedScopedArtifacts.reason}`
+);
+assert(
+  crowdedScopedArtifacts.candidates.some((item) =>
+    item.path.endsWith("wecom-external-group-ai-bot-capabilities.md")
+  ),
+  "the host-declared task artifact root was not inspected before the bounded workspace scan"
+);
+fs.rmSync(crowdedWorkspace, { recursive: true, force: true });
+
 function fakeStudentClient(json) {
   return {
     chat: {

package/src/agent-runner.js

@@ -5495,10 +5495,12 @@ export function isSubstantiveTestCommand(command = "", config = {}) {
   if (isRetainedExactVerificationCommand(command, config)) return true;
   const normalized = normalizeProjectCommand(normalizeCommandForPolicy(command, config));
   if (projectTestCommandWrapper(normalized)) return true;
-  const text = projectExitStatusWrapper(normalized)?.command || normalized;
+  const wrappedTestCommand =
+    projectExitStatusWrapper(normalized)?.command || normalized;
+  const text = normalizeLeadingWorkspaceCd(wrappedTestCommand, config);
   if (!text) return false;
-  const classification = classifyCommand(text);
-  if (classification.substantiveTest !== true) return false;
+  const classification = boundedTestCommandClassification(text);
+  if (classification.policy.substantiveTest !== true) return false;
   const sequence = parseTopLevelShellSequence(text);
   if (sequence.commands.length <= 1) return true;
   if (!sequence.separators.every((separator) => separator === "&&")) return false;
@@ -5506,9 +5508,17 @@ export function isSubstantiveTestCommand(command = "", config = {}) {
   let lastTestIndex = -1;
   let lastMutationIndex = -1;
   sequence.commands.forEach((segment, index) => {
-    const segmentPolicy = classifyCommand(segment);
+    const segmentClassification = boundedTestCommandClassification(segment);
+    const segmentPolicy = segmentClassification.policy;
     if (segmentPolicy.substantiveTest === true) lastTestIndex = index;
-    if (commandCanMutateProjectContent(segment, segmentPolicy)) lastMutationIndex = index;
+    if (
+      commandCanMutateProjectContent(
+        segmentClassification.executableCommand,
+        segmentPolicy
+      )
+    ) {
+      lastMutationIndex = index;
+    }
   });
   return lastTestIndex >= 0 && lastTestIndex >= lastMutationIndex;
 }

package/src/scs-evidence.js

@@ -2654,58 +2654,86 @@ function taskArtifactMutationPaths(state = {}) {
   return paths;
 }
 
-function collectRequestedArtifactCandidates(commandCwd = process.cwd(), state = {}) {
+function collectRequestedArtifactCandidates(
+  commandCwd = process.cwd(),
+  state = {},
+  artifactRoot = ""
+) {
   const root = path.resolve(commandCwd || process.cwd());
   const freshnessBoundary = taskArtifactFreshnessBoundary(state);
   const mutationPaths = taskArtifactMutationPaths(state);
   const candidates = [];
-  const queue = [{ absolutePath: root, depth: 0 }];
-  let visited = 0;
-  while (queue.length && candidates.length < 3000 && visited < 6000) {
-    const current = queue.shift();
-    visited += 1;
-    let entries = [];
+  const seenFiles = new Set();
+  const scanRoots = [];
+  const appendScanRoot = (rawPath = "") => {
+    const absolutePath = rawPath
+      ? resolveContractPath(root, rawPath)
+      : root;
+    if (!absolutePath || scanRoots.includes(absolutePath)) return;
     try {
-      entries = fs.readdirSync(current.absolutePath, { withFileTypes: true });
+      if (!fs.statSync(absolutePath).isDirectory()) return;
     } catch {
-      continue;
+      return;
     }
-    for (const entry of entries) {
-      if (entry.isSymbolicLink()) continue;
-      const absolutePath = path.join(current.absolutePath, entry.name);
-      if (entry.isDirectory()) {
-        if (
-          current.depth < 7 &&
-          !ARTIFACT_SCAN_IGNORED_DIRECTORIES.has(entry.name) &&
-          !entry.name.startsWith(".cache")
-        ) {
-          queue.push({ absolutePath, depth: current.depth + 1 });
-        }
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      let stat;
+    scanRoots.push(absolutePath);
+  };
+  // A host-declared task artifact root is authoritative and usually sits deep
+  // inside a large application workspace. Inspect it before the bounded broad
+  // workspace scan so unrelated files cannot exhaust the candidate limit and
+  // hide a valid task deliverable.
+  appendScanRoot(artifactRoot);
+  appendScanRoot();
+  let visited = 0;
+  for (const scanRoot of scanRoots) {
+    const queue = [{ absolutePath: scanRoot, depth: 0 }];
+    while (queue.length && candidates.length < 3000 && visited < 6000) {
+      const current = queue.shift();
+      visited += 1;
+      let entries = [];
       try {
-        stat = fs.statSync(absolutePath);
+        entries = fs.readdirSync(current.absolutePath, { withFileTypes: true });
       } catch {
         continue;
       }
-      if (!stat.size) continue;
-      const relativePath = path.relative(root, absolutePath).replace(/\\/g, "/");
-      const normalized = normalizedContractPath(relativePath).toLocaleLowerCase("en-US");
-      const fresh = Boolean(
-        mutationPaths.has(normalized) ||
-          freshnessBoundary === 0 ||
-          Number(stat.mtimeMs || 0) >= freshnessBoundary
-      );
-      candidates.push({
-        path: relativePath,
-        extension: path.extname(entry.name).toLocaleLowerCase("en-US"),
-        basename: entry.name.toLocaleLowerCase("en-US"),
-        bytes: stat.size,
-        mtimeMs: Number(stat.mtimeMs || 0),
-        fresh,
-      });
+      for (const entry of entries) {
+        if (entry.isSymbolicLink()) continue;
+        const absolutePath = path.join(current.absolutePath, entry.name);
+        if (entry.isDirectory()) {
+          if (
+            current.depth < 7 &&
+            !ARTIFACT_SCAN_IGNORED_DIRECTORIES.has(entry.name) &&
+            !entry.name.startsWith(".cache")
+          ) {
+            queue.push({ absolutePath, depth: current.depth + 1 });
+          }
+          continue;
+        }
+        if (!entry.isFile()) continue;
+        if (seenFiles.has(absolutePath)) continue;
+        seenFiles.add(absolutePath);
+        let stat;
+        try {
+          stat = fs.statSync(absolutePath);
+        } catch {
+          continue;
+        }
+        if (!stat.size) continue;
+        const relativePath = path.relative(root, absolutePath).replace(/\\/g, "/");
+        const normalized = normalizedContractPath(relativePath).toLocaleLowerCase("en-US");
+        const fresh = Boolean(
+          mutationPaths.has(normalized) ||
+            freshnessBoundary === 0 ||
+            Number(stat.mtimeMs || 0) >= freshnessBoundary
+        );
+        candidates.push({
+          path: relativePath,
+          extension: path.extname(entry.name).toLocaleLowerCase("en-US"),
+          basename: entry.name.toLocaleLowerCase("en-US"),
+          bytes: stat.size,
+          mtimeMs: Number(stat.mtimeMs || 0),
+          fresh,
+        });
+      }
     }
   }
   return candidates;
@@ -2763,7 +2791,11 @@ export function evaluateRequestedArtifactRequirements(
       reason: "No semantic artifact-set contract was inferred.",
     };
   }
-  const candidates = collectRequestedArtifactCandidates(commandCwd, state);
+  const candidates = collectRequestedArtifactCandidates(
+    commandCwd,
+    state,
+    String(contract.artifactRoot || "")
+  );
   const requireFresh = contract.requiresFileMutation === true;
   const usableCandidates = requireFresh
     ? candidates.filter((candidate) => candidate.fresh)