@lazyingart/agintiflow 0.20.252 → 0.20.254

package/package.json

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

@@ -341,6 +341,129 @@ assert.ok(
   "DeepSeek runtime compaction exceeded the bounded retry target"
 );
 
+const staleReadAfterMutationState = {
+  goal: "Repair service_ctl.py from current source and verify the service lifecycle tests.",
+  plan: "Use current source state and latest test evidence.",
+  messages: [
+    { role: "system", content: "Preserve current source truth across compaction." },
+    { role: "user", content: "Continue the current service recovery task." },
+    {
+      role: "assistant",
+      content: "",
+      tool_calls: [
+        {
+          id: "stale-source-read",
+          type: "function",
+          function: {
+            name: "read_file",
+            arguments: JSON.stringify({ path: "service_ctl.py", startLine: 1, lineLimit: 40 }),
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: "stale-source-read",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "service_ctl.py",
+        startLine: 1,
+        lineLimit: 40,
+        lineCount: 80,
+        bytes: 3200,
+        sha256: "1111111111111111111111111111111111111111111111111111111111111111",
+        contentTruncated: false,
+        content: "STALE-SERVICE-CONTENT command = f'python gateway_service.py'",
+      }),
+    },
+    {
+      role: "assistant",
+      content: "",
+      tool_calls: [
+        {
+          id: "current-source-mutation",
+          type: "function",
+          function: {
+            name: "apply_patch",
+            arguments: JSON.stringify({
+              path: "service_ctl.py",
+              search: "command = f'python gateway_service.py'",
+              replace: "command = [sys.executable, 'gateway_service.py']",
+            }),
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: "current-source-mutation",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "apply_patch",
+        path: "service_ctl.py",
+        summary: "1 file change applied",
+      }),
+    },
+    {
+      role: "assistant",
+      content: "",
+      tool_calls: [
+        {
+          id: "fresh-source-read",
+          type: "function",
+          function: {
+            name: "read_file",
+            arguments: JSON.stringify({ path: "service_ctl.py", startLine: 41, lineLimit: 40 }),
+          },
+        },
+      ],
+    },
+    {
+      role: "tool",
+      tool_call_id: "fresh-source-read",
+      content: JSON.stringify({
+        ok: true,
+        toolName: "read_file",
+        path: "service_ctl.py",
+        startLine: 41,
+        lineLimit: 40,
+        lineCount: 80,
+        bytes: 3300,
+        sha256: "2222222222222222222222222222222222222222222222222222222222222222",
+        contentTruncated: false,
+        content: "FRESH-SERVICE-CONTENT shell=False and lifecycle helpers are current",
+      }),
+    },
+    ...Array.from({ length: 8 }, (_, index) => readOnlyDiagnosticPair(index + 30)).flat(),
+  ],
+};
+const staleReadAfterMutationMessages = buildContextBudgetCompactionMessages(
+  staleReadAfterMutationState,
+  config,
+  { title: "", url: "" },
+  12,
+  { reason: "discard stale pre-mutation source reads" }
+);
+const staleReadAfterMutationText = staleReadAfterMutationMessages
+  .map((message) => message.content || "")
+  .join("\n");
+assert.ok(
+  !staleReadAfterMutationText.includes("STALE-SERVICE-CONTENT"),
+  "compaction retained a source read that predates a successful mutation of the same file"
+);
+assert.ok(
+  staleReadAfterMutationText.includes("FRESH-SERVICE-CONTENT"),
+  "compaction discarded the bounded source read made after the successful mutation"
+);
+assert.ok(
+  staleReadAfterMutationMessages.some((message) =>
+    Array.isArray(message.tool_calls) &&
+    message.tool_calls.some((call) => call?.function?.name === "apply_patch")
+  ),
+  "compaction discarded the successful mutation while invalidating its stale predecessor read"
+);
+
 function noisyFullReadPair(index, generation) {
   const id = `validator-${generation}-${index}`;
   const file = `tmp/validator-${generation}-${index}.py`;

package/scripts/smoke-local-failure-recovery.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -11,7 +12,11 @@ import {
   decideLocalFailureRecovery,
   localFailureRecoveryInstruction,
 } from "../src/local-failure-recovery.js";
-import { nextStepRuntimeConfig, runAgent } from "../src/agent-runner.js";
+import {
+  nextStepRuntimeConfig,
+  repeatedSuccessfulMutationBlock,
+  runAgent,
+} from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { SessionStore } from "../src/session-store.js";
 
@@ -190,6 +195,157 @@ assert.match(instruction, /preserve successful work/i);
 assert.match(instruction, /Do not repeat the failing call/i);
 assert.match(instruction, /rerun the smallest relevant verification/i);
 
+const durablePatchArgs = {
+  path: "service_ctl.py",
+  search: "command = f'python gateway_service.py'",
+  replace: "command = [sys.executable, 'gateway_service.py']",
+};
+const digest = (value) => crypto.createHash("sha256").update(value).digest("hex");
+const durableMutation = {
+  revision: 4,
+  goalRevision: 7,
+  taskHash: digest("Repair the sensor gateway lifecycle."),
+  toolName: "apply_patch",
+  paths: ["service_ctl.py"],
+  patch: {
+    path: "./service_ctl.py",
+    searchHash: digest(durablePatchArgs.search),
+    replaceHash: digest(durablePatchArgs.replace),
+  },
+};
+const durablePatchState = {
+  meta: {
+    goalContract: {
+      revision: 7,
+      taskGoal: "Repair the sensor gateway lifecycle.",
+      history: [
+        {
+          revision: 7,
+          kind: "initial",
+          hash: digest("Repair the sensor gateway lifecycle."),
+        },
+      ],
+    },
+    toolLoop: {
+      recent: Array.from({ length: 20 }, (_, index) =>
+        failed("apply_patch", `later-failure-${index}`)
+      ),
+      stagnationEpoch: 23,
+    },
+    projectVerification: {
+      mutationRevision: 4,
+      mutationHistory: [durableMutation],
+    },
+  },
+};
+assert.equal(
+  repeatedSuccessfulMutationBlock(durablePatchState, "apply_patch", durablePatchArgs, {
+    commandCwd: process.cwd(),
+  })?.category,
+  "repeated-successful-mutation",
+  "a successful exact patch must remain blocked after it falls out of the short tool-loop window"
+);
+assert.equal(
+  repeatedSuccessfulMutationBlock(
+    {
+      ...durablePatchState,
+      meta: {
+        ...durablePatchState.meta,
+        goalContract: {
+          revision: 8,
+          taskGoal: "Repair the sensor gateway lifecycle.",
+          history: [
+            ...durablePatchState.meta.goalContract.history,
+            {
+              revision: 8,
+              kind: "same-task-continuation",
+              relation: "same-task",
+              taskHash: digest("Repair the sensor gateway lifecycle."),
+            },
+          ],
+        },
+      },
+    },
+    "apply_patch",
+    durablePatchArgs,
+    { commandCwd: process.cwd() }
+  )?.category,
+  "repeated-successful-mutation",
+  "a same-task continuation must not forget an earlier successful mutation"
+);
+assert.equal(
+  repeatedSuccessfulMutationBlock(
+    {
+      ...durablePatchState,
+      meta: {
+        ...durablePatchState.meta,
+        goalContract: {
+          revision: 8,
+          taskGoal: "Implement a separate service migration.",
+          history: [
+            ...durablePatchState.meta.goalContract.history,
+            {
+              revision: 8,
+              kind: "continuation",
+              relation: "new-request",
+              taskHash: digest("Implement a separate service migration."),
+            },
+          ],
+        },
+      },
+    },
+    "apply_patch",
+    durablePatchArgs,
+    { commandCwd: process.cwd() }
+  ),
+  null,
+  "a genuine new task boundary must not inherit an unrelated mutation block"
+);
+const sanitizedDurablePatchArgs = {
+  ...durablePatchArgs,
+  search: durablePatchArgs.search.slice(0, 20),
+  replace: durablePatchArgs.replace.slice(0, 20),
+  searchHash: digest(durablePatchArgs.search),
+  replaceHash: digest(durablePatchArgs.replace),
+};
+assert.equal(
+  repeatedSuccessfulMutationBlock(
+    durablePatchState,
+    "apply_patch",
+    sanitizedDurablePatchArgs,
+    { commandCwd: process.cwd() }
+  )?.category,
+  "repeated-successful-mutation",
+  "redacted patch previews must use their retained full-content hashes for idempotency"
+);
+assert.equal(
+  repeatedSuccessfulMutationBlock(
+    {
+      ...durablePatchState,
+      meta: {
+        ...durablePatchState.meta,
+        projectVerification: {
+          mutationRevision: 5,
+          mutationHistory: [
+            durableMutation,
+            {
+              revision: 5,
+              goalRevision: 7,
+              toolName: "write_file",
+              paths: ["service_ctl.py"],
+            },
+          ],
+        },
+      },
+    },
+    "apply_patch",
+    durablePatchArgs,
+    { commandCwd: process.cwd() }
+  ),
+  null,
+  "an intervening successful mutation must permit the same exact patch when source state changed"
+);
+
 function assistant(content, toolCalls = []) {
   return {
     choices: [{ message: { role: "assistant", content, ...(toolCalls.length ? { tool_calls: toolCalls } : {}) } }],

package/src/agent-runner.js

@@ -877,11 +877,22 @@ function summarizeRetainedSourceEvidence(messages = [], limit = 28) {
     const payload = retained?.payload || safeParseToolContent(message.content);
     if (!payload || payload.ok === false || payload.blocked || payload.skipped) continue;
     const toolName = String(retained?.name || payload.toolName || payload.name || "");
+    const args = retained?.args || payload.args || {};
+    const sourcePath = String(payload.path || args.path || "").trim();
+    if (["apply_patch", "write_file"].includes(toolName) && sourcePath) {
+      for (const [key, record] of bySource.entries()) {
+        if (
+          record.toolName === "read_file" &&
+          retainedPathMatchesAny(record.sourcePath, [sourcePath])
+        ) {
+          bySource.delete(key);
+        }
+      }
+      continue;
+    }
     if (!["read_file", "list_files", "search_files", "inspect_project", "run_command"].includes(toolName)) {
       continue;
     }
-    const args = retained?.args || payload.args || {};
-    const sourcePath = String(payload.path || args.path || "").trim();
     const command = String(args.command || "").trim();
     const readRange = toolName === "read_file" ? retainedReadRange(payload, args) : null;
     const key = `${toolName}:${sourcePath || command}${readRange ? `:${readRange.key}` : ""}`;
@@ -937,9 +948,15 @@ function summarizeRetainedSourceEvidence(messages = [], limit = 28) {
       if (payload.stdout) parts.push(`stdout=${compactSingleLine(payload.stdout, 260)}`);
       if (payload.stderr) parts.push(`stderr=${compactSingleLine(payload.stderr, 220)}`);
     }
-    bySource.set(key, redactSensitiveText(parts.join(" | ")));
+    bySource.set(key, {
+      toolName,
+      sourcePath,
+      text: redactSensitiveText(parts.join(" | ")),
+    });
   }
-  return [...bySource.values()].slice(-Math.max(1, Number(limit) || 28));
+  return [...bySource.values()]
+    .slice(-Math.max(1, Number(limit) || 28))
+    .map((record) => record.text);
 }
 
 const COMPACTION_STATE_TOOL_NAMES = new Set([
@@ -1076,6 +1093,16 @@ function retainedToolStateMessages(messages = [], limit = 12, outputPaths = [],
     if (!COMPACTION_STATE_TOOL_NAMES.has(name)) return;
     if (!payload || payload.ok === false || payload.blocked || payload.skipped) return;
     const sourcePath = String(payload.path || args?.path || "").trim();
+    if (["apply_patch", "write_file"].includes(name) && sourcePath) {
+      for (const [key, record] of recordsByKey.entries()) {
+        if (
+          record.name === "read_file" &&
+          retainedPathMatchesAny(record.sourcePath, [sourcePath])
+        ) {
+          recordsByKey.delete(key);
+        }
+      }
+    }
     const command = String(args?.command || payload.args?.command || "").trim();
     const durableIdentity = String(
       sourcePath || command || payload.researchId || args?.researchId || args?.query || name
@@ -1085,6 +1112,7 @@ function retainedToolStateMessages(messages = [], limit = 12, outputPaths = [],
     recordsByKey.set(key, {
       ordinal: ordinal += 1,
       name,
+      sourcePath,
       args: redactValue(args),
       payload: compactRetainedToolPayload(name, payload, args),
     });
@@ -4369,9 +4397,13 @@ function clearRequiredCommandBatch(verification = {}) {
 }
 
 function appendProjectMutation(state = {}, verification = {}, mutation = {}, config = {}) {
+  const taskGoal = String(
+    state.meta?.goalContract?.taskGoal || state.goal || ""
+  ).trim();
   const record = {
     ...mutation,
     goalRevision: Math.max(0, Number(state.meta?.goalContract?.revision || 0)),
+    taskHash: taskGoal ? hashForLog(taskGoal) : "",
     revision: Math.max(0, Number(mutation.revision || verification.mutationRevision || 0)),
     paths: Array.isArray(mutation.paths)
       ? [...new Set(mutation.paths.map((item) => String(item || "")).filter(Boolean))].slice(0, 24)
@@ -6200,7 +6232,7 @@ export function repeatedSuccessfulMutationBlock(state, toolName, args = {}, conf
     commandCwd: config.commandCwd,
   });
   const stagnationEpoch = Math.max(0, Number(toolLoop.stagnationEpoch || 0));
-  const alreadyApplied = (Array.isArray(toolLoop.recent) ? toolLoop.recent : []).some(
+  const recentlyApplied = (Array.isArray(toolLoop.recent) ? toolLoop.recent : []).some(
     (entry) =>
       entry?.signature === signature &&
       entry?.toolName === "apply_patch" &&
@@ -6209,10 +6241,79 @@ export function repeatedSuccessfulMutationBlock(state, toolName, args = {}, conf
       entry?.successfulMutation === true &&
       Number(entry?.stagnationEpoch || 0) === stagnationEpoch
   );
+  const verification = state.meta?.projectVerification || {};
+  const history = Array.isArray(verification.mutationHistory)
+    ? verification.mutationHistory
+    : verification.lastMutation
+      ? [verification.lastMutation]
+      : [];
+  const targetPath = typeof args.path === "string" ? safeRecoveryEvidencePath(args.path) : "";
+  const searchHash = String(
+    args.searchHash || (typeof args.search === "string" ? hashForLog(args.search) : "")
+  );
+  const replaceHash = String(
+    args.replaceHash || (typeof args.replace === "string" ? hashForLog(args.replace) : "")
+  );
+  const goalContract = state.meta?.goalContract || {};
+  const currentGoalRevision = Math.max(0, Number(goalContract.revision || 0));
+  const currentTaskGoal = String(goalContract.taskGoal || state.goal || "").trim();
+  const currentTaskHash = currentTaskGoal ? hashForLog(currentTaskGoal) : "";
+  const goalHistory = Array.isArray(goalContract.history) ? goalContract.history : [];
+  const mutationBelongsToCurrentTask = (mutation = {}) => {
+    const mutationGoalRevision = Math.max(0, Number(mutation.goalRevision || 0));
+    const goalEntry = goalHistory.find(
+      (entry) => Number(entry?.revision || 0) === mutationGoalRevision
+    );
+    const mutationTaskHash = String(
+      mutation.taskHash ||
+      goalEntry?.taskHash ||
+      (goalEntry?.kind === "initial" ? goalEntry?.hash : "") ||
+      ""
+    );
+    if (currentTaskHash && mutationTaskHash) return currentTaskHash === mutationTaskHash;
+    if (mutationGoalRevision === currentGoalRevision) return true;
+    const interveningGoalEntries = goalHistory.filter((entry) => {
+      const revision = Number(entry?.revision || 0);
+      return revision > mutationGoalRevision && revision <= currentGoalRevision;
+    });
+    return (
+      interveningGoalEntries.length > 0 &&
+      interveningGoalEntries.every(
+        (entry) =>
+          String(entry?.relation || "") === "same-task" ||
+          String(entry?.kind || "") === "same-task-continuation"
+      )
+    );
+  };
+  let matchingHistoryIndex = -1;
+  if (targetPath && searchHash && replaceHash) {
+    for (let index = history.length - 1; index >= 0; index -= 1) {
+      const mutation = history[index];
+      if (
+        mutation?.toolName === "apply_patch" &&
+        mutationBelongsToCurrentTask(mutation) &&
+        safeRecoveryEvidencePath(mutation?.patch?.path) === targetPath &&
+        String(mutation?.patch?.searchHash || "") === searchHash &&
+        String(mutation?.patch?.replaceHash || "") === replaceHash
+      ) {
+        matchingHistoryIndex = index;
+        break;
+      }
+    }
+  }
+  const persistentlyApplied =
+    matchingHistoryIndex >= 0 &&
+    !history.slice(matchingHistoryIndex + 1).some(
+      (mutation) =>
+        mutationBelongsToCurrentTask(mutation) &&
+        Number(mutation?.revision || 0) >
+          Number(history[matchingHistoryIndex]?.revision || 0)
+    );
+  const alreadyApplied = recentlyApplied || persistentlyApplied;
   if (!alreadyApplied) return null;
   return {
     reason:
-      "This exact patch already succeeded without an intervening successful mutation or user continuation.",
+      "This exact patch already succeeded in the current task lineage without a later successful mutation that changed source state.",
     category: "repeated-successful-mutation",
     permissionAdvice: {
       category: "repeated-successful-mutation",