@lazyingart/agintiflow 0.20.237 → 0.20.238

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.237",
+  "version": "0.20.238",
   "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-document-artifact-quality.js

@@ -3,7 +3,9 @@ import assert from "node:assert/strict";
 import {
   evaluateCurrentStateText,
   evaluateDocumentConsistency,
+  evaluateExtractedDocumentText,
   evaluatePdfPageBalance,
+  evaluatePdfTextBounds,
   extractSupersededLiterals,
 } from "../src/document-artifact-quality.js";
 
@@ -122,4 +124,21 @@ const readableOnePage = evaluatePdfPageBalance(
 );
 assert.equal(readableOnePage.ok, true, "readable one-page typography was rejected");
 
+const cleanExtractedText = evaluateExtractedDocumentText("Page one\n\fPage two\tvalue\r\n");
+assert.equal(cleanExtractedText.ok, true, "normal whitespace and PDF form feeds were rejected");
+
+const corruptExtractedText = evaluateExtractedDocumentText("Reference detector \u0016 complete \ufffd");
+assert.equal(corruptExtractedText.ok, false, "control and replacement glyphs were accepted");
+assert.deepEqual(corruptExtractedText.codePoints, [0x16, 0xfffd]);
+assert.equal(corruptExtractedText.defects[0]?.code, "corrupt-extracted-text");
+
+const boundedText = evaluatePdfTextBounds(`<doc>${page(20)}</doc>`);
+assert.equal(boundedText.ok, true, "text inside readable margins was rejected");
+
+const clippedText = evaluatePdfTextBounds(
+  '<doc><page width="595" height="842"><word xMin="8" yMin="60" xMax="90" yMax="70">clipped</word></page></doc>'
+);
+assert.equal(clippedText.ok, false, "text outside readable margins was accepted");
+assert.equal(clippedText.defects[0]?.code, "pdf-text-outside-readable-margin");
+
 console.log("document artifact quality smoke test passed");

package/scripts/smoke-model-roles.js

@@ -29,7 +29,13 @@ import {
   shouldActivateScs,
   shouldRequestScsReplan,
 } from "../src/scs-controller.js";
-import { buildScsEvidenceLedger, deriveScsTaskContract, evaluateScsEvidence } from "../src/scs-evidence.js";
+import {
+  buildScsEvidenceLedger,
+  deriveScsTaskContract,
+  evaluateScsEvidence,
+  gitActionsSatisfyContract,
+  inferSuccessfulGitActionsFromCommandResult,
+} from "../src/scs-evidence.js";
 import { resolveRuntimeConfig } from "../src/config.js";
 import { classifyGoalIntent, isDirectAnswerIntent } from "../src/goal-intent.js";
 import { languageWriterDefaults } from "../src/writing-specialist.js";
@@ -922,6 +928,26 @@ assert(
     !committedEvaluation.missing.some((item) => item.category === "git"),
   "a successful git commit did not satisfy the explicit git requirement"
 );
+const recoveredCommitActions = inferSuccessfulGitActionsFromCommandResult({
+  ok: true,
+  exitCode: 0,
+  args: {
+    command:
+      'echo "seed author: $(git log -1 --format=\'%an <%ae>\')"; git config user.name "$(git log -1 --format=\'%an\')"; git commit -m "finish handoff" && git log -1 --oneline',
+  },
+  stdout: "[main abc1234] finish handoff\n 8 files changed, 499 insertions(+)",
+});
+assert(
+  recoveredCommitActions.length === 1 && recoveredCommitActions[0] === "commit",
+  "a canonical successful commit was lost because its command had a setup prefix or shell expansion"
+);
+assert(
+  gitActionsSatisfyContract(
+    { requiredGitActions: ["add", "commit"] },
+    recoveredCommitActions
+  ),
+  "a successful commit did not satisfy the implied staging step after a partially successful add/commit chain"
+);
 const explainCodeContract = deriveScsTaskContract({
   goal: "Explain JavaScript closures at a high level.",
   taskProfile: "code",

package/skills/word-documents/SKILL.md

@@ -20,3 +20,16 @@ tools:
 Prefer safe conversions through available tools such as `pandoc`, `libreoffice`, or Python libraries when installed. Preserve originals; write converted or edited outputs to a new file unless overwrite is explicit.
 
 If binary `.docx` content cannot be inspected directly, explain the needed converter and create a project-local script or setup note.
+
+For a repository handoff or generated document project:
+
+- synthesize the authoritative current state instead of narrating superseded values unless history was requested;
+- keep editable source plus the requested reader format, normally DOCX and a phone-readable PDF;
+- provide and document a conventional project-local `build.sh` entry point, even when it delegates to a Python or TeX implementation;
+- make a clean-checkout build provision or clearly verify its dependencies rather than relying silently on the current shell;
+- preserve source inputs byte-for-byte and keep session data, visual-inspection renders, LaTeX intermediates, caches, and other transient evidence ignored; prefer ignore rules over deleting evidence, and never couple cleanup commands to the build or validation command;
+- validate extracted DOCX/PDF text for current facts, stale or private values, encoding damage, and missing action/evidence content;
+- render every PDF page and inspect it for clipping, overlap, orphaned headings, sparse spill pages, readable margins, and phone-scale readability;
+- when the task is in a git repository and requests a finished handoff, commit only intentional project files and finish with a clean worktree unless the user says not to commit.
+
+Visual polish does not establish content quality. Cross-check names, dates, totals, counts, statuses, decisions, actions, risks, evidence, and limitations against the source material before completion.

package/src/document-artifact-quality.js

@@ -30,6 +30,7 @@ const INTENTIONAL_SPARSE_PAGE_PATTERN =
 const HISTORICAL_TRANSITION_PATTERN =
   /\b(?:formerly|no longer|previously|replac(?:ed|ing)|supersed(?:e|ed|es|ing)|used to be)\b/i;
 const MIN_READABLE_MEDIAN_WORD_HEIGHT_PT = 8.8;
+const MIN_READABLE_HORIZONTAL_MARGIN_PT = 18;
 const COUNT_WORDS = new Map([
   ["zero", 0], ["one", 1], ["two", 2], ["three", 3], ["four", 4], ["five", 5],
   ["six", 6], ["seven", 7], ["eight", 8], ["nine", 9], ["ten", 10],
@@ -239,6 +240,49 @@ export function evaluatePdfPageBalance(bboxXml = "") {
   };
 }
 
+export function evaluateExtractedDocumentText(text = "") {
+  const unexpected = [...String(text || "").matchAll(/[\u0000-\u0008\u000b\u000e-\u001f\u007f-\u009f\ufffd]/gu)]
+    .map((match) => match[0].codePointAt(0))
+    .filter(Number.isInteger);
+  const codePoints = [...new Set(unexpected)].sort((a, b) => a - b);
+  const defects = [];
+  if (codePoints.length) {
+    defects.push({
+      code: "corrupt-extracted-text",
+      message: `The independently extracted reader text contains unexpected control or replacement glyphs: ${codePoints
+        .map((value) => `U+${value.toString(16).toUpperCase().padStart(4, "0")}`)
+        .join(", ")}. Repair the document encoding or generator instead of stripping these bytes only during validation.`,
+    });
+  }
+  return { ok: defects.length === 0, defects, codePoints };
+}
+
+export function evaluatePdfTextBounds(bboxXml = "", minimumMargin = MIN_READABLE_HORIZONTAL_MARGIN_PT) {
+  const pages = parsePdfBboxPages(bboxXml);
+  const defects = [];
+  for (const [index, page] of pages.entries()) {
+    if (!Number.isFinite(page.width) || page.width <= 0) continue;
+    const outside = page.words.filter((word) =>
+      word.text && (
+        !Number.isFinite(word.xMin) ||
+        !Number.isFinite(word.xMax) ||
+        word.xMin < minimumMargin ||
+        word.xMax > page.width - minimumMargin
+      )
+    );
+    if (!outside.length) continue;
+    const sample = outside
+      .slice(0, 4)
+      .map((word) => `${JSON.stringify(word.text)} at ${Number(word.xMin).toFixed(1)}..${Number(word.xMax).toFixed(1)} pt`)
+      .join("; ");
+    defects.push({
+      code: "pdf-text-outside-readable-margin",
+      message: `PDF page ${index + 1} places ${outside.length} text item${outside.length === 1 ? "" : "s"} outside the ${minimumMargin} pt horizontal readability margin (${sample}). Reflow the text or table instead of accepting clipping.`,
+    });
+  }
+  return { ok: pages.length > 0 && defects.length === 0, checked: pages.length > 0, defects };
+}
+
 export function evaluateCurrentStateText({ sourceText = "", outputText = "", currentStateRequired = false } = {}) {
   const supersededLiterals = extractSupersededLiterals(sourceText);
   const presentSupersededLiterals = supersededLiterals.filter((literal) => containsLiteral(outputText, literal));
@@ -475,9 +519,11 @@ export async function validateWordDocumentArtifacts({
     try {
       if (artifact.extension === ".pdf") {
         const extracted = await extractPdf(artifact);
+        const textQuality = evaluateExtractedDocumentText(extracted.text);
         const semantic = evaluateCurrentStateText({ sourceText, outputText: extracted.text, currentStateRequired });
         const consistency = evaluateDocumentConsistency(extracted.text);
         const pageBalance = evaluatePdfPageBalance(extracted.bbox);
+        const textBounds = evaluatePdfTextBounds(extracted.bbox);
         if (!String(extracted.text || "").trim()) {
           defects.push({
             code: "empty-pdf-text",
@@ -493,8 +539,10 @@ export async function validateWordDocumentArtifacts({
           });
         }
         defects.push(...semantic.defects.map((item) => ({ ...item, path: artifact.path })));
+        defects.push(...textQuality.defects.map((item) => ({ ...item, path: artifact.path })));
         defects.push(...consistency.defects.map((item) => ({ ...item, path: artifact.path })));
         defects.push(...pageBalance.defects.map((item) => ({ ...item, path: artifact.path })));
+        defects.push(...textBounds.defects.map((item) => ({ ...item, path: artifact.path })));
         artifactReports.push({
           path: artifact.path,
           extension: artifact.extension,
@@ -506,6 +554,7 @@ export async function validateWordDocumentArtifacts({
         });
       } else {
         const text = await extractDocxText(artifact);
+        const textQuality = evaluateExtractedDocumentText(text);
         const semantic = evaluateCurrentStateText({ sourceText, outputText: text, currentStateRequired });
         const consistency = evaluateDocumentConsistency(text);
         if (!String(text || "").trim()) {
@@ -516,6 +565,7 @@ export async function validateWordDocumentArtifacts({
           });
         }
         defects.push(...semantic.defects.map((item) => ({ ...item, path: artifact.path })));
+        defects.push(...textQuality.defects.map((item) => ({ ...item, path: artifact.path })));
         defects.push(...consistency.defects.map((item) => ({ ...item, path: artifact.path })));
         artifactReports.push({
           path: artifact.path,

package/src/scs-evidence.js

@@ -204,7 +204,20 @@ function missingRequiredGitActionSequence(required = [], observed = []) {
   let cursor = 0;
   for (let index = 0; index < expected.length; index += 1) {
     const observedIndex = actual.indexOf(expected[index], cursor);
-    if (observedIndex < 0) return expected.slice(index);
+    if (observedIndex < 0) {
+      // A successful commit proves that an index was staged, even when the
+      // preceding `git add` happened in an earlier partially successful shell
+      // chain or the commit used `-a`. Preserve the requested add -> commit
+      // order without forcing the model to repeat a completed commit.
+      if (expected[index] === "add" && expected[index + 1] === "commit") {
+        const commitIndex = actual.indexOf("commit", cursor);
+        if (commitIndex >= 0) {
+          cursor = commitIndex;
+          continue;
+        }
+      }
+      return expected.slice(index);
+    }
     cursor = observedIndex + 1;
   }
   if (expected.at(-1) === "push") {
@@ -1070,7 +1083,20 @@ export function inferSuccessfulGitActionsFromCommandResult(payload = {}) {
     return inferGitActionsFromCommand(exitWrapper.command);
   }
   if (payload.ok === false || Number(payload.exitCode ?? 0) !== 0) return [];
-  return inferGitActionsFromCommand(command);
+  const inferred = inferGitActionsFromCommand(command);
+  if (inferred.length) return inferred;
+
+  // Shell expansion or a setup prefix can make the full command ambiguous to
+  // the static parser. A canonical successful commit line plus an explicit
+  // top-level `git commit` still provides concrete commit evidence.
+  const output = String(payload.stdout || payload.result || "");
+  if (
+    /(?:^|[;&|]\s*)git\s+commit\b/i.test(command) &&
+    /^\[[^\]\n]+\s+[0-9a-f]{7,}\]\s+\S+/mi.test(output)
+  ) {
+    return ["commit"];
+  }
+  return [];
 }
 
 function observedProjectCommandSatisfies(requiredCommand = "", item = {}) {