@lazyingart/agintiflow 0.20.239 → 0.20.241

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.239",
+  "version": "0.20.241",
   "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-deep-research.js

@@ -8,7 +8,11 @@ import { checkToolUse } from "../src/guardrails.js";
 import { flushHousekeeping } from "../src/housekeeping.js";
 import { requestNextStep, toolChoiceForProvider } from "../src/model-client.js";
 import { providerStructuredOutputAttempts } from "../src/provider-contract.js";
-import { hasExplicitDeepResearchIntent } from "../src/research-routing.js";
+import {
+  hasExplicitDeepResearchIntent,
+  hasLocalResearchWorkspaceIntent,
+  shouldStartWithDeepResearch,
+} from "../src/research-routing.js";
 import { SessionStore } from "../src/session-store.js";
 import { canonicalizeWebUrl, isPublicWebUrl, readWebPage, searchWeb } from "../src/web-search.js";
 
@@ -48,6 +52,17 @@ async function main() {
   assert(!excessiveResearch.allowed, "deep_research accepted an excessive query/source budget");
 
   assert(hasExplicitDeepResearchIntent("literature review with primary papers"), "explicit research intent was not detected");
+  const localEvidenceGoal =
+    "Turn the messy project notes in this folder into an evidence review, write sources.json, and commit the intentional work.";
+  assert(hasLocalResearchWorkspaceIntent(localEvidenceGoal), "local research workspace intent was not detected");
+  assert(
+    !shouldStartWithDeepResearch(localEvidenceGoal),
+    "local-source research incorrectly forced deep_research before workspace inspection"
+  );
+  assert(
+    shouldStartWithDeepResearch("Write a deep web research report comparing three primary papers."),
+    "standalone deep research no longer starts with the bounded research workflow"
+  );
   assert(
     !hasExplicitDeepResearchIntent("Create a phone-friendly document from this folder.", [
       {

package/scripts/smoke-dynamic-step-budget.js

@@ -2302,6 +2302,112 @@ try {
     shellMutationState.meta.projectVerification?.mutationRevision === 1,
     "metadata-only Git chain with observational output invalidated current verification"
   );
+  assert(
+    classifyCommand("md5sum output/report.pdf").writesWorkspace === false &&
+      classifyCommand("md5sum -c .aginti/verification/source-hashes.txt").writesWorkspace === false &&
+      classifyCommand("diff .aginti/verification/run-1.txt .aginti/verification/run-2.txt").writesWorkspace === false,
+    "checksum or diff evidence probes were not classified as read-only"
+  );
+  const privateEvidenceState = {
+    meta: {
+      goalContract: { revision: 1 },
+      projectVerification: { requiredCommands: ["bash build.sh"] },
+    },
+  };
+  const privateEvidenceBuild = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: "bash build.sh" },
+    stdout: "build complete\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, privateEvidenceBuild, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+    allowShellTool: true,
+    sandboxMode: "host",
+  });
+  const privateEvidenceRevision =
+    privateEvidenceState.meta.projectVerification?.mutationRevision;
+  const privateEvidenceCommand = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: {
+      command:
+        "md5sum output/report.pdf > .aginti/verification/hashes-final.txt && cat .aginti/verification/hashes-final.txt && diff .aginti/verification/hashes-run1.txt .aginti/verification/hashes-final.txt && md5sum -c .aginti/verification/source-hashes.txt && git status --porcelain",
+    },
+    stdout: "MATCH\n",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, privateEvidenceCommand, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+    allowShellTool: true,
+    sandboxMode: "host",
+  });
+  const privateEvidenceWrite = {
+    toolName: "write_file",
+    ok: true,
+    path: ".aginti/verification/visual-check.txt",
+    changes: [
+      {
+        path: ".aginti/verification/visual-check.txt",
+        created: true,
+        beforeHash: "",
+        afterHash: "private-evidence",
+      },
+    ],
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, privateEvidenceWrite, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+  });
+  const privateEvidenceContract = augmentScsTaskContractWithProjectVerification(
+    {
+      requiresExternalEvidence: false,
+      requiredEvidence: [],
+      requiredToolCalls: [],
+      requiredGitActions: [],
+      taskProfile: "writing",
+    },
+    privateEvidenceState,
+    { taskProfile: "writing" }
+  );
+  const privateEvidenceLedger = buildScsEvidenceLedger({
+    state: {
+      messages: [privateEvidenceBuild, privateEvidenceCommand, privateEvidenceWrite].map((result) =>
+        toolMessage(result)
+      ),
+    },
+  });
+  assert(
+    privateEvidenceRevision === 1 &&
+      privateEvidenceState.meta.projectVerification?.mutationRevision === 1 &&
+      privateEvidenceState.meta.projectVerification?.requiredCommandBatch?.complete === true &&
+      evaluateScsEvidence(privateEvidenceContract, privateEvidenceLedger).ok,
+    "ignored private verification evidence invalidated a successful canonical build"
+  );
+  const publicEvidenceMutation = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: "md5sum output/report.pdf > output/hashes-final.txt" },
+    stdout: "",
+    stderr: "",
+  };
+  recordProjectVerificationOutcome(privateEvidenceState, publicEvidenceMutation, {
+    commandCwd: workspace,
+    taskProfile: "writing",
+    allowShellTool: true,
+    sandboxMode: "host",
+  });
+  assert(
+    privateEvidenceState.meta.projectVerification?.mutationRevision === 2 &&
+      !privateEvidenceState.meta.projectVerification?.requiredCommandBatch,
+    "a non-private output write was incorrectly exempted from project mutation tracking"
+  );
   const gitCheckoutResult = {
     toolName: "run_command",
     ok: true,

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

@@ -1475,6 +1475,21 @@ const explicitDeepResearchFollowup = selectProgressiveTools(allTools, {
 });
 assert(names(explicitDeepResearchFollowup).includes("web_search"), "deep-research follow-up did not restore targeted recovery tools");
 
+const localEvidenceResearchStarter = selectProgressiveTools(allTools, {
+  config: { provider: "deepseek" },
+  goal:
+    "Investigate the reliability problem in this folder, correct PROJECT_NOTES.md, write an evidence review and sources.json, then commit the intentional work.",
+  profile: "research",
+});
+assert(names(localEvidenceResearchStarter).includes("deep_research"), "local evidence research omitted deep_research");
+assert(names(localEvidenceResearchStarter).includes("read_file"), "local evidence research omitted read_file");
+assert(names(localEvidenceResearchStarter).includes("write_file"), "local evidence research omitted write_file");
+assert(names(localEvidenceResearchStarter).includes("run_command"), "local evidence research omitted shell/git access");
+assert(
+  !(names(localEvidenceResearchStarter).length === 2 && names(localEvidenceResearchStarter)[0] === "deep_research"),
+  "local evidence research was trapped on deep_research before reading its source material"
+);
+
 const documentRuntimeSnapshot =
   'Step 1/30. Latest runtime snapshot:\n{"pageText":"Workspace file tools are ready. Web search and resumable deep research are available when current evidence is required."}';
 const localDocumentStarter = selectProgressiveTools(allTools, {

package/src/agent-runner.js

@@ -5991,6 +5991,49 @@ const WORKTREE_CHANGING_GIT_ACTIONS = new Set([
   "switch",
 ]);
 
+function isPrivateVerificationEvidencePath(value = "") {
+  const normalized = String(value || "")
+    .trim()
+    .replace(/^["']|["']$/g, "")
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "");
+  return Boolean(
+    normalized === ".aginti/verification" ||
+      normalized.startsWith(".aginti/verification/") ||
+      normalized.includes("/.aginti/verification/")
+  );
+}
+
+function commandWritesOnlyPrivateVerificationEvidence(command = "") {
+  const normalized = String(command || "").trim();
+  if (!normalized) return false;
+  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);
+    return targets.length > 0 && targets.every(isPrivateVerificationEvidencePath);
+  }
+  if (tokens[0] === "mkdir") {
+    const targets = tokens.slice(1).filter((token) => token !== "-p" && token !== "--");
+    return targets.length > 0 && targets.every(isPrivateVerificationEvidencePath);
+  }
+
+  let strippedPrivateRedirect = false;
+  const withoutPrivateRedirects = normalized.replace(
+    /(^|\s)(?:\d*>>?|&>>?)\s*("[^"]+"|'[^']+'|[^\s;&|]+)/g,
+    (match, prefix, target) => {
+      if (!isPrivateVerificationEvidencePath(target)) return match;
+      strippedPrivateRedirect = true;
+      return prefix;
+    }
+  ).trim();
+  if (!strippedPrivateRedirect || !withoutPrivateRedirects) return false;
+  const underlyingPolicy = classifyCommand(withoutPrivateRedirects);
+  return underlyingPolicy.writesWorkspace !== true && underlyingPolicy.mayMutateProject !== true;
+}
+
 function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
   if (commandPolicy.writesWorkspace !== true && commandPolicy.mayMutateProject !== true) return false;
   const sequence = parseTopLevelShellSequence(String(command || ""));
@@ -6004,6 +6047,7 @@ function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
       commandCanMutateProjectContent(segment, classifyCommand(segment))
     );
   }
+  if (commandWritesOnlyPrivateVerificationEvidence(command)) return false;
   const category = String(commandPolicy.category || "");
   if (!["git-workflow", "git-remote"].includes(category)) return true;
   if (/\bgit\s+clone\b/i.test(String(command || ""))) return true;
@@ -6490,7 +6534,7 @@ function successfulProjectMutationPaths(toolResult = {}) {
       [
         toolResult.path,
         ...actualChanges.flatMap((change) => [change.path, change.fromPath]),
-      ].filter(Boolean)
+      ].filter((candidate) => candidate && !isPrivateVerificationEvidencePath(candidate))
     ),
   ];
 }

package/src/command-policy.js

@@ -108,17 +108,31 @@ function isReadOnlyUniqFilter(command = "") {
   );
 }
 
-function isReadOnlySha256Command(command = "") {
+function isReadOnlyDigestCommand(command = "") {
   const normalized = stripBenignRedirections(command);
   if (hasActiveShellExpansion(normalized)) return false;
   const tokens = tokenizeShellWords(normalized);
-  if (tokens[0] !== "sha256sum" || tokens.length < 2) return false;
-  const paths = tokens.slice(1).filter((token) => token !== "--");
+  if (!["md5sum", "sha256sum"].includes(tokens[0]) || tokens.length < 2) return false;
+  let index = 1;
+  if (["-c", "--check"].includes(tokens[index])) index += 1;
+  if (tokens[index] === "--") index += 1;
+  const paths = tokens.slice(index);
   return paths.length > 0 && paths.every((token) =>
     !token.startsWith("-") && READ_ONLY_FOR_LOOP_LITERAL_PATTERN.test(token)
   );
 }
 
+function isReadOnlyDiffCommand(command = "") {
+  const normalized = stripBenignRedirections(command);
+  if (hasActiveShellExpansion(normalized)) return false;
+  const tokens = tokenizeShellWords(normalized);
+  if (tokens[0] !== "diff" || tokens.length < 3) return false;
+  const operands = tokens.slice(1).filter((token) => token !== "--" && !token.startsWith("-"));
+  return operands.length === 2 && operands.every((token) =>
+    READ_ONLY_FOR_LOOP_LITERAL_PATTERN.test(token)
+  );
+}
+
 function isReadOnlyFindCommand(command = "") {
   const normalized = stripBenignRedirections(command);
   if (!/^find\s+/.test(normalized)) return false;
@@ -1511,7 +1525,8 @@ function classifySimpleCommand(normalized) {
     isReadOnlyPrintfCommand(commandForPatternMatching) ||
     isReadOnlyTrDeleteFilter(commandForPatternMatching) ||
     isReadOnlyUniqFilter(commandForPatternMatching) ||
-    isReadOnlySha256Command(commandForPatternMatching) ||
+    isReadOnlyDigestCommand(commandForPatternMatching) ||
+    isReadOnlyDiffCommand(commandForPatternMatching) ||
     isReadOnlyFindCommand(normalized) ||
     (!hasActiveShellExpansion(benignRedirectCommand) && isReadOnlyShellCondition(benignRedirectCommand))
   ) {

package/src/progressive-tool-selection.js

@@ -1,4 +1,7 @@
-import { shouldStartWithDeepResearch } from "./research-routing.js";
+import {
+  hasLocalResearchWorkspaceIntent,
+  shouldStartWithDeepResearch,
+} from "./research-routing.js";
 import { hasAgintiEvidenceScope, scopedChatopsEvidenceGoal } from "./scs-evidence.js";
 import {
   INTEGRATION_TEXT_WORKSPACE_PROFILE_ID,
@@ -1241,6 +1244,13 @@ function compactToolNames({ config, goal, profile, messages }) {
   for (const bundle of inferred) {
     if (!bundleOrder.includes(bundle)) bundleOrder.push(bundle);
   }
+  if (
+    bundleOrder.includes("research") &&
+    hasLocalResearchWorkspaceIntent(goal || config.goal, messages) &&
+    !bundleOrder.includes("code")
+  ) {
+    bundleOrder.push("code");
+  }
   if (bundleOrder.length === 0 && explicitProfileTools.length === 0) bundleOrder.push("general");
 
   const names = [];

package/src/research-routing.js

@@ -48,6 +48,22 @@ export function hasExplicitDeepResearchIntent(goal = "", messages = []) {
   );
 }
 
+export function hasLocalResearchWorkspaceIntent(goal = "", messages = []) {
+  const recent = hasAgintiEvidenceScope(goal)
+    ? ""
+    : genuineUserMessages(messages)
+        .slice(-4)
+        .map((message) => scopedChatopsEvidenceGoal(messageText(message.content)))
+        .join("\n");
+  const text = `${scopedChatopsEvidenceGoal(goal)}\n${recent}`;
+  return (
+    /\b(?:this|current|existing|project|workspace|local)\s+(?:folder|directory|repo(?:sitory)?|files?|notes?|sources?|artifacts?)\b/i.test(text) ||
+    /\b(?:task|project|source|research|evidence|notes?|manifest|readme)[-_A-Za-z0-9]*\.(?:md|json|ya?ml|txt|csv|bib|tex)\b/i.test(text) ||
+    /\b(?:inspect|read|reconcile|correct|rewrite|update)\b.{0,120}\b(?:workspace|folder|directory|repo(?:sitory)?|local files?|project notes?|existing notes?)\b/i.test(text) ||
+    /\b(?:git\s+)?commit\b/i.test(text)
+  );
+}
+
 export function toolWasRequested(messages = [], toolName = "") {
   return messages.some((message) => {
     if (
@@ -65,5 +81,9 @@ export function toolWasRequested(messages = [], toolName = "") {
 }
 
 export function shouldStartWithDeepResearch(goal = "", messages = []) {
-  return hasExplicitDeepResearchIntent(goal, messages) && !toolWasRequested(messages, "deep_research");
+  return (
+    hasExplicitDeepResearchIntent(goal, messages) &&
+    !hasLocalResearchWorkspaceIntent(goal, messages) &&
+    !toolWasRequested(messages, "deep_research")
+  );
 }