@lazyingart/agintiflow 0.20.308 → 0.20.310

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.308",
+  "version": "0.20.310",
   "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.",
@@ -7524,7 +7549,7 @@ try {
     "run_command",
     { command: "git add -- daily_memo.tex daily_memo.pdf && git commit -m memo" },
     {
-      commandCwd: missingArtifactCommitWorkspace,
+      commandCwd: documentEvidenceWorkspace,
       taskProfile: "writing",
       documentArtifactValidator: async (input) => {
         currentGoalDocumentValidatorInput = input;
@@ -7556,6 +7581,351 @@ try {
       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"
@@ -7642,7 +8012,7 @@ try {
     "run_command",
     { command: "git add -- daily_memo.tex daily_memo.pdf && git commit -m memo" },
     {
-      commandCwd: missingArtifactCommitWorkspace,
+      commandCwd: documentEvidenceWorkspace,
       taskProfile: "writing",
       documentArtifactValidator: async (input) => {
         semanticGateValidatorInput = input;

package/scripts/smoke-truthful-completion.js

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
+  completionRequirementCoverageInstruction,
   continuationExecutionContractDirective,
   removeSupersededCompletionRepairInstructions,
   runAgent,
@@ -17,6 +18,13 @@ const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."
 const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "agintiflow-truthful-completion-"));
 process.env.AGINTIFLOW_HOME = path.join(tempRoot, "home");
 
+const completionCoverageInstruction = completionRequirementCoverageInstruction();
+assert.match(completionCoverageInstruction, /requirement by requirement/i);
+assert.match(completionCoverageInstruction, /Every distinct subject/i);
+assert.match(completionCoverageInstruction, /authoritative structured routine/i);
+assert.match(completionCoverageInstruction, /every relevant section/i);
+assert.match(completionCoverageInstruction, /instead of summarizing only failures or only successes/i);
+
 assert.equal(
   finishResultClaimsIncompleteWork(
     "The report is complete and the verification that was previously paused now passes. No work remains."

package/src/agent-runner.js

@@ -2969,6 +2969,10 @@ function usesFocusedRuntimePrompt(config = {}) {
   return config.executionTier === "focused" && !config.scsActive;
 }
 
+export function completionRequirementCoverageInstruction() {
+  return "Before finishing, check the current user request requirement by requirement. Every distinct subject, requested action, and deliverable must be completed, answered, deliberately grouped under one verified shared state, or named with a concrete blocker. When an authoritative structured routine returns named sections relevant to the request, report every relevant section instead of summarizing only failures or only successes.";
+}
+
 function focusedCapabilityContext(config = {}) {
   return [
     config.allowFileTools
@@ -3012,6 +3016,7 @@ function buildFocusedRuntimeMessages({
         "You are AgInTiFlow, a persistent tool-capable agent.",
         "Answer ordinary conversation directly. For executable work, act through the smallest relevant routine or tool, verify in proportion to risk, then stop.",
         "Treat queued user input as a safe-boundary interruption: preserve every material requirement, merge related consecutive messages, revise the durable goal, and never repeat a completed external side effect.",
+        completionRequirementCoverageInstruction(),
         "Established project routines are capabilities to invoke, not workflows to reimplement. Discover more context only when the current task needs it.",
         formatBehaviorContractForPrompt({ mode: "focused" }),
         languageInstruction(config.language || "en"),
@@ -3230,6 +3235,7 @@ async function createInitialState(config, sessionId) {
             : "For website/app/code/LaTeX/Python/C/shell tasks, create or edit real workspace files, run available build/compile/test commands, and surface artifacts through the canvas when useful.",
           "For LaTeX/PDF tasks, check existing latexmk/pdflatex first and compile with the available host or Docker TeX toolchain before installing packages or rebuilding the sandbox.",
           "For research or web-search tasks, use browser tools or safe shell network tools when the current policy allows; cite or save useful sources in workspace notes when the task needs traceability.",
+          completionRequirementCoverageInstruction(),
           browserStateReconciliationGuidance(),
           isRetainedWorkspaceProfile(config)
             ? "Choose descriptive non-conflicting workspace paths for durable outputs."
@@ -10257,7 +10263,7 @@ export async function documentQualityCommitAssessment(
       ? contract.exactOutputPaths
       : []),
     ...exactOutputPathsForState(state),
-    ...currentGoalDocumentArtifactPathsForState(state),
+    ...currentGoalDocumentArtifactPathsForState(state, config),
     ...(Array.isArray(config.taskOwnedCommitPaths)
       ? config.taskOwnedCommitPaths
       : []),
@@ -14186,7 +14192,163 @@ function exactOutputPathsForState(state = {}) {
   ], exclusions).slice(0, 32);
 }
 
-function currentGoalDocumentArtifactPathsForState(state = {}) {
+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
@@ -14199,7 +14361,7 @@ function currentGoalDocumentArtifactPathsForState(state = {}) {
   const candidates = [];
   const seen = new Set();
   for (const mutation of history) {
-    if (Number(mutation?.goalRevision || 0) !== currentGoalRevision) continue;
+    if (!currentGoalRevisionBelongsToActiveTask(state, mutation)) continue;
     const paths = [
       ...(Array.isArray(mutation?.paths) ? mutation.paths : []),
       ...(Array.isArray(mutation?.projectMutationPaths)
@@ -14214,6 +14376,13 @@ function currentGoalDocumentArtifactPathsForState(state = {}) {
       if (
         !candidate ||
         !/\.(?:docx|pdf)$/iu.test(candidate) ||
+        !currentGoalDocumentArtifactStillExists(candidate, state, config) ||
+        !retainedDocumentArtifactMutationIsFresh(
+          state,
+          history,
+          mutation,
+          candidate
+        ) ||
         seen.has(candidate)
       ) {
         continue;
@@ -21430,7 +21599,7 @@ async function completionEvidenceDecision({ config, state, store, observers, ste
   const documentExactOutputPaths = [
     ...(assessment.contract?.exactOutputPaths || []),
     ...exactOutputPathsForState(state),
-    ...currentGoalDocumentArtifactPathsForState(state),
+    ...currentGoalDocumentArtifactPathsForState(state, config),
   ];
   const documentContractText = `${completionContractGoal(config, state)}\n${candidateResult}`;
   const documentDeliverableRequested =