@lazyingart/agintiflow 0.20.289 → 0.20.291

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/supervision-campaign-ledger.md

@@ -408,3 +408,26 @@ The same real session was replayed against the patched source at goal revision
 The target stayed at commit `2b35928` with no mutation. Focused planning,
 truthful-completion, and dynamic-budget regressions pass, as does the complete
 AgInTiFlow npm suite. The fix is released in AgInTiFlow `0.20.251`.
+
+### Exact source recovery after context loss
+
+`database-migration-049` repeated an imperfect SQLite repair task against a
+fresh broken workspace. Automatic routing selected only `qa-testing` and
+`database`, but the first run read the canonical source immediately before
+proactive context compaction. The compacted model correctly requested that
+source again; the retained failed-test read budget exposed a different file,
+so two safe but schema-invalid reads stopped the session without dispatch.
+
+AgInTiFlow now treats proactive compaction, local context-window recovery,
+model-timeout compaction, and same-task continuation as bounded context-loss
+boundaries. A current failed-test packet may reopen only its evidence-derived
+production repair paths after such a boundary. Tests, broad discovery,
+arbitrary commands, and unrelated writes remain closed. Once the exact source
+is read in the new context, the ordinary mutation and verification gates apply.
+
+The original session resumed against the patched runtime, repaired the
+transactional schema migration, preserved IDs and tags on URL updates, made
+punctuation search literal, added regression coverage, passed four unit tests,
+and committed a clean tree at `b956470`. The independent migration-safety
+contract also passed. The complete npm suite passes, and the runtime fix is
+released in AgInTiFlow `0.20.291`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.289",
+  "version": "0.20.291",
   "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

@@ -2818,6 +2818,113 @@ assertStrict.deepEqual(
   ["service_ctl.py"],
   "DeepSeek repair reread fallback was not constrained to the canonical source"
 );
