@lazyingart/agintiflow 0.20.278 → 0.20.280

package/package.json

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

@@ -182,6 +182,91 @@ function toolMessage(payload) {
 }
 
 try {
+  const readOnlyVerificationGoal = [
+    "Continue this exact saved task in the same workspace. Do not start over and do",
+    "not modify source_brief.md, measurements.csv, prompt.txt, or TASK.md.",
+    "The prior run completed the task-owned repository repair. Run exactly `git status --short`.",
+    "Do not rebuild, rewrite, recommit, or restore obsolete outputs when the worktree is clean.",
+  ].join("\n");
+  const readOnlyVerificationState = {
+    goal: readOnlyVerificationGoal,
+    messages: [
+      toolMessage({
+        toolName: "run_command",
+        ok: true,
+        exitCode: 0,
+        args: { command: "git status --short" },
+        stdout: "",
+        goalRevision: 15,
+        projectMutationRevision: 23,
+      }),
+    ],
+    meta: {
+      goalContract: {
+        version: 3,
+        revision: 15,
+        activeGoalRevision: 15,
+        taskGoal: "Create the editable deck, commit the focused repair, and verify it.",
+        activeGoal: readOnlyVerificationGoal,
+        currentRequest: readOnlyVerificationGoal,
+        currentPreview: readOnlyVerificationGoal,
+        history: [{ revision: 15, refreshExecutionContract: true }],
+      },
+      activeExecutionContract: {
+        revision: 15,
+        startedMutationRevision: 22,
+        requiresWorkspaceMutation: false,
+        requiresFileMutation: false,
+        requiresSourceGrounding: false,
+        requiredProjectCommands: ["git status --short"],
+      },
+      projectVerification: {
+        mutationRevision: 23,
+        requiredCommands: ["git status --short"],
+      },
+      durableGitActions: ["commit", "status"],
+      durableGitEvidence: [
+        { action: "commit", goalRevision: 13, mutationRevision: 19 },
+        { action: "status", goalRevision: 15, mutationRevision: 23 },
+      ],
+    },
+  };
+  const readOnlyVerificationContract = completionTaskContract(
+    { taskProfile: "slides" },
+    readOnlyVerificationState
+  );
+  assert(
+    readOnlyVerificationContract.requiresWorkspaceMutation === false &&
+      readOnlyVerificationContract.requiresFileMutation === false &&
+      readOnlyVerificationContract.requiresSourceGrounding === false,
+    "a verification-only continuation inherited stale mutation requirements from retained task context"
+  );
+  assert(
+    readOnlyVerificationContract.requiredGitActions.includes("commit") &&
+      Number(readOnlyVerificationContract.requiredGitRevision || 0) === 0 &&
+      Number(readOnlyVerificationContract.requiredGitMutationRevision || 0) === 0,
+    "a verification-only continuation demanded a new commit instead of accepting retained same-task Git evidence"
+  );
+  const readOnlyGitEvaluation = evaluateScsEvidence(
+    {
+      ...readOnlyVerificationContract,
+      requiresExternalEvidence: false,
+      requiredEvidence: [],
+      requiredProjectCommands: [],
+    },
+    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"
+  );
+
   const runLockConfig = {
     sessionsDir: path.join(tempRoot, "run-lock-sessions"),
   };

package/src/agent-runner.js

@@ -11319,6 +11319,19 @@ export function completionTaskContract(config = {}, state = {}) {
   const currentContract = currentRequest
     ? deriveScsTaskContract({ goal: currentRequest, taskProfile })
     : null;
+  const authoritativeReadOnlyContinuation = Boolean(
+    currentRequest &&
+      refreshesExecutionContract &&
+      activeExecutionContractIsAuthoritative &&
+      activeExecutionContract.requiresWorkspaceMutation !== true &&
+      activeExecutionContract.requiresFileMutation !== true &&
+      activeExecutionContract.requiresSourceGrounding !== true &&
+      currentContract?.requiresWorkspaceMutation !== true &&
+      currentContract?.requiresFileMutation !== true &&
+      currentContract?.requiresSourceGrounding !== true &&
+      !(Array.isArray(currentContract?.requiredGitActions) &&
+        currentContract.requiredGitActions.length > 0)
+  );
   if (
     currentRequest &&
     (refreshesExecutionContract || activeExecutionContractIsAuthoritative) &&
@@ -11383,12 +11396,15 @@ export function completionTaskContract(config = {}, state = {}) {
     contract = {
       ...contract,
       requiredEvidence: [...evidenceByCategory.values()],
-      requiresWorkspaceMutation: Boolean(
-        contract.requiresWorkspaceMutation || currentContract?.requiresWorkspaceMutation
-      ),
-      requiresFileMutation: Boolean(
-        contract.requiresFileMutation || currentContract?.requiresFileMutation
-      ),
+      requiresWorkspaceMutation: authoritativeReadOnlyContinuation
+        ? false
+        : Boolean(contract.requiresWorkspaceMutation || currentContract?.requiresWorkspaceMutation),
+      requiresFileMutation: authoritativeReadOnlyContinuation
+        ? false
+        : Boolean(contract.requiresFileMutation || currentContract?.requiresFileMutation),
+      requiresSourceGrounding: authoritativeReadOnlyContinuation
+        ? false
+        : Boolean(contract.requiresSourceGrounding || currentContract?.requiresSourceGrounding),
       currentEvidenceCategories: [...currentEvidenceCategories],
       currentEvidenceRevision: currentGoalRevision,
       currentMutationBaseline: startedMutationRevision,
@@ -11414,14 +11430,22 @@ export function completionTaskContract(config = {}, state = {}) {
   if (Array.isArray(contract.requiredGitActions) && contract.requiredGitActions.length) {
     contract = {
       ...contract,
-      requiredGitRevision: Math.max(
-        Number(contract.requiredGitRevision || 0),
-        Number(goalContract.activeGoalRevision || goalContract.revision || 0)
-      ),
-      requiredGitMutationRevision: Math.max(
-        Number(contract.requiredGitMutationRevision || 0),
-        Number(contract.projectMutationRevision || state.meta?.projectVerification?.mutationRevision || 0)
-      ),
+      requiredGitRevision: authoritativeReadOnlyContinuation
+        ? Number(contract.requiredGitRevision || 0)
+        : Math.max(
+            Number(contract.requiredGitRevision || 0),
+            Number(goalContract.activeGoalRevision || goalContract.revision || 0)
+          ),
+      requiredGitMutationRevision: authoritativeReadOnlyContinuation
+        ? Number(contract.requiredGitMutationRevision || 0)
+        : Math.max(
+            Number(contract.requiredGitMutationRevision || 0),
+            Number(
+              contract.projectMutationRevision ||
+                state.meta?.projectVerification?.mutationRevision ||
+                0
+            )
+          ),
     };
   }
   return contract;

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" &&