@lazyingart/agintiflow 0.20.231 → 0.20.232

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.231",
+  "version": "0.20.232",
   "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",
@@ -102,6 +102,7 @@
     "scripts/smoke-localllm-provider.js",
     "scripts/smoke-progressive-tool-selection.js",
     "scripts/smoke-truthful-completion.js",
+    "scripts/smoke-document-artifact-quality.js",
     "scripts/smoke-writing-specialist-routing.js",
     "scripts/eval-provider-attribution.js",
     "scripts/local-first-agent-eval.mjs",
@@ -174,6 +175,7 @@
     "smoke:localllm-provider": "node scripts/smoke-localllm-provider.js",
     "smoke:progressive-tools": "node scripts/smoke-progressive-tool-selection.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",
     "smoke:mcp": "node scripts/smoke-mcp.js",
     "smoke:model-roles": "node scripts/smoke-model-roles.js",
@@ -217,7 +219,7 @@
     "storage:migrate": "node bin/aginti-cli.js storage migrate",
     "publish:env": "node scripts/npm-publish-from-env.js publish --access public",
     "publish:env:whoami": "node scripts/npm-publish-from-env.js whoami",
-    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:integration-storage-authority && npm run smoke:integration-retained-durable-common && npm run smoke:integration-retained-file-lock && npm run smoke:integration-retained-event-ledger && npm run smoke:integration-retained-event-ledger-bundle && npm run smoke:integration-retained-repository-kernel && npm run smoke:integration-retained-session-state-store && npm run smoke:integration-retained-native-session-repository-state && npm run smoke:integration-retained-native-execution-evidence && npm run smoke:integration-retained-runtime-repository-surface && npm run smoke:integration-retained-runtime-repository-phase-b && npm run smoke:integration-runtime-repository-contract && npm run smoke:integration-runtime-authority && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:integration-production-mount && npm run smoke:integration-storage-authority && npm run smoke:integration-retained-durable-common && npm run smoke:integration-retained-file-lock && npm run smoke:integration-retained-event-ledger && npm run smoke:integration-retained-event-ledger-bundle && npm run smoke:integration-retained-repository-kernel && npm run smoke:integration-retained-session-state-store && npm run smoke:integration-retained-native-session-repository-state && npm run smoke:integration-retained-native-execution-evidence && npm run smoke:integration-retained-runtime-repository-surface && npm run smoke:integration-retained-runtime-repository-phase-b && npm run smoke:integration-runtime-repository-contract && npm run smoke:integration-runtime-authority && npm run smoke:localllm-provider && npm run smoke:localllm-model-tiers && npm run smoke:localllm-code-routing && npm run smoke:local-failure-recovery && npm run smoke:localllm-auto-max && npm run smoke:local-resource-policy && npm run smoke:context-budget-recovery && npm run smoke:session-runtime && npm run smoke:runtime-core && npm run smoke:progressive-tools && npm run smoke:truthful-completion && npm run smoke:document-artifact-quality && npm run smoke:writing-specialist-routing && npm run eval:local-first-agent && npm run eval:provider-attribution && npm run smoke:runtime-compat && npm run smoke:autoupdate && npm run smoke:web-api && npm run smoke:math-rendering && npm run smoke:web-ui && npm run smoke:web-autostart && npm run smoke:webapp-command && npm run smoke:web-port-fallback && npm run smoke:docker-command && npm run smoke:coding-tools && npm run smoke:dynamic-step-budget && npm run smoke:execution-policy && npm run smoke:aaps-adapter && npm run smoke:auxiliary-tools && npm run smoke:perception-research && npm run smoke:deep-research && npm run smoke:public-research && npm run smoke:safe-chat && npm run smoke:auth && npm run smoke:agentlink && npm run smoke:canvas-artifacts && npm run smoke:capabilities && npm run smoke:mcp && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:permission-modes && npm run smoke:skills && npm run smoke:skillmesh && npm run smoke:supervision-ledger && npm run smoke:tmux-tools && npm run smoke:long-jobs && npm run smoke:run-stdin && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

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