+const postCompactionRepairRuntime = nextStepRuntimeConfig(
+  { provider: "deepseek", taskProfile: "qa" },
+  {
+    ...packetPathReadState,
+    meta: {
+      ...packetPathReadState.meta,
+      failedTestRecoveryPacket: {
+        ...packetPathReadState.meta.failedTestRecoveryPacket,
+        paths: ["tests/test_service_ctl.py", "legacy_fixture.py", "service_ctl.py"],
+        repairPaths: ["legacy_fixture.py", "service_ctl.py"],
+      },
+      toolLoop: {
+        stagnationEpoch: 10,
+        lastContextRecovery: {
+          reason: "proactive-context-compaction",
+          at: "2026-08-24T02:00:13.000Z",
+          preservedStaticEvidence: true,
+        },
+        recent: [
+          ...packetPathReadState.meta.toolLoop.recent,
+          {
+            toolName: "read_file",
+            path: "tests/test_service_ctl.py",
+            ok: true,
+            blocked: false,
+            at: "2026-08-24T02:00:12.000Z",
+          },
+          {
+            toolName: "read_file",
+            path: "legacy_fixture.py",
+            ok: true,
+            blocked: false,
+            at: "2026-08-24T02:00:12.500Z",
+          },
+        ],
+      },
+    },
+  }
+);
+assertStrict.deepEqual(
+  postCompactionRepairRuntime.testFailureRepairContextPaths,
+  ["legacy_fixture.py", "service_ctl.py"],
+  "context compaction did not reopen the exact production source lost from model context"
+);
+assertStrict.equal(
+  postCompactionRepairRuntime.testFailureRepairNeedsPatchContext,
+  true,
+  "context compaction did not restore one bounded source-context turn before mutation"
+);
+const postCompactionRepairTools = selectProgressiveTools(allTools, {
+  config: postCompactionRepairRuntime,
+  goal: "Continue the failed-test repair after proactive context compaction.",
+  profile: "qa",
+});
+sameNames(
+  postCompactionRepairTools,
+  ["read_file", "apply_patch", "finish"],
+  "post-compaction repair reopened broad discovery or verification tools"
+);
+assertStrict.deepEqual(
+  postCompactionRepairTools[0].function.parameters.properties.path.enum,
+  ["legacy_fixture.py", "service_ctl.py"],
+  "post-compaction repair did not constrain rereads to all canonical production sources"
+);
+const sameTaskContinuationRepairRuntime = nextStepRuntimeConfig(
+  { provider: "deepseek", taskProfile: "qa" },
+  {
+    ...packetPathReadState,
+    meta: {
+      ...packetPathReadState.meta,
+      failedTestRecoveryPacket: {
+        ...packetPathReadState.meta.failedTestRecoveryPacket,
+        paths: ["tests/test_service_ctl.py", "legacy_fixture.py", "service_ctl.py"],
+        repairPaths: ["legacy_fixture.py", "service_ctl.py"],
+      },
+      toolLoop: {
+        stagnationEpoch: 11,
+        lastContextRecovery: {
+          reason: "same-task-continuation",
+          at: "2026-08-24T02:01:00.000Z",
+        },
+        recent: [
+          ...packetPathReadState.meta.toolLoop.recent,
+          {
+            toolName: "read_file",
+            path: "tests/test_service_ctl.py",
+            ok: true,
+            blocked: false,
+            at: "2026-08-24T02:00:12.000Z",
+          },
+          {
+            toolName: "read_file",
+            path: "legacy_fixture.py",
+            ok: true,
+            blocked: false,
+            at: "2026-08-24T02:00:12.500Z",
+          },
+        ],
+      },
+    },
+  }
+);
+assertStrict.deepEqual(
+  sameTaskContinuationRepairRuntime.testFailureRepairContextPaths,
+  ["legacy_fixture.py", "service_ctl.py"],
+  "same-task continuation did not reopen all retained canonical production sources"
+);
 const testOnlyPacketState = {
   meta: {
     projectVerification: {

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

@@ -14588,11 +14588,34 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
       Date.parse(String(state.meta?.failedTestRecoveryPacket?.generatedAt || "")),
       Date.parse(String(state.meta?.failedTestFocusedRecovery?.at || "")),
     ].filter(Number.isFinite);
-    const recoveryPacketContextAt = Number.isFinite(failureAt)
+    const retainedRecoveryPacketContextAt = Number.isFinite(failureAt)
       ? failureAt
       : recoveryPacketContextMarkers.length
         ? Math.max(...recoveryPacketContextMarkers)
         : Number.NaN;
+    const latestContextRecovery = state.meta?.toolLoop?.lastContextRecovery;
+    const latestContextRecoveryAt = Date.parse(
+      String(latestContextRecovery?.at || "")
+    );
+    const postContextLossRepairContext = Boolean(
+      Number.isFinite(latestContextRecoveryAt) &&
+        (!Number.isFinite(retainedRecoveryPacketContextAt) ||
+          latestContextRecoveryAt > retainedRecoveryPacketContextAt) &&
+        [
+          "proactive-context-compaction",
+          "local-context-budget-retry",
+          "model-timeout-retry",
+          "same-task-continuation",
+        ].includes(String(latestContextRecovery?.reason || ""))
+    );
+    const recoveryPacketContextAt = postContextLossRepairContext
+      ? latestContextRecoveryAt
+      : retainedRecoveryPacketContextAt;
+    const activeRecoveryPacketPaths = postContextLossRepairContext
+      ? recoveryPacketRepairPaths
+          .filter((item) => !failedTestPathIsTestEvidence(item))
+          .slice(0, 6)
+      : recoveryPacketPaths;
     const consumedRecoveryPacketPaths = new Set(
       Number.isFinite(recoveryPacketContextAt)
         ? (Array.isArray(toolLoop.recent) ? toolLoop.recent : [])
@@ -14610,7 +14633,7 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
             .filter(Boolean)
         : []
     );
-    const unreadRecoveryPacketPaths = recoveryPacketPaths.filter(
+    const unreadRecoveryPacketPaths = activeRecoveryPacketPaths.filter(
       (item) => !consumedRecoveryPacketPaths.has(item)
     );
     const recoveryPacketReadCounts = new Map();
@@ -14635,7 +14658,7 @@ export function nextStepRuntimeConfig(config = {}, state = {}) {
       }
     }
     const exactRecoveryPacketContextActive = Boolean(
-      recoveryPacketPaths.length && Number.isFinite(recoveryPacketContextAt)
+      activeRecoveryPacketPaths.length && Number.isFinite(recoveryPacketContextAt)
     );
     const recoveryPacketHasProductionContext = [
       ...recoveryPacketPaths,

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);