@lazyingart/agintiflow 0.20.310 → 0.20.312

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.310",
+  "version": "0.20.312",
   "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-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/scripts/smoke-truthful-completion.js

@@ -8,6 +8,7 @@ import {
   completionRequirementCoverageInstruction,
   continuationExecutionContractDirective,
   removeSupersededCompletionRepairInstructions,
+  repositorySourcePrecedenceInstruction,
   runAgent,
 } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
@@ -25,6 +26,36 @@ assert.match(completionCoverageInstruction, /authoritative structured routine/i)
 assert.match(completionCoverageInstruction, /every relevant section/i);
 assert.match(completionCoverageInstruction, /instead of summarizing only failures or only successes/i);
 
+const sourcePrecedenceInstruction = repositorySourcePrecedenceInstruction();
+assert.match(sourcePrecedenceInstruction, /current direct user request/i);
+assert.match(sourcePrecedenceInstruction, /closest project instructions/i);
+assert.match(sourcePrecedenceInstruction, /most specific current implementation and tests/i);
+assert.match(sourcePrecedenceInstruction, /stale guides/i);
+assert.match(sourcePrecedenceInstruction, /AGENTS\.md/i);
+
+const readOnlyContractAuditGoal = `
+Audit the current source-intake contract and cover an ordinary video, a hypothetical
+same-chat publish request, a Finder card, and a document attachment. Do not send any
+message, publish anything, alter a queue, open a browser, or modify configuration.
+`;
+const readOnlyContractAudit = deriveScsTaskContract({
+  goal: readOnlyContractAuditGoal,
+  taskProfile: "auto",
+});
+assert.equal(readOnlyContractAudit.readOnlyReadiness, true);
+assert(
+  !readOnlyContractAudit.requiredEvidence.some((item) => item.category === "publish"),
+  "a hypothetical publish case inside a forbidden read-only contract audit required live publish evidence"
+);
+assert(
+  !readOnlyContractAudit.requiredEvidence.some((item) => item.category === "browser"),
+  "a forbidden browser action inside a read-only contract audit required browser evidence"
+);
+assert(
+  readOnlyContractAudit.forbiddenActions.some((item) => /publish anything/i.test(item)),
+  "the read-only audit lost its explicit publish prohibition"
+);
+
 assert.equal(
   finishResultClaimsIncompleteWork(
     "The report is complete and the verification that was previously paused now passes. No work remains."

package/src/agent-runner.js

@@ -2973,6 +2973,10 @@ export function completionRequirementCoverageInstruction() {
   return "Before finishing, check the current user request requirement by requirement. Every distinct subject, requested action, and deliverable must be completed, answered, deliberately grouped under one verified shared state, or named with a concrete blocker. When an authoritative structured routine returns named sections relevant to the request, report every relevant section instead of summarizing only failures or only successes.";
 }
 
+export function repositorySourcePrecedenceInstruction() {
+  return "Treat the current direct user request and the closest project instructions as authoritative. When describing an existing contract, inspect the most specific current implementation and tests, reconcile conflicting documentation, and never let examples, stale guides, or historical notes override AGENTS.md or current code. State any unresolved conflict instead of choosing silently.";
+}
+
 function focusedCapabilityContext(config = {}) {
   return [
     config.allowFileTools
@@ -3017,6 +3021,7 @@ function buildFocusedRuntimeMessages({
         "Answer ordinary conversation directly. For executable work, act through the smallest relevant routine or tool, verify in proportion to risk, then stop.",
         "Treat queued user input as a safe-boundary interruption: preserve every material requirement, merge related consecutive messages, revise the durable goal, and never repeat a completed external side effect.",
         completionRequirementCoverageInstruction(),
+        repositorySourcePrecedenceInstruction(),
         "Established project routines are capabilities to invoke, not workflows to reimplement. Discover more context only when the current task needs it.",
         formatBehaviorContractForPrompt({ mode: "focused" }),
         languageInstruction(config.language || "en"),
@@ -3236,6 +3241,7 @@ async function createInitialState(config, sessionId) {
           "For LaTeX/PDF tasks, check existing latexmk/pdflatex first and compile with the available host or Docker TeX toolchain before installing packages or rebuilding the sandbox.",
           "For research or web-search tasks, use browser tools or safe shell network tools when the current policy allows; cite or save useful sources in workspace notes when the task needs traceability.",
           completionRequirementCoverageInstruction(),
+          repositorySourcePrecedenceInstruction(),
           browserStateReconciliationGuidance(),
           isRetainedWorkspaceProfile(config)
             ? "Choose descriptive non-conflicting workspace paths for durable outputs."
@@ -10165,7 +10171,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))
     )
@@ -12675,7 +12682,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()
@@ -12694,6 +12703,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;
@@ -17604,10 +17648,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;
   }
@@ -17638,16 +17683,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 || "")
   ) {
@@ -17688,8 +17734,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 || "")
       )
     : [];
