@lazyingart/agintiflow 0.20.311 → 0.20.313

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.311",
+  "version": "0.20.313",
   "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-local-failure-recovery.js

@@ -1009,6 +1009,93 @@ assert.equal(
   "the first exact-search mismatch did not immediately open one bounded current-source refresh"
 );
 const tracebackFirstRefreshState = structuredClone(stalePatchRefreshState);
+const scopedArtifactPath =
+  "output/webapp/agent/tasks/source-intake-audit/report.md";
+const scopedArtifactRoot = path.join(
+  repoRoot,
+  "output/webapp/agent/tasks/source-intake-audit"
+);
+const scopedArtifactGoal = [
+  "Correct and verify the exact source-intake audit report.",
+  `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+    mode: "task",
+    request: "Correct and verify the exact source-intake audit report.",
+    artifact_root: scopedArtifactRoot,
+  })}`,
+].join("\n");
+const scopedArtifactRefreshState = {
+  commandCwd: repoRoot,
+  meta: {
+    goalContract: {
+      revision: 9,
+      activeGoal: scopedArtifactGoal,
+      taskGoal: scopedArtifactGoal,
+      history: [],
+    },
+    projectVerification: {
+      mutationRevision: 2,
+      testRuns: [],
+    },
+    toolLoop: {
+      stagnationEpoch: 4,
+      recent: [],
+    },
+  },
+};
+const scopedArtifactRefresh = patchContextRefreshDecision(
+  scopedArtifactRefreshState,
+  {
+    toolName: "apply_patch",
+    args: {
+      path: scopedArtifactPath,
+      search: "Planned dynamic check: run the guarded document reader test.",
+      replace: "Guarded document reader test: passed.",
+    },
+    ok: false,
+    category: "workspace-patch",
+    error: `Patch search text was not found in ${scopedArtifactPath}.`,
+  }
+);
+assert.equal(
+  scopedArtifactRefresh?.path,
+  scopedArtifactPath,
+  "a stale patch inside the exact scoped task artifact root was not recoverable"
+);
+scopedArtifactRefreshState.meta.toolLoop.patchContextRequired =
+  scopedArtifactRefresh;
+assert.equal(
+  activePatchContextRefresh(scopedArtifactRefreshState)?.path,
+  scopedArtifactPath,
+  "the scoped task-artifact refresh marker was rejected as a generic output path"
+);
+assert.equal(
+  nextStepRuntimeConfig(baseConfig, scopedArtifactRefreshState)
+    .patchContextRefreshPath,
+  scopedArtifactPath,
+  "the scoped task-artifact refresh path did not reach the next constrained turn"
+);
+const scopedArtifactSource = [
+  "# Source Intake Audit",
+  "",
+  "Document reader verification is pending.",
+  "",
+].join("\n");
+assert.equal(
+  consumePatchContextRefreshRead(scopedArtifactRefreshState, {
+    toolName: "read_file",
+    args: { path: scopedArtifactPath },
+    result: { path: scopedArtifactPath },
+    content: scopedArtifactSource,
+    ok: true,
+  })?.path,
+  scopedArtifactPath,
+  "an exact reread did not consume the scoped task-artifact refresh"
+);
+assert.equal(
+  activePatchContextRepair(scopedArtifactRefreshState)?.path,
+  scopedArtifactPath,
+  "the scoped task-artifact reread did not leave a bounded repair anchor"
+);
 tracebackFirstRefreshState.meta.projectVerification.testRuns[0].failureSummary =
   'File "./service_ctl.py", line 139 -> return start_service(args.state_dir, args.host, args.port) parser = argparse.ArgumentParser()';
 const tracebackFirstRefresh = patchContextRefreshDecision(tracebackFirstRefreshState, {

package/scripts/smoke-planning-timeout-recovery.js

@@ -11,6 +11,7 @@ import {
   modelPlanningTimeoutRetryRoute,
   nextStepRuntimeConfig,
   recordAlreadyCommittedRepositoryRepair,
+  recordProjectVerificationOutcome,
   runAgent,
 } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
@@ -155,43 +156,42 @@ try {
       artifact_root: scopedArtifactRoot,
     })}`,
   ].join("\n");
-  const scopedRuntime = nextStepRuntimeConfig(
-    { commandCwd: scopedRepairRoot, goal: scopedGoal },
-    {
-      goal: scopedGoal,
-      commandCwd: scopedRepairRoot,
-      meta: {
-        goalContract: {
-          revision: 1,
-          currentRequest: scopedGoal,
-          currentHash: "scoped-repair",
-        },
-        activeExecutionContract: {
-          revision: 1,
-          refreshedAt,
-          startedMutationRevision: 0,
-          requiresWorkspaceMutation: true,
-          requiresFileMutation: true,
-          requiresSourceGrounding: true,
-        },
-        projectVerification: {
-          mutationRevision: 0,
-          mutationHistory: [],
-          testRuns: [],
-          discoveredTests: [],
-        },
-        toolLoop: {
-          recent: [{
-            toolName: "read_file",
-            ok: true,
-            blocked: false,
-            path: scopedSource,
-            at: groundedAt,
-          }],
-        },
+  const scopedState = {
+    goal: scopedGoal,
+    commandCwd: scopedRepairRoot,
+    meta: {
+      goalContract: {
+        revision: 1,
+        currentRequest: scopedGoal,
+        currentHash: "scoped-repair",
       },
-    }
-  );
+      activeExecutionContract: {
+        revision: 1,
+        refreshedAt,
+        startedMutationRevision: 0,
+        requiresWorkspaceMutation: true,
+        requiresFileMutation: true,
+        requiresSourceGrounding: true,
+      },
+      projectVerification: {
+        mutationRevision: 0,
+        mutationHistory: [],
+        testRuns: [],
+        discoveredTests: [],
+      },
+      toolLoop: {
+        recent: [{
+          toolName: "read_file",
+          ok: true,
+          blocked: false,
+          path: scopedSource,
+          at: groundedAt,
+        }],
+      },
+    },
+  };
+  const scopedConfig = { commandCwd: scopedRepairRoot, goal: scopedGoal };
+  const scopedRuntime = nextStepRuntimeConfig(scopedConfig, scopedState);
   assert.equal(scopedRuntime.scopedArtifactTask, true);
   assert.equal(
     scopedRuntime.completionFreshMutationRequired,
@@ -200,6 +200,34 @@ try {
   );
   assert.deepEqual(scopedRuntime.completionFreshMutationPaths, [scopedSource]);
   assert.equal(scopedRuntime.completionFreshMutationNeedsSourceRead, false);
+  recordProjectVerificationOutcome(
+    scopedState,
+    {
+      toolName: "write_file",
+      ok: true,
+      path: scopedSource,
+      args: { path: scopedSource },
+      change: {
+        path: scopedSource,
+        beforeHash: "rejected-report",
+        afterHash: "corrected-report",
+        beforeBytes: 18,
+        afterBytes: 96,
+      },
+    },
+    { ...scopedConfig, ...scopedRuntime }
+  );
+  assert.deepEqual(
+    scopedState.meta.activeExecutionContract.scopedArtifactMutationPaths,
+    [scopedSource],
+    "a successful scoped artifact write did not persist its current-turn mutation"
+  );
+  const scopedRuntimeAfterWrite = nextStepRuntimeConfig(scopedConfig, scopedState);
+  assert.equal(
+    scopedRuntimeAfterWrite.completionFreshMutationRequired,
+    undefined,
+    "a successful current-turn scoped artifact write remained trapped in source-mutation recovery"
+  );
 } finally {
   await fs.rm(scopedRepairRoot, { recursive: true, force: true });
 }

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

@@ -734,6 +734,41 @@ assertStrict.deepEqual(
   { path: mandatoryRefreshPath },
   "mandatory patch-context recovery did not preserve the exact constrained path"
 );
+const scopedMandatoryRefreshPath =
+  "output/webapp/agent/tasks/source-intake-audit/report.md";
+const scopedMandatoryRefreshRoot =
+  "output/webapp/agent/tasks/source-intake-audit";
+const scopedMandatoryRefreshReadDescriptor = {
+  ...canonicalReadDescriptor,
+  function: {
+    ...canonicalReadDescriptor.function,
+    parameters: {
+      ...canonicalReadDescriptor.function.parameters,
+      properties: {
+        path: { type: "string", enum: [scopedMandatoryRefreshPath] },
+      },
+    },
+  },
+};
+const recoveredScopedMandatoryRefresh =
+  recoverRequiredPatchContextReadWithoutToolCall(
+    {
+      commandCwd: process.cwd(),
+      scopedArtifactRoot: scopedMandatoryRefreshRoot,
+      patchContextRefreshRequired: true,
+      patchContextRefreshPath: scopedMandatoryRefreshPath,
+    },
+    [],
+    createToolContract([scopedMandatoryRefreshReadDescriptor, tool("finish")]),
+    { ok: true, calls: [], acceptedToolCalls: [], deferredToolCalls: [] }
+  );
+assertStrict.deepEqual(
+  JSON.parse(
+    recoveredScopedMandatoryRefresh.acceptedToolCalls[0].function.arguments
+  ),
+  { path: scopedMandatoryRefreshPath },
+  "mandatory patch-context recovery rejected the exact scoped task artifact"
+);
 const recoveredPrematureRefreshFinish = recoverRequiredPatchContextReadWithoutToolCall(
   {
     patchContextRefreshRequired: true,

package/src/agent-runner.js

@@ -6622,6 +6622,28 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
   const projectMutationPaths = successfulProjectMutationPaths(toolResult, state, config);
   const privateMutationPaths = successfulPrivateVerificationMutationPaths(toolResult);
   const materialMutationPaths = materialProjectMutationPaths(toolResult, state, config);
+  const scopedArtifactMutationPaths = successfulScopedArtifactMutationPaths(
+    toolResult,
+    state,
+    config
+  );
+  const activeExecutionContract = state.meta?.activeExecutionContract;
+  if (
+    ["write_file", "apply_patch"].includes(toolName) &&
+    scopedArtifactMutationPaths.length > 0 &&
+    Number(activeExecutionContract?.revision || 0) ===
+      Number(state.meta?.goalContract?.revision || 0)
+  ) {
+    activeExecutionContract.scopedArtifactMutationAt = now;
+    activeExecutionContract.scopedArtifactMutationPaths = [
+      ...new Set([
+        ...(Array.isArray(activeExecutionContract.scopedArtifactMutationPaths)
+          ? activeExecutionContract.scopedArtifactMutationPaths
+          : []),
+        ...scopedArtifactMutationPaths,
+      ]),
+    ].slice(0, 24);
+  }
   if (["write_file", "apply_patch"].includes(toolName) && privateMutationPaths.length) {
     delete state.meta.verifiedCompletionCandidate;
     verification.privateMutationRevision += 1;
@@ -6669,7 +6691,6 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
           }
         : {}),
     }, config);
-    const activeExecutionContract = state.meta?.activeExecutionContract;
     if (
       materialMutationPaths.length > 0 &&
       Number(activeExecutionContract?.revision || 0) ===
@@ -10171,7 +10192,8 @@ export function repeatedStaticToolBlock(state, toolName, args = {}, config = {})
     (
       (
         requiredPatchRefresh &&
-        safeRecoveryEvidencePath(args?.path) === requiredPatchRefresh.path
+        safePatchContextEvidencePath(args?.path, state, config) ===
+          requiredPatchRefresh.path
       ) ||
       boundedFailedTestReadPaths.includes(safeRecoveryEvidencePath(args?.path))
     )
@@ -12681,7 +12703,9 @@ function isPrivateVerificationEvidencePath(value = "") {
 }
 
 function isScopedTaskArtifactEvidencePath(value = "", state = {}, config = {}) {
-  const artifactRoot = scopedArtifactRoot(completionContractGoal(config, state));
+  const artifactRoot =
+    scopedArtifactRoot(completionContractGoal(config, state)) ||
+    String(config.scopedArtifactRoot || "").trim();
   if (!artifactRoot) return false;
   const raw = String(value || "")
     .trim()
@@ -12700,6 +12724,41 @@ function isScopedTaskArtifactEvidencePath(value = "", state = {}, config = {}) {
   );
 }
 
+function safePatchContextEvidencePath(value = "", state = {}, config = {}) {
+  const sourcePath = safeRecoveryEvidencePath(value);
+  if (sourcePath) return sourcePath;
+
+  const raw = String(value || "")
+    .trim()
+    .replace(/^["']|["']$/g, "")
+    .replace(/\\/g, "/");
+  if (
+    !raw ||
+    raw.includes("\0") ||
+    /^https?:\/\//i.test(raw) ||
+    /(?:secret|credential|password|private[-_]?key|access[-_]?token)/i.test(raw)
+  ) {
+    return "";
+  }
+  const commandCwd = path.resolve(
+    config.commandCwd || state.commandCwd || process.cwd()
+  );
+  const absolutePath = path.isAbsolute(raw)
+    ? path.resolve(raw)
+    : path.resolve(commandCwd, raw);
+  const relativePath = path.relative(commandCwd, absolutePath).replace(/\\/g, "/");
+  if (
+    !relativePath ||
+    relativePath.startsWith("..") ||
+    path.isAbsolute(relativePath) ||
+    !PLAIN_TEXT_FILE_EXTENSIONS.has(path.extname(relativePath).toLowerCase()) ||
+    !isScopedTaskArtifactEvidencePath(raw, state, config)
+  ) {
+    return "";
+  }
+  return relativePath;
+}
+
 function commandWritesOnlyEvidenceMatching(command = "", pathMatches = () => false) {
   const normalized = String(command || "").trim();
   if (!normalized) return false;
@@ -13782,6 +13841,33 @@ function successfulMutationPaths(toolResult = {}) {
   return [...new Set([toolResult.path, ...changes.map((change) => change.path)].filter(Boolean))];
 }
 
+function successfulScopedArtifactMutationPaths(
+  toolResult = {},
+  state = {},
+  config = {}
+) {
+  const artifactRoot = String(
+    config.scopedArtifactRoot ||
+      scopedArtifactRoot(completionContractGoal(config, state)) ||
+      ""
+  ).trim();
+  if (!artifactRoot) return [];
+  const commandCwd = path.resolve(
+    config.commandCwd || state.commandCwd || process.cwd()
+  );
+  const resolvedRoot = path.resolve(commandCwd, artifactRoot);
+  return successfulMutationPaths(toolResult)
+    .map((candidate) => path.resolve(commandCwd, String(candidate || "")))
+    .filter((candidate) => {
+      const relative = path.relative(resolvedRoot, candidate);
+      return (
+        relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative))
+      );
+    })
+    .map((candidate) => path.relative(commandCwd, candidate).replace(/\\/g, "/"));
+}
+
 function successfulWorkspaceMutationPaths(toolResult = {}) {
   if (!toolResult || toolResult.blocked || toolResult.skipped) return [];
   if (!["write_file", "apply_patch"].includes(String(toolResult.toolName || ""))) return [];
@@ -15283,6 +15369,20 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
     runtimeConfig.scopedArtifactRoot = scopedRootRelative.replace(/\\/g, "/");
     runtimeConfig.workspaceWritePathScopeRoots = [runtimeConfig.scopedArtifactRoot];
   }
+  const scopedArtifactMutationAt = Date.parse(
+    String(groundingExecutionContract.scopedArtifactMutationAt || "")
+  );
+  const executionContractRefreshedAt = Date.parse(
+    String(groundingExecutionContract.refreshedAt || "")
+  );
+  const groundingScopedArtifactMutationSatisfied = Boolean(
+    scopedArtifactTask &&
+      Number.isFinite(scopedArtifactMutationAt) &&
+      (
+        !Number.isFinite(executionContractRefreshedAt) ||
+        scopedArtifactMutationAt >= executionContractRefreshedAt
+      )
+  );
   if (
     (
       groundingTaskContract.requiresSourceGrounding === true ||
@@ -15397,7 +15497,8 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
   const currentTurnRequiresFreshMutation = Boolean(
     groundingExecutionContract.requiresFileMutation === true &&
       groundingExecutionContract.requiresSourceGrounding === true &&
-      !groundingFreshMutationSatisfied
+      !groundingFreshMutationSatisfied &&
+      !groundingScopedArtifactMutationSatisfied
   );
   const explicitHeadRestore = currentTurnRequiresFreshMutation
     ? explicitlyRequestedDirtyHeadRestore(state, config)
@@ -17610,10 +17711,11 @@ function validatedPatchContextCompleteSource(marker = {}) {
 
 export function activePatchContextRefresh(state = {}) {
   const marker = state.meta?.toolLoop?.patchContextRequired;
+  const markerPath = safePatchContextEvidencePath(marker?.path, state);
   if (
     !marker ||
     Number(marker.version || 0) !== PATCH_CONTEXT_REFRESH_VERSION ||
-    !safeRecoveryEvidencePath(marker.path)
+    !markerPath
   ) {
     return null;
   }
@@ -17644,16 +17746,17 @@ export function activePatchContextRefresh(state = {}) {
   }
   return {
     ...marker,
-    path: safeRecoveryEvidencePath(marker.path),
+    path: markerPath,
   };
 }
 
 export function activePatchContextRepair(state = {}) {
   const marker = state.meta?.toolLoop?.patchContextRepair;
+  const markerPath = safePatchContextEvidencePath(marker?.path, state);
   if (
     !marker ||
     Number(marker.version || 0) !== PATCH_CONTEXT_REPAIR_VERSION ||
-    !safeRecoveryEvidencePath(marker.path) ||
+    !markerPath ||
     !String(marker.search || "") ||
     !String(marker.searchHash || "")
   ) {
@@ -17694,8 +17797,7 @@ export function activePatchContextRepair(state = {}) {
   const samePathFocuses = diagnosticMatchesRevision
     ? (Array.isArray(diagnostic.focuses) ? diagnostic.focuses : []).filter(
         (focus) =>
-          safeRecoveryEvidencePath(focus?.path) ===
-            safeRecoveryEvidencePath(marker.path) &&
+          safePatchContextEvidencePath(focus?.path, state) === markerPath &&
           String(focus?.directSearch || "")
       )
     : [];
@@ -17712,7 +17814,7 @@ export function activePatchContextRepair(state = {}) {
   const completeSource = validatedPatchContextCompleteSource(marker);
   return {
     ...marker,
-    path: safeRecoveryEvidencePath(marker.path),
+    path: markerPath,
     completeSource,
     completeSourceHash: completeSource ? String(marker.completeSourceHash || "") : "",
     completeSourceBytes: completeSource
@@ -18072,7 +18174,7 @@ function failedTestTracebackLineAnchor(state = {}, targetPath = "") {
 export function bindPatchContextRepairArguments(state = {}, requestedArgs = {}) {
   const marker = activePatchContextRepair(state);
   if (!marker || typeof requestedArgs?.replace !== "string") return null;
-  const requestedPath = safeRecoveryEvidencePath(requestedArgs.path);
+  const requestedPath = safePatchContextEvidencePath(requestedArgs.path, state);
   if (requestedPath && requestedPath !== marker.path) return null;
   const requestedSearch = String(requestedArgs.search || "");
   const boundedSubrange = revisionBoundRequestedPatchSubrange(
@@ -18164,7 +18266,7 @@ export function bindPatchContextRepairArguments(state = {}, requestedArgs = {})
 }
 
 export function patchContextScopeMismatchAttemptCount(state = {}, targetPath = "") {
-  const normalizedPath = safeRecoveryEvidencePath(targetPath);
+  const normalizedPath = safePatchContextEvidencePath(targetPath, state);
   if (!normalizedPath) return 0;
   const toolLoop = state.meta?.toolLoop || {};
   const stagnationEpoch = Math.max(0, Number(toolLoop.stagnationEpoch || 0));
@@ -18178,7 +18280,7 @@ export function patchContextScopeMismatchAttemptCount(state = {}, targetPath = "
       entry?.toolName !== "apply_patch" ||
       entry?.ok !== false ||
       entry?.category !== "patch-context-scope-mismatch" ||
-      safeRecoveryEvidencePath(entry?.path) !== normalizedPath ||
+      safePatchContextEvidencePath(entry?.path, state) !== normalizedPath ||
       Number(entry?.stagnationEpoch || 0) !== stagnationEpoch
     ) {
       return false;
@@ -18259,7 +18361,7 @@ export function patchContextRefreshDecision(state = {}, toolResult = {}) {
   const recent = Array.isArray(toolLoop.recent) ? toolLoop.recent : [];
   const samePathRecent = recent.filter(
     (entry) =>
-      safeRecoveryEvidencePath(entry?.path) === targetPath &&
+      safePatchContextEvidencePath(entry?.path, state) === targetPath &&
       Number(entry?.stagnationEpoch || 0) === stagnationEpoch
   );
   const priorMissingSearches = samePathRecent.filter(
@@ -18570,7 +18672,8 @@ export function consumePatchContextRepairMutation(state = {}, toolResult = {}) {
     String(toolResult.toolName || "") !== "apply_patch" ||
     toolResult.ok === false ||
     toolResult.blocked === true ||
-    toolResultWorkspacePath(toolResult) !== safeRecoveryEvidencePath(marker.path) ||
+    toolResultWorkspacePath(toolResult) !==
+      safePatchContextEvidencePath(marker.path, state) ||
     ![
       String(marker.searchHash || ""),
       String(marker.lastBoundSearchHash || ""),
@@ -24211,11 +24314,13 @@ export function recoverRequiredPatchContextReadWithoutToolCall(
   const selectedFailedTestReadMode = Boolean(
     !refreshMode && !repairMode && !selectedFailedTestDiagnosticReadMode && failedTestReadMode
   );
+  const patchContextPath = (value) =>
+    safePatchContextEvidencePath(value, {}, config);
   const exactPath = selectedFailedTestDiagnosticReadMode
     ? safeGeneratedDiagnosticEvidencePath(
         config.testFailureWorkspaceDiagnosticReadPaths?.[0]
       )
-    : safeRecoveryEvidencePath(
+    : (refreshMode || repairMode ? patchContextPath : safeRecoveryEvidencePath)(
         refreshMode
           ? config.patchContextRefreshPath
           : repairMode
@@ -24226,7 +24331,9 @@ export function recoverRequiredPatchContextReadWithoutToolCall(
   const requestedCall = calls.length === 1 ? calls[0] : null;
   const requestedToolName = String(requestedCall?.function?.name || "");
   const requestedArgs = safeParseToolArgs(requestedCall);
-  const requestedPath = safeRecoveryEvidencePath(requestedArgs.path);
+  const requestedPath = (refreshMode || repairMode
+    ? patchContextPath
+    : safeRecoveryEvidencePath)(requestedArgs.path);
   const missingRefreshCall = validation?.ok === true && calls.length === 0 && refreshMode;
   const unavailableContextCall =
     validation?.ok !== true &&
@@ -24295,7 +24402,9 @@ export function recoverRequiredPatchContextReadWithoutToolCall(
     readDescriptor.function?.parameters?.properties?.path?.enum;
   const normalizeAllowedPath = selectedFailedTestDiagnosticReadMode
     ? safeGeneratedDiagnosticEvidencePath
-    : safeRecoveryEvidencePath;
+    : refreshMode || repairMode
+      ? patchContextPath
+      : safeRecoveryEvidencePath;
   if (
     !Array.isArray(allowedPaths) ||
     (!selectedFailedTestReadMode && !selectedFailedTestDiagnosticReadMode && allowedPaths.length !== 1) ||