@lazyingart/agintiflow 0.20.259 → 0.20.261

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.259",
+  "version": "0.20.261",
   "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-deep-research.js

@@ -175,13 +175,86 @@ async function main() {
     toolChoiceForProvider(
       { provider: "deepseek" },
       [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }]
-    ) === "auto",
-    "DeepSeek thinking mode received unsupported required tool selection during recovery"
+    ) === "required",
+    "DeepSeek action recovery did not require a tool call"
+  );
+  assert(
+    JSON.stringify(toolChoiceForProvider(
+      { provider: "deepseek" },
+      [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }],
+      [
+        { type: "function", function: { name: "apply_patch" } },
+        { type: "function", function: { name: "finish" } },
+      ]
+    )) === JSON.stringify({ type: "function", function: { name: "apply_patch" } }),
+    "DeepSeek action recovery did not force the only executable tool"
   );
   assert(
     JSON.stringify(providerStructuredOutputAttempts("deepseek")) === JSON.stringify(["json_object", "prompt"]),
     "DeepSeek structured extraction still probes an unsupported JSON Schema mode"
   );
+  let deepSeekActionPayload = null;
+  await requestNextStep(
+    {
+      chat: {
+        completions: {
+          create: async (payload) => {
+            deepSeekActionPayload = payload;
+            return {
+              choices: [{
+                message: {
+                  role: "assistant",
+                  content: "",
+                  tool_calls: [{
+                    id: "deepseek-action-patch",
+                    type: "function",
+                    function: {
+                      name: "apply_patch",
+                      arguments: JSON.stringify({
+                        path: "service.py",
+                        search: "old",
+                        replace: "new",
+                        expectedReplacements: 1,
+                      }),
+                    },
+                  }],
+                },
+              }],
+            };
+          },
+        },
+      },
+    },
+    {
+      provider: "deepseek",
+      model: "deepseek-v4-pro",
+      reasoning: "xhigh",
+      goal: "Repair service.py from exact retained source.",
+      taskProfile: "code",
+      allowFileTools: true,
+      allowShellTool: false,
+      allowWebSearch: false,
+      allowMcpTools: false,
+      allowWrapperTools: false,
+      allowAuxiliaryTools: false,
+      completionFreshMutationRequired: true,
+      completionFreshMutationNeedsSourceRead: false,
+      completionFreshMutationPaths: ["service.py"],
+    },
+    [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }]
+  );
+  assert(
+    deepSeekActionPayload?.thinking?.type === "disabled",
+    "DeepSeek reasoning-only recovery did not disable a second expensive thinking pass"
+  );
+  assert(
+    deepSeekActionPayload?.tool_choice?.function?.name === "apply_patch",
+    "DeepSeek reasoning-only recovery did not force its single executable tool"
+  );
+  assert(
+    !Object.hasOwn(deepSeekActionPayload || {}, "reasoning_effort"),
+    "DeepSeek action-only recovery sent a conflicting reasoning effort"
+  );
 
   assert(!isPublicWebUrl("http://127.0.0.1/private"), "public URL guard accepted loopback");
   assert(!isPublicWebUrl("http://10.0.0.1/private"), "public URL guard accepted RFC1918 address");

package/scripts/smoke-dynamic-step-budget.js

@@ -705,6 +705,24 @@ try {
       tracebackPacket.content.includes("### tests/test_traceback_packet.py"),
     "exact same-workspace test files named by a traceback were omitted when discovery metadata was empty"
   );