@@ -17706,7 +17751,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
@@ -18066,7 +18111,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(
@@ -18158,7 +18203,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));
@@ -18172,7 +18217,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;
@@ -18253,7 +18298,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(
@@ -18564,7 +18609,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 || ""),
@@ -24205,11 +24251,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
@@ -24220,7 +24268,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 &&
@@ -24289,7 +24339,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) ||

package/src/scs-evidence.js

@@ -454,6 +454,13 @@ function normalizeWrappedNegativePrefixes(goal = "") {
   );
 }
 
+function normalizeSoftLineWraps(goal = "") {
+  return normalizeWrappedNegativePrefixes(goal).replace(
+    /([A-Za-z0-9,])[ \t]*\r?\n[ \t]*(?=[a-z])/g,
+    "$1 "
+  );
+}
+
 function inferExactOutputPaths(goal = "") {
   const paths = [];
   const lines = String(goal || "").split(/\n/);
@@ -1406,10 +1413,17 @@ function isReadOnlyReadinessTask(goal = "") {
     /\b(?:readiness|capability)\s+(?:audit|check|report|assessment)\b/i.test(text) ||
     /\bwhether\s+(?:i|we|the\s+(?:agent|system))\s+can\b/i.test(text) ||
     /只读检查|只讀檢查|就绪检查|就緒檢查|能力检查|能力檢查|检查是否|檢查是否/.test(text);
+  const contractAuditSignal =
+    /\b(?:audit|inspect|review|assess|document|report\s+on)\s+(?:the\s+)?(?:current\s+)?[^.\n;]{0,140}\b(?:contract|policy|behavio(?:u)?r|workflow|implementation|routine|routing|readiness|capabilit(?:y|ies))\b/i.test(
+      text
+    ) ||
+    /(?:审计|審計|检查|檢查|审查|審查|评估|評估|记录|記錄)[^。；\n]{0,120}(?:契约|契約|策略|行为|行為|流程|实现|實現|例程|路由|就绪|就緒|能力)/.test(
+      text
+    );
   const noActionSignal =
-    /\b(?:do not|don't|dont|never|without)\b[^.\n;]{0,260}\b(?:generate|submit|upload|publish|deploy|log in|login|restart|edit|modify|delete|purchase|pay)\b/i.test(text) ||
+    /\b(?:do not|don't|dont|never|without)\b[^.\n;]{0,260}\b(?:send|generate|submit|upload|publish|deploy|open|browse|focus|restart|alter|change|edit|modify|write|mutate|delete|purchase|pay|log in|login)\b/i.test(text) ||
     /(?:不要|禁止)[^。\n；]{0,260}(?:生成|提交|上传|上傳|发布|發布|部署|登录|登入|重启|重啟|编辑|編輯|修改|删除|刪除|购买|購買|支付)/.test(text);
-  return readinessSignal && noActionSignal;
+  return (readinessSignal || contractAuditSignal) && noActionSignal;
 }
 
 function requiresSourceGrounding(goal = "") {
@@ -1550,7 +1564,7 @@ function inferRequirementCategories(goal = "", taskProfile = "", acceptanceCrite
 }
 
 function inferForbiddenActions(goal = "") {
-  const text = String(goal || "");
+  const text = normalizeSoftLineWraps(goal);
   const forbidden = [];
   const isAction = (value = "") =>
     /\b(use|open|click|browse|browser|upload|attach|submit|publish|deploy|run|execute|install|delete|remove|commit|push|call|api|alter|chang(?:e|ing)|edit(?:ing)?|fix(?:ing)?|modif(?:y|ying)|patch(?:ing)?|repair(?:ing)?|rewrit(?:e|ing)|send(?:ing)?|touch(?:ing)?|writ(?:e|ing))\b/i.test(
@@ -1601,7 +1615,7 @@ function inferRequiredToolCalls(goal = "") {
 }
 
 function stripForbiddenLanguage(goal = "") {
-  return normalizeWrappedNegativePrefixes(goal)
+  return normalizeSoftLineWraps(goal)
     .replace(/\b(do not|don't|dont|must not|should not|never|no need to)\s+([^.\n;]+)/gi, "")
     .replace(/\bwithout\s+([^.,:\uFF1A\n;]+)/gi, "")
     .replace(/不要([^。\n；]+)/g, "")