@lazyingart/agintiflow 0.20.209 → 0.20.211

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.209",
+  "version": "0.20.211",
   "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-context-budget-recovery.js

@@ -52,6 +52,17 @@ const artifactContract = deriveScsTaskContract({
 });
 assert.equal(artifactContract.requiresExternalEvidence, true, "real chat artifact work lost its evidence gate");
 assert.ok(artifactContract.requiredEvidence.some((item) => item.category === "artifact"));
+const scopedArtifactRootContract = deriveScsTaskContract({
+  goal:
+    'AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create result.txt with the exact requested content.","artifact_root":"/tmp/labcanvas-task-artifacts"}',
+  taskProfile: "chatops",
+});
+assert.equal(scopedArtifactRootContract.artifactRoot, "/tmp/labcanvas-task-artifacts");
+assert.deepEqual(
+  scopedArtifactRootContract.exactOutputPaths,
+  ["/tmp/labcanvas-task-artifacts/result.txt"],
+  "a bare task artifact filename was not resolved against the host-declared artifact root"
+);
 
 let capturedPayload = null;
 const client = {

package/scripts/smoke-progressive-tool-selection.js

@@ -770,6 +770,41 @@ const explicitDeepResearchFollowup = selectProgressiveTools(allTools, {
 });
 assert(names(explicitDeepResearchFollowup).includes("web_search"), "deep-research follow-up did not restore targeted recovery tools");
 
+const scopedArtifactPrompt = `You are a persistent workspace agent. The surrounding policy mentions an evidence review.
+AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Create one plain-text artifact and verify it."}
+Repository evidence to consult as relevant: literature review, evidence review, research report.`;
+const scopedArtifactTools = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek", progressiveTools: true },
+  goal: scopedArtifactPrompt,
+  profile: "auto",
+  messages: [
+    { role: "user", content: scopedArtifactPrompt },
+    {
+      role: "user",
+      content: "Runtime snapshot: consult the surrounding literature review and evidence review policy before acting.",
+    },
+  ],
+});
+assert(names(scopedArtifactTools).includes("write_file"), "scoped artifact task omitted write_file");
+assert(
+  !(names(scopedArtifactTools).length === 2 && names(scopedArtifactTools)[0] === "deep_research"),
+  "surrounding policy prose incorrectly forced a scoped artifact task into deep research"
+);
+
+const scopedDeepResearchPrompt = `Generic workspace policy.
+AGINTI_EVIDENCE_SCOPE_JSON: {"mode":"task","request":"Write a deep research evidence review comparing three primary papers."}`;
+const scopedDeepResearchTools = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek", progressiveTools: true },
+  goal: scopedDeepResearchPrompt,
+  profile: "auto",
+  messages: [{ role: "user", content: scopedDeepResearchPrompt }],
+});
+sameNames(
+  scopedDeepResearchTools,
+  ["deep_research", "finish"],
+  "explicit deep research inside the scoped user request was not preserved"
+);
+
 const writingTools = selectProgressiveTools(allTools, {
   config: { provider: "localllm" },
   goal: "Draft and revise a chapter, then save it.",

package/scripts/smoke-web-api.js

@@ -10,7 +10,9 @@ import { WebDatabase } from "../src/web-db.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const fixtureMcpServer = path.join(repoRoot, "scripts", "fixtures", "mcp-stdio-smoke-server.mjs");
-const runtimeDir = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-api-smoke-"));
+const fixtureRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-api-smoke-root-"));
+const runtimeDir = path.join(fixtureRoot, "workspace");
+await fs.mkdir(runtimeDir, { recursive: true });
 const agintiflowHome = path.join(runtimeDir, ".agintiflow-home");
 process.env.AGINTIFLOW_HOME = agintiflowHome;
 const port = 43000 + Math.floor(Math.random() * 1000);
@@ -863,5 +865,5 @@ try {
 } finally {
   server.kill("SIGTERM");
   await delay(150);
-  await fs.rm(runtimeDir, { recursive: true, force: true });
+  await fs.rm(fixtureRoot, { recursive: true, force: true });
 }

package/src/progressive-tool-selection.js

@@ -1,4 +1,5 @@
 import { shouldStartWithDeepResearch } from "./research-routing.js";
+import { hasAgintiEvidenceScope, scopedChatopsEvidenceGoal } from "./scs-evidence.js";
 import {
   INTEGRATION_TEXT_WORKSPACE_PROFILE_ID,
   isIntegrationTextWorkspaceToolAllowed,
@@ -514,15 +515,17 @@ function textContent(content) {
 }
 
 function taskText(goal, config, messages) {
-  const recentConversation = Array.isArray(messages)
+  const rawGoal = goal || config.goal || "";
+  const scopedGoal = scopedChatopsEvidenceGoal(rawGoal);
+  const recentConversation = !hasAgintiEvidenceScope(rawGoal) && Array.isArray(messages)
     ? messages
         .filter((message) => message && (message.role === "user" || message.role === "assistant"))
         .slice(-6)
-        .map((message) => textContent(message.content))
+        .map((message) => scopedChatopsEvidenceGoal(textContent(message.content)))
         .filter(Boolean)
         .join("\n")
     : "";
-  return `${String(goal || config.goal || "")}\n${recentConversation}`.trim().toLowerCase();
+  return `${scopedGoal}\n${recentConversation}`.trim().toLowerCase();
 }
 
 function currentTaskMessages(messages) {

package/src/research-routing.js

@@ -1,3 +1,5 @@
+import { hasAgintiEvidenceScope, scopedChatopsEvidenceGoal } from "./scs-evidence.js";
+
 function messageText(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -5,12 +7,14 @@ function messageText(content) {
 }
 
 export function hasExplicitDeepResearchIntent(goal = "", messages = []) {
-  const recent = messages
-    .filter((message) => message?.role === "user")
-    .slice(-4)
-    .map((message) => messageText(message.content))
-    .join("\n");
-  const text = `${String(goal || "")}\n${recent}`.toLowerCase();
+  const recent = hasAgintiEvidenceScope(goal)
+    ? ""
+    : messages
+        .filter((message) => message?.role === "user")
+        .slice(-4)
+        .map((message) => scopedChatopsEvidenceGoal(messageText(message.content)))
+        .join("\n");
+  const text = `${scopedChatopsEvidenceGoal(goal)}\n${recent}`.toLowerCase();
   return (
     /\b(deep (?:web )?research|literature review|systematic review|multi[- ]source research|evidence review)\b/i.test(text) ||
     /\b(research report|compare at least|independent (?:primary|scholarly|official) sources?)\b.{0,160}\b(primary|scholarly|papers?|pdf|citations?|evidence|sources?)\b/i.test(text) ||

package/src/scs-evidence.js

@@ -670,9 +670,27 @@ function stripForbiddenLanguage(goal = "") {
     .replace(/禁止([^。\n；]+)/g, "");
 }
 
-function scopedChatopsEvidenceGoal(goal = "", taskProfile = "") {
-  const match = String(goal || "").match(/^AGINTI_EVIDENCE_SCOPE_JSON:\s*(\{[^\n]+\})\s*$/m);
-  if (!match) {
+function parseAgintiEvidenceScope(goal = "") {
+  const matches = [
+    ...String(goal || "").matchAll(/^AGINTI_EVIDENCE_SCOPE_JSON:\s*(\{[^\n]+\})\s*$/gm),
+  ];
+  const match = matches.at(-1);
+  if (!match) return null;
+  try {
+    const payload = JSON.parse(match[1]);
+    return payload && typeof payload === "object" ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+export function hasAgintiEvidenceScope(goal = "") {
+  return Boolean(parseAgintiEvidenceScope(goal));
+}
+
+export function scopedChatopsEvidenceGoal(goal = "", taskProfile = "") {
+  const payload = parseAgintiEvidenceScope(goal);
+  if (!payload) {
     const text = String(goal || "");
     const lines = text
       .split(/\r?\n/)
@@ -690,22 +708,32 @@ function scopedChatopsEvidenceGoal(goal = "", taskProfile = "") {
     }
     return text;
   }
-  try {
-    const payload = JSON.parse(match[1]);
-    if (!payload || typeof payload !== "object") return String(goal || "");
-    const mode = String(payload.mode || "").trim().toLowerCase();
-    if (["chat-response", "host-managed-response", "plan-response", "read-only-answer"].includes(mode)) {
-      return "Answer the current chat turn directly without external execution.";
-    }
-    const request = String(payload.request || "").trim();
-    return request || String(goal || "");
-  } catch {
-    return String(goal || "");
+  const mode = String(payload.mode || "").trim().toLowerCase();
+  if (["chat-response", "host-managed-response", "plan-response", "read-only-answer"].includes(mode)) {
+    return "Answer the current chat turn directly without external execution.";
   }
+  const request = String(payload.request || "").trim();
+  return request || String(goal || "");
+}
+
+function scopedArtifactRoot(goal = "") {
+  const payload = parseAgintiEvidenceScope(goal);
+  if (!payload || String(payload.mode || "").trim().toLowerCase() !== "task") return "";
+  return String(payload.artifact_root || "").trim();
+}
+
+function applyScopedArtifactRoot(items = [], artifactRoot = "") {
+  if (!artifactRoot) return items;
+  return items.map((item) => {
+    const value = String(item || "").trim();
+    if (!value || path.isAbsolute(value) || value.startsWith("~/") || /[\\/]/.test(value)) return value;
+    return path.join(artifactRoot, value);
+  });
 }
 
 export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceCriteria = [] } = {}) {
   const evidenceGoal = scopedChatopsEvidenceGoal(goal, taskProfile);
+  const artifactRoot = scopedArtifactRoot(goal);
   const requirementCategories = inferRequirementCategories(evidenceGoal, taskProfile, acceptanceCriteria);
   const requiredToolCalls = inferRequiredToolCalls(evidenceGoal);
   const requiresExternalEvidence = requirementCategories.length > 0 || requiredToolCalls.length > 0 || goalRequiresEvidence(evidenceGoal, taskProfile);
@@ -714,8 +742,11 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     category,
     description: CATEGORY_LABELS[category] || category,
   }));
-  const exactOutputPaths = inferExactOutputPaths(evidenceGoal);
-  const exactInputPaths = inferExactInputPaths(evidenceGoal).filter((item) => !exactOutputPaths.includes(item));
+  const inferredOutputPaths = inferExactOutputPaths(evidenceGoal);
+  const exactOutputPaths = applyScopedArtifactRoot(inferredOutputPaths, artifactRoot);
+  const exactInputPaths = inferExactInputPaths(evidenceGoal).filter(
+    (item) => !inferredOutputPaths.includes(item) && !exactOutputPaths.includes(item)
+  );
   const declaredSourceRoots = inferDeclaredSourceRoots(evidenceGoal);
   return {
     version: 1,
@@ -725,6 +756,7 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
     requiredEvidence,
     forbiddenActions: inferForbiddenActions(evidenceGoal),
     exactOutputPaths,
+    artifactRoot,
     exactInputPaths,
     declaredSourceRoots,
     readOnlyReadiness: isReadOnlyReadinessTask(evidenceGoal),
@@ -782,11 +814,12 @@ export function augmentScsTaskContractWithProjectVerification(contract = {}, sta
       .map((item) => String(item?.path || item || "").trim())
       .filter(Boolean)
   ).slice(0, 80);
-  const requiredOutputs = unique(
+  const requiredOutputs = unique(applyScopedArtifactRoot(
     (Array.isArray(verification.requiredOutputs) ? verification.requiredOutputs : [])
       .map((item) => String(item || "").trim())
-      .filter(Boolean)
-  ).slice(0, 64);
+      .filter(Boolean),
+    String(contract.artifactRoot || "")
+  )).slice(0, 64);
   const requiredProjectCommands = unique(
     (Array.isArray(verification.requiredCommands) ? verification.requiredCommands : [])
       .map(normalizeProjectCommand)