@lazyingart/agintiflow 0.20.301 → 0.20.302

package/README.md

@@ -39,6 +39,7 @@ The two screenshots below match the current website hero: terminal-first launch
 | Website | [https://flow.lazying.art](https://flow.lazying.art) |
 | GitHub | [https://github.com/lazyingart/AgInTiFlow](https://github.com/lazyingart/AgInTiFlow) |
 | npm | [https://www.npmjs.com/package/@lazyingart/agintiflow](https://www.npmjs.com/package/@lazyingart/agintiflow) |
+| npm package chart | [https://npm.chart.dev/@lazyingart/agintiflow](https://npm.chart.dev/@lazyingart/agintiflow) |
 | AAPS npm | [https://www.npmjs.com/package/@lazyingart/aaps](https://www.npmjs.com/package/@lazyingart/aaps) |
 | Product positioning | [references/agintiflow-product-positioning.md](references/agintiflow-product-positioning.md) |
 | Full archived README reference | [references/notes/readme-full-reference-2026-05-05.md](references/notes/readme-full-reference-2026-05-05.md) |

package/docs/supervision-campaign-ledger.md

@@ -588,3 +588,65 @@ fallback derives a concise public answer from the successful bounded command
 output. JSON status snapshots summarize visible delivered/retrying schedule
 states, ingress reachability, queue counts, and top-level health while keeping
 the original SCS checks for genuinely unfinished agent work.
+
+### Retained tmux Git completion evidence
+
+`labcanvas-mix2s-recovery-review-061` exposed a restart boundary in supervised
+project work. The retained AgInTi session had sent a marked commit command to a
+project-owned tmux pane, captured the canonical successful commit output, and
+left the target worktree clean at `90d61bb`. SCS still rejected completion
+after resume because the durable event ledger did not reconstruct that tmux
+sequence as a consequential Git action.
+
+AgInTiFlow now binds an explicit uppercase start marker and requested Git
+action to the exact tmux target, accepts a commit only when the same pane later
+contains canonical commit output plus a zero exit marker, and preserves the
+tail of truncated captures. Restart reconciliation replays the ordered
+`tool.started`, successful `tmux_send_keys`, and successful same-pane capture
+events to recover goal- and mutation-revision-scoped evidence. Failed sends,
+wrong panes, stale markers, and nonzero exits remain rejected.
+
+The real retained session then finished without repeating the commit or any
+external side effect. The complete npm suite, focused evidence regressions, and
+registry installation passed. The fix is released as AgInTiFlow `0.20.301`.
+
+### Context-complete document repair and semantic validation
+
+Memo retests `082` through `084` exercised a retained LocalLLM document task
+against a realistic mixed-language chat history. The task required a compiled
+PDF, faithful current-state reconciliation, and a committed artifact. The
+campaign exposed three independent AgInTiFlow runtime gaps rather than a
+LabCanvas-specific routing problem.
+
+In `082`, the TeX compiler repeatedly identified one exact line containing an
+unescaped underscore. After several valid repairs, the provider ignored the
+remaining narrow patch schema and attempted to replace the whole document.
+AgInTiFlow now derives the mechanically safe replacement from the compiler
+diagnostic and current source, constrains the trusted patch contract to that
+replacement, and can recover an invalid broad model patch into the exact
+evidence-derived edit. The recovery is limited to one active
+revision-bound producer diagnostic and cannot generalize into an arbitrary
+rewrite.
+
+In `083`, the provider repaired a quality defect by deleting the remainder of
+the TeX document. Patch anchoring now recognizes LaTeX section boundaries and
+binds a defect to its containing section. A replacement is rejected when it
+changes the net balance of revision-bound LaTeX environments, preventing a
+local list repair from dropping later sections or environment terminators.
+
+In `084`, the provider produced and committed a syntactically valid PDF that
+described the document-generation process but omitted the substantive source
+topics. Document validation now extracts bounded salient topic anchors from a
+complete-context source and requires representative coverage when the request
+explicitly asks for complete, reconciled, or context-complete output. It also
+preserves unverified source status, rejects contradictory completion claims,
+validates LaTeX source structure, and keeps decimal measurements such as
+`0.25 mm` intact during status parsing.
+
+The release also preserves requested artifact and project contracts across
+compaction, replays failed requested PDF producers without repeating successful
+side effects, retains exact compiler lines through bounded retries, rejects
+append-only repairs when replacement is required, and caps repair schemas so a
+small local model receives only the actionable tool surface. Focused coding,
+truthful-completion, writing-routing, progressive-tool, document-quality, and
+dynamic-budget suites pass. These fixes are prepared for AgInTiFlow `0.20.302`.

package/package.json

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

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 import {
   buildModelTimeoutRetryMessages,
   genericArtifactFilenameBlock,
+  goalClearlyAllowsOverwrite,
   modelTimeoutExhaustionRoute,
   modelTimeoutRetryRoute,
   normalizeNoMatchQueryResult,
@@ -917,6 +918,14 @@ try {
       exactPdfHeaderAuditPolicy.writesWorkspace === false,
     "a bounded workspace-local PDF header audit incorrectly required destructive host permission"
   );
+  const pdfinfoPolicy = evaluateCommandPolicy("pdfinfo report.pdf", hostWorkspacePolicy);
+  assert(
+    pdfinfoPolicy.allowed &&
+      pdfinfoPolicy.category === "read-only" &&
+      pdfinfoPolicy.needsNetwork === false &&
+      pdfinfoPolicy.writesWorkspace === false,
+    "plain workspace-local pdfinfo inspection incorrectly required host permission"
+  );
   for (const unsafeXxdCommand of [
     "xxd -r - output.bin",
     "xxd report.pdf output.hex",
@@ -1181,12 +1190,40 @@ try {
   );
   assert(pdflatexCompilePolicy.allowed, "workspace-local pdflatex compile should be allowed without package installs");
   assert(pdflatexCompilePolicy.category === "toolchain", "workspace-local pdflatex compile should be classified as toolchain");
+  for (const engine of ["xelatex", "lualatex"]) {
+    const unicodeLatexCompilePolicy = evaluateCommandPolicy(
+      `${engine} -interaction=nonstopmode -halt-on-error main.tex`,
+      hostWorkspacePolicy
+    );
+    assert(unicodeLatexCompilePolicy.allowed, `workspace-local ${engine} compile should be allowed without destructive host access`);
+    assert(unicodeLatexCompilePolicy.category === "toolchain", `workspace-local ${engine} compile should be classified as toolchain`);
+  }
   const latexmkCompilePolicy = evaluateCommandPolicy(
     'cd profile-latex-20260506 && latexmk -pdf main.tex 2>&1; echo "LATEXMK_EXIT:$?"',
     dockerWorkspaceNoInstallsPolicy
   );
   assert(latexmkCompilePolicy.allowed, "workspace-local latexmk compile should be allowed without package installs");
   assert(latexmkCompilePolicy.category === "toolchain", "workspace-local latexmk compile should be classified as toolchain");
+  const latexmkSynctexCompilePolicy = evaluateCommandPolicy(
+    "latexmk -synctex=1 -interaction=nonstopmode main.tex",
+    dockerWorkspaceNoInstallsPolicy
+  );
+  assert(
+    latexmkSynctexCompilePolicy.allowed,
+    "bounded workspace-local latexmk synctex compile should be allowed"
+  );
+  assert(
+    latexmkSynctexCompilePolicy.category === "toolchain",
+    "bounded workspace-local latexmk synctex compile should be classified as toolchain"
+  );
+  assert(
+    goalClearlyAllowsOverwrite("Remove the unrelated article and produce the requested memo."),
+    "explicit removal of a wrong artifact did not authorize its coherent replacement"
+  );
+  assert(
+    goalClearlyAllowsOverwrite("删除错误文件后生成正确报告。"),
+    "explicit Chinese deletion request did not authorize coherent replacement"
+  );
   const pythonUnittestPolicy = evaluateCommandPolicy(
     "python3 -m unittest test_data_helper.py 2>&1",
     dockerWorkspaceNoInstallsPolicy

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

@@ -1,11 +1,20 @@
 import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
 
 import {
+  collectDocumentSourceDocuments,
+  currentStateRequested,
+  documentArtifactVersioningDefect,
   evaluateCurrentStateText,
   evaluateDocumentConsistency,
   evaluateExtractedDocumentText,
+  evaluateLatexSourceStructure,
   evaluatePdfPageBalance,
   evaluatePdfTextBounds,
+  evaluateSourceTopicCoverage,
+  evaluateUnverifiedSourceCompletionClaims,
   extractSupersededLiterals,
 } from "../src/document-artifact-quality.js";
 import { evaluateSpreadsheetStructure } from "../src/spreadsheet-artifact-quality.js";
@@ -82,6 +91,121 @@ const currentDocument = evaluateCurrentStateText({
 });
 assert.equal(currentDocument.ok, true, "authoritative current-state prose was rejected");
 
+const multilingualUnverifiedSource = [
+  "09:40 Lachlan: 我把一本显微成像的 PDF 发到群里了。请保存到 Downloads/Books，并同步 Nutstore 私人备份。",
+  "17:40 Lachlan: 今日真正完成：JLC 已付款；adapter 已验证；书籍归档请求已收到。书是否真的同步成功需要查证后才能写完成。",
+].join("\n");
+const unsupportedBookCompletion = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: multilingualUnverifiedSource,
+  outputText: "Completed Today\nBook on microscopy archived to Downloads/Books and synced to Nutstore.",
+});
+assert.equal(unsupportedBookCompletion.ok, false, "an unverified cross-language backup was reported as completed");
+assert(
+  unsupportedBookCompletion.defects.some((item) => item.code === "source-unverified-completion-claim"),
+  "an unsupported completion claim did not produce a precise source-status defect"
+);
+const preservedBookUncertainty = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: multilingualUnverifiedSource,
+  outputText: "Pending\nVerify whether the microscopy book reached Nutstore; the archive request was received only.",
+});
+assert.equal(preservedBookUncertainty.ok, true, "a correctly preserved unverified source state was rejected");
+
+const contextCompleteChatSource = [
+  "08:07 Lachlan: Instagram retry must reuse the existing LazyEdit output.",
+  "09:02 Sunny: Dataset publication permission remains unconfirmed.",
+  "09:40 Lachlan: Archive the microscopy PDF and verify the Nutstore backup.",
+  "10:15 Lachlan: Record the 5V 400mA PCB idea only; do not manufacture it.",
+  "14:04 Lachlan: The M10-to-M6 adapter is assembled and verified.",
+  "17:40 Lachlan: JLC is paid, but the book backup is still unverified.",
+].join("\n");
+const genericProcessOnlyReport = evaluateSourceTopicCoverage({
+  goal: "Read the complete chat history and produce a context-complete report.",
+  sourceText: contextCompleteChatSource,
+  outputText:
+    "This report read the source and created a structured LaTeX document. The PDF is ready for verification.",
+});
+assert.equal(
+  genericProcessOnlyReport.ok,
+  false,
+  "a process-only report passed despite omitting every salient source topic"
+);
+assert(
+  genericProcessOnlyReport.defects.some(
+    (item) => item.code === "source-topic-coverage-incomplete"
+  ),
+  "missing source topic coverage did not produce a precise semantic defect"
+);
+const contextGroundedReport = evaluateSourceTopicCoverage({
+  goal: "Read the complete chat history and produce a context-complete report.",
+  sourceText: contextCompleteChatSource,
+  outputText: [
+    "Retry Instagram from the existing LazyEdit result only.",
+    "Wait for Sunny before dataset publication and verify the Nutstore book backup.",
+    "JLC is already paid and the M10-to-M6 adapter is verified.",
+    "Keep the 5V 400mA PCB item as a note; do not manufacture it.",
+  ].join(" "),
+});
+assert.equal(
+  contextGroundedReport.ok,
+  true,
+  `a report grounded in the source topics was rejected: ${JSON.stringify(contextGroundedReport)}`
+);
+const contradictoryBookCompletion = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: multilingualUnverifiedSource,
+  outputText: "Completed Today\nMicroscopy PDF archived to Downloads/Books and synced to Nutstore (verification pending).",
+});
+assert.equal(
+  contradictoryBookCompletion.ok,
+  false,
+  "a positive completion claim escaped validation merely by appending a pending-verification qualifier"
+);
+const unrelatedVerifiedCompletion = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: multilingualUnverifiedSource,
+  outputText: "Completed Today\nJLC order paid and adapter verified.",
+});
+assert.equal(unrelatedVerifiedCompletion.ok, true, "a separately verified completion was tied to an unrelated source uncertainty");
+const repeatedSpeakerDoesNotJoinStatuses = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: [
+    "09:06 Lachlan: 在 Sunny 明确确认许可前不要上传数据。",
+    "10:43 Lachlan: 已支付的 JLC 订单不需要再操作。",
+  ].join("\n"),
+  outputText: "Completed Today\nJLC order paid and confirmed.",
+});
+assert.equal(
+  repeatedSpeakerDoesNotJoinStatuses.ok,
+  true,
+  "transport sender labels connected an unresolved item to an unrelated verified completion"
+);
+const transitiveChatTermsDoNotJoinStatuses = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: [
+    "09:06 Lachlan: 在 Sunny 明确确认许可前不要上传数据。",
+    "10:43 Lachlan: 已支付的 JLC 订单不需要再操作。",
+    "14:35 Lachlan: 每日 memo 要整理完成事项、等待事项和明确边界。",
+    "16:28 Lachlan: 数据上传任务状态是等待 Sunny，明天中午检查。",
+  ].join("\n"),
+  outputText: "Daily Memo\nCompleted Today\nJLC order paid and confirmed.",
+});
+assert.equal(
+  transitiveChatTermsDoNotJoinStatuses.ok,
+  true,
+  "transitive chat vocabulary connected an unresolved dataset to an unrelated JLC completion"
+);
+const adjacentPronounCompletion = evaluateUnverifiedSourceCompletionClaims({
+  sourceText: [
+    "13:12 System: Instagram automation reports login required; no upload started.",
+    "13:18 Lachlan: 这是阻塞，不是失败。等登录恢复后只重试 Instagram。",
+  ].join("\n"),
+  outputText: [
+    "Instagram upload is blocked by login; retry only after login is restored.",
+    "Do not re-publish the bird video on Instagram; it has already been posted.",
+  ].join("\n"),
+});
+assert.equal(
+  adjacentPronounCompletion.ok,
+  false,
+  "an adjacent pronoun completion claim contradicted a source-verified login blocker"
+);
+
 const supersedesHistory = evaluateCurrentStateText({
   sourceText: source,
   outputText: "This document supersedes earlier planning notes. The current owner is Mei.",
@@ -117,6 +241,164 @@ const consistentActions = evaluateDocumentConsistency([
 ].join("\n"));
 assert.equal(consistentActions.ok, true, "matching declared and section action counts were rejected");
 
+const duplicatedProse = evaluateDocumentConsistency(
+  "Ideas: the concept of the concept of an instrument as agent."
+);
+assert.equal(duplicatedProse.ok, false, "an adjacent duplicated prose fragment was accepted");
+assert(
+  duplicatedProse.defects.some((item) => item.code === "duplicated-prose-fragment"),
+  "an adjacent duplicated prose fragment did not produce its quality defect"
+);
+const duplicatedWrappedBullet = evaluateDocumentConsistency([
+  "Future Ideas",
+  "\u0088 Develop a conceptual article titled Turning Instruments into Collaborators, using case studies",
+  "from closed-loop microscopy, active spectroscopy, and autonomous experimentation.",
+  "\u0088 Explore another bounded idea for the roadmap and preserve it for later review.",
+  "\u0088 Develop a conceptual article titled Turning Instruments into Collaborators, using case studies",
+  "from closed-loop microscopy, active spectroscopy, and autonomous experimentation.",
+].join("\n"));
+assert.equal(
+  duplicatedWrappedBullet.ok,
+  false,
+  "a repeated non-adjacent wrapped PDF bullet was accepted"
+);
+assert(
+  duplicatedWrappedBullet.defects.some(
+    (item) => item.code === "duplicated-prose-fragment"
+  ),
+  "a repeated wrapped PDF bullet did not produce its quality defect"
+);
+
+const unverifiedCompletedSection = evaluateDocumentConsistency([
+  "Completed Tasks",
+  "\u0088 A microscopy book was received and archived to the designated",
+  "local and cloud storage locations; verification is pending.",
+  "Pending Actions",
+  "\u0088 Verify the private backup evidence.",
+].join("\n"));
+assert.equal(
+  unverifiedCompletedSection.ok,
+  false,
+  "wrapped unverified work inside a Completed section was accepted"
+);
+assert(
+  unverifiedCompletedSection.defects.some(
+    (item) => item.code === "completed-section-contains-unverified-work"
+  ),
+  "a wrapped completed/pending contradiction did not produce its section defect"
+);
+
+const contradictoryStatus = evaluateDocumentConsistency([
+  "Completed: JLC paid; book archive synchronized.",
+  "Pending: book archive evidence remains unverified.",
+].join("\n"));
+assert.equal(contradictoryStatus.ok, false, "completed and unverified status for one subject was accepted");
+assert(
+  contradictoryStatus.defects.some((item) => item.code === "completed-unverified-status-conflict"),
+  "a completed/unverified status conflict did not produce its quality defect"
+);
+
+const separateStatusBullets = evaluateDocumentConsistency([
+  "Executive Summary",
+  "This report outlines the current work without assigning status.",
+  "- Completed: authentication tests passed.",
+  "- Pending: deployment verification is waiting.",
+].join("\n"));
+assert.equal(
+  separateStatusBullets.defects.some((item) => item.code === "completed-unverified-status-conflict"),
+  false,
+  "the status parser treated report preamble text as part of a wrapped status bullet"
+);
+
+const malformedLatexSource = evaluateLatexSourceStructure([
+  "\\documentclass{article}",
+  "\\begin{document}",
+  "Current report.",
+  "\\end{document}",
+  "Duplicated report suffix.",
+  "\\end{document}",
+].join("\n"));
+assert.equal(malformedLatexSource.ok, false, "duplicated LaTeX document suffix was accepted");
+assert(
+  malformedLatexSource.defects.some((item) => item.code === "latex-content-after-document-end") &&
+    malformedLatexSource.defects.some((item) => item.code === "latex-duplicate-document-end"),
+  "malformed LaTeX source did not report both trailing content and duplicate document termination"
+);
+const validLatexSource = evaluateLatexSourceStructure([
+  "\\documentclass{article}",
+  "\\begin{document}",
+  "Current report with an escaped \\% sign.",
+  "\\end{document}",
+  "% \\end{document} in a comment is harmless.",
+].join("\n"));
+assert.equal(validLatexSource.ok, true, "valid LaTeX source with trailing comments was rejected");
+const duplicateLatexDate = evaluateLatexSourceStructure([
+  "\\documentclass{article}",
+  "\\date{2026-08-23}",
+  "% \\date{ignored comment}",
+  "\\date{2026-09-01}",
+  "\\begin{document}",
+  "Current report.",
+  "\\end{document}",
+].join("\n"));
+assert.equal(duplicateLatexDate.ok, false, "duplicate active LaTeX date declarations were accepted");
+assert(
+  duplicateLatexDate.defects.some(
+    (item) => item.code === "latex-duplicate-singleton-command" && item.command === "date"
+  ),
+  "duplicate LaTeX date declarations did not produce a precise source defect"
+);
+
+assert(
+  currentStateRequested(
+    "Read the complete chat history and reconcile corrections into the current memo.",
+    "更正：巴黎视频今天不要发布，上面这句取消。"
+  ),
+  "multilingual current-state correction language did not activate reconciliation checks"
+);
+
+const exactSourceRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-document-source-"));
+try {
+  await fs.writeFile(
+    path.join(exactSourceRoot, "chat_history.md"),
+    "Later correction: keep the publication blocked until login is restored.\n",
+    "utf8"
+  );
+  const exactSources = await collectDocumentSourceDocuments(
+    exactSourceRoot,
+    ["chat_history.md"]
+  );
+  assert.deepEqual(
+    exactSources.map((item) => item.path),
+    ["chat_history.md"],
+    "an exact root-level source path was omitted from document validation"
+  );
+} finally {
+  await fs.rm(exactSourceRoot, { recursive: true, force: true });
+}
+
+const versioningRoot = await fs.mkdtemp(path.join(os.tmpdir(), "aginti-document-versioning-"));
+try {
+  const { execFile } = await import("node:child_process");
+  const { promisify } = await import("node:util");
+  const run = promisify(execFile);
+  await run("git", ["init", "-q"], { cwd: versioningRoot });
+  await fs.writeFile(path.join(versioningRoot, "report.pdf"), "fixture", "utf8");
+  assert.equal(
+    (await documentArtifactVersioningDefect(versioningRoot, "report.pdf"))?.code,
+    "document-artifact-not-versioned",
+    "an untracked final document artifact passed commit-aware validation"
+  );
+  await run("git", ["add", "--", "report.pdf"], { cwd: versioningRoot });
+  assert.equal(
+    await documentArtifactVersioningDefect(versioningRoot, "report.pdf"),
+    null,
+    "a staged document artifact was reported as unversioned"
+  );
+} finally {
+  await fs.rm(versioningRoot, { recursive: true, force: true });
+}
+
 function page(
   words,
   { height = 842, startY = 60, endY = 700, heading = "Section", wordHeight = 10 } = {}
@@ -169,6 +451,17 @@ assert.equal(corruptExtractedText.ok, false, "control and replacement glyphs wer
 assert.deepEqual(corruptExtractedText.codePoints, [0x16, 0xfffd]);
 assert.equal(corruptExtractedText.defects[0]?.code, "corrupt-extracted-text");
 
+const latexBulletExtraction = evaluateExtractedDocumentText(
+  "Completed tasks\n\u0088 First item\n\u0088 Second item\n"
+);
+assert.equal(
+  latexBulletExtraction.ok,
+  true,
+  "the bounded pdflatex list-marker extraction glyph was treated as document corruption"
+);
+const embeddedControl = evaluateExtractedDocumentText("broken\u0088inside");
+assert.equal(embeddedControl.ok, false, "an embedded C1 control byte was accepted as a list marker");
+
 const boundedText = evaluatePdfTextBounds(`<doc>${page(20)}</doc>`);
 assert.equal(boundedText.ok, true, "text inside readable margins was rejected");