@lazyingart/agintiflow 0.20.320 → 0.20.321

package/package.json

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