@lazyingart/agintiflow 0.20.307 → 0.20.309

package/package.json

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

@@ -7348,6 +7348,31 @@ try {
     "missing-artifact-commit"
   );
   await fs.mkdir(missingArtifactCommitWorkspace, { recursive: true });
+  const documentEvidenceWorkspace = path.join(
+    tempRoot,
+    "document-evidence"
+  );
+  await fs.mkdir(documentEvidenceWorkspace, { recursive: true });
+  await fs.writeFile(
+    path.join(documentEvidenceWorkspace, "daily_memo.pdf"),
+    "%PDF-1.4\n% current task generated PDF evidence\n",
+    "utf8"
+  );
+  await fs.writeFile(
+    path.join(documentEvidenceWorkspace, "retained_memo.pdf"),
+    "%PDF-1.4\n% retained same-task PDF evidence\n",
+    "utf8"
+  );
+  await fs.writeFile(
+    path.join(documentEvidenceWorkspace, "stale-root.pdf"),
+    "%PDF-1.4\n% wrong-task stale PDF evidence\n",
+    "utf8"
+  );
+  await fs.writeFile(
+    path.join(documentEvidenceWorkspace, "retained_memo.tex"),
+    "\\documentclass{article}\n\\begin{document}\nRetained memo.\n\\end{document}\n",
+    "utf8"
+  );
   const missingArtifactCommitState = {
     goal:
       "Create editable memo.tex and compiled mobile-readable memo.pdf, verify both, and commit only the intentional work.",
@@ -7471,6 +7496,557 @@ 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: documentEvidenceWorkspace,
+      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 resumedTaskGoal =
+    "Read TASK.md and complete it carefully. Use the complete chat history, verify the finished PDF, and leave the repository clean.";
+  const resumedTaskHash = crypto
+    .createHash("sha256")
+    .update(resumedTaskGoal)
+    .digest("hex");
+  const sameTaskResumeDocumentState = {
+    goal:
+      "Continue the same task. Reuse the existing verified source and PDF unless the diagnostic finds a real defect, then commit cleanly.",
+    messages: [],
+    meta: {
+      taskProfile: "writing",
+      goalContract: {
+        version: 3,
+        revision: 2,
+        activeGoalRevision: 2,
+        taskGoal: resumedTaskGoal,
+        activeGoal:
+          "Continue the same task. Reuse the existing verified source and PDF unless the diagnostic finds a real defect, then commit cleanly.",
+        currentRequest:
+          "Continue the same task. Reuse the existing verified source and PDF unless the diagnostic finds a real defect, then commit cleanly.",
+        taskRelation: "same-task",
+        history: [
+          {
+            revision: 1,
+            kind: "initial",
+            hash: resumedTaskHash,
+            preview: resumedTaskGoal,
+          },
+          {
+            revision: 2,
+            kind: "same-task-continuation",
+            relation: "same-task",
+            hash: crypto
+              .createHash("sha256")
+              .update(
+                "Continue the same task. Reuse the existing verified source and PDF unless the diagnostic finds a real defect, then commit cleanly."
+              )
+              .digest("hex"),
+            taskHash: resumedTaskHash,
+            previousHash: resumedTaskHash,
+          },
+        ],
+      },
+      projectVerification: {
+        mutationRevision: 6,
+        privateMutationRevision: 0,
+        mutationHistory: [
+          {
+            revision: 2,
+            at: "2026-09-01T10:00:00.000Z",
+            toolName: "run_command",
+            paths: ["retained_memo.pdf"],
+            commandCategory: "toolchain",
+            goalRevision: 1,
+            taskHash: resumedTaskHash,
+          },
+          {
+            revision: 3,
+            at: "2026-09-01T10:01:00.000Z",
+            toolName: "run_command",
+            paths: ["stale-root.pdf"],
+            commandCategory: "toolchain",
+            goalRevision: 1,
+            taskHash: "different-task",
+          },
+          {
+            revision: 4,
+            at: "2026-09-01T10:02:00.000Z",
+            toolName: "run_command",
+            paths: ["missing-retained.pdf"],
+            commandCategory: "toolchain",
+            goalRevision: 1,
+            taskHash: resumedTaskHash,
+          },
+          {
+            revision: 5,
+            at: "2026-09-01T10:03:00.000Z",
+            toolName: "apply_patch",
+            paths: ["TASK.md"],
+            patch: {
+              path: "TASK.md",
+              searchHash: "before-task-touch",
+              replaceHash: "temporary-task-touch",
+            },
+            goalRevision: 2,
+            taskHash: resumedTaskHash,
+          },
+          {
+            revision: 6,
+            at: "2026-09-01T10:04:00.000Z",
+            toolName: "apply_patch",
+            paths: ["TASK.md"],
+            patch: {
+              path: "TASK.md",
+              searchHash: "temporary-task-touch",
+              replaceHash: "before-task-touch",
+            },
+            goalRevision: 2,
+            taskHash: resumedTaskHash,
+          },
+        ],
+      },
+    },
+  };
+  let sameTaskResumeValidatorInput = null;
+  const sameTaskResumeAssessment = await documentQualityCommitAssessment(
+    sameTaskResumeDocumentState,
+    "run_command",
+    { command: "git add -- retained_memo.pdf && git commit -m memo" },
+    {
+      commandCwd: documentEvidenceWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        sameTaskResumeValidatorInput = input;
+        return {
+          ok: true,
+          checked: true,
+          artifacts: [{ path: "retained_memo.pdf" }],
+          defects: [],
+          reason:
+            "Independent document checks passed for retained_memo.pdf.",
+        };
+      },
+    }
+  );
+  assert(
+    sameTaskResumeAssessment?.ok === true &&
+      sameTaskResumeValidatorInput?.exactOutputPaths?.includes(
+        "retained_memo.pdf"
+      ) &&
+      !sameTaskResumeValidatorInput.exactOutputPaths.includes(
+        "stale-root.pdf"
+      ) &&
+      !sameTaskResumeValidatorInput.exactOutputPaths.includes(
+        "missing-retained.pdf"
+      ) &&
+      sameTaskResumeDocumentState.meta.completionEvidenceRepair === undefined,
+    `same-task resume did not preserve the prior verified document artifact safely: ${JSON.stringify({
+      assessment: sameTaskResumeAssessment,
+      input: sameTaskResumeValidatorInput,
+      repair: sameTaskResumeDocumentState.meta.completionEvidenceRepair,
+    })}`
+  );
+  const missingMutationHashState = structuredClone(sameTaskResumeDocumentState);
+  delete missingMutationHashState.meta.projectVerification.mutationHistory[0]
+    .taskHash;
+  let missingMutationHashValidatorInput = null;
+  const missingMutationHashAssessment = await documentQualityCommitAssessment(
+    missingMutationHashState,
+    "run_command",
+    { command: "git add -- retained_memo.pdf && git commit -m memo" },
+    {
+      commandCwd: documentEvidenceWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        missingMutationHashValidatorInput = 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(
+    missingMutationHashAssessment?.ok === false &&
+      missingMutationHashAssessment.category ===
+        "document-quality-incomplete" &&
+      !missingMutationHashValidatorInput?.exactOutputPaths?.includes(
+        "retained_memo.pdf"
+      ),
+    `a cross-revision retained PDF with missing mutation task hash was accepted: ${JSON.stringify({
+      assessment: missingMutationHashAssessment,
+      input: missingMutationHashValidatorInput,
+    })}`
+  );
+  const missingContinuationHashState = structuredClone(
+    sameTaskResumeDocumentState
+  );
+  delete missingContinuationHashState.meta.goalContract.history[1].taskHash;
+  let missingContinuationHashValidatorInput = null;
+  const missingContinuationHashAssessment =
+    await documentQualityCommitAssessment(
+      missingContinuationHashState,
+      "run_command",
+      { command: "git add -- retained_memo.pdf && git commit -m memo" },
+      {
+        commandCwd: documentEvidenceWorkspace,
+        taskProfile: "writing",
+        documentArtifactValidator: async (input) => {
+          missingContinuationHashValidatorInput = 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(
+    missingContinuationHashAssessment?.ok === false &&
+      missingContinuationHashAssessment.category ===
+        "document-quality-incomplete" &&
+      !missingContinuationHashValidatorInput?.exactOutputPaths?.includes(
+        "retained_memo.pdf"
+      ),
+    `a cross-revision retained PDF with missing same-task continuation hash was accepted: ${JSON.stringify({
+      assessment: missingContinuationHashAssessment,
+      input: missingContinuationHashValidatorInput,
+    })}`
+  );
+  const staleSourceResumeState = structuredClone(sameTaskResumeDocumentState);
+  staleSourceResumeState.meta.projectVerification = {
+    mutationRevision: 3,
+    privateMutationRevision: 0,
+    mutationHistory: [
+      {
+        revision: 2,
+        at: "2026-09-01T10:00:00.000Z",
+        toolName: "run_command",
+        paths: ["retained_memo.pdf"],
+        commandCategory: "toolchain",
+        goalRevision: 1,
+        taskHash: resumedTaskHash,
+      },
+      {
+        revision: 3,
+        at: "2026-09-01T10:05:00.000Z",
+        toolName: "apply_patch",
+        paths: ["retained_memo.tex"],
+        patch: {
+          path: "retained_memo.tex",
+          searchHash: "old-retained-source",
+          replaceHash: "changed-retained-source",
+        },
+        goalRevision: 2,
+        taskHash: resumedTaskHash,
+      },
+    ],
+  };
+  let staleSourceValidatorInput = null;
+  const staleSourceAssessment = await documentQualityCommitAssessment(
+    staleSourceResumeState,
+    "run_command",
+    { command: "git add -- retained_memo.tex retained_memo.pdf && git commit -m memo" },
+    {
+      commandCwd: documentEvidenceWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        staleSourceValidatorInput = 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(
+    staleSourceAssessment?.ok === false &&
+      staleSourceAssessment.category === "document-quality-incomplete" &&
+      !staleSourceValidatorInput?.exactOutputPaths?.includes(
+        "retained_memo.pdf"
+      ) &&
+      staleSourceResumeState.meta.completionEvidenceRepair
+        ?.documentArtifactGenerationRequired === true &&
+      staleSourceResumeState.meta.completionEvidenceRepair
+        ?.documentArtifactProducerCommand.includes("retained_memo.tex"),
+    `a retained prior PDF survived a later same-task source mutation or failed to keep producer repair active: ${JSON.stringify({
+      assessment: staleSourceAssessment,
+      input: staleSourceValidatorInput,
+      repair: staleSourceResumeState.meta.completionEvidenceRepair,
+    })}`
+  );
+  const differentGoalResumeState = structuredClone(sameTaskResumeDocumentState);
+  differentGoalResumeState.goal =
+    "Start a different memo task and create a new verified PDF.";
+  differentGoalResumeState.meta.goalContract = {
+    version: 3,
+    revision: 2,
+    activeGoalRevision: 2,
+    taskGoal: "Start a different memo task and create a new verified PDF.",
+    activeGoal: "Start a different memo task and create a new verified PDF.",
+    currentRequest:
+      "Start a different memo task and create a new verified PDF.",
+    taskRelation: "different-task",
+    history: [
+      {
+        revision: 1,
+        kind: "initial",
+        hash: resumedTaskHash,
+        preview: resumedTaskGoal,
+      },
+      {
+        revision: 2,
+        kind: "new-task",
+        relation: "different-task",
+        hash: crypto
+          .createHash("sha256")
+          .update("Start a different memo task and create a new verified PDF.")
+          .digest("hex"),
+      },
+    ],
+  };
+  let differentGoalValidatorInput = null;
+  const differentGoalAssessment = await documentQualityCommitAssessment(
+    differentGoalResumeState,
+    "run_command",
+    { command: "git add -- retained_memo.pdf && git commit -m memo" },
+    {
+      commandCwd: documentEvidenceWorkspace,
+      taskProfile: "writing",
+      documentArtifactValidator: async (input) => {
+        differentGoalValidatorInput = 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(
+    differentGoalAssessment?.ok === false &&
+      differentGoalAssessment.category === "document-quality-incomplete" &&
+      !differentGoalValidatorInput?.exactOutputPaths?.includes(
+        "retained_memo.pdf"
+      ),
+    `a different task reused a prior same-root document artifact: ${JSON.stringify(
+      differentGoalValidatorInput
+    )}`
+  );
+  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: documentEvidenceWorkspace,
+      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/src/agent-runner.js

@@ -10257,6 +10257,7 @@ export async function documentQualityCommitAssessment(
       ? contract.exactOutputPaths
       : []),
     ...exactOutputPathsForState(state),
+    ...currentGoalDocumentArtifactPathsForState(state, config),
     ...(Array.isArray(config.taskOwnedCommitPaths)
       ? config.taskOwnedCommitPaths
       : []),
@@ -14185,6 +14186,209 @@ function exactOutputPathsForState(state = {}) {
   ], exclusions).slice(0, 32);
 }
 
+function currentGoalRevisionBelongsToActiveTask(state = {}, mutation = {}) {
+  const goalContract = state.meta?.goalContract || {};
+  const currentGoalRevision = Math.max(0, Number(goalContract.revision || 0));
+  const mutationGoalRevision = Math.max(0, Number(mutation?.goalRevision || 0));
+  if (
+    currentGoalRevision <= 0 ||
+    mutationGoalRevision <= 0 ||
+    mutationGoalRevision > currentGoalRevision
+  ) {
+    return false;
+  }
+  const taskGoal = String(goalContract.taskGoal || state.goal || "").trim();
+  const currentTaskHash = taskGoal ? hashForLog(taskGoal) : "";
+  const goalHistory = Array.isArray(goalContract.history)
+    ? goalContract.history
+    : [];
+  const mutationGoalEntry = goalHistory.find(
+    (entry) => Number(entry?.revision || 0) === mutationGoalRevision
+  );
+  const mutationTaskHash = String(
+    mutation?.taskHash ||
+      mutationGoalEntry?.taskHash ||
+      (mutationGoalEntry?.kind === "initial" ? mutationGoalEntry?.hash : "") ||
+      ""
+  );
+  if (
+    currentTaskHash &&
+    mutationTaskHash &&
+    mutationTaskHash !== currentTaskHash
+  ) {
+    return false;
+  }
+  if (mutationGoalRevision === currentGoalRevision) return true;
+  const explicitMutationTaskHash = String(mutation?.taskHash || "");
+  if (
+    !currentTaskHash ||
+    !explicitMutationTaskHash ||
+    explicitMutationTaskHash !== currentTaskHash
+  ) {
+    return false;
+  }
+  const interveningGoalEntries = goalHistory.filter((entry) => {
+    const revision = Number(entry?.revision || 0);
+    return revision > mutationGoalRevision && revision <= currentGoalRevision;
+  });
+  if (!interveningGoalEntries.length) return false;
+  return interveningGoalEntries.every((entry) => {
+    const relation = String(entry?.relation || "");
+    const kind = String(entry?.kind || "");
+    const entryTaskHash = String(entry?.taskHash || "");
+    return (
+      (relation === "same-task" || kind === "same-task-continuation") &&
+      entryTaskHash === currentTaskHash
+    );
+  });
+}
+
+function currentGoalDocumentArtifactStillExists(candidate = "", state = {}, config = {}) {
+  const normalized = safeTaskOwnedCommitPath(candidate);
+  if (!normalized || !/\.(?:docx|pdf)$/iu.test(normalized)) return false;
+  if (
+    isPrivateVerificationEvidencePath(normalized) ||
+    isScopedTaskArtifactEvidencePath(normalized, state, config)
+  ) {
+    return false;
+  }
+  const commandCwd = path.resolve(
+    config.commandCwd || state.commandCwd || process.cwd()
+  );
+  const absolutePath = path.resolve(commandCwd, normalized);
+  const relativePath = path.relative(commandCwd, absolutePath);
+  if (
+    !relativePath ||
+    relativePath.startsWith("..") ||
+    path.isAbsolute(relativePath)
+  ) {
+    return false;
+  }
+  try {
+    const stat = fsSync.lstatSync(absolutePath);
+    return stat.isFile() && !stat.isSymbolicLink() && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+const LIKELY_DOCUMENT_SOURCE_EXTENSIONS = new Set([
+  ".tex",
+  ".md",
+  ".markdown",
+  ".rmd",
+  ".qmd",
+  ".typ",
+]);
+
+function documentArtifactFreshnessKey(value = "") {
+  const candidate = safeTaskOwnedCommitPath(value);
+  if (!candidate) return "";
+  const extension = path.posix.extname(candidate).toLocaleLowerCase("en-US");
+  const basename = path.posix.basename(candidate, extension);
+  const dirname = path.posix.dirname(candidate);
+  return `${dirname === "." ? "" : `${dirname}/`}${basename}`.toLocaleLowerCase("en-US");
+}
+
+function mutationArtifactPaths(mutation = {}) {
+  return [
+    ...(Array.isArray(mutation?.paths) ? mutation.paths : []),
+    ...(Array.isArray(mutation?.projectMutationPaths)
+      ? mutation.projectMutationPaths
+      : []),
+    ...(Array.isArray(mutation?.verifiedGeneratedOutputPaths)
+      ? mutation.verifiedGeneratedOutputPaths
+      : []),
+  ];
+}
+
+function mutationInvalidatesDocumentArtifact(mutation = {}, artifactPath = "") {
+  const artifact = safeTaskOwnedCommitPath(artifactPath);
+  if (!artifact) return false;
+  const artifactKey = documentArtifactFreshnessKey(artifact);
+  if (!artifactKey) return false;
+  for (const value of mutationArtifactPaths(mutation)) {
+    const candidate = safeTaskOwnedCommitPath(value);
+    if (!candidate) continue;
+    if (candidate === artifact) return true;
+    const extension = path.posix.extname(candidate).toLocaleLowerCase("en-US");
+    if (
+      LIKELY_DOCUMENT_SOURCE_EXTENSIONS.has(extension) &&
+      documentArtifactFreshnessKey(candidate) === artifactKey
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function retainedDocumentArtifactMutationIsFresh(
+  state = {},
+  history = [],
+  mutation = {},
+  artifactPath = ""
+) {
+  const artifactRevision = Math.max(0, Number(mutation?.revision || 0));
+  if (artifactRevision <= 0) return false;
+  for (const laterMutation of history) {
+    if (Math.max(0, Number(laterMutation?.revision || 0)) <= artifactRevision) {
+      continue;
+    }
+    if (!currentGoalRevisionBelongsToActiveTask(state, laterMutation)) continue;
+    if (mutationInvalidatesDocumentArtifact(laterMutation, artifactPath)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function currentGoalDocumentArtifactPathsForState(state = {}, config = {}) {
+  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 (!currentGoalRevisionBelongsToActiveTask(state, mutation)) 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) ||
+        !currentGoalDocumentArtifactStillExists(candidate, state, config) ||
+        !retainedDocumentArtifactMutationIsFresh(
+          state,
+          history,
+          mutation,
+          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 +21593,7 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
   const documentExactOutputPaths = [
     ...(assessment.contract?.exactOutputPaths || []),
     ...exactOutputPathsForState(state),
+    ...currentGoalDocumentArtifactPathsForState(state, config),
   ];
   const documentContractText = `${completionContractGoal(config, state)}\n${candidateResult}`;
   const documentDeliverableRequested =