+  const repeatedTracebackPacketState = structuredClone(tracebackPacketState);
+  repeatedTracebackPacketState.meta.projectVerification.testRuns[0].failureSignature =
+    "repeated-validator-traceback-file-recovery";
+  repeatedTracebackPacketState.meta.projectVerification.testRuns[0].failureSummary =
+    [
+      `File "${path.join(workspace, "duplicate-source.py")}", line 1, in first`,
+      `File "${path.join(workspace, "duplicate-source.py")}", line 2, in second`,
+      `File "${path.join(workspace, "duplicate-source.py")}", line 3, in third`,
+      `File "${path.join(workspace, "tests", "test_traceback_packet.py")}", line 4, in test_contract`,
+    ].join("\n");
+  const repeatedTracebackPacket = await buildFailedTestRecoveryPacket(
+    { commandCwd: workspace },
+    repeatedTracebackPacketState
+  );
+  assert(
+    repeatedTracebackPacket.paths.includes("tests/test_traceback_packet.py"),
+    "duplicate frames from one validator crowded the actual failing test out of recovery evidence"
+  );
   assert(
     (await failedTestRepairPatchBlock(
       duplicateRepairState,
@@ -2650,6 +2668,82 @@ try {
       JSON.stringify(["python3 -m unittest discover -s tests -v"]),
     "ordinary operator examples became mandatory acceptance commands"
   );
+  const refreshedAcceptanceState = {
+    commandCwd: workspace,
+    meta: {
+      projectVerification: {
+        requiredOutputs: ["stale-output.txt"],
+        requiredCommands: [
+          "python3 service_ctl.py start --state-dir .runtime",
+          "python3 service_ctl.py status --state-dir .runtime",
+        ],
+        acceptanceSource: "README.md",
+      },
+    },
+  };
+  recordProjectVerificationOutcome(
+    refreshedAcceptanceState,
+    {
+      ok: true,
+      toolName: "read_file",
+      path: "README.md",
+      content: operatorGuideMarkdown,
+    },
+    { commandCwd: workspace, taskProfile: "devops" }
+  );
+  assert(
+    JSON.stringify(refreshedAcceptanceState.meta.projectVerification.requiredCommands) ===
+      JSON.stringify(["python3 -m unittest discover -s tests -v"]) &&
+      refreshedAcceptanceState.meta.projectVerification.requiredOutputs.length === 0,
+    "rereading one authoritative source retained its stale acceptance requirements"
+  );
+  const resumedAcceptanceWorkspace = path.join(workspace, "resumed-acceptance");
+  await fs.mkdir(resumedAcceptanceWorkspace, { recursive: true });
+  await fs.writeFile(
+    path.join(resumedAcceptanceWorkspace, "README.md"),
+    operatorGuideMarkdown,
+    "utf8"
+  );
+  const resumedAcceptanceState = {
+    commandCwd: resumedAcceptanceWorkspace,
+    goal: "Repair the service and run its tests.",
+    meta: {
+      goalContract: { revision: 4, currentRequest: "Repair the service and run its tests." },
+      projectVerification: {
+        requiredCommands: [
+          "python3 service_ctl.py start --state-dir .runtime",
+          "python3 service_ctl.py status --state-dir .runtime",
+        ],
+        acceptanceSource: "README.md",
+      },
+    },
+  };
+  resetSameTaskExecutionContract(resumedAcceptanceState, 4);
+  assert(
+    JSON.stringify(resumedAcceptanceState.meta.projectVerification.requiredCommands) ===
+      JSON.stringify(["python3 -m unittest discover -s tests -v"]),
+    "same-task resume retained stale requirements from an older README parser"
+  );
+  recordProjectVerificationOutcome(
+    refreshedAcceptanceState,
+    {
+      ok: true,
+      toolName: "read_file",
+      path: "TASK.md",
+      content: requiredCommandMarkdown,
+    },
+    { commandCwd: workspace, taskProfile: "devops" }
+  );
+  assert(
+    JSON.stringify(refreshedAcceptanceState.meta.projectVerification.requiredCommands) ===
+      JSON.stringify([
+        "python3 -m unittest discover -s tests -v",
+        "npm run check",
+        "npm test",
+        "python scripts/verify.py --strict",
+      ]),
+    "source-scoped acceptance refresh discarded a distinct authoritative source"
+  );
   const operatorContinuedCommandMarkdown = [
     "# Task",
     "",

package/src/agent-runner.js

@@ -3769,6 +3769,67 @@ export function resetGoalScopedRuntimeState(state = {}) {
   return removed;
 }
 
+function refreshPersistedProjectAcceptance(state = {}) {
+  const verification = state.meta?.projectVerification;
+  if (!verification || typeof verification !== "object") return false;
+  const priorBySource =
+    verification.acceptanceBySource &&
+    typeof verification.acceptanceBySource === "object" &&
+    !Array.isArray(verification.acceptanceBySource)
+      ? verification.acceptanceBySource
+      : {};
+  const sources = [
+    ...Object.keys(priorBySource),
+    String(verification.acceptanceSource || "").trim(),
+  ].filter(Boolean);
+  if (!sources.length) return false;
+
+  const commandCwd = path.resolve(state.commandCwd || process.cwd());
+  const refreshed = {};
+  let inspected = 0;
+  for (const source of [...new Set(sources)].slice(-16)) {
+    const sourceKey = normalizedProjectAcceptancePath(source, commandCwd);
+    if (!sourceKey || !projectAcceptanceSourceIsAuthoritative(sourceKey, {
+      commandCwd,
+      authoritativePaths: [sourceKey],
+    })) {
+      continue;
+    }
+    const absolutePath = path.resolve(commandCwd, sourceKey);
+    if (absolutePath !== commandCwd && !absolutePath.startsWith(`${commandCwd}${path.sep}`)) continue;
+    inspected += 1;
+    if (!fsSync.existsSync(absolutePath)) continue;
+    try {
+      const acceptance = projectAcceptanceFromMarkdown(
+        fsSync.readFileSync(absolutePath, "utf8"),
+        sourceKey,
+        { commandCwd, authoritativePaths: [sourceKey] }
+      );
+      refreshed[sourceKey] = {
+        requiredOutputs: acceptance.requiredOutputs,
+        requiredCommands: acceptance.requiredCommands,
+        readAt: new Date().toISOString(),
+      };
+    } catch {
+      inspected -= 1;
+    }
+  }
+  if (!inspected) return false;
+  verification.acceptanceBySource = refreshed;
+  verification.requiredOutputs = [
+    ...new Set(
+      Object.values(refreshed).flatMap((item) => item.requiredOutputs || [])
+    ),
+  ].slice(0, 64);
+  verification.requiredCommands = [
+    ...new Set(
+      Object.values(refreshed).flatMap((item) => item.requiredCommands || [])
+    ),
+  ].slice(0, 24);
+  verification.acceptanceRefreshedAt = new Date().toISOString();
+  return true;
+}
+
 export function resetSameTaskExecutionContract(state = {}, revision = 0) {
   state.meta = state.meta || {};
   const keys = [
@@ -3786,6 +3847,7 @@ export function resetSameTaskExecutionContract(state = {}, revision = 0) {
     removed.push(key);
   }
   state.plan = "";
+  refreshPersistedProjectAcceptance(state);
   const activeRevision = Math.max(0, Number(revision || state.meta?.goalContract?.revision || 0));
   const currentRequest = String(state.meta?.goalContract?.currentRequest || state.goal || "").trim();
   const currentTurnContract = deriveScsTaskContract({
@@ -4715,8 +4777,8 @@ async function failedTestTracebackSourceDocuments(testRun = {}, config = {}) {
       ? path.resolve(reportedPath)
       : path.resolve(commandCwd, reportedPath);
     const line = Math.max(1, Number(match[2] || 1));
-    if (seen.has(`${absolutePath}:${line}`)) continue;
-    seen.add(`${absolutePath}:${line}`);
+    if (seen.has(absolutePath)) continue;
+    seen.add(absolutePath);
     const insideWorkspace =
       absolutePath === commandCwd || absolutePath.startsWith(`${commandCwd}${path.sep}`);
     const namedByCommand = command.includes(absolutePath);
@@ -4735,7 +4797,7 @@ async function failedTestTracebackSourceDocuments(testRun = {}, config = {}) {
     const raw = await fs.readFile(absolutePath, "utf8").catch(() => "");
     if (!raw) continue;
     documents.push({ absolutePath, line, raw });
-    if (documents.length >= 3) break;
+    if (documents.length >= 5) break;
   }
   return documents;
 }
@@ -5381,11 +5443,9 @@ function normalizedProjectAcceptancePath(sourcePath = "", commandCwd = "") {
   return raw.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 
-export function projectAcceptanceFromMarkdown(content = "", sourcePath = "", options = {}) {
+function projectAcceptanceSourceIsAuthoritative(sourcePath = "", options = {}) {
   const basename = path.basename(String(sourcePath || "")).toLowerCase();
-  if (!/^(?:readme|task|agents?|aginti)(?:\.[^.]+)?$/.test(basename)) {
-    return { requiredOutputs: [], requiredCommands: [] };
-  }
+  if (!/^(?:readme|task|agents?|aginti)(?:\.[^.]+)?$/.test(basename)) return false;
   const normalizedSource = normalizedProjectAcceptancePath(
     sourcePath,
     options.commandCwd
@@ -5395,10 +5455,11 @@ export function projectAcceptanceFromMarkdown(content = "", sourcePath = "", opt
       .map((item) => normalizedProjectAcceptancePath(item, options.commandCwd))
       .filter(Boolean)
   );
-  if (
-    normalizedSource.includes("/") &&
-    !authoritativePaths.has(normalizedSource)
-  ) {
+  return !normalizedSource.includes("/") || authoritativePaths.has(normalizedSource);
+}
+
+export function projectAcceptanceFromMarkdown(content = "", sourcePath = "", options = {}) {
+  if (!projectAcceptanceSourceIsAuthoritative(sourcePath, options)) {
     return { requiredOutputs: [], requiredCommands: [] };
   }
   return {
@@ -5778,29 +5839,72 @@ export function recordProjectVerificationOutcome(state = {}, toolResult = {}, co
       goal: completionContractGoal(config, state),
       taskProfile: config.taskProfile || state.meta?.taskProfile || "auto",
     });
+    const sourcePath = String(toolResult.path || toolResult.args?.path || "");
+    const acceptanceOptions = {
+      commandCwd: config.commandCwd || state.commandCwd || process.cwd(),
+      authoritativePaths: [
+        ...(Array.isArray(currentTaskContract.exactInputPaths)
+          ? currentTaskContract.exactInputPaths
+          : []),
+        ...(Array.isArray(currentTaskContract.exactOutputPaths)
+          ? currentTaskContract.exactOutputPaths
+          : []),
+      ],
+    };
     const acceptance = projectAcceptanceFromMarkdown(
       toolResult.content,
-      toolResult.path || toolResult.args?.path || "",
-      {
-        commandCwd: config.commandCwd || state.commandCwd || process.cwd(),
-        authoritativePaths: [
-          ...(Array.isArray(currentTaskContract.exactInputPaths)
-            ? currentTaskContract.exactInputPaths
-            : []),
-          ...(Array.isArray(currentTaskContract.exactOutputPaths)
-            ? currentTaskContract.exactOutputPaths
-            : []),
-        ],
-      }
+      sourcePath,
+      acceptanceOptions
     );
-    verification.requiredOutputs = [
-      ...new Set([...verification.requiredOutputs, ...acceptance.requiredOutputs]),
-    ].slice(0, 64);
-    verification.requiredCommands = [
-      ...new Set([...verification.requiredCommands, ...acceptance.requiredCommands]),
-    ].slice(0, 24);
-    if (acceptance.requiredOutputs.length || acceptance.requiredCommands.length) {
-      verification.acceptanceSource = String(toolResult.path || toolResult.args?.path || "");
+    if (projectAcceptanceSourceIsAuthoritative(sourcePath, acceptanceOptions)) {
+      const sourceKey = normalizedProjectAcceptancePath(
+        sourcePath,
+        acceptanceOptions.commandCwd
+      );
+      const acceptanceBySource =
+        verification.acceptanceBySource &&
+        typeof verification.acceptanceBySource === "object" &&
+        !Array.isArray(verification.acceptanceBySource)
+          ? { ...verification.acceptanceBySource }
+          : {};
+      const legacySourceKey = normalizedProjectAcceptancePath(
+        verification.acceptanceSource || "",
+        acceptanceOptions.commandCwd
+      );
+      if (
+        !Object.keys(acceptanceBySource).length &&
+        legacySourceKey &&
+        legacySourceKey !== sourceKey
+      ) {
+        acceptanceBySource[legacySourceKey] = {
+          requiredOutputs: [...verification.requiredOutputs],
+          requiredCommands: [...verification.requiredCommands],
+          readAt: verification.acceptanceReadAt || "",
+        };
+      }
+      acceptanceBySource[sourceKey] = {
+        requiredOutputs: acceptance.requiredOutputs,
+        requiredCommands: acceptance.requiredCommands,
+        readAt: now,
+      };
+      verification.acceptanceBySource = Object.fromEntries(
+        Object.entries(acceptanceBySource).slice(-16)
+      );
+      verification.requiredOutputs = [
+        ...new Set(
+          Object.values(verification.acceptanceBySource).flatMap((item) =>
+            Array.isArray(item?.requiredOutputs) ? item.requiredOutputs : []
+          )
+        ),
+      ].slice(0, 64);
+      verification.requiredCommands = [
+        ...new Set(
+          Object.values(verification.acceptanceBySource).flatMap((item) =>
+            Array.isArray(item?.requiredCommands) ? item.requiredCommands : []
+          )
+        ),
+      ].slice(0, 24);
+      verification.acceptanceSource = sourcePath;
       verification.acceptanceReadAt = now;
     }
   }

package/src/model-client.js

@@ -134,6 +134,10 @@ function chatReasoningEffort(config = {}) {
 }
 
 function withChatReasoningEffort(payload = {}, config = {}) {
+  if (payload.thinking?.type === "disabled") {
+    const { reasoning_effort: _reasoningEffort, ...rest } = payload;
+    return rest;
+  }
   const reasoning = chatReasoningEffort(config);
   if (!reasoning) {
     const { reasoning_effort: _reasoningEffort, ...rest } = payload;
@@ -336,17 +340,35 @@ function assertLocalRequestWithinContext(payload = {}, config = {}, label = "age
 
 export { hasExplicitDeepResearchIntent } from "./research-routing.js";
 
-export function toolChoiceForProvider(config, messages = []) {
-  const requiresConcreteContinuation = messages.slice(-3).some(
+function requiresConcreteToolContinuation(messages = []) {
+  return messages.slice(-3).some(
     (message) =>
       message?.role === "user" &&
       /emit exactly one enabled tool call that performs the next concrete action/i.test(String(message.content || ""))
   );
-  // DeepSeek thinking models reject tool_choice="required" even though they
-  // accept the same native tool schema with auto selection. The continuation
-  // instruction remains explicit in the messages, so keep the supported
-  // provider mode instead of turning a recoverable truncation into HTTP 400.
-  if (requiresConcreteContinuation && normalizeProviderId(config.provider, "") !== "deepseek") {
+}
+
+function deepSeekActionOnlyRequest(config = {}, messages = []) {
+  return normalizeProviderId(config.provider, "") === "deepseek" &&
+    requiresConcreteToolContinuation(messages);
+}
+
+export function toolChoiceForProvider(config, messages = [], tools = []) {
+  const requiresConcreteContinuation = requiresConcreteToolContinuation(messages);
+  if (requiresConcreteContinuation) {
+    const actionable = (Array.isArray(tools) ? tools : [])
+      .filter((tool) => tool?.type === "function" && tool.function?.name !== "finish")
+      .map((tool) => String(tool.function?.name || ""))
+      .filter(Boolean);
+    if (
+      normalizeProviderId(config.provider, "") === "deepseek" &&
+      actionable.length === 1
+    ) {
+      return {
+        type: "function",
+        function: { name: actionable[0] },
+      };
+    }
     return "required";
   }
   if (config.provider !== "venice") return "auto";
@@ -2649,10 +2671,13 @@ export async function requestNextStep(client, config, messages) {
   const nativePayload = {
     model: config.model,
     temperature: 0,
-    tool_choice: toolChoiceForProvider(config, messages),
+    tool_choice: toolChoiceForProvider(config, messages, requestTools),
     parallel_tool_calls: false,
     messages: prepareMessages(config, messages),
     tools: requestTools,
+    ...(deepSeekActionOnlyRequest(config, messages)
+      ? { thinking: { type: "disabled" } }
+      : {}),
     ...(Number(config.maxOutputTokens || 0) > 0 ? { max_tokens: Number(config.maxOutputTokens) } : {}),
   };
   const textPayload = {

package/src/provider-contract.js

@@ -75,7 +75,7 @@ export const PROVIDER_CONTRACTS = Object.freeze({
     defaultModel: "deepseek-v4-flash",
     toolProtocol: "native",
     structuredOutput: "json_object",
-    supportsReasoningEffort: false,
+    supportsReasoningEffort: true,
     textToolFallback: false,
   }),
   openai: Object.freeze({