@lazyingart/agintiflow 0.20.283 → 0.20.285

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.283",
+  "version": "0.20.285",
   "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",
@@ -180,6 +180,7 @@
     "smoke:localllm-model-tiers": "node scripts/smoke-localllm-model-tiers.js",
     "smoke:localllm-provider": "node scripts/smoke-localllm-provider.js",
     "smoke:progressive-tools": "node scripts/smoke-progressive-tool-selection.js",
+    "smoke:scoped-artifact-research": "node scripts/smoke-scoped-artifact-research.js",
     "smoke:truthful-completion": "node scripts/smoke-truthful-completion.js",
     "smoke:document-artifact-quality": "node scripts/smoke-document-artifact-quality.js",
     "smoke:writing-specialist-routing": "node scripts/smoke-writing-specialist-routing.js",

package/scripts/smoke-capabilities.js

@@ -147,7 +147,7 @@ try {
     capabilities.tools?.taskProfiles?.some((profile) => profile.id === "pipeline"),
     "capabilities did not report pipeline task profile"
   );
-  for (const profileId of ["docs", "data", "qa", "database", "devops", "security", "slides", "education", "java", "ios", "go", "rust", "dotnet", "php", "ruby"]) {
+  for (const profileId of ["docs", "data", "qa", "database", "devops", "security", "slides", "education", "java", "ios", "go", "rust", "dotnet", "php", "ruby", "cad"]) {
     assert(
       capabilities.tools?.taskProfiles?.some((profile) => profile.id === profileId),
       `capabilities did not report ${profileId} task profile`
@@ -157,6 +157,16 @@ try {
   assert(qaProfile, "QA profile is missing");
   assert(defaultMaxStepsForProfile("qa") >= 40, "QA profile step budget is too low for verification and cleanup");
   assert(defaultMaxStepsForProfile("pipeline") >= 44, "pipeline profile step budget is too low for repair/verify/resume loops");
+  const cadProfile = listTaskProfiles().find((profile) => profile.id === "cad");
+  assert(cadProfile, "CAD profile is missing");
+  assert(defaultMaxStepsForProfile("cad") >= 44, "CAD profile step budget is too low for build/render/validation repair loops");
+  assert(/one canonical machine-readable validation section/i.test(cadProfile.prompt), "CAD profile permits ambiguous validation aliases");
+  assert(/top-level `validation` object/i.test(cadProfile.prompt), "CAD profile does not establish one stable validation schema");
+  assert(/`solid_count`[\s\S]*`bbox_mm`[\s\S]*`watertight`[\s\S]*`object_count`/i.test(cadProfile.prompt), "CAD profile omits conventional format-native evidence field names");
+  assert(/enrich its missing direct evidence fields instead of renaming/i.test(cadProfile.prompt), "CAD profile permits same-failure schema oscillation");
+  assert(/STEP\/B-rep evidence needs solid count/i.test(cadProfile.prompt), "CAD profile does not require format-native STEP evidence");
+  assert(/STL evidence needs watertightness/i.test(cadProfile.prompt), "CAD profile does not require format-native STL evidence");
+  assert(/3MF evidence needs package validity/i.test(cadProfile.prompt), "CAD profile does not require format-native 3MF evidence");
   assert(!/misleading failing test/i.test(qaProfile.prompt), "QA profile still encourages misleading test fixtures");
   assert(/do not stage fake bugs/i.test(qaProfile.prompt), "QA profile does not discourage fake staged failures");
   const slidesProfile = listTaskProfiles().find((profile) => profile.id === "slides");

package/scripts/smoke-coding-tools.js

@@ -2,6 +2,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import {
   buildModelTimeoutRetryMessages,
@@ -11,6 +12,7 @@ import {
   normalizeNoMatchQueryResult,
   applyModelTimeoutRetryRoute,
   recoverFocusedTextRewriteWithWritingSpecialist,
+  reconcileRuntimeRepositoryState,
   repairModelMessageHistory,
   shouldResetStaticDiscoveryPhase,
   runAgent,
@@ -99,7 +101,78 @@ async function runMock(goal, sessionId, { resume = false } = {}) {
   };
 }
 
+async function verifyRunAgentRuntimeGitHygiene() {
+  const gitWorkspace = path.join(tempRoot, "runtime-git-workspace");
+  await fs.mkdir(gitWorkspace, { recursive: true });
+  const initialized = spawnSync("git", ["init"], {
+    cwd: gitWorkspace,
+    encoding: "utf8",
+  });
+  assert(initialized.status === 0, `runtime Git hygiene setup failed: ${initialized.stderr || initialized.stdout}`);
+  const config = resolveRuntimeConfig(
+    {
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      goal: "hello",
+      commandCwd: gitWorkspace,
+      maxSteps: 2,
+    },
+    {
+      baseDir: runtimeDir,
+      packageDir: repoRoot,
+      provider: "mock",
+      routingMode: "manual",
+      model: "mock-agent",
+      commandCwd: gitWorkspace,
+      allowShellTool: false,
+      allowFileTools: true,
+      sandboxMode: "host",
+      packageInstallPolicy: "block",
+      sessionId: "coding-runtime-git-hygiene",
+    }
+  );
+  await runAgent(config);
+  const localExclude = await fs.readFile(path.join(gitWorkspace, ".git", "info", "exclude"), "utf8");
+  assert(
+    localExclude.includes(".aginti/codebase-map.json") &&
+      localExclude.includes(".aginti/verification/"),
+    "runAgent did not protect runtime cache paths in its resolved commandCwd"
+  );
+  const gitignore = await fs.readFile(path.join(gitWorkspace, ".gitignore"), "utf8").catch(() => "");
+  assert(gitignore === "", "runAgent runtime setup edited the tracked .gitignore");
+  const staleRepositoryState = {
+    meta: {
+      projectVerification: {
+        mutationRevision: 4,
+        privateMutationRevision: 0,
+        testRuns: [{
+          command: "python3 acceptance.py",
+          mutationRevision: 4,
+          privateMutationRevision: 0,
+          passed: false,
+          failureSignature: "dirty-worktree",
+          failureSummary: "FAIL: Git worktree is not clean: ?? .aginti/",
+        }],
+      },
+      testFailureRepair: { key: "4:dirty-worktree" },
+    },
+  };
+  const reconciled = await reconcileRuntimeRepositoryState(
+    staleRepositoryState,
+    { commandCwd: gitWorkspace },
+    { changed: false }
+  );
+  assert(
+    reconciled?.clean === true &&
+      staleRepositoryState.meta.projectVerification.privateMutationRevision === 1 &&
+      !staleRepositoryState.meta.testFailureRepair,
+    "a retained cleanliness failure was not invalidated after the live worktree became clean"
+  );
+}
+
 try {
+  await verifyRunAgentRuntimeGitHygiene();
   const externalValidatorPath = path.join(
     tempRoot,
     "private-acceptance",
@@ -145,6 +218,38 @@ try {
       `external validator source inspection escaped the opaque contract: ${inspectionCommand}`
     );
   }
+  const combinedValidatorCommand =
+    `python3 build_artifact.py; ${externalValidatorCommand}`;
+  const combinedValidatorDecision = evaluateCommandPolicy(
+    combinedValidatorCommand,
+    opaqueValidatorPolicy
+  );
+  assert(
+    combinedValidatorDecision.allowed === false &&
+      combinedValidatorDecision.category === "opaque-external-validator-inspection" &&
+      combinedValidatorDecision.recoverable === true,
+    "a combined producer and external validator command escaped the opaque validator contract"
+  );
+  const combinedValidatorAdvice = buildPermissionAdvice({
+    toolName: "run_command",
+    args: { command: combinedValidatorCommand },
+    guard: combinedValidatorDecision,
+    config: opaqueValidatorPolicy,
+    state: { sessionId: "opaque-validator-command-shape-smoke" },
+  });
+  assert(
+    combinedValidatorAdvice.autoRecover === true &&
+      !combinedValidatorAdvice.suggestedCommand &&
+      /separately|standalone/i.test(combinedValidatorAdvice.instruction) &&
+      /exact declared external validator command unchanged/i.test(
+        combinedValidatorAdvice.instruction
+      ) &&
+      !shouldPauseForPermissionAdvice({
+        blocked: true,
+        permissionAdvice: combinedValidatorAdvice,
+      }),
+    "a recoverable external-validator command-shape error became a permission pause"
+  );
 
   const genericArtifactBlock = await genericArtifactFilenameBlock(
     "write_file",
@@ -598,6 +703,16 @@ try {
   );
   assert(guidance.includes("Surgical editing contract:"), "engineering guidance did not include surgical editing contract");
   assert(guidance.includes("Evidence-card template:"), "engineering guidance did not include evidence-card template");
+  const cadGuidance = engineeringGuidanceForTask(
+    "Build a centered parametric CAD cradle and export STEP, STL, 3MF, and a render for 3D printing.",
+    "auto"
+  );
+  assert(cadGuidance.includes("CAD/fabrication:"), "auto guidance did not recognize a CAD fabrication task");
+  assert(cadGuidance.includes("one canonical validation section"), "auto CAD guidance permits ambiguous validation aliases");
+  assert(
+    recommendedMaxStepsForTask({ goal: "Build a CAD holder with STEP STL and 3MF validation.", taskProfile: "auto" }) >= 44,
+    "auto CAD task did not receive a complete build/render/validation budget"
+  );
   assert(
     shouldUseSurgicalContextForTask({
       goal: "fix this large repository bug by tracing callers",
@@ -2076,6 +2191,10 @@ try {
   assert(largeModelRead.contentTruncated, "large model-facing read was not bounded");
   assert(largeModelRead.content.length <= 12100, "large model-facing read exceeded the context cap");
   assert(largeModelRead.nextStartLine > 1, "large model-facing read omitted its continuation line");
+  assert(
+    largeModelRead.continuationHint.includes(`startLine=${largeModelRead.nextStartLine}`),
+    "large model-facing read described a continuation argument that the read_file schema does not accept"
+  );
   const largeModelList = toolResultForModel({
     ok: true,
     toolName: "list_files",
@@ -2991,6 +3110,7 @@ try {
         workspace,
         checks: [
           "deepseek_history_repair",
+          "run_agent_runtime_git_hygiene",
           "interleaved_tool_history_repair",
           "blocked_tool_batch_short_circuit",
           "deepseek_pro_patch_route",

package/scripts/smoke-context-budget-recovery.js

@@ -339,6 +339,53 @@ assert.ok(!runtimeText.includes("OLD-COMPACTION-MUST-NOT-RECUR"));
 assert.match(runtimeText, /Do not reread a listed source solely because compaction occurred/);
 assert.match(runtimeText, /never restart a full-file read loop after compaction/);
 
+const latestSemanticCorrection = [
+  "Continue the current task from the preserved state.",
+  "LATEST-CORRECTION-AUTHORITY replaces the stale interpretation with a detailed current behavior contract that deliberately contains no exact file path or shell command.",
+  "Preserve verified progress, reconcile the remaining implementation against this correction, avoid repeating rejected states, and verify the current result before finishing.",
+].join(" ");
+const staleGoalCompactionState = {
+  goal: "STALE-ACTIVE-GOAL continue the older interpretation.",
+  plan: "Use current evidence and finish the retained task.",
+  messages: [
+    { role: "system", content: "Preserve the latest substantive same-task correction." },
+    { role: "user", content: `Continue the current task from saved state: ${latestSemanticCorrection}` },
+  ],
+  meta: {
+    taskProfile: "auto",
+    goalContract: {
+      version: 3,
+      revision: 9,
+      activeGoalRevision: 8,
+      taskGoal: "Complete the retained task.",
+      activeGoal: "STALE-ACTIVE-GOAL continue the older interpretation.",
+      currentRequest: latestSemanticCorrection,
+      history: [{ revision: 9, refreshExecutionContract: false }],
+    },
+  },
+};
+const staleGoalCompactionMessages = buildContextBudgetCompactionMessages(
+  staleGoalCompactionState,
+  config,
+  { title: "", url: "" },
+  17,
+  { reason: "recover the latest semantic correction from an older saved session" }
+);
+const staleGoalCompactionText = staleGoalCompactionMessages
+  .map((message) => message.content || "")
+  .join("\n");
+const authoritativeGoalSection = staleGoalCompactionText
+  .split("Authoritative current goal:")[1]
+  ?.split("Current plan:")[0] || "";
+assert.ok(
+  authoritativeGoalSection.includes("LATEST-CORRECTION-AUTHORITY"),
+  "compaction kept an older active goal above a substantive latest correction"
+);
+assert.ok(
+  !authoritativeGoalSection.includes("STALE-ACTIVE-GOAL"),
+  "compaction still labeled the stale active goal as authoritative"
+);
+
 const deepSeekRuntimeMessages = buildContextBudgetCompactionMessages(
   compactionState,
   { ...config, provider: "deepseek", model: "deepseek-chat" },
@@ -728,4 +775,85 @@ assert.ok(
   "cumulative DeepSeek compaction exceeded the bounded retry target"
 );
 
+const instructionReadPair = [
+  {
+    role: "assistant",
+    content: "",
+    reasoning_content: "Read the exact project instructions before editing.",
+    tool_calls: [
+      {
+        id: "read-project-instructions",
+        type: "function",
+        function: { name: "read_file", arguments: '{"path":"AGENTS.md"}' },
+      },
+    ],
+  },
+  {
+    role: "tool",
+    tool_call_id: "read-project-instructions",
+    content: JSON.stringify({
+      ok: true,
+      toolName: "read_file",
+      path: "AGENTS.md",
+      sha256: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      content: "PROJECT-INSTRUCTION-MARKER preserve inputs and never inspect the external validator source.",
+    }),
+  },
+];
+const instructionCompactionState = {
+  ...compactionState,
+  messages: [
+    { role: "system", content: "system" },
+    { role: "user", content: "Repair the canonical CAD producer." },
+    ...instructionReadPair,
+    { role: "user", content: "Continue the current task from saved state: repair after validation." },
+    ...Array.from({ length: 18 }, (_, index) => noisyFullReadPair(index + 1, 7)).flat(),
+  ],
+};
+const instructionCompacted = buildContextBudgetCompactionMessages(
+  instructionCompactionState,
+  { ...config, provider: "deepseek", model: "deepseek-chat" },
+  { title: "", url: "" },
+  22,
+  { reason: "preserve project instructions across a continuation boundary" }
+);
+const instructionCompactedText = instructionCompacted
+  .map((message) => message.content || "")
+  .join("\n");
+assert.ok(
+  instructionCompactedText.includes("PROJECT-INSTRUCTION-MARKER"),
+  "compaction lost a project instruction read that preceded the latest continuation boundary"
+);
+const instructionCompactedAgain = buildContextBudgetCompactionMessages(
+  {
+    ...instructionCompactionState,
+    messages: [
+      ...instructionCompacted,
+      { role: "user", content: "Continue the current task from saved state: apply the bounded repair." },
+      ...Array.from({ length: 18 }, (_, index) => noisyFullReadPair(index + 1, 8)).flat(),
+    ],
+  },
+  { ...config, provider: "deepseek", model: "deepseek-chat" },
+  { title: "", url: "" },
+  26,
+  { reason: "preserve project instructions through repeated compaction" }
+);
+const instructionCompactedAgainText = instructionCompactedAgain
+  .map((message) => message.content || "")
+  .join("\n");
+assert.ok(
+  instructionCompactedAgainText.includes("PROJECT-INSTRUCTION-MARKER"),
+  "repeated compaction dropped durable project instruction evidence"
+);
+assert.equal(
+  instructionCompactedAgain.filter(
+    (message) =>
+      message.role === "user" &&
+      /Tool:\s*read_file/.test(message.content || "") &&
+      /Arguments:\s*\{\"path\":\"AGENTS\.md\"\}/.test(message.content || "")
+  ).length,
+  1,
+  "repeated compaction duplicated the durable AGENTS.md tool record"
+);
+
 console.log("context budget recovery smoke passed");

package/scripts/smoke-deep-research.js

@@ -343,6 +343,101 @@ async function main() {
     !Object.hasOwn(deepSeekActionPayload || {}, "reasoning_effort"),
     "DeepSeek action-only recovery sent a conflicting reasoning effort"
   );
+  let deepSeekRepairRethinkPayload = null;
+  await requestNextStep(
+    {
+      chat: {
+        completions: {
+          create: async (payload) => {
+            deepSeekRepairRethinkPayload = payload;
+            return {
+              choices: [{
+                message: {
+                  role: "assistant",
+                  reasoning_content: "The unchanged proposal must be revised from the retained failure evidence.",
+                  content: "",
+                  tool_calls: [{
+                    id: "deepseek-rethink-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: "Repair the retained source from the exact failure evidence." },
+      {
+        role: "assistant",
+        content: "",
+        tool_calls: [{
+          id: "deepseek-rejected-patch",
+          type: "function",
+          function: {
+            name: "apply_patch",
+            arguments: JSON.stringify({
+              path: "service.py",
+              search: "old",
+              replace: "old",
+              expectedReplacements: 1,
+            }),
+          },
+        }],
+      },
+      {
+        role: "tool",
+        tool_call_id: "deepseek-rejected-patch",
+        content: JSON.stringify({
+          ok: false,
+          blocked: true,
+          recoverable: true,
+          toolName: "apply_patch",
+          category: "failed-test-nonrepairing-patch",
+          reason: "The replacement leaves the current actionable line unchanged.",
+        }),
+      },
+      { role: "user", content: "Continue from the exact tool result." },
+    ]
+  );
+  assert(
+    deepSeekRepairRethinkPayload?.thinking?.type === "enabled",
+    "DeepSeek did not restore thinking after a deterministic non-repairing patch rejection"
+  );
+  assert(
+    !Object.hasOwn(deepSeekRepairRethinkPayload || {}, "tool_choice"),
+    "DeepSeek repair rethink sent tool_choice even though V4 thinking tool calls reject it"
+  );
+  assert(
+    deepSeekRepairRethinkPayload?.tools?.some((tool) => tool?.function?.name === "apply_patch"),
+    "DeepSeek repair rethink dropped the constrained mutation tool"
+  );
   let deepSeekRepairReadPayload = null;
   await requestNextStep(
     {