@lazyingart/agintiflow 0.20.288 → 0.20.289

package/docs/state-of-the-art-agent-runtime.md

@@ -130,6 +130,13 @@ only after a categorized provider failure and must not replay verified side
 effects. Codex and Claude remain explicit opt-in backends rather than hidden
 fallbacks.
 
+Timeout compaction also preserves goal-scoped deep-research completion. A
+same-task repair of the immediately preceding report keeps ordinary file,
+shell, and validation tools after a model switch instead of forcing another
+research pass. A genuinely new research request does not inherit that marker
+and still begins with the bounded `deep_research` workflow. Native function
+calling and the text-tool fallback apply the same rule.
+
 ## Machine Host Protocol
 
 The supported subprocess boundary is:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.288",
+  "version": "0.20.289",
   "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-progressive-tool-selection.js

@@ -5151,6 +5151,113 @@ assert(
   "post-research compaction forgot the completed bounded research call"
 );
 
+const timeoutCompactedResearchRepairGoal =
+  "External verification failed for the existing research report. Preserve the report and evidence, add the missing sources.json and PDF, run the validator, and commit the repair.";
+const timeoutCompactedResearchRepairState = {
+  goal: timeoutCompactedResearchRepairGoal,
+  meta: {
+    goalContract: {
+      revision: 2,
+      currentHash: "research-repair-goal",
+      currentRequest: timeoutCompactedResearchRepairGoal,
+      history: [
+        { revision: 1, hash: "original-research-goal" },
+        {
+          revision: 2,
+          hash: "research-repair-goal",
+          previousHash: "original-research-goal",
+        },
+      ],
+    },
+    completedDeepResearch: [
+      {
+        goalKey: "original-research-goal",
+        result: {
+          ok: true,
+          version: 14,
+          reportPath: path.join(repoRoot, "package.json"),
+        },
+      },
+    ],
+  },
+};
+const timeoutCompactedResearchRepairRuntime = nextStepRuntimeConfig(
+  {
+    provider: "deepseek",
+    goal: timeoutCompactedResearchRepairGoal,
+    commandCwd: repoRoot,
+  },
+  timeoutCompactedResearchRepairState
+);
+assertStrict.equal(
+  timeoutCompactedResearchRepairRuntime.deepResearchCompletedForCurrentWork,
+  true,
+  "a successor artifact repair lost the completed research record from its immediately preceding goal"
+);
+const timeoutCompactedResearchRepair = selectProgressiveTools(allTools, {
+  config: timeoutCompactedResearchRepairRuntime,
+  goal: timeoutCompactedResearchRepairGoal,
+  profile: "research",
+  messages: [
+    {
+      role: "user",
+      content:
+        "A previous agent-step request was interrupted by a model timeout. Continue from this compacted, valid transcript.",
+    },
+    {
+      role: "user",
+      content:
+        "Retained runtime tool evidence. This operation already completed; use its result and do not repeat it solely because context was compacted.\nTool: read_file\nVerified result: existing evidence report",
+    },
+  ],
+});
+assert(names(timeoutCompactedResearchRepair).includes("run_command"), "timeout-compacted research repair omitted shell validation");
+assert(names(timeoutCompactedResearchRepair).includes("write_file"), "timeout-compacted research repair omitted artifact writing");
+assert(
+  !(names(timeoutCompactedResearchRepair).length === 2 && names(timeoutCompactedResearchRepair)[0] === "deep_research"),
+  "timeout recovery forced a completed research task back into deep_research"
+);
+
+const unrelatedNewResearchGoal =
+  "Write a new deep research report comparing current optical sensor calibration methods.";
+const unrelatedNewResearchRuntime = nextStepRuntimeConfig(
+  { provider: "deepseek", goal: unrelatedNewResearchGoal, commandCwd: repoRoot },
+  {
+    ...timeoutCompactedResearchRepairState,
+    goal: unrelatedNewResearchGoal,
+    meta: {
+      ...timeoutCompactedResearchRepairState.meta,
+      goalContract: {
+        revision: 3,
+        currentHash: "new-research-goal",
+        currentRequest: unrelatedNewResearchGoal,
+        history: [
+          ...timeoutCompactedResearchRepairState.meta.goalContract.history,
+          {
+            revision: 3,
+            hash: "new-research-goal",
+            previousHash: "research-repair-goal",
+          },
+        ],
+      },
+    },
+  }
+);
+assertStrict.equal(
+  unrelatedNewResearchRuntime.deepResearchCompletedForCurrentWork,
+  undefined,
+  "an old completed report suppressed a genuinely new research request"
+);
+sameNames(
+  selectProgressiveTools(allTools, {
+    config: unrelatedNewResearchRuntime,
+    goal: unrelatedNewResearchGoal,
+    profile: "research",
+  }),
+  ["deep_research", "finish"],
+  "a genuinely new research request did not retain the bounded deep-research starter"
+);
+
 const documentRuntimeSnapshot =
   'Step 1/30. Latest runtime snapshot:\n{"pageText":"Workspace file tools are ready. Web search and resumable deep research are available when current evidence is required."}';
 const localDocumentStarter = selectProgressiveTools(allTools, {

package/src/agent-runner.js

@@ -13687,6 +13687,45 @@ export function convergenceSuppressedToolNames(state = {}) {
   return [toolName];
 }
 
+function currentWorkHasCompletedDeepResearch(state = {}, config = {}) {
+  const records = Array.isArray(state.meta?.completedDeepResearch)
+    ? state.meta.completedDeepResearch
+    : [];
+  if (!records.length) return false;
+
+  const goalContract = state.meta?.goalContract || {};
+  const currentKey = String(
+    goalContract.currentHash || goalContract.activeHash || currentGoalKey(state)
+  ).trim();
+  const latestHistory = Array.isArray(goalContract.history)
+    ? goalContract.history.at(-1) || {}
+    : {};
+  const previousKey = String(latestHistory.previousHash || "").trim();
+  const currentRequest = String(
+    goalContract.currentRequest || config.goal || state.goal || ""
+  ).replace(/\s+/g, " ").trim();
+  const continuesExistingResearchArtifact = Boolean(
+    previousKey &&
+    /\b(?:preserve|reuse|continue|recover|repair|fix|correct|revise|validate|verify|rebuild|missing|existing|completed|retained|saved)\b/i.test(currentRequest) &&
+    /\b(?:research|report|evidence|sources?|citations?|manifest|pdf|artifact|validation|validator)\b/i.test(currentRequest)
+  );
+
+  return records.some((record) => {
+    const result = record?.result || {};
+    if (
+      result.ok !== true ||
+      Number(result.version || 0) !== RESEARCH_VERSION ||
+      !String(result.reportPath || "").trim() ||
+      !fsSync.existsSync(String(result.reportPath))
+    ) {
+      return false;
+    }
+    const recordKey = String(record.goalKey || "").trim();
+    if (recordKey && recordKey === currentKey) return true;
+    return continuesExistingResearchArtifact && recordKey === previousKey;
+  });
+}
+
 export function nextStepRuntimeConfig(config = {}, state = {}) {
   const staticOrder = Array.isArray(state.meta?.toolLoop?.staticOrder)
     ? state.meta.toolLoop.staticOrder
@@ -13699,6 +13738,9 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
   const runtimeConfig = {
     ...applyLocalFailureRecovery(config, state),
     ...(retainedDataDiscoveryReady ? { dataProjectDiscoveryReady: true } : {}),
+    ...(currentWorkHasCompletedDeepResearch(state, config)
+      ? { deepResearchCompletedForCurrentWork: true }
+      : {}),
   };
   const suppressedToolNames = convergenceSuppressedToolNames(state);
   if (suppressedToolNames.length) {

package/src/model-client.js

@@ -517,7 +517,9 @@ function messagesWithTextToolProtocol(config, messages, tools) {
     }
     return message;
   });
-  const requireDeepResearch = tools.some((tool) => tool?.function?.name === "deep_research") &&
+  const requireDeepResearch =
+    config.deepResearchCompletedForCurrentWork !== true &&
+    tools.some((tool) => tool?.function?.name === "deep_research") &&
     shouldStartWithDeepResearch(config.goal, messages);
   const protocol = {
     role: "system",

package/src/progressive-tool-selection.js

@@ -2741,7 +2741,10 @@ export function selectProgressiveTools(
       )
     : enabled;
 
-  if (shouldStartWithDeepResearch(goal || config.goal, messages)) {
+  if (
+    config.deepResearchCompletedForCurrentWork !== true &&
+    shouldStartWithDeepResearch(goal || config.goal, messages)
+  ) {
     const deepResearch = phaseEnabled.find(({ name }) => name === "deep_research")?.tool;
     if (deepResearch) return [deepResearch, finish];
   }

package/src/research-routing.js

@@ -10,7 +10,7 @@ const RUNTIME_USER_MESSAGE_PATTERNS = Object.freeze([
   /^Step \d+\/\d+\b.*Latest runtime snapshot:/i,
   /^Retained runtime tool evidence\./i,
   /^The runtime proactively compacted a long agent history/i,
-  /^A previous agent-step model request timed out/i,
+  /^A previous agent-step (?:model request timed out|request was interrupted by a (?:model timeout|transient provider transport interruption))/i,
   /^Continue from this compacted, valid transcript/i,
   /^Previous assistant response retained as compacted history/i,
   /^Highest-priority retained state:/i,