@lazyingart/agintiflow 0.20.288 → 0.20.290

package/docs/skills-and-tools.md

@@ -79,6 +79,14 @@ tools:
 
 Selected skills are injected into the plan and execution prompts. The LLM still decides what to do; skills only provide domain playbooks and guardrails.
 
+Automatic selection requires substantive relevance. Exact IDs, focused short
+requests, specific triggers, and several matching description terms score
+strongly. Generic words such as `data`, `search`, `project`, or `commit` are
+discounted when they occur incidentally inside a longer request, and automatic
+mode omits weak matches instead of filling the skill budget. Explicit profiles
+and direct topic wording remain authoritative. This keeps unrelated guidance
+out of the context without hard-coding task-specific exclusions.
+
 ## Adding A Skill
 
 For a reusable project workflow, create `.aginti/skills/<id>/SKILL.md` with valid YAML frontmatter and a short Markdown body. These skills are loaded from the current project, shown as `source=project-local`, and are preferred for task-specific knowledge that should not become core runtime policy.

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.290",
   "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/scripts/smoke-skills.js

@@ -112,6 +112,24 @@ const pythonSkill = skills.find((skill) => skill.id === "python");
 assert(pythonSkill?.body.includes("PEP 701 relaxed f-strings"), "Python skill must mention 3.12 f-string compatibility traps");
 assert(pythonSkill?.body.includes("only proves the active interpreter"), "Python skill must guard syntax-check overclaims");
 assert(selectedIds("write SQL migrations for sqlite schema").includes("database"), "database prompt did not select database");
+const imperfectDatabaseRepairSkills = selectedIds(
+  "The reading archive broke after its recent schema upgrade: an old library came back empty, and search gives surprising results for some punctuation. Please inspect the project, fix the underlying problems without discarding existing data, add useful regression coverage, run the checks, and commit the intentional repair. Keep the implementation small and standard-library only."
+);
+assert(imperfectDatabaseRepairSkills.includes("database"), "normal database repair prompt omitted database guidance");
+assert(imperfectDatabaseRepairSkills.includes("qa-testing"), "normal database repair prompt omitted regression-test guidance");
+for (const unrelated of [
+  "autonomous-artifact-pipeline",
+  "bgpt-paper-search",
+  "data-analysis",
+  "exa-search",
+  "exploratory-data-analysis",
+  "optimize-for-gpu",
+]) {
+  assert(
+    !imperfectDatabaseRepairSkills.includes(unrelated),
+    `normal database repair prompt selected unrelated ${unrelated} guidance`
+  );
+}
 assert(selectedIds("debug Docker deployment logs and port config").includes("devops-deployment"), "devops prompt did not select devops-deployment");
 assert(selectedIds("review auth security and secrets handling").includes("security-review"), "security prompt did not select security-review");
 assert(selectedIds("make a PowerPoint pitch deck").includes("presentation-slides"), "slides prompt did not select presentation-slides");

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,

package/src/skill-library.js

