@lazyingart/agintiflow 0.20.281 → 0.20.283

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.281",
+  "version": "0.20.283",
   "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-coding-tools.js

@@ -25,7 +25,11 @@ import { createToolContract, resolveDispatchableToolCallBatch } from "../src/too
 import { formatBehaviorContractForPrompt } from "../src/behavior-contract.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { readCodebaseMap } from "../src/codebase-map.js";
-import { classifyCommand, evaluateCommandPolicy } from "../src/command-policy.js";
+import {
+  classifyCommand,
+  evaluateCommandPolicy,
+  externalValidatorCommandContract,
+} from "../src/command-policy.js";
 import { checkToolUse } from "../src/guardrails.js";
 import { shouldReviewToolResult } from "../src/scs-controller.js";
 import {
@@ -96,6 +100,52 @@ async function runMock(goal, sessionId, { resume = false } = {}) {
 }
 
 try {
+  const externalValidatorPath = path.join(
+    tempRoot,
+    "private-acceptance",
+    "spreadsheet_contract.py"
+  );
+  const externalValidatorCommand = `python3 ${externalValidatorPath}`;
+  assert(
+    externalValidatorCommandContract(externalValidatorCommand, {
+      commandCwd: workspace,
+    })?.path === externalValidatorPath,
+    "an exact external validator command did not produce an opaque contract"
+  );
+  assert(
+    externalValidatorCommandContract("python3 tests/local_contract.py", {
+      commandCwd: workspace,
+    }) === null,
+    "an in-workspace project test was incorrectly treated as an opaque external validator"
+  );
+  const opaqueValidatorPolicy = {
+    commandCwd: workspace,
+    allowShellTool: true,
+    sandboxMode: "host",
+    packageInstallPolicy: "block",
+    opaqueExternalValidatorPaths: [externalValidatorPath],
+    opaqueExternalValidatorCommands: [externalValidatorCommand],
+  };
+  assert(
+    evaluateCommandPolicy(externalValidatorCommand, opaqueValidatorPolicy).allowed === true,
+    "the exact declared external validator execution was blocked"
+  );
+  for (const inspectionCommand of [
+    `cat ${externalValidatorPath}`,
+    `sed -n '1,160p' ${externalValidatorPath}`,
+    `cat ${path.relative(workspace, externalValidatorPath)}`,
+    `V=${externalValidatorPath}; grep -n expected "$V"`,
+    `echo validator; cat ${externalValidatorPath}; git status --short`,
+  ]) {
+    const decision = evaluateCommandPolicy(inspectionCommand, opaqueValidatorPolicy);
+    assert(
+      decision.allowed === false &&
+        decision.category === "opaque-external-validator-inspection" &&
+        decision.recoverable === true,
+      `external validator source inspection escaped the opaque contract: ${inspectionCommand}`
+    );
+  }
+
   const genericArtifactBlock = await genericArtifactFilenameBlock(
     "write_file",
     { path: "report.md", content: "summary" },

package/scripts/smoke-document-artifact-quality.js

@@ -8,6 +8,43 @@ import {
   evaluatePdfTextBounds,
   extractSupersededLiterals,
 } from "../src/document-artifact-quality.js";
+import { evaluateSpreadsheetStructure } from "../src/spreadsheet-artifact-quality.js";
+
+const workbookWithPlaceholder = evaluateSpreadsheetStructure({
+  sheets: [
+    { name: "Sheet", state: "visible", cellCount: 0, formulaCount: 0 },
+    { name: "Raw Inventory", state: "visible", cellCount: 30, formulaCount: 0 },
+    { name: "Reorder Plan", state: "visible", cellCount: 20, formulaCount: 8 },
+  ],
+  chartCount: 1,
+  externalLinkCount: 0,
+  hasMacros: false,
+});
+assert.equal(workbookWithPlaceholder.ok, false, "an empty default workbook sheet was accepted");
+assert.equal(workbookWithPlaceholder.defects[0]?.code, "unused-default-worksheet");
+
+const emptyWorkbook = evaluateSpreadsheetStructure({
+  sheets: [{ name: "Sheet", state: "visible", cellCount: 0, formulaCount: 0 }],
+  chartCount: 0,
+  externalLinkCount: 0,
+  hasMacros: false,
+});
+assert.equal(emptyWorkbook.ok, false, "a completely empty workbook was accepted");
+assert.equal(emptyWorkbook.defects[0]?.code, "workbook-has-no-content");
+
+const purposefulWorkbook = evaluateSpreadsheetStructure({
+  sheets: [
+    { name: "Raw Inventory", state: "visible", cellCount: 30, formulaCount: 0 },
+    { name: "Reorder Plan", state: "visible", cellCount: 20, formulaCount: 8 },
+    { name: "Dashboard", state: "visible", cellCount: 12, formulaCount: 3 },
+  ],
+  chartCount: 1,
+  externalLinkCount: 0,
+  hasMacros: false,
+});
+assert.equal(purposefulWorkbook.ok, true, "a workbook with only purposeful sheets was rejected");
+assert.equal(purposefulWorkbook.formulaCount, 11);
+assert.equal(purposefulWorkbook.chartCount, 1);
 
 const source = [
   "Initial plan: the demonstration date was September 12.",

package/scripts/smoke-dynamic-step-budget.js

@@ -53,6 +53,7 @@ import {
   isSubstantiveTestCommand,
   mergeDurableGitEvidence,
   nextStepRuntimeConfig,
+  patchContextRefreshDecision,
   patchContextScopeMismatchAttemptCount,
   parseGitPorcelainStatus,
   pythonMainGuardOrderDefects,
@@ -1216,6 +1217,100 @@ try {
       Boolean(unrelatedInsertionBinding?.scopeIssue),
     "an unrelated missing declaration escaped the active failed-test symbol contract"
   );
+  const declarationBoundarySource = [
+    "def build_preview():",
+    "    path = 'preview.png'",
+    "    return path",
+    "",
+    "def main():",
+    "    return build_preview()",
+    "",
+  ].join("\n");
+  const declarationBoundaryOffset = declarationBoundarySource.indexOf("def main():");
+  const declarationBoundaryAnchor = declarationBoundarySource.slice(
+    0,
+    declarationBoundaryOffset
+  );
+  const declarationBoundaryState = {
+    meta: {
+      goalContract: { revision: 1 },
+      projectVerification: { mutationRevision: 1, privateMutationRevision: 0 },
+      toolLoop: {
+        patchContextRepair: {
+          version: 1,
+          path: "preview_builder.py",
+          goalRevision: 1,
+          mutationRevision: 1,
+          privateMutationRevision: 0,
+          search: declarationBoundaryAnchor,
+          searchHash: crypto
+            .createHash("sha256")
+            .update(declarationBoundaryAnchor)
+            .digest("hex"),
+          sourceHash: crypto
+            .createHash("sha256")
+            .update(declarationBoundarySource)
+            .digest("hex"),
+          anchorKind: "declaration-identity",
+          anchorIdentity: "build_preview",
+        },
+      },
+    },
+  };
+  const declarationBoundaryBinding = bindPatchContextRepairArguments(
+    declarationBoundaryState,
+    {
+      replace: [
+        "def build_preview():",
+        "    path = 'preview-fixed.png'",
+        "    return path",
+      ].join("\n"),
+    }
+  );
+  assert(
+    declarationBoundaryBinding?.boundaryWhitespacePreserved === true &&
+      declarationBoundaryBinding.args.replace.endsWith("\n") &&
+      /return path\n+def main\(\):/.test(
+        `${declarationBoundaryBinding.args.replace}${declarationBoundarySource.slice(declarationBoundaryOffset)}`
+      ),
+    "revision-bound declaration replacement did not preserve its Python declaration boundary"
+  );
+  await fs.writeFile(
+    path.join(workspace, "preview_builder.py"),
+    declarationBoundarySource,
+    "utf8"
+  );
+  assert(
+    (await prospectivePythonExactPatchSyntaxBlock(
+      "apply_patch",
+      declarationBoundaryBinding.args,
+      { commandCwd: workspace }
+    )) === null,
+    "the boundary-preserved declaration replacement still produced invalid Python"
+  );
+  const syntaxRefreshDecision = patchContextRefreshDecision(
+    {
+      meta: {
+        goalContract: { revision: 1 },
+        projectVerification: { mutationRevision: 1, privateMutationRevision: 0 },
+        toolLoop: { stagnationEpoch: 0, recent: [] },
+      },
+    },
+    {
+      toolName: "apply_patch",
+      ok: false,
+      category: "python-syntax-regression",
+      args: {
+        path: "preview_builder.py",
+        search: declarationBoundaryAnchor,
+      },
+    }
+  );
+  assert(
+    syntaxRefreshDecision?.triggerCategory === "python-syntax-regression" &&
+      syntaxRefreshDecision.path === "preview_builder.py",
+    "a prospective Python syntax regression did not force a fresh exact-source read"
+  );
   const semanticScopeMismatchState = {
     meta: {
       goalContract: { revision: 4 },
@@ -5444,6 +5539,43 @@ try {
   );
   const generatedDeckValidator =
     `python3 ${generatedDeckValidatorPath} --root .`;
+  const opaqueExternalValidatorState = {
+    goal: [
+      "Create the requested workbook from the local inputs.",
+      `Run exactly: \`${generatedDeckValidator}\``,
+      "Do not edit that external validator.",
+    ].join("\n"),
+    meta: {
+      taskProfile: "data",
+      goalContract: {
+        revision: 1,
+        currentRequest: "Create the requested workbook and run the exact validator.",
+      },
+      projectVerification: {
+        mutationRevision: 0,
+        mutationHistory: [],
+        commandRuns: [],
+        testRuns: [],
+      },
+      toolLoop: { recent: [] },
+    },
+  };
+  const opaqueExternalValidatorRuntime = nextStepRuntimeConfig(
+    {
+      provider: "deepseek",
+      taskProfile: "data",
+      commandCwd: workspace,
+      goal: opaqueExternalValidatorState.goal,
+    },
+    opaqueExternalValidatorState
+  );
+  assert(
+    JSON.stringify(opaqueExternalValidatorRuntime.opaqueExternalValidatorPaths) ===
+      JSON.stringify([generatedDeckValidatorPath]) &&
+      JSON.stringify(opaqueExternalValidatorRuntime.opaqueExternalValidatorCommands) ===
+        JSON.stringify([generatedDeckValidator]),
+    "an exact external validator was not retained as an opaque execute-only contract before its first run"
+  );
   await fs.writeFile(
     path.join(workspace, "build_deck.py"),
     "print('build canonical deck')\n",
@@ -10364,6 +10496,60 @@ try {
   assert(resumedBudget?.extensionsUsed === 0, "runAgent retained stale extension usage after an explicit resumed max-steps patch");
   assert(resumedBudget?.resetFromExplicitOverride === true, "runAgent did not record the explicit budget reset boundary");
 
+  const educationWorkspace = path.join(tempRoot, "education-artifact-contract");
+  await fs.mkdir(path.join(educationWorkspace, "workshop"), { recursive: true });
+  await fs.writeFile(path.join(educationWorkspace, "workshop", "lesson-deck.md"), "# Lesson\n");
+  const educationGoal =
+    "Create an editable lesson deck, a separate practice sheet and answer key, printable materials, a helpful preview, and a reproducible build entrypoint. Verify and commit the work.";
+  const educationState = {
+    goal: educationGoal,
+    commandCwd: educationWorkspace,
+    plan: "Create every requested artifact, verify them, and commit the complete set.",
+    messages: [
+      {
+        role: "tool",
+        content: JSON.stringify({
+          ok: true,
+          toolName: "write_file",
+          path: "workshop/lesson-deck.md",
+          goalRevision: 1,
+          projectMutationRevision: 1,
+        }),
+      },
+    ],
+    meta: {
+      taskProfile: "education",
+      goalContract: {
+        revision: 1,
+        currentRequest: educationGoal,
+        taskGoal: educationGoal,
+        activeGoalRevision: 1,
+        lifecycle: [{ at: new Date(Date.now() - 2000).toISOString() }],
+      },
+      projectVerification: {
+        mutationRevision: 1,
+        mutationHistory: [
+          {
+            revision: 1,
+            at: new Date().toISOString(),
+            toolName: "write_file",
+            paths: ["workshop/lesson-deck.md"],
+            goalRevision: 1,
+          },
+        ],
+      },
+    },
+  };
+  const incompleteEducationRuntime = nextStepRuntimeConfig(
+    { goal: educationGoal, taskProfile: "education", commandCwd: educationWorkspace },
+    educationState
+  );
+  assert(
+    incompleteEducationRuntime.requestedArtifactRequirementsPending === true &&
+      incompleteEducationRuntime.taskOwnedCommitPending !== true,
+    "a partial multi-artifact task entered task-owned Git completion before its deliverables existed"
+  );
+
   await fs.rm(tempRoot, { recursive: true, force: true });
   console.log("smoke-dynamic-step-budget ok");
 } catch (error) {

package/scripts/smoke-scs-evidence-visibility.js

@@ -12,6 +12,7 @@ import {
 import {
   buildScsEvidenceLedger,
   deriveScsTaskContract,
+  evaluateRequestedArtifactRequirements,
   evaluateScsSemanticContract,
   extractMarkdownCommandEvidence,
   extractMarkdownPathEvidence,
@@ -19,6 +20,73 @@ import {
   finishResultClaimsIncompleteWork,
 } from "../src/scs-evidence.js";
 
+const educationArtifactGoal =
+  "Create an editable lesson deck, a separate practice sheet and answer key, printable materials, a helpful preview, and a reproducible build entrypoint.";
+const educationArtifactContract = deriveScsTaskContract({
+  goal: educationArtifactGoal,
+  taskProfile: "education",
+});
+assert.deepEqual(
+  educationArtifactContract.requiredArtifactKinds.map((item) => item.id).sort(),
+  [
+    "answer-material",
+    "editable-presentation",
+    "practice-material",
+    "printable-document",
+    "reproducible-build-entrypoint",
+    "visual-preview",
+  ],
+  "multi-artifact education request did not retain each semantic deliverable"
+);
+assert.deepEqual(
+  deriveScsTaskContract({
+    goal: "Create a canvas artifact preview for this smoke test.",
+    taskProfile: "auto",
+  }).requiredArtifactKinds,
+  [],
+  "a generic frontend canvas preview was incorrectly converted into a required image-file artifact"
+);
+const educationWorkspace = fs.mkdtempSync(path.join(os.tmpdir(), "aginti-education-artifacts-"));
+const educationState = {
+  meta: {
+    goalContract: {
+      lifecycle: [{ at: new Date(Date.now() - 2000).toISOString() }],
+    },
+    projectVerification: { mutationHistory: [] },
+  },
+};
+fs.mkdirSync(path.join(educationWorkspace, "workshop"), { recursive: true });
+fs.writeFileSync(path.join(educationWorkspace, "workshop", "lesson-deck.md"), "# Lesson deck\n");
+const incompleteEducationArtifacts = evaluateRequestedArtifactRequirements(
+  educationArtifactContract,
+  { commandCwd: educationWorkspace, state: educationState }
+);
+assert.equal(incompleteEducationArtifacts.ok, false);
+assert.ok(
+  incompleteEducationArtifacts.missing.some((item) => item.id === "editable-presentation"),
+  "Markdown-only deck incorrectly satisfied the editable presentation contract"
+);
+for (const [name, content] of [
+  ["lesson-deck.pptx", "pptx"],
+  ["practice-sheet.md", "practice"],
+  ["answer-key.md", "answers"],
+  ["practice-sheet.pdf", "pdf"],
+  ["lesson-preview.png", "png"],
+  ["build_materials.py", "print('build')\n"],
+]) {
+  fs.writeFileSync(path.join(educationWorkspace, "workshop", name), content);
+}
+const completeEducationArtifacts = evaluateRequestedArtifactRequirements(
+  educationArtifactContract,
+  { commandCwd: educationWorkspace, state: educationState }
+);
+assert.equal(
+  completeEducationArtifacts.ok,
+  true,
+  `complete semantic artifact set was rejected: ${completeEducationArtifacts.reason}`
+);
+fs.rmSync(educationWorkspace, { recursive: true, force: true });
+
 function fakeStudentClient(json) {
   return {
     chat: {

package/scripts/smoke-web-api.js

@@ -68,12 +68,23 @@ async function waitForHealth() {
 async function waitForRun(sessionId, terminalStatuses = ["finished", "failed"]) {
   const acceptedStatuses = new Set(terminalStatuses);
   const deadline = Date.now() + 20000;
+  let lastRun = null;
   while (Date.now() < deadline) {
     const run = await fetchJson(`/api/runs/${encodeURIComponent(sessionId)}`);
+    lastRun = run;
     if (acceptedStatuses.has(run.status)) return run;
     await delay(400);
   }
-  throw new Error(`run ${sessionId} did not finish in time`);
+  throw new Error(
+    `run ${sessionId} did not finish in time; ` +
+      `lastRun=${JSON.stringify(lastRun ? {
+        status: lastRun.status,
+        error: lastRun.error,
+        endedAt: lastRun.endedAt,
+        logs: Array.isArray(lastRun.logs) ? lastRun.logs.slice(-12) : [],
+      } : null)} ` +
+      `stdout=${stdout.slice(-1000)} stderr=${stderr.slice(-1000)}`
+  );
 }
 
 try {