@lazyingart/agintiflow 0.20.306 → 0.20.308

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.306",
+  "version": "0.20.308",
   "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-dynamic-step-budget.js

@@ -7471,6 +7471,212 @@ try {
       precommitDocumentQualityState.meta.completionEvidenceRepair === undefined,
     "a passing pre-commit document check did not clear its bounded repair marker"
   );
+  const currentGoalGeneratedDocumentState = {
+    goal:
+      "Read TASK.md, produce a verified PDF memo for the current task, and commit only the intentional work.",
+    messages: [],
+    meta: {
+      taskProfile: "writing",
+      goalContract: {
+        revision: 5,
+        activeGoalRevision: 5,
+        activeGoal:
+          "Read TASK.md, produce a verified PDF memo for the current task, and commit only the intentional work.",
+      },
+      projectVerification: {
+        mutationRevision: 12,
+        privateMutationRevision: 0,
+        mutationHistory: [
+          {
+            revision: 8,
+            at: "2026-09-01T09:00:00.000Z",
+            toolName: "run_command",
+            paths: ["stale-root.pdf"],
+            goalRevision: 4,
+          },
+          {
+            revision: 11,
+            at: "2026-09-01T09:05:00.000Z",
+            toolName: "write_file",
+            paths: ["daily_memo.tex"],
+            goalRevision: 5,
+          },
+          {
+            revision: 12,
+            at: "2026-09-01T09:06:00.000Z",
+            toolName: "run_command",
+            paths: [
+              "daily_memo.pdf",
+              "daily_memo.aux",
+              "/tmp/escape.pdf",
+              ".env.pdf",
+              "secrets/hidden.pdf",
+            ],
+            goalRevision: 5,
+          },
+        ],
+      },
+    },
+  };
+  let currentGoalDocumentValidatorInput = null;
+  const currentGoalDocumentAssessment = await documentQualityCommitAssessment(
+    currentGoalGeneratedDocumentState,
+    "run_command",
+    { command: "git add -- daily_memo.tex daily_memo.pdf && git commit -m memo" },
+    {
+      commandCwd: missingArtifactCommitWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        currentGoalDocumentValidatorInput = input;
+        return {
+          ok: true,
+          checked: true,
+          artifacts: [{ path: "daily_memo.pdf" }],
+          defects: [],
+          reason: "Independent document checks passed for daily_memo.pdf.",
+        };
+      },
+    }
+  );
+  assert(
+    currentGoalDocumentAssessment?.ok === true &&
+      currentGoalDocumentValidatorInput?.exactOutputPaths?.includes(
+        "daily_memo.pdf"
+      ) &&
+      !currentGoalDocumentValidatorInput.exactOutputPaths.includes(
+        "stale-root.pdf"
+      ) &&
+      !currentGoalDocumentValidatorInput.exactOutputPaths.includes(
+        "daily_memo.aux"
+      ) &&
+      !currentGoalDocumentValidatorInput.exactOutputPaths.includes(
+        "secrets/hidden.pdf"
+      ),
+    `a current-goal generated root PDF was not discovered safely for pre-commit validation: ${JSON.stringify(
+      currentGoalDocumentValidatorInput
+    )}`
+  );
+  const unrelatedRootWorkspace = path.join(
+    tempRoot,
+    "unrelated-root-document"
+  );
+  await fs.mkdir(unrelatedRootWorkspace, { recursive: true });
+  await fs.writeFile(
+    path.join(unrelatedRootWorkspace, "unrelated.pdf"),
+    "pre-existing root PDF that the current goal did not create",
+    "utf8"
+  );
+  const unrelatedRootDocumentState = {
+    goal:
+      "Produce a verified PDF artifact for this task and commit the intentional work.",
+    messages: [],
+    meta: {
+      taskProfile: "writing",
+      goalContract: {
+        revision: 6,
+        activeGoalRevision: 6,
+        activeGoal:
+          "Produce a verified PDF artifact for this task and commit the intentional work.",
+      },
+      projectVerification: {
+        mutationRevision: 4,
+        privateMutationRevision: 0,
+        mutationHistory: [
+          {
+            revision: 3,
+            at: "2026-09-01T09:10:00.000Z",
+            toolName: "run_command",
+            paths: ["unrelated.pdf"],
+            goalRevision: 5,
+          },
+          {
+            revision: 4,
+            at: "2026-09-01T09:12:00.000Z",
+            toolName: "write_file",
+            paths: ["notes.tex"],
+            goalRevision: 6,
+          },
+        ],
+      },
+    },
+  };
+  let unrelatedRootValidatorInput = null;
+  const unrelatedRootAssessment = await documentQualityCommitAssessment(
+    unrelatedRootDocumentState,
+    "run_command",
+    { command: "git add -- notes.tex && git commit -m notes" },
+    {
+      commandCwd: unrelatedRootWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        unrelatedRootValidatorInput = input;
+        return {
+          ok: false,
+          checked: true,
+          artifacts: [],
+          defects: [{ code: "missing-document-artifact" }],
+          reason: "No readable DOCX or PDF artifact was found for the completed document task.",
+        };
+      },
+    }
+  );
+  assert(
+    unrelatedRootAssessment?.ok === false &&
+      unrelatedRootAssessment.category === "document-quality-incomplete" &&
+      !unrelatedRootValidatorInput?.exactOutputPaths?.includes(
+        "unrelated.pdf"
+      ),
+    `an unrelated pre-existing root PDF was accepted as current-goal evidence: ${JSON.stringify(
+      unrelatedRootValidatorInput
+    )}`
+  );
+  const semanticGateDocumentState = structuredClone(
+    currentGoalGeneratedDocumentState
+  );
+  semanticGateDocumentState.meta.scs = {
+    taskContract: { exactInputPaths: ["TASK.md"] },
+  };
+  let semanticGateValidatorInput = null;
+  const semanticGateAssessment = await documentQualityCommitAssessment(
+    semanticGateDocumentState,
+    "run_command",
+    { command: "git add -- daily_memo.tex daily_memo.pdf && git commit -m memo" },
+    {
+      commandCwd: missingArtifactCommitWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        semanticGateValidatorInput = input;
+        return {
+          ok: false,
+          checked: true,
+          artifacts: [{ path: "daily_memo.pdf" }],
+          defects: [{
+            code: "source-topic-coverage-incomplete",
+            path: "daily_memo.pdf",
+            message: "The memo omitted current source-status facts.",
+          }],
+          reason: "daily_memo.pdf: The memo omitted current source-status facts.",
+        };
+      },
+    }
+  );
+  assert(
+    semanticGateAssessment?.ok === false &&
+      semanticGateAssessment.category === "document-quality-incomplete" &&
+      semanticGateDocumentState.meta.completionEvidenceRepair
+        ?.artifactQualityRepairRequired === true &&
+      semanticGateDocumentState.meta.completionEvidenceRepair
+        ?.documentArtifactGenerationRequired !== true &&
+      semanticGateValidatorInput?.exactOutputPaths?.includes(
+        "daily_memo.pdf"
+      ) &&
+      semanticGateValidatorInput?.exactInputPaths?.includes("TASK.md"),
+    `current-goal artifact discovery bypassed source/status quality gates or reopened the missing-artifact loop: ${JSON.stringify({
+      assessment: semanticGateAssessment,
+      input: semanticGateValidatorInput,
+      repair: semanticGateDocumentState.meta.completionEvidenceRepair,
+    })}`
+  );
   await fs.writeFile(
     path.join(missingArtifactCommitWorkspace, "TASK.md"),
     [

package/scripts/smoke-truthful-completion.js

@@ -11,7 +11,7 @@ import {
 } from "../src/agent-runner.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { SessionStore } from "../src/session-store.js";
-import { finishResultClaimsIncompleteWork } from "../src/scs-evidence.js";
+import { deriveScsTaskContract, finishResultClaimsIncompleteWork } from "../src/scs-evidence.js";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-truthful-completion-"));
@@ -198,6 +198,9 @@ async function runCase({
   id,
   goal,
   taskProfile = "auto",
+  provider = "openai",
+  model = "scripted-model",
+  routingMode = "manual",
   responses,
   allowShellTool = false,
   allowFileTools = false,
@@ -205,6 +208,9 @@ async function runCase({
   executionTier = "",
   maxOutputTokens = undefined,
   resume = false,
+  runtimePatch = undefined,
+  expectedRuntimeRevision = undefined,
+  providerReadinessMode = undefined,
   setup = null,
   scsActive = false,
 }) {
@@ -215,11 +221,20 @@ async function runCase({
   if (typeof setup === "function") await setup(workspace);
   const calls = [];
   const client = scriptedClient([...responses], calls);
+  const factoryConfigs = [];
+  const clientFactory = async (runtimeConfig = {}) => {
+    factoryConfigs.push({
+      provider: runtimeConfig.provider,
+      model: runtimeConfig.model,
+    });
+    return client;
+  };
+  clientFactory.agintiDeterministicTest = true;
   const config = resolveRuntimeConfig(
     {
-      provider: "openai",
-      routingMode: "manual",
-      model: "scripted-model",
+      provider,
+      routingMode,
+      model,
       goal,
       taskProfile,
       executionTier,
@@ -236,9 +251,9 @@ async function runCase({
     {
       baseDir: workspace,
       packageDir: repoRoot,
-      provider: "openai",
-      routingMode: "manual",
-      model: "scripted-model",
+      provider,
+      routingMode,
+      model,
       executionTier,
       sessionId: id,
       resume: resume ? id : "",
@@ -255,13 +270,13 @@ async function runCase({
       allowMcpTools: false,
       allowParallelScouts: false,
       enableScs: scsActive ? "auto" : "off",
-      clientFactory: async () => client,
+      clientFactory,
     }
   );
   Object.assign(config, {
     apiKey: "scripted-test-only",
     resume: resume ? id : "",
-    clientFactory: async () => client,
+    clientFactory,
     sessionsDir,
     projectSessionsDir,
     useDockerSandbox: false,
@@ -283,17 +298,51 @@ async function runCase({
       : undefined,
     modelTimeoutMs: 1_000,
     ...(executionTier ? { executionTier, executionPolicy: { tier: executionTier, requiresPlan: false, reason: "Scripted completion smoke." } } : {}),
+    ...(providerReadinessMode ? { providerReadinessMode } : {}),
+    ...(runtimePatch ? { runtimePatch } : {}),
+    ...(expectedRuntimeRevision !== undefined ? { expectedRuntimeRevision } : {}),
   });
   const result = await runAgent(config);
   const store = new SessionStore(sessionsDir, id, { projectRoot: workspace, commandCwd: workspace, projectSessionsDir });
   return {
     result,
     calls,
+    factoryConfigs,
     events: await store.loadEvents(),
     state: await store.loadState(),
   };
 }
 
+function providerRuntimePatch(provider, model) {
+  return {
+    provider,
+    model,
+    routingMode: "manual",
+    routeProvider: provider,
+    routeModel: model,
+    mainProvider: provider,
+    mainModel: model,
+    spareProvider: provider,
+    spareModel: model,
+  };
+}
+
+function scopedTaskGoal(request, artifactRoot) {
+  return [
+    "User request:",
+    request,
+    "",
+    `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
+      mode: "task",
+      request,
+      artifact_root: artifactRoot,
+    })}`,
+    "",
+    "Artifact contract:",
+    "- If no file is produced, use an empty artifacts list.",
+  ].join("\n");
+}
+
 try {
   const explanation = await runCase({
     id: "ordinary-explanation",
@@ -410,6 +459,125 @@ try {
   assert.equal(quotedChatClassification.result.result, '{"intent":"generation_only","publish":false}');
   assert(!quotedChatClassification.events.some((event) => event.type === "completion.evidence_rejected"));
 
+  const providerSwitchSessionId = "provider-switch-resume-contract";
+  const providerSwitchFirstTurn = await runCase({
+    id: providerSwitchSessionId,
+    goal: "Create provider-switch-proof.md with the exact text provider switch proof.",
+    taskProfile: "auto",
+    provider: "localllm",
+    model: "localllm-fast",
+    providerReadinessMode: "deterministic-test",
+    allowFileTools: true,
+    responses: [
+      assistant("", [
+        toolCall("write-provider-switch-proof", "write_file", {
+          path: "provider-switch-proof.md",
+          mode: "create",
+          content: "provider switch proof\n",
+        }),
+      ]),
+      assistant("", [
+        toolCall("finish-provider-switch-proof", "finish", {
+          result: "Created provider-switch-proof.md.",
+        }),
+      ]),
+    ],
+  });
+  assert.equal(providerSwitchFirstTurn.result.stopped, undefined);
+  assert.equal(providerSwitchFirstTurn.state.meta?.runtimeConfig?.provider, "localllm");
+  assert.equal(providerSwitchFirstTurn.state.meta?.runtimeConfig?.model, "localllm-fast");
+
+  const providerSwitchSecondTurn = await runCase({
+    id: providerSwitchSessionId,
+    goal: "Resume this exact session with the default provider and return exactly: DEEPSEEK_RESUME_OK",
+    taskProfile: "auto",
+    provider: "deepseek",
+    model: "deepseek-v4-flash",
+    resume: true,
+    runtimePatch: providerRuntimePatch("deepseek", "deepseek-v4-flash"),
+    expectedRuntimeRevision: providerSwitchFirstTurn.state.meta.runtimeConfig.revision,
+    responses: [
+      assistant("", [
+        toolCall("finish-provider-switch-deepseek", "finish", {
+          result: "DEEPSEEK_RESUME_OK",
+        }),
+      ]),
+    ],
+  });
+  assert.equal(providerSwitchSecondTurn.result.stopped, undefined);
+  assert.equal(providerSwitchSecondTurn.result.result, "DEEPSEEK_RESUME_OK");
+  assert.equal(providerSwitchSecondTurn.state.meta?.runtimeConfig?.provider, "deepseek");
+  assert.equal(providerSwitchSecondTurn.state.meta?.runtimeConfig?.model, "deepseek-v4-flash");
+  assert.equal(
+    providerSwitchSecondTurn.events.filter(
+      (event) => event.type === "session.runtime_resolved" && event.data?.provider === "deepseek"
+    ).length,
+    1,
+    "explicit DeepSeek resume did not persist a provider switch"
+  );
+
+  const forcedLocalRequest =
+    "Resume this exact session and return exactly: LOCALLLM_FORCED_RESUME_OK Do not create or modify any file.";
+  const forcedLocalGoal = scopedTaskGoal(
+    forcedLocalRequest,
+    path.join(tempRoot, "artifacts", "provider-switch-resume-contract")
+  );
+  const forcedLocalContract = deriveScsTaskContract({ goal: forcedLocalGoal, taskProfile: "auto" });
+  assert.equal(
+    forcedLocalContract.requiresExternalEvidence,
+    false,
+    "a forbidden file-mutation clause made a pure response-only resume require external evidence"
+  );
+  assert.deepEqual(forcedLocalContract.requiredEvidence, []);
+  assert.deepEqual(forcedLocalContract.exactOutputPaths, []);
+  assert(
+    forcedLocalContract.forbiddenActions.some((item) => /create or modify any file/i.test(item)),
+    "forbidden file mutation was not retained as a guardrail"
+  );
+
+  const forcedLocalResume = await runCase({
+    id: providerSwitchSessionId,
+    goal: forcedLocalGoal,
+    taskProfile: "auto",
+    provider: "localllm",
+    model: "localllm-fast",
+    providerReadinessMode: "deterministic-test",
+    resume: true,
+    runtimePatch: providerRuntimePatch("localllm", "localllm-fast"),
+    expectedRuntimeRevision: providerSwitchSecondTurn.state.meta.runtimeConfig.revision,
+    responses: [
+      assistant("", [
+        toolCall("finish-provider-switch-localllm", "finish", {
+          result: "LOCALLLM_FORCED_RESUME_OK",
+        }),
+      ]),
+    ],
+  });
+  assert.equal(forcedLocalResume.result.stopped, undefined);
+  assert.equal(forcedLocalResume.result.result, "LOCALLLM_FORCED_RESUME_OK");
+  assert.equal(forcedLocalResume.calls.length, 1);
+  assert.deepEqual(forcedLocalResume.factoryConfigs, [{ provider: "localllm", model: "localllm-fast" }]);
+  assert.equal(forcedLocalResume.state.meta?.runtimeConfig?.provider, "localllm");
+  assert.equal(forcedLocalResume.state.meta?.runtimeConfig?.model, "localllm-fast");
+  assert.equal(
+    forcedLocalResume.events.filter(
+      (event) =>
+        event.type === "session.runtime_resolved" &&
+        event.data?.provider === "localllm" &&
+        event.data?.model === "localllm-fast"
+    ).length,
+    1,
+    "explicit LocalLLM resume did not persist the forced provider/model switch"
+  );
+  assert(
+    !forcedLocalResume.events.some(
+      (event) =>
+        event.type === "completion.evidence_rejected" &&
+        /ledger is empty/i.test(String(event.data?.reason || ""))
+    ),
+    "pure LocalLLM resume was rejected for missing external evidence"
+  );
+
   const proseOnlyAction = await runCase({
     id: "prose-only-action",
     goal: "Run pwd and report the output.",

package/src/agent-runner.js

@@ -10257,6 +10257,7 @@ export async function documentQualityCommitAssessment(
       ? contract.exactOutputPaths
       : []),
     ...exactOutputPathsForState(state),
+    ...currentGoalDocumentArtifactPathsForState(state),
     ...(Array.isArray(config.taskOwnedCommitPaths)
       ? config.taskOwnedCommitPaths
       : []),
@@ -14185,6 +14186,46 @@ function exactOutputPathsForState(state = {}) {
   ], exclusions).slice(0, 32);
 }
 
+function currentGoalDocumentArtifactPathsForState(state = {}) {
+  const verification = state.meta?.projectVerification || {};
+  const history = Array.isArray(verification.mutationHistory)
+    ? verification.mutationHistory
+    : [];
+  const currentGoalRevision = Math.max(
+    0,
+    Number(state.meta?.goalContract?.revision || 0)
+  );
+  if (currentGoalRevision <= 0) return [];
+  const candidates = [];
+  const seen = new Set();
+  for (const mutation of history) {
+    if (Number(mutation?.goalRevision || 0) !== currentGoalRevision) continue;
+    const paths = [
+      ...(Array.isArray(mutation?.paths) ? mutation.paths : []),
+      ...(Array.isArray(mutation?.projectMutationPaths)
+        ? mutation.projectMutationPaths
+        : []),
+      ...(Array.isArray(mutation?.verifiedGeneratedOutputPaths)
+        ? mutation.verifiedGeneratedOutputPaths
+        : []),
+    ];
+    for (const value of paths) {
+      const candidate = safeTaskOwnedCommitPath(value);
+      if (
+        !candidate ||
+        !/\.(?:docx|pdf)$/iu.test(candidate) ||
+        seen.has(candidate)
+      ) {
+        continue;
+      }
+      seen.add(candidate);
+      candidates.push(candidate);
+      if (candidates.length >= 16) return candidates;
+    }
+  }
+  return candidates;
+}
+
 function exactInputPathsForState(state = {}) {
   const scsInputPaths = Array.isArray(state.meta?.scs?.taskContract?.exactInputPaths)
     ? state.meta.scs.taskContract.exactInputPaths.filter(Boolean)
@@ -21389,6 +21430,7 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
   const documentExactOutputPaths = [
     ...(assessment.contract?.exactOutputPaths || []),
     ...exactOutputPathsForState(state),
+    ...currentGoalDocumentArtifactPathsForState(state),
   ];
   const documentContractText = `${completionContractGoal(config, state)}\n${candidateResult}`;
   const documentDeliverableRequested =

package/src/scs-evidence.js

@@ -2059,7 +2059,8 @@ export function deriveScsTaskContract({ goal = "", taskProfile = "", acceptanceC
   if (requiredGitActions.length && !requirementCategories.includes("git")) {
     requirementCategories.push("git");
   }
-  const requiresExternalEvidence = requirementCategories.length > 0 || requiredToolCalls.length > 0 || goalRequiresEvidence(evidenceGoal, taskProfile);
+  const requiresExternalEvidence =
+    requirementCategories.length > 0 || requiredToolCalls.length > 0 || goalRequiresEvidence(positiveEvidenceGoal, taskProfile);
   const requiredEvidence = requirementCategories.map((category) => ({
     id: category,
     category,