@@ -419,21 +419,31 @@ const DESCRIPTION_STOP_WORDS = new Set([
   "after",
   "also",
   "before",
+  "checks",
   "content",
   "create",
+  "data",
   "exact",
+  "existing",
   "file",
   "files",
   "from",
   "general",
   "into",
+  "keep",
+  "only",
   "output",
   "path",
   "paths",
   "project",
   "read",
+  "reading",
+  "recent",
   "report",
   "request",
+  "results",
+  "search",
+  "standard",
   "task",
   "that",
   "their",
@@ -443,14 +453,19 @@ const DESCRIPTION_STOP_WORDS = new Set([
   "user",
   "when",
   "with",
+  "without",
   "work",
   "write",
 ]);
 
 const SKILL_ID_STOP_WORDS = new Set([
+  "and",
   "agent",
   "aginti",
+  "for",
   "development",
+  "of",
+  "the",
   "production",
   "skill",
   "system",
@@ -459,6 +474,30 @@ const SKILL_ID_STOP_WORDS = new Set([
   "workflow",
 ]);
 
+// These words are useful in a focused request, but occur incidentally across
+// many unrelated tasks. Weakening them in longer goals keeps one generic word
+// from consuming a full skill slot while preserving short requests such as
+// "analyze data" or "commit changes".
+const GENERIC_ROUTING_TERMS = new Set([
+  "analysis",
+  "app",
+  "application",
+  "code",
+  "commit",
+  "data",
+  "file",
+  "files",
+  "project",
+  "report",
+  "result",
+  "results",
+  "search",
+  "test",
+  "tests",
+  "testing",
+  "work",
+]);
+
 function descriptionTerms(value = "") {
   return [
     ...new Set(
@@ -470,7 +509,16 @@ function descriptionTerms(value = "") {
   ];
 }
 
-function scoreSkill(skill, text, taskProfile) {
+function focusedGenericSignal(goalText, needle) {
+  if (!GENERIC_ROUTING_TERMS.has(needle)) return true;
+  const terms = String(goalText || "")
+    .toLowerCase()
+    .split(/[^a-z0-9+#.]+/)
+    .filter(Boolean);
+  return terms.length <= 4 && textHasTrigger(goalText, needle);
+}
+
+function scoreSkill(skill, text, taskProfile, goalText = text) {
   let score = 0;
   if (skill.id === taskProfile) score += 10;
   if (skill.triggers.includes(taskProfile)) score += 6;
@@ -479,13 +527,14 @@ function scoreSkill(skill, text, taskProfile) {
     .split(/[^a-z0-9+#.]+/)
     .filter((term) => term.length >= 3 && !SKILL_ID_STOP_WORDS.has(term));
   for (const term of idTerms) {
-    if (textHasTrigger(text, term)) score += 2;
+    if (textHasTrigger(text, term)) score += focusedGenericSignal(goalText, term) ? 2 : 0.5;
   }
   for (const trigger of skill.triggers) {
     const needle = trigger.toLowerCase();
     if (!needle) continue;
     if (textHasTrigger(text, needle)) {
-      score += Math.max(2, Math.min(6, Math.ceil(needle.length / 6)));
+      const triggerScore = Math.max(2, Math.min(6, Math.ceil(needle.length / 6)));
+      score += focusedGenericSignal(goalText, needle) ? triggerScore : 0.5;
       continue;
     }
     const triggerTerms = descriptionTerms(needle);
@@ -495,7 +544,7 @@ function scoreSkill(skill, text, taskProfile) {
   }
   const descriptionMatches = descriptionTerms(skill.description).filter((token) => textHasTrigger(text, token));
   if (descriptionMatches.length >= 3) {
-    score += Math.min(3, descriptionMatches.length * 0.35);
+    score += Math.min(3, descriptionMatches.length * 0.5);
   }
   return score;
 }
@@ -516,19 +565,19 @@ function textHasTrigger(text, needle) {
 
 export function selectSkillsForGoal(goal = "", { taskProfile = "auto", limit = 6, includeBody = true, projectRoot = process.cwd() } = {}) {
   const goalText = String(goal || "").toLowerCase();
-  const text = `${goalText} ${taskProfile}`.toLowerCase();
+  const text = goalText;
   const skills = listSkills({ includeBody, projectRoot });
   const ranked = skills
     .map((skill) => ({
       skill,
-      score: scoreSkill(skill, text, taskProfile),
-      directGoalScore: scoreSkill(skill, goalText, "auto"),
+      score: scoreSkill(skill, text, taskProfile, goalText),
+      directGoalScore: scoreSkill(skill, goalText, "auto", goalText),
     }))
     .filter((item) => item.score > 0)
     .sort((a, b) => b.score - a.score || a.skill.id.localeCompare(b.skill.id));
   const explicitProfile = Boolean(taskProfile && taskProfile !== "auto");
   const bestScore = ranked[0]?.score || 0;
-  const relevanceFloor = explicitProfile && bestScore >= 6 ? Math.max(2, bestScore * 0.5) : 0;
+  const relevanceFloor = explicitProfile && bestScore >= 6 ? Math.max(2, bestScore * 0.5) : 2;
   const scored = ranked
     .filter((item) => item.score >= relevanceFloor || item.directGoalScore >= 4)
     .map((item) => item.skill);