@lazyingart/agintiflow 0.20.279 → 0.20.281

package/package.json

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

@@ -191,15 +191,6 @@ try {
   const readOnlyVerificationState = {
     goal: readOnlyVerificationGoal,
     messages: [
-      toolMessage({
-        toolName: "run_command",
-        ok: true,
-        exitCode: 0,
-        args: { command: "git commit -m 'Complete retained repair'" },
-        stdout: "[main abcdef1] Complete retained repair\n 1 file changed, 1 insertion(+)",
-        goalRevision: 13,
-        projectMutationRevision: 19,
-      }),
       toolMessage({
         toolName: "run_command",
         ok: true,
@@ -265,6 +256,12 @@ try {
     },
     buildScsEvidenceLedger({ state: readOnlyVerificationState })
   );
+  assert(
+    readOnlyVerificationState.messages.every(
+      (message) => !String(message.content || "").includes("git commit")
+    ),
+    "read-only compaction regression accidentally retained the historical commit message"
+  );
   assert(
     readOnlyGitEvaluation.missingGitActions.length === 0,
     "a prior verified same-task commit did not satisfy a read-only completion continuation"
@@ -2785,6 +2782,16 @@ try {
       acceptanceClassification.substantiveTest === true,
     "a structurally named Python acceptance validator was treated as an arbitrary mutating script"
   );
+  const externalAcceptanceValidator =
+    "/opt/conda/bin/python /tmp/supervision/acceptance/webapp_booking_contract.py";
+  const externalAcceptanceClassification = classifyCommand(externalAcceptanceValidator);
+  assert(
+    externalAcceptanceClassification.category === "general-shell" &&
+      externalAcceptanceClassification.writesWorkspace === true &&
+      externalAcceptanceClassification.mayMutateProject === true &&
+      externalAcceptanceClassification.semanticMayMutateProject === false,
+    "trusted-shell authorization for an external Python validator was conflated with project mutation"
+  );
   assert(
     classifyCommand(`${acceptanceValidator} --output report.json`).writesWorkspace === true,
     "a Python acceptance validator with an explicit output destination was treated as read-only"
@@ -3682,6 +3689,32 @@ try {
       readOnlyValidatorResult.projectMutationRevision === 0,
     "a semantically read-only validator fabricated project mutation progress"
   );
+  const externalReadOnlyValidatorState = { meta: { goalContract: { revision: 1 } } };
+  const externalReadOnlyValidatorCommand =
+    "cd . && /opt/conda/bin/python /tmp/supervision/acceptance/webapp_booking_contract.py && git status --short";
+  const externalReadOnlyValidatorResult = {
+    toolName: "run_command",
+    ok: true,
+    exitCode: 0,
+    args: { command: externalReadOnlyValidatorCommand },
+    stdout: "webapp booking contract: PASS\n",
+    stderr: "",
+    commandPolicy: classifyCommand(externalReadOnlyValidatorCommand),
+  };
+  recordProjectVerificationOutcome(
+    externalReadOnlyValidatorState,
+    externalReadOnlyValidatorResult,
+    {
+      commandCwd: workspace,
+      taskProfile: "app",
+      sandboxMode: "host",
+    }
+  );
+  assert(
+    externalReadOnlyValidatorState.meta.projectVerification?.mutationRevision === 0 &&
+      externalReadOnlyValidatorResult.projectMutationRevision === 0,
+    "an absolute-interpreter acceptance validator forced a post-validation commit"
+  );
   const shellMutationState = { meta: { goalContract: { revision: 1 } } };
   const shellMutationResult = {
     toolName: "run_command",

package/src/agent-runner.js

@@ -10110,6 +10110,12 @@ function commandCanMutateProjectContent(command = "", commandPolicy = {}) {
   const category = String(commandPolicy.category || "");
   const requiresGitMutationInspection =
     ["git-workflow", "git-remote"].includes(category);
+  if (
+    commandPolicy.semanticMayMutateProject === false &&
+    !requiresGitMutationInspection
+  ) {
+    return false;
+  }
   if (requiresGitMutationInspection && commandPolicy.gitOnly === true) {
     return inferGitActionsFromCommand(command, { requireFailurePropagation: false }).some((action) =>
       WORKTREE_CHANGING_GIT_ACTIONS.has(action)

package/src/command-policy.js

@@ -293,8 +293,9 @@ function delegatedValidationPlanClassification(tokens = []) {
   const args = tokens.slice(1).map((token) => String(token || ""));
   const executablePath = validationExecutablePathMetadata(tokens[0]);
   const basenameCommand = [executable, ...args].join(" ");
+  const structuredValidation = structuredValidationCommand(basenameCommand);
   const validationLike = Boolean(
-    structuredValidationCommand(basenameCommand) || matchAny(TEST_PATTERNS, basenameCommand)
+    structuredValidation || matchAny(TEST_PATTERNS, basenameCommand)
   );
   if (executablePath.outsideWorkspace && validationLike) {
     return {
@@ -302,6 +303,12 @@ function delegatedValidationPlanClassification(tokens = []) {
       needsNetwork: true,
       writesWorkspace: true,
       mayMutateProject: true,
+      // Requiring trusted-shell authorization for an external executable does
+      // not prove that its bounded validation invocation mutates the project.
+      // Preserve that semantic distinction for post-command evidence tracking.
+      semanticMayMutateProject:
+        structuredValidation?.mayMutateProject ??
+        validationCommandMayMutateProject(basenameCommand),
       substantiveTest: false,
       reason:
         "The validation executable is outside the current workspace and requires trusted shell policy.",

package/src/scs-evidence.js

@@ -3359,7 +3359,20 @@ export function buildScsEvidenceLedger({ state = {}, context = {} } = {}) {
     .slice(-80)
     .map((item) => revalidateArtifactEvidence(item, state, context));
   const verifiedItems = items.filter((item) => item?.verified !== false);
-  const categories = unique(verifiedItems.map((item) => item.category));
+  const durableGitEvidence = (
+    Array.isArray(state.meta?.durableGitEvidence) ? state.meta.durableGitEvidence : []
+  )
+    .map((item) => ({
+      action: String(item?.action || "").toLowerCase(),
+      goalRevision: Math.max(0, Number(item?.goalRevision || 0)),
+      mutationRevision: Math.max(0, Number(item?.mutationRevision || 0)),
+    }))
+    .filter((item) => item.action)
+    .slice(-80);
+  const categories = unique([
+    ...verifiedItems.map((item) => item.category),
+    ...(durableGitEvidence.length ? ["git"] : []),
+  ]);
   const toolNames = unique(verifiedItems.map((item) => item.toolName).filter(Boolean));
   const blockerEvents = events
     .filter((event) => ["tool.blocked", "tool.failed"].includes(String(event?.type || "")))
@@ -3392,6 +3405,7 @@ export function buildScsEvidenceLedger({ state = {}, context = {} } = {}) {
     toolNames,
     blockerCount: blockers.length,
     blockers,
+    durableGitEvidence,
     items: items.map((item, index) => ({
       id: `e${String(index + 1).padStart(3, "0")}`,
       ...item,
@@ -3410,8 +3424,26 @@ export function evaluateScsEvidence(contract = {}, ledger = {}) {
     0,
     Number(contract.requiredGitMutationRevision || 0)
   );
+  const durableGitEvidence = (
+    Array.isArray(ledger.durableGitEvidence) ? ledger.durableGitEvidence : []
+  ).filter(
+    (item) =>
+      item?.action &&
+      (requiredGitRevision === 0 || Number(item?.goalRevision || 0) >= requiredGitRevision) &&
+      (requiredGitMutationRevision === 0 ||
+        Number(item?.mutationRevision || 0) >= requiredGitMutationRevision)
+  );
+  const observedGitEvidence = durableGitEvidence.length
+    ? durableGitEvidence.map((item) => ({
+        category: "git",
+        verified: true,
+        gitAction: item.action,
+        goalRevision: item.goalRevision,
+        mutationRevision: item.mutationRevision,
+      }))
+    : ledgerItems;
   const observedGitActionSequence =
-    ledgerItems
+    observedGitEvidence
       .filter(
         (item) =>
           item?.category === "git" &&