@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+
+import {
+  evaluateCurrentStateText,
+  evaluatePdfPageBalance,
+  extractSupersededLiterals,
+} from "../src/document-artifact-quality.js";
+
+const source = [
+  "Initial plan: the demonstration date was September 12.",
+  "Preliminary total budget was HKD 18,000.",
+  "Correction: the demonstration is September 19, 2026, not September 12.",
+  "Mei is the integration owner, replacing Ana.",
+  "Use Vendor C; Vendor A is no longer selected.",
+].join("\n");
+
+assert.deepEqual(
+  extractSupersededLiterals(source),
+  ["HKD 18,000", "September 12", "Ana", "Vendor A"],
+  "explicit corrections did not produce a stable superseded-fact set"
+);
+
+const staleDocument = evaluateCurrentStateText({
+  sourceText: source,
+  outputText: "Mei owns integration, replacing Ana. The approved cap is HKD 16,500, not HKD 18,000. Vendor A is no longer selected.",
+  currentStateRequired: true,
+});
+assert.equal(staleDocument.ok, false, "current-state validation accepted superseded history");
+assert(
+  staleDocument.defects.some((item) => item.code === "superseded-facts-present"),
+  "superseded literals were not reported"
+);
+assert(
+  staleDocument.defects.some((item) => item.code === "historical-transition-prose"),
+  "historical transition prose was not reported"
+);
+
+const currentDocument = evaluateCurrentStateText({
+  sourceText: source,
+  outputText: "The demonstration is September 19, 2026. Mei owns integration. The approved cap is HKD 16,500. Vendor C supplies the filter.",
+  currentStateRequired: true,
+});
+assert.equal(currentDocument.ok, true, "authoritative current-state prose was rejected");
+
+function page(words, { height = 842, startY = 60, endY = 700, heading = "Section" } = {}) {
+  const items = [];
+  const count = Math.max(1, words);
+  for (let index = 0; index < count; index += 1) {
+    const ratio = count === 1 ? 0 : index / (count - 1);
+    const y = startY + (endY - startY) * ratio;
+    const text = index === 0 ? heading : `word${index}`;
+    items.push(`<word xMin="60" yMin="${y.toFixed(2)}" xMax="100" yMax="${(y + 10).toFixed(2)}">${text}</word>`);
+  }
+  items.push(`<word xMin="250" yMin="810" xMax="300" yMax="820">footer</word>`);
+  return `<page width="595" height="${height}">${items.join("")}</page>`;
+}
+
+const sparse = evaluatePdfPageBalance(`<doc>${page(240)}${page(55, { endY: 190, heading: "Risks" })}</doc>`);
+assert.equal(sparse.ok, false, "a sparse trailing spill page was accepted");
+assert.equal(sparse.defects[0]?.code, "sparse-trailing-page");
+
+const balanced = evaluatePdfPageBalance(`<doc>${page(220)}${page(160, { endY: 620, heading: "Risks" })}</doc>`);
+assert.equal(balanced.ok, true, "a balanced two-page document was rejected");
+
+const intentionalAppendix = evaluatePdfPageBalance(
+  `<doc>${page(220)}${page(35, { endY: 170, heading: "Appendix" })}</doc>`
+);
+assert.equal(intentionalAppendix.ok, true, "an intentional sparse appendix page was rejected");
+
+console.log("document artifact quality smoke test passed");

package/scripts/smoke-truthful-completion.js

@@ -503,6 +503,36 @@ try {
   assert.match(futureWorkFinish.result.result, /verified the working directory/i);
   assert(futureWorkFinish.events.some((event) => event.type === "completion.evidence_rejected"));
 
+  const wordCompletionWithoutArtifact = await runCase({
+    id: "word-completion-without-artifact",
+    goal: "Create an editable, phone-friendly project handoff from this folder.",
+    taskProfile: "word",
+    allowFileTools: true,
+    responses: [
+      assistant("", [toolCall("word-finish-without-file-1", "finish", { result: "The handoff is complete." })]),
+      assistant("", [toolCall("word-finish-without-file-2", "finish", { result: "The handoff is complete." })]),
+    ],
+  });
+  assert.equal(wordCompletionWithoutArtifact.result.stopped, true);
+  assert.equal(wordCompletionWithoutArtifact.result.reason, "model_did_not_execute");
+  assert(
+    wordCompletionWithoutArtifact.events.some(
+      (event) =>
+        event.type === "document.quality_assessed" &&
+        event.data?.ok === false &&
+        /no readable DOCX or PDF/i.test(String(event.data?.reason || ""))
+    ),
+    "Word completion without a document artifact bypassed the independent quality gate"
+  );
+  assert(
+    wordCompletionWithoutArtifact.events.some(
+      (event) =>
+        event.type === "completion.evidence_rejected" &&
+        /no readable DOCX or PDF/i.test(String(event.data?.reason || ""))
+    ),
+    "missing Word artifacts did not produce an actionable completion repair"
+  );
+
   const verifiedAction = await runCase({
     id: "verified-action",
     goal: "Execute the shell command pwd and report the output.",

package/scripts/smoke-web-api.js

@@ -21,6 +21,7 @@ const server = spawn(process.execPath, [path.join(repoRoot, "bin/aginti-cli.js")
   cwd: runtimeDir,
   env: {
     ...process.env,
+    AGINTIFLOW_NO_AUTO_UPDATE: "1",
     AGINTIFLOW_RUNTIME_DIR: runtimeDir,
     AGINTIFLOW_HOME: agintiflowHome,
   },

package/scripts/smoke-web-port-fallback.js

@@ -63,6 +63,7 @@ const child = spawn(process.execPath, [path.join(repoRoot, "bin/aginti-cli.js"),
   cwd: runtimeDir,
   env: {
     ...process.env,
+    AGINTIFLOW_NO_AUTO_UPDATE: "1",
     AGINTIFLOW_RUNTIME_DIR: runtimeDir,
     AGINTIFLOW_HOME: path.join(runtimeDir, ".agintiflow-home"),
   },

package/scripts/smoke-web-ui.js

@@ -15,6 +15,7 @@ const server = spawn(process.execPath, [path.join(repoRoot, "bin/aginti-cli.js")
   cwd: runtimeDir,
   env: {
     ...process.env,
+    AGINTIFLOW_NO_AUTO_UPDATE: "1",
     AGINTIFLOW_HOME: agintiflowHome,
     AGINTIFLOW_RUNTIME_DIR: runtimeDir,
   },
@@ -35,17 +36,21 @@ function delay(ms) {
 }
 
 async function waitForHealth() {
-  const deadline = Date.now() + 15000;
+  const deadline = Date.now() + 30000;
+  let lastError = "";
   while (Date.now() < deadline) {
     if (server.exitCode !== null) break;
     try {
       const health = await fetch(`${baseUrl}/health`).then((response) => response.json());
       if (health.ok) return health;
-    } catch {
+    } catch (error) {
+      lastError = String(error?.message || error);
       await delay(250);
     }
   }
-  throw new Error(`web server did not become healthy. stdout=${stdout.slice(-500)} stderr=${stderr.slice(-500)}`);
+  throw new Error(
+    `web server did not become healthy. lastError=${lastError} stdout=${stdout.slice(-500)} stderr=${stderr.slice(-500)}`
+  );
 }
 
 async function waitForRunState(page, status, timeout = 20000) {

package/scripts/smoke-webapp-command.js

@@ -77,6 +77,7 @@ async function runCase({ port, env = {}, expectHeader, label }) {
     cwd: runtimeDir,
     env: {
       ...process.env,
+      AGINTIFLOW_NO_AUTO_UPDATE: "1",
       AGINTIFLOW_NO_ANIMATION: "1",
       AGINTIFLOW_HOME: path.join(runtimeDir, `.ignored-cli-home-${label}`),
       AGINTIFLOW_WEB_HOME: path.join(runtimeDir, `.agintiflow-web-home-${label}`),

package/src/agent-runner.js

@@ -51,6 +51,7 @@ import {
 } from "./workspace-tools.js";
 import { normalizeCanvasPayload, persistCanvasPayloadFile } from "./artifact-tunnel.js";
 import { getTaskProfile } from "./task-profiles.js";
+import { validateWordDocumentArtifacts } from "./document-artifact-quality.js";
 import { generateImage, listAuxiliarySkills } from "./auxiliary-tools.js";
 import {
   engineeringGuidanceForTask,
@@ -9122,6 +9123,66 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
       },
     };
   }
+  let documentQuality = null;
+  if (String(config.taskProfile || state.meta?.taskProfile || "").toLowerCase() === "word") {
+    try {
+      documentQuality = await validateWordDocumentArtifacts({
+        commandCwd: config.commandCwd || state.commandCwd || process.cwd(),
+        candidateResult,
+        goal: completionContractGoal(config, state),
+        exactOutputPaths: [
+          ...(assessment.contract?.exactOutputPaths || []),
+          ...exactOutputPathsForState(state),
+        ],
+      });
+    } catch (error) {
+      documentQuality = {
+        ok: false,
+        checked: true,
+        artifacts: [],
+        defects: [{
+          code: "document-quality-check-failed",
+          message: String(error?.message || error),
+        }],
+        reason: `Independent document-quality validation failed: ${String(error?.message || error)}`,
+      };
+    }
+    state.meta = state.meta || {};
+    state.meta.documentArtifactQuality = documentQuality;
+    const qualityEvent = {
+      step,
+      mode,
+      ok: documentQuality.ok,
+      reason: documentQuality.reason,
+      artifacts: documentQuality.artifacts || [],
+      defects: documentQuality.defects || [],
+      sourcePaths: documentQuality.sourcePaths || [],
+    };
+    await store.appendEvent("document.quality_assessed", qualityEvent);
+    observers.event("document.quality_assessed", qualityEvent);
+    if (!documentQuality.ok) {
+      const priorSemanticReason = assessment.semantic?.checked && !assessment.semantic?.ok
+        ? String(assessment.semantic.reason || "")
+        : "";
+      const qualityReason = String(documentQuality.reason || "The document artifact failed independent quality checks.");
+      assessment = {
+        ...assessment,
+        ok: false,
+        documentQuality,
+        evaluation: {
+          ...assessment.evaluation,
+          ok: false,
+          reason: qualityReason,
+        },
+        semantic: {
+          ...assessment.semantic,
+          checked: true,
+          ok: false,
+          reason: [priorSemanticReason, qualityReason].filter(Boolean).join(" "),
+        },
+      };
+    }
+  }
   const hasRealBlocker = finishResultClaimsBlocker(candidateResult) && hasScsBlockerEvidence(assessment.ledger);
   if (assessment.ok && !claimsIncompleteWork) return { action: "accept", assessment };
   if (claimsIncompleteWork) {
@@ -9168,6 +9229,13 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
       ok: Boolean(assessment.semantic.ok),
       reason: assessment.semantic.reason || "",
     },
+    documentQuality: documentQuality
+      ? {
+          ok: Boolean(documentQuality.ok),
+          reason: documentQuality.reason || "",
+          defects: documentQuality.defects || [],
+        }
+      : null,
     progressCount,
   };
   state.meta = state.meta || {};

package/src/document-artifact-quality.js

@@ -0,0 +1,478 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+const DOCUMENT_EXTENSIONS = new Set([".csv", ".json", ".md", ".rst", ".tsv", ".txt", ".yaml", ".yml"]);
+const SOURCE_DIRECTORY_NAMES = new Set(["input", "inputs", "material", "materials", "notes", "reference", "references", "source", "sources"]);
+const ROOT_SOURCE_NAMES = /^(?:agents?|brief|project[-_ ]?notes?|readme|requirements?|style[-_ ]?notes?|task)(?:\.[^.]+)?$/i;
+const EXCLUDED_DIRECTORY_NAMES = new Set([
+  ".aginti",
+  ".aginti-preview",
+  ".aginti-sessions",
+  ".git",
+  ".venv",
+  "__pycache__",
+  "artifacts",
+  "build",
+  "coverage",
+  "dist",
+  "node_modules",
+  "output",
+  "outputs",
+  "temp",
+  "tmp",
+]);
+const INTENTIONAL_SPARSE_PAGE_PATTERN =
+  /^(?:appendix|approval|approvals|acknowledgements?|back cover|contact|notes|references|sign[- ]?off|signatures?)\b/i;
+const HISTORICAL_TRANSITION_PATTERN =
+  /\b(?:formerly|no longer|previously|replac(?:ed|ing)|superseded|used to be)\b/i;
+
+function portablePath(value = "") {
+  return String(value || "").replace(/\\/g, "/");
+}
+
+function isInsideRoot(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function decodeXml(value = "") {
+  return String(value || "")
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16)))
+    .replace(/&#([0-9]+);/g, (_, decimal) => String.fromCodePoint(Number.parseInt(decimal, 10)))
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, "&");
+}
+
+function textFromDocumentXml(xml = "") {
+  return decodeXml(
+    String(xml || "")
+      .replace(/<w:tab\b[^>]*\/>/g, "\t")
+      .replace(/<w:br\b[^>]*\/>/g, "\n")
+      .replace(/<\/w:p>/g, "\n")
+      .replace(/<\/w:tr>/g, "\n")
+      .replace(/<[^>]+>/g, "")
+  )
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function normalizedComparableText(value = "") {
+  return String(value || "")
+    .normalize("NFKC")
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u2013\u2014]/g, "-")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+}
+
+function containsLiteral(text = "", literal = "") {
+  const normalizedText = normalizedComparableText(text);
+  const normalizedLiteral = normalizedComparableText(literal);
+  if (!normalizedText || !normalizedLiteral) return false;
+  const escaped = normalizedLiteral.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?:^|[^\\p{L}\\p{N}])${escaped}(?=$|[^\\p{L}\\p{N}])`, "iu").test(
+    normalizedText
+  );
+}
+
+function cleanedSupersededLiteral(value = "") {
+  return String(value || "")
+    .replace(/^[\s:;,()\[\]-]+|[\s:;,()\[\].-]+$/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function extractSupersededLiterals(sourceText = "") {
+  const text = String(sourceText || "");
+  const values = [];
+  const add = (value) => {
+    const cleaned = cleanedSupersededLiteral(value);
+    if (cleaned.length < 2 || cleaned.length > 80) return;
+    if (!/[\p{L}\p{N}]/u.test(cleaned)) return;
+    values.push(cleaned);
+  };
+
+  for (const sentence of text.split(/(?<=[.!?])\s+|\n+/u)) {
+    if (/\b(?:correction|corrected|revis(?:ed|ion)|update(?:d)?)\b/i.test(sentence)) {
+      for (const match of sentence.matchAll(
+        /\bnot\s+((?:[A-Z][\p{L}.'-]+(?:\s+\d{1,2}(?:,\s*\d{4})?)?)|(?:(?:HKD|USD|EUR|GBP|JPY|CNY|RMB)\s*[\d,.]+)|(?:[A-Z][\p{L}\p{N}&.'/-]*(?:\s+[A-Z][\p{L}\p{N}&.'/-]*){0,4}))/gu
+      )) {
+        add(match[1]);
+      }
+    }
+    for (const match of sentence.matchAll(
+      /\breplac(?:ed|ing)\s+([A-Z][\p{L}\p{N}&.'/-]*(?:\s+[A-Z][\p{L}\p{N}&.'/-]*){0,4})/gu
+    )) {
+      add(match[1]);
+    }
+    for (const match of sentence.matchAll(
+      /([A-Z][\p{L}\p{N}&.'/-]*(?:\s+[A-Z][\p{L}\p{N}&.'/-]*){0,4})\s+(?:is|was)\s+no longer\b/gu
+    )) {
+      add(match[1]);
+    }
+    if (/\bpreliminary\b/i.test(sentence)) {
+      for (const match of sentence.matchAll(
+        /(?:(?:HKD|USD|EUR|GBP|JPY|CNY|RMB)\s*[\d,.]+|[$€£¥]\s*[\d,.]+)/gu
+      )) {
+        add(match[0]);
+      }
+    }
+  }
+
+  const seen = new Set();
+  return values.filter((value) => {
+    const key = normalizedComparableText(value);
+    if (!key || seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function parsePdfBboxPages(bboxXml = "") {
+  const pages = [];
+  const pagePattern = /<page\b[^>]*width="([^"]+)"[^>]*height="([^"]+)"[^>]*>([\s\S]*?)<\/page>/gi;
+  for (const pageMatch of String(bboxXml || "").matchAll(pagePattern)) {
+    const width = Number(pageMatch[1]);
+    const height = Number(pageMatch[2]);
+    const words = [];
+    const wordPattern =
+      /<word\b[^>]*xMin="([^"]+)"[^>]*yMin="([^"]+)"[^>]*xMax="([^"]+)"[^>]*yMax="([^"]+)"[^>]*>([\s\S]*?)<\/word>/gi;
+    for (const wordMatch of pageMatch[3].matchAll(wordPattern)) {
+      words.push({
+        xMin: Number(wordMatch[1]),
+        yMin: Number(wordMatch[2]),
+        xMax: Number(wordMatch[3]),
+        yMax: Number(wordMatch[4]),
+        text: decodeXml(wordMatch[5]).replace(/<[^>]+>/g, "").trim(),
+      });
+    }
+    pages.push({ width, height, words });
+  }
+  return pages;
+}
+
+function median(values = []) {
+  const sorted = values.filter(Number.isFinite).sort((a, b) => a - b);
+  if (!sorted.length) return 0;
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}
+
+export function evaluatePdfPageBalance(bboxXml = "") {
+  const pages = parsePdfBboxPages(bboxXml);
+  const metrics = pages.map((page, index) => {
+    const footerCutoff = Number.isFinite(page.height) ? page.height - 60 : Number.POSITIVE_INFINITY;
+    const contentWords = page.words.filter((word) => word.text && word.yMin < footerCutoff);
+    const yValues = contentWords.flatMap((word) => [word.yMin, word.yMax]).filter(Number.isFinite);
+    const usableHeight = Math.max(1, Number(page.height || 0) - 120);
+    const occupiedHeight = yValues.length ? Math.max(...yValues) - Math.min(...yValues) : 0;
+    return {
+      page: index + 1,
+      wordCount: contentWords.length,
+      occupiedRatio: occupiedHeight / usableHeight,
+      leadingText: contentWords.slice(0, 16).map((word) => word.text).join(" ").trim(),
+    };
+  });
+  const defects = [];
+  if (metrics.length > 1) {
+    const priorWordCounts = metrics.slice(0, -1).map((item) => item.wordCount).filter((value) => value > 0);
+    const last = metrics.at(-1);
+    const comparisonCount = Math.max(80, median(priorWordCounts) * 0.45);
+    const intentionalSparsePage = INTENTIONAL_SPARSE_PAGE_PATTERN.test(last.leadingText);
+    if (
+      !intentionalSparsePage &&
+      last.wordCount > 0 &&
+      last.wordCount < comparisonCount &&
+      last.occupiedRatio < 0.35
+    ) {
+      defects.push({
+        code: "sparse-trailing-page",
+        message: `Page ${last.page} is a sparse spill page (${last.wordCount} words; ${(last.occupiedRatio * 100).toFixed(0)}% usable-height occupancy). Reflow the preceding content or rebalance sections so the final page is intentional and useful.`,
+      });
+    }
+  }
+  return {
+    ok: pages.length > 0 && defects.length === 0,
+    checked: pages.length > 0,
+    pages: metrics,
+    defects,
+  };
+}
+
+export function evaluateCurrentStateText({ sourceText = "", outputText = "", currentStateRequired = false } = {}) {
+  const supersededLiterals = extractSupersededLiterals(sourceText);
+  const presentSupersededLiterals = supersededLiterals.filter((literal) => containsLiteral(outputText, literal));
+  const defects = [];
+  if (presentSupersededLiterals.length) {
+    defects.push({
+      code: "superseded-facts-present",
+      message: `The reader-facing document still contains superseded source values: ${presentSupersededLiterals.join(", ")}. State only the authoritative current values unless history was explicitly requested.`,
+    });
+  }
+  if (currentStateRequired) {
+    const historicalMarkers = [...new Set(
+      (String(outputText || "").match(new RegExp(HISTORICAL_TRANSITION_PATTERN.source, "gi")) || [])
+        .map((value) => value.toLowerCase())
+    )];
+    if (historicalMarkers.length) {
+      defects.push({
+        code: "historical-transition-prose",
+        message: `This is a current-state document, but it narrates superseded history (${historicalMarkers.join(", ")}). Remove transition commentary and retain only current decisions.`,
+      });
+    }
+  }
+  return { ok: defects.length === 0, defects, supersededLiterals, presentSupersededLiterals };
+}
+
+async function collectSourceDocuments(commandCwd) {
+  const documents = [];
+  let totalBytes = 0;
+  const maxFiles = 128;
+  const maxTotalBytes = 4 * 1024 * 1024;
+  const maxFileBytes = 512 * 1024;
+
+  async function visit(directory, sourceRoot = false, depth = 0) {
+    if (documents.length >= maxFiles || totalBytes >= maxTotalBytes || depth > 5) return;
+    let entries;
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (documents.length >= maxFiles || totalBytes >= maxTotalBytes) break;
+      const absolutePath = path.join(directory, entry.name);
+      const lowerName = entry.name.toLowerCase();
+      if (entry.isDirectory()) {
+        if (EXCLUDED_DIRECTORY_NAMES.has(lowerName)) continue;
+        const nextSourceRoot = sourceRoot || SOURCE_DIRECTORY_NAMES.has(lowerName);
+        if (nextSourceRoot) await visit(absolutePath, true, depth + 1);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      const extension = path.extname(lowerName);
+      const rootCandidate = directory === commandCwd && ROOT_SOURCE_NAMES.test(entry.name);
+      if (!(sourceRoot && DOCUMENT_EXTENSIONS.has(extension)) && !rootCandidate) continue;
+      try {
+        const stat = await fs.stat(absolutePath);
+        if (stat.size <= 0 || stat.size > maxFileBytes || totalBytes + stat.size > maxTotalBytes) continue;
+        const text = await fs.readFile(absolutePath, "utf8");
+        documents.push({ path: portablePath(path.relative(commandCwd, absolutePath)), text });
+        totalBytes += stat.size;
+      } catch {
+        // Unreadable source material is left to the existing source-coverage gate.
+      }
+    }
+  }
+
+  await visit(commandCwd, false, 0);
+  return documents;
+}
+
+function artifactCandidatesFromText(text = "") {
+  const candidates = [];
+  const pattern = /(?:`([^`\n]+\.(?:docx|pdf))`|((?:\.?\.?\/[\w .()\/-]+|[\w.-]+(?:\/[\w .()\/-]+)*)\.(?:docx|pdf)))/gi;
+  for (const match of String(text || "").matchAll(pattern)) {
+    const candidate = String(match[1] || match[2] || "").trim().replace(/[),.;:]+$/g, "");
+    if (candidate) candidates.push(candidate);
+  }
+  return candidates;
+}
+
+async function collectOutputDirectoryCandidates(commandCwd) {
+  const candidates = [];
+  for (const name of ["output", "outputs"]) {
+    const root = path.join(commandCwd, name);
+    let entries;
+    try {
+      entries = await fs.readdir(root, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries.slice(0, 80)) {
+      if (!entry.isFile() || !/\.(?:docx|pdf)$/i.test(entry.name)) continue;
+      candidates.push(portablePath(path.join(name, entry.name)));
+    }
+  }
+  return candidates;
+}
+
+async function resolveExistingArtifacts(commandCwd, values = []) {
+  const artifacts = [];
+  const seen = new Set();
+  for (const value of values) {
+    const absolutePath = path.resolve(commandCwd, String(value || ""));
+    if (!isInsideRoot(commandCwd, absolutePath) || seen.has(absolutePath)) continue;
+    seen.add(absolutePath);
+    try {
+      const stat = await fs.stat(absolutePath);
+      if (!stat.isFile() || stat.size <= 0) continue;
+      artifacts.push({
+        path: portablePath(path.relative(commandCwd, absolutePath)),
+        absolutePath,
+        extension: path.extname(absolutePath).toLowerCase(),
+        size: stat.size,
+      });
+    } catch {
+      // Missing candidates are reported only when no document artifact exists.
+    }
+  }
+  return artifacts;
+}
+
+async function extractPdf(artifact) {
+  const [textResult, bboxResult] = await Promise.all([
+    execFileAsync("pdftotext", [artifact.absolutePath, "-"], {
+      encoding: "utf8",
+      maxBuffer: 8 * 1024 * 1024,
+      timeout: 20_000,
+    }),
+    execFileAsync("pdftotext", ["-bbox", artifact.absolutePath, "-"], {
+      encoding: "utf8",
+      maxBuffer: 16 * 1024 * 1024,
+      timeout: 20_000,
+    }),
+  ]);
+  return { text: textResult.stdout, bbox: bboxResult.stdout };
+}
+
+async function extractDocxText(artifact) {
+  const script = [
+    "import sys, zipfile",
+    "with zipfile.ZipFile(sys.argv[1]) as archive:",
+    "    sys.stdout.buffer.write(archive.read('word/document.xml'))",
+  ].join("\n");
+  const result = await execFileAsync("python3", ["-c", script, artifact.absolutePath], {
+    encoding: "utf8",
+    maxBuffer: 16 * 1024 * 1024,
+    timeout: 20_000,
+  });
+  return textFromDocumentXml(result.stdout);
+}
+
+function currentStateRequested(goal = "", sourceText = "") {
+  const contractText = `${goal}\n${sourceText}`;
+  return /\b(?:authoritative current|current state|latest explicit correction|latest correction|superseded|use the latest)\b/i.test(
+    contractText
+  );
+}
+
+export async function validateWordDocumentArtifacts({
+  commandCwd = process.cwd(),
+  candidateResult = "",
+  goal = "",
+  exactOutputPaths = [],
+} = {}) {
+  const workspace = path.resolve(commandCwd || process.cwd());
+  const outputCandidates = [
+    ...(Array.isArray(exactOutputPaths) ? exactOutputPaths : []),
+    ...artifactCandidatesFromText(candidateResult),
+    ...(await collectOutputDirectoryCandidates(workspace)),
+  ];
+  const artifacts = await resolveExistingArtifacts(workspace, outputCandidates);
+  const relevantArtifacts = artifacts.filter((item) => [".docx", ".pdf"].includes(item.extension));
+  const defects = [];
+  if (!relevantArtifacts.length) {
+    return {
+      ok: false,
+      checked: true,
+      artifacts: [],
+      defects: [{
+        code: "missing-document-artifact",
+        message: "The Word/document task claimed completion without a readable DOCX or PDF artifact in the declared output paths or output directory.",
+      }],
+      reason: "No readable DOCX or PDF artifact was found for the completed document task.",
+    };
+  }
+
+  const sourceDocuments = await collectSourceDocuments(workspace);
+  const sourceText = sourceDocuments.map((item) => item.text).join("\n\n");
+  const currentStateRequired = currentStateRequested(goal, sourceText);
+  const artifactReports = [];
+  for (const artifact of relevantArtifacts) {
+    try {
+      if (artifact.extension === ".pdf") {
+        const extracted = await extractPdf(artifact);
+        const semantic = evaluateCurrentStateText({ sourceText, outputText: extracted.text, currentStateRequired });
+        const pageBalance = evaluatePdfPageBalance(extracted.bbox);
+        if (!String(extracted.text || "").trim()) {
+          defects.push({
+            code: "empty-pdf-text",
+            path: artifact.path,
+            message: "The PDF has no independently extractable reader text.",
+          });
+        }
+        if (!pageBalance.checked) {
+          defects.push({
+            code: "pdf-page-geometry-unavailable",
+            path: artifact.path,
+            message: "The PDF page geometry could not be extracted, so page balance and clipping cannot be verified.",
+          });
+        }
+        defects.push(...semantic.defects.map((item) => ({ ...item, path: artifact.path })));
+        defects.push(...pageBalance.defects.map((item) => ({ ...item, path: artifact.path })));
+        artifactReports.push({
+          path: artifact.path,
+          extension: artifact.extension,
+          textChars: extracted.text.length,
+          pageCount: pageBalance.pages.length,
+          pages: pageBalance.pages,
+          supersededLiterals: semantic.supersededLiterals,
+        });
+      } else {
+        const text = await extractDocxText(artifact);
+        const semantic = evaluateCurrentStateText({ sourceText, outputText: text, currentStateRequired });
+        if (!String(text || "").trim()) {
+          defects.push({
+            code: "empty-docx-text",
+            path: artifact.path,
+            message: "The DOCX has no independently extractable editable document text.",
+          });
+        }
+        defects.push(...semantic.defects.map((item) => ({ ...item, path: artifact.path })));
+        artifactReports.push({
+          path: artifact.path,
+          extension: artifact.extension,
+          textChars: text.length,
+          supersededLiterals: semantic.supersededLiterals,
+        });
+      }
+    } catch (error) {
+      defects.push({
+        code: "document-extraction-failed",
+        path: artifact.path,
+        message: `Could not independently extract and inspect ${artifact.path}: ${String(error?.message || error).slice(0, 300)}.`,
+      });
+    }
+  }
+
+  const uniqueDefects = [];
+  const defectKeys = new Set();
+  for (const defect of defects) {
+    const key = `${defect.code}\n${defect.message}`;
+    if (defectKeys.has(key)) continue;
+    defectKeys.add(key);
+    uniqueDefects.push(defect);
+  }
+  return {
+    ok: uniqueDefects.length === 0,
+    checked: true,
+    artifacts: artifactReports,
+    sourcePaths: sourceDocuments.map((item) => item.path),
+    currentStateRequired,
+    defects: uniqueDefects,
+    reason: uniqueDefects.length
+      ? uniqueDefects.map((item) => `${item.path ? `${item.path}: ` : ""}${item.message}`).join(" ")
+      : `Independent document checks passed for ${artifactReports.map((item) => item.path).join(", ")}.`,
+  };
+}

package/src/task-profiles.js

@@ -276,7 +276,7 @@ export const TASK_PROFILES = {
     id: "word",
     label: "Word documents",
     prompt:
-      "Bias toward Word/docx/document workflows while still using writing, conversion, LaTeX, or scripts when useful. Preserve source material byte-for-byte and synthesize a reader-facing document from the authoritative current facts instead of concatenating notes, logs, schemas, task IDs, private paths, or delivery instructions. Reconcile conflicting or superseded source facts before drafting: values labeled corrected, replaced, earlier, old, prior, cancelled, or no longer selected identify what to discard, and those discarded literals must not appear in the final document unless the user explicitly requests history or the history is necessary to explain a live decision. Before finishing, extract the final text and search for every superseded literal found in the sources. Prefer mature editable-document tooling already available in the workspace, such as python-docx, pandoc, or LibreOffice, over hand-written OOXML; when direct OOXML is genuinely necessary, validate its package parts and openability. Keep one maintainable source of truth and a reproducible project-local build command. Verify the DOCX is structurally editable, compile the PDF, run pdftotext or an equivalent extraction check that rejects replacement characters and unexpected control glyphs, and verify PDF text bounding boxes remain inside a readable page margin. Render every PDF page to a separate image under an ignored build/verification directory. Inspect one rendered page per read_image call, never batch pages into one vision call, and repair orphaned headings, near-empty spill pages, awkward table or paragraph breaks, overlaps, clipping, excessive whitespace, weak hierarchy, and inconsistent number formatting before finishing. Retain ignored verification renders as evidence; optional cleanup must never block completion. Use clear descriptive filenames, exclude caches and generated debris from commits, inspect git status/diff before committing, and report success only after the editable source, reader-facing current-state content, visual layout, searchable text, and requested artifacts all pass.",
+      "Bias toward Word/docx/document workflows while still using writing, conversion, LaTeX, or scripts when useful. Preserve source material byte-for-byte and synthesize a reader-facing document from the authoritative current facts instead of concatenating notes, logs, schemas, task IDs, private paths, or delivery instructions. Reconcile conflicting or superseded source facts before drafting: values labeled corrected, replaced, earlier, old, prior, cancelled, or no longer selected identify what to discard, and those discarded literals must not appear in the final document unless the user explicitly requests history or the history is necessary to explain a live decision. Keep the reconciliation history private: a current-state handoff should say who owns the work, which value is approved, and which option is selected, not narrate who was replaced or which preliminary value is no longer used. Before finishing, extract the final text and search for every superseded literal found in the sources. Prefer mature editable-document tooling already available in the workspace, such as python-docx, pandoc, or LibreOffice, over hand-written OOXML; when direct OOXML is genuinely necessary, validate its package parts and openability. Keep one maintainable source of truth and a reproducible project-local build command. Verify the DOCX is structurally editable, compile the PDF, run pdftotext or an equivalent extraction check that rejects replacement characters and unexpected control glyphs, and verify PDF text bounding boxes remain inside a readable page margin. Render every PDF page to a separate image under an ignored build/verification directory. Inspect one rendered page per read_image call, never batch pages into one vision call, and repair orphaned headings, near-empty spill pages, awkward table or paragraph breaks, overlaps, clipping, excessive whitespace, weak hierarchy, and inconsistent number formatting before finishing. Prefer one balanced readable page over pushing one short section onto a mostly empty trailing page; preserve an intentionally sparse appendix, approval, signature, reference, or back-matter page when it serves a real purpose. Retain ignored verification renders as evidence; optional cleanup must never block completion. Use clear descriptive filenames, exclude caches and generated debris from commits, inspect git status/diff before committing, and report success only after the editable source, reader-facing current-state content, visual layout, searchable text, and requested artifacts all pass.",
     tools: ["files", "shell", "canvas", "sandbox"],
   },
   latex: {