@lazyingart/agintiflow 0.20.208 → 0.20.210

package/docs/supervision-campaign-ledger.md

@@ -38,6 +38,11 @@ Create, start, and finish a concrete run with `test`, `start`, `event`, and
 idempotent or append-only SQLite operation suitable for a persistent tmux
 campaign.
 
+Test registration validates that any named capability and scenario belong to
+the same campaign. Finishing a test updates the test, capability, and scenario
+status in one SQLite transaction, so a typo cannot silently leave the campaign
+matrix stale or split across contradictory states.
+
 Inspect current coverage:
 
 ```bash
@@ -48,3 +53,25 @@ node scripts/supervision-ledger.js status \
 Do not mark a test passed from the agent's prose. Verify session events, files,
 checks, external state, and side-effect boundaries first, then store those paths
 in `evidence_json` and `events`.
+
+## Current Campaign Findings
+
+### Data analysis retained-state recovery
+
+`data-analysis-local-011` passed after reusable runtime fixes. AgInTi completed
+the mixed sensor-export project, repaired its own unclosed CSV handles, created
+commits `2f79553` and `3317a59`, and resumed the same durable session after a
+control-loop pause. Independent validation ran both the unit suite and the
+canonical generator with `ResourceWarning` promoted to an error; all tests,
+audit counts, condition means, plot bytes, and clean-git checks passed.
+
+The incident established two general contracts:
+
+- A canonical command wrapped only by an explicit exit-status probe, such as
+  `python analysis.py; echo "EXIT=$?"`, is valid evidence when the captured
+  status is zero. Arbitrary semicolon chains remain invalid because a later
+  command can hide an earlier failure.
+- User-facing artifacts keep canonical workspace paths but receive a readable
+  canvas/download filename derived from the task title and source purpose.
+  Internal collision identifiers are short suffixes, never the leading or only
+  visible filename information.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.208",
+  "version": "0.20.210",
   "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",
@@ -61,6 +61,7 @@
     "scripts/setup-agent-toolchain-docker.sh",
     "scripts/real-deepseek-capabilities.js",
     "scripts/postinstall-webapp.js",
+    "scripts/check-js-syntax.js",
     "scripts/seed-supervised-homework.js",
     "scripts/supervision-ledger.js",
     "scripts/smoke-supervision-ledger.js",
@@ -73,7 +74,11 @@
     "scripts/smoke-integration-retained-repository-kernel.js",
     "scripts/smoke-integration-retained-session-state-store.js",
     "scripts/smoke-integration-retained-native-session-repository-state.js",
+    "scripts/smoke-integration-retained-native-execution-evidence.js",
+    "scripts/smoke-integration-retained-runtime-repository-surface.js",
+    "scripts/smoke-integration-retained-runtime-repository-phase-b.js",
     "scripts/smoke-integration-runtime-repository-contract.js",
+    "scripts/smoke-integration-runtime-authority.js",
     "scripts/smoke-auxiliary-tools.js",
     "scripts/smoke-agentlink.js",
     "scripts/smoke-auth.js",
@@ -91,6 +96,7 @@
     "scripts/smoke-long-jobs.js",
     "scripts/smoke-localllm-auto-max.js",
     "scripts/smoke-localllm-code-routing.js",
+    "scripts/smoke-local-failure-recovery.js",
     "scripts/smoke-local-resource-policy.js",
     "scripts/smoke-localllm-model-tiers.js",
     "scripts/smoke-localllm-provider.js",
@@ -139,7 +145,7 @@
   "scripts": {
     "start": "node run.js",
     "web": "node web.js",
-    "check": "node --check run.js && node --check web.js && node --check bin/aginti-cli.js && node --check bin/aginti-integration.js && node --check bin/aginti-public-research.js && node --check bin/aginti-safe-chat.js && node --check src/*.js && node --check src/mcp/*.js && node --check public/*.js && node --check scripts/postinstall-webapp.js && node --check scripts/seed-supervised-homework.js && node --check scripts/supervision-ledger.js && node --check scripts/smoke-supervision-ledger.js && node --check scripts/smoke-integration-production-mount.js && node --check scripts/smoke-integration-storage-authority.js && node --check scripts/smoke-integration-retained-durable-common.js && node --check scripts/smoke-integration-retained-file-lock.js && node --check scripts/smoke-integration-retained-event-ledger.js && node --check scripts/smoke-integration-retained-event-ledger-bundle.js && node --check scripts/smoke-integration-retained-repository-kernel.js && node --check scripts/smoke-integration-retained-session-state-store.js && node --check scripts/smoke-integration-retained-native-session-repository-state.js && node --check scripts/smoke-integration-runtime-repository-contract.js && node --check scripts/eval-provider-attribution.js && node --check scripts/smoke-agentlink.js && node --check scripts/smoke-execution-policy.js && node --check scripts/smoke-math-rendering.js && node --check scripts/smoke-mcp.js && node --check scripts/smoke-public-research-wrapper.js && node --check scripts/smoke-runtime-core.js && node --check scripts/smoke-safe-chat.js && node --check scripts/smoke-web-ui.js && node --check scripts/smoke-scs-evidence-visibility.js && node --check scripts/fixtures/mcp-stdio-smoke-server.mjs",
+    "check": "node scripts/check-js-syntax.js",
     "setup:toolchain-docker": "scripts/setup-agent-toolchain-docker.sh",
     "smoke:coding-tools": "node scripts/smoke-coding-tools.js",
     "smoke:dynamic-step-budget": "node scripts/smoke-dynamic-step-budget.js",
@@ -203,11 +209,15 @@
     "smoke:integration-retained-repository-kernel": "node --experimental-test-module-mocks scripts/smoke-integration-retained-repository-kernel.js",
     "smoke:integration-retained-session-state-store": "node --experimental-test-module-mocks scripts/smoke-integration-retained-session-state-store.js",
     "smoke:integration-retained-native-session-repository-state": "node --experimental-test-module-mocks scripts/smoke-integration-retained-native-session-repository-state.js",
+    "smoke:integration-retained-native-execution-evidence": "node scripts/smoke-integration-retained-native-execution-evidence.js",
+    "smoke:integration-retained-runtime-repository-surface": "node scripts/smoke-integration-retained-runtime-repository-surface.js",
+    "smoke:integration-retained-runtime-repository-phase-b": "node scripts/smoke-integration-retained-runtime-repository-phase-b.js",
     "smoke:integration-runtime-repository-contract": "node scripts/smoke-integration-runtime-repository-contract.js",
+    "smoke:integration-runtime-authority": "node scripts/smoke-integration-runtime-authority.js",
     "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-runtime-repository-contract && 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: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/check-js-syntax.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const roots = ["run.js", "web.js", "bin", "src", "public", "scripts"];
+const extensions = new Set([".cjs", ".js", ".mjs"]);
+
+async function collect(entryPath, files) {
+  const stat = await fs.lstat(entryPath);
+  if (stat.isSymbolicLink()) return;
+  if (stat.isDirectory()) {
+    const entries = await fs.readdir(entryPath, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      await collect(path.join(entryPath, entry.name), files);
+    }
+    return;
+  }
+  if (stat.isFile() && extensions.has(path.extname(entryPath).toLowerCase())) files.push(entryPath);
+}
+
+const files = [];
+for (const root of roots) await collect(path.join(projectRoot, root), files);
+
+for (const filePath of files) {
+  const checked = spawnSync(process.execPath, ["--check", filePath], {
+    cwd: projectRoot,
+    encoding: "utf8",
+  });
+  if (checked.status !== 0) {
+    process.stderr.write(checked.stderr || checked.stdout || `Syntax check failed: ${filePath}\n`);
+    process.exit(checked.status || 1);
+  }
+}
+
+console.log(`JavaScript syntax check passed (${files.length} files).`);

package/scripts/smoke-canvas-artifacts.js

@@ -40,6 +40,24 @@ async function main() {
   const persisted = await persistCanvasPayloadFile(normalized.payload, { config, store });
   if (!persisted.ok) throw new Error(persisted.reason || "canvas artifact persistence failed");
   if (!persisted.payload.artifactPersisted) throw new Error("canvas file was not persisted into session artifacts");
+  if (persisted.payload.downloadName !== "durable-report.md") {
+    throw new Error(`canvas artifact lost its meaningful download name: ${persisted.payload.downloadName}`);
+  }
+  if (!/^durable-report--[A-Za-z0-9_-]{8}\.md$/.test(path.basename(persisted.payload.sessionFilePath))) {
+    throw new Error(`canvas persistence put an opaque id before the filename: ${persisted.payload.sessionFilePath}`);
+  }
+
+  const genericNamed = normalizeCanvasPayload(
+    {
+      title: "Fluorescence Experiment Analysis",
+      kind: "pdf",
+      path: "report.pdf",
+    },
+    config
+  );
+  if (!genericNamed.ok || genericNamed.payload.downloadName !== "Fluorescence-Experiment-Analysis.pdf") {
+    throw new Error(`generic artifact did not receive a task-meaningful filename: ${genericNamed.payload?.downloadName}`);
+  }
 
   await fs.rm(sourcePath);
 
@@ -59,6 +77,7 @@ async function main() {
   const content = await readArtifactContent(items[0], { store, config });
   if (!content.ok) throw new Error(content.error || "persisted artifact could not be read");
   if (!String(content.text || "").includes("Durable report")) throw new Error("persisted artifact content mismatch");
+  if (content.filename !== "durable-report.md") throw new Error("artifact read metadata lost the download filename");
 
   const largeImagePath = path.join(workspace, "large-preview.png");
   const pngHeader = Buffer.from("89504e470d0a1a0a", "hex");

package/scripts/smoke-cli-chat.js

@@ -1190,6 +1190,7 @@ try {
 
   const resumeStatePath = path.join(agintiflowHome, "sessions", resumedSessionId, "state.json");
   const runtimeBeforeAmbientResume = JSON.parse(await fs.readFile(resumeStatePath, "utf8"));
+  const completedArtifactBeforeAmbientResume = await fs.stat(path.join(tempRoot, "notes/interactive.md"));
   const ambientSecret = "must-not-persist-cli-resume-secret";
   const ordinaryResume = await runCli(
     ["resume", resumedSessionId, "--", "Continue this saved mock session without changing its runtime."],
@@ -1204,6 +1205,7 @@ try {
     }
   );
   const runtimeAfterAmbientResume = JSON.parse(await fs.readFile(resumeStatePath, "utf8"));
+  const completedArtifactAfterAmbientResume = await fs.stat(path.join(tempRoot, "notes/interactive.md"));
   if (
     runtimeAfterAmbientResume.meta.runtimeConfig.provider !== "mock" ||
     runtimeAfterAmbientResume.meta.runtimeConfig.model !== "mock-agent" ||
@@ -1213,6 +1215,14 @@ try {
   ) {
     throw new Error("ordinary one-shot resume drifted to ambient provider/model/key settings");
   }
+  if (
+    completedArtifactAfterAmbientResume.mtimeMs !== completedArtifactBeforeAmbientResume.mtimeMs ||
+    runtimeAfterAmbientResume.meta.goalContract.status !== "completed" ||
+    runtimeAfterAmbientResume.meta.goalContract.lifecycle.at(-1)?.reason !== "completed_task_noop" ||
+    !ordinaryResume.stdout.includes("did not repeat any tool or external side effect")
+  ) {
+    throw new Error("generic resume of a completed task repeated work instead of preserving the verified result");
+  }
 
   await runCli(
     ["resume", resumedSessionId, "--no-web-search", "--no-auxiliary-tools", "--", "Continue with explicitly reduced tools."],

package/scripts/smoke-coding-tools.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   buildModelTimeoutRetryMessages,
+  genericArtifactFilenameBlock,
   modelTimeoutRetryRoute,
   repairModelMessageHistory,
   shouldResetStaticDiscoveryPhase,
@@ -83,6 +84,40 @@ async function runMock(goal, sessionId, { resume = false } = {}) {
 }
 
 try {
+  const genericArtifactBlock = await genericArtifactFilenameBlock(
+    "write_file",
+    { path: "report.md", content: "summary" },
+    { commandCwd: workspace, taskProfile: "data", goal: "Analyze the fluorescence experiment exports." },
+    { goal: "Analyze the fluorescence experiment exports.", messages: [], meta: {} }
+  );
+  assert(
+    genericArtifactBlock?.category === "artifact-filename" &&
+      /fluorescence|experiment/i.test(genericArtifactBlock.permissionAdvice?.instruction || ""),
+    "new generic artifact filename was not redirected to a meaningful topic-derived name"
+  );
+  assert(
+    (await genericArtifactFilenameBlock(
+      "write_file",
+      { path: "outputs/summary.json", content: "{}" },
+      { commandCwd: workspace, taskProfile: "data", goal: "Analyze the experiment." },
+      {
+        goal: "Analyze the experiment.",
+        messages: [],
+        meta: { projectVerification: { requiredOutputs: ["outputs/summary.json"] } },
+      }
+    )) === null,
+    "an exact project-declared artifact filename was incorrectly rejected as generic"
+  );
+  assert(
+    (await genericArtifactFilenameBlock(
+      "write_file",
+      { path: "reports/fluorescence-dose-response-analysis.md", content: "summary" },
+      { commandCwd: workspace, taskProfile: "data" },
+      { goal: "Analyze the experiment.", messages: [], meta: {} }
+    )) === null,
+    "a descriptive artifact filename was incorrectly blocked"
+  );
+
   const staleDeepSeekState = {
     messages: [
       { role: "system", content: "system" },
@@ -1385,6 +1420,30 @@ try {
   const unifiedText = await fs.readFile(path.join(workspace, "unified-target.txt"), "utf8");
   assert(unified.ok && unifiedText === "alpha\nnew\nomega\n", "unified apply_patch did not update expected file");
 
+  await fs.writeFile(path.join(workspace, "hybrid-patch-target.txt"), "alpha\nold\nomega\n", "utf8");
+  const hybridPatch = await executeWorkspaceTool(
+    "apply_patch",
+    {
+      patch: [
+        "*** Begin Patch ***",
+        "--- a/hybrid-patch-target.txt",
+        "+++ b/hybrid-patch-target.txt",
+        "@@ -1,3 +1,3 @@",
+        " alpha",
+        "-old",
+        "+new",
+        " omega",
+        "*** End Patch ***",
+      ].join("\n"),
+    },
+    { commandCwd: workspace, allowFileTools: true }
+  );
+  const hybridPatchText = await fs.readFile(path.join(workspace, "hybrid-patch-target.txt"), "utf8");
+  assert(
+    hybridPatch.ok && hybridPatchText === "alpha\nnew\nomega\n",
+    "hybrid wrapped unified apply_patch did not update expected file"
+  );
+
   await fs.writeFile(path.join(workspace, "repair-report.md"), "old report\n", "utf8");
   const ordinaryAddExistingError = await executeWorkspaceTool(
     "apply_patch",

package/scripts/smoke-deep-research.js

@@ -52,6 +52,13 @@ async function main() {
     toolChoiceForProvider({ provider: "deepseek" }, []) === "auto",
     "provider-neutral research routing added an unsupported named tool_choice"
   );
+  assert(
+    toolChoiceForProvider(
+      { provider: "deepseek" },
+      [{ role: "user", content: "Emit exactly one enabled tool call that performs the next concrete action." }]
+    ) === "auto",
+    "DeepSeek thinking mode received unsupported required tool selection during recovery"
+  );
   assert(
     JSON.stringify(providerStructuredOutputAttempts("deepseek")) === JSON.stringify(["json_object", "prompt"]),
     "DeepSeek structured extraction still probes an unsupported JSON Schema mode"

package/scripts/smoke-dynamic-step-budget.js

@@ -18,21 +18,34 @@ import {
   artifactValidationScopeBlock,
   canonicalizeVerifiedArtifactCompletion,
   completedDeepResearchReuse,
+  completionEvidenceNeedsCommand,
+  enqueueFailedTestRepairInstruction,
   nextStepRuntimeConfig,
+  projectAcceptanceFromMarkdown,
+  recordCanonicalGeneratedOutputProgress,
+  recordProjectVerificationOutcome,
   recordExactOutputProgress,
   recordStaticDiscoveryProgress,
+  resetStaticDiscoveryAfterContextLoss,
   rememberCompletedDeepResearch,
   repeatedNoProgressToolBlock,
   repeatedSuccessfulMutationBlock,
   repeatedStaticToolBlock,
+  reopenedArtifactRepairPending,
   shouldResetStaticDiscoveryPhase,
 } from "../src/agent-runner.js";
+import {
+  augmentScsTaskContractWithProjectVerification,
+  buildScsEvidenceLedger,
+  evaluateScsEvidence,
+} from "../src/scs-evidence.js";
 import {
   createStepBudgetState,
   decideStepBudgetExtension,
   isStaticDiscoveryToolCall,
   staticToolCallSignature,
   normalizeDynamicStepsMode,
+  shouldEvaluateResumeBoundary,
   summarizeRepeatedStaticDiscovery,
 } from "../src/step-budget-controller.js";
 import { SessionStore } from "../src/session-store.js";
@@ -59,6 +72,18 @@ function toolMessage(payload) {
 
 try {
   assert(normalizeDynamicStepsMode("off") === "off", "dynamic mode off did not normalize");
+  assert(
+    completionEvidenceNeedsCommand({ missingProjectCommands: ["python analysis.py"] }),
+    "a pending canonical command did not reopen command execution"
+  );
+  assert(
+    completionEvidenceNeedsCommand({ missingGitActions: ["commit"] }),
+    "a pending git action did not reopen command execution"
+  );
+  assert(
+    !completionEvidenceNeedsCommand({ missing: [], missingProjectCommands: [], missingGitActions: [] }),
+    "satisfied completion evidence kept command execution open"
+  );
   assert(normalizeDynamicStepsMode("always") === "on", "dynamic mode always did not normalize to on");
   assert(normalizeDynamicStepsMode("smart") === "auto", "dynamic mode smart did not normalize to auto");
   const inheritedBudget = createStepBudgetState(
@@ -111,6 +136,27 @@ try {
   assert(uniqueDiscovery.staticTotal === 2, "duplicate reads consumed the unique convergence budget");
   assert(uniqueDiscovery.staticCallTotal === 3, "raw static call telemetry did not retain duplicate calls");
   assert(uniqueDiscovery.staticCounts["read_file:/reference/A.md"] === 2, "per-signature loop accounting was lost");
+  const compactedDiscoveryState = {
+    meta: {
+      toolLoop: {
+        recent: [],
+        warned: ["file-read:/reference/A.md", "run_command:keep"],
+        staticCounts: { "file-read:/reference/A.md": 1 },
+        staticOrder: ["file-read:/reference/A.md"],
+        staticTotal: 1,
+        staticCallTotal: 1,
+        convergenceAnnounced: { staticTotal: 1 },
+      },
+    },
+  };
+  resetStaticDiscoveryAfterContextLoss(compactedDiscoveryState, "smoke-compaction");
+  assert(compactedDiscoveryState.meta.toolLoop.staticTotal === 0, "context recovery kept a stale static convergence total");
+  assert(compactedDiscoveryState.meta.toolLoop.staticOrder.length === 0, "context recovery kept stale read signatures active");
+  assert(compactedDiscoveryState.meta.toolLoop.staticHistory.length === 1, "context recovery did not archive discovery telemetry");
+  assert(
+    JSON.stringify(compactedDiscoveryState.meta.toolLoop.warned) === JSON.stringify(["run_command:keep"]),
+    "context recovery did not clear only stale static-read warnings"
+  );
   const exactReadSignature = staticToolCallSignature("read_file", { path: "/reference/A.md" }, {
     commandCwd: workspace,
   });
@@ -379,6 +425,35 @@ try {
     deleteOutputBlock?.category === "artifact-validation-delete-output",
     "artifact validation allowed delete-and-recreate repair of an exact output"
   );
+  const reopenedSourceReadState = {
+    commandCwd: workspace,
+    meta: {
+      artifactProgress: {
+        exactOutputPaths: ["outputs/report.md"],
+        needsRepair: true,
+        needsSourceRead: true,
+        reopenedSourcePaths: ["analysis.py"],
+      },
+    },
+  };
+  assert(
+    artifactValidationScopeBlock(
+      reopenedSourceReadState,
+      "read_file",
+      { path: "analysis.py" },
+      { commandCwd: workspace, artifactValidationPhase: true }
+    ) === null,
+    "a correction request could not inspect its exact named source file"
+  );
+  assert(
+    artifactValidationScopeBlock(
+      reopenedSourceReadState,
+      "read_file",
+      { path: "unrelated.py" },
+      { commandCwd: workspace, artifactValidationPhase: true }
+    )?.category === "artifact-validation-scope",
+    "the correction source allowance leaked to unrelated files"
+  );
   const artifactProgress = recordExactOutputProgress(
     artifactState,
     {
@@ -395,6 +470,28 @@ try {
     nextStepRuntimeConfig({ provider: "localllm" }, artifactState).artifactValidationPhase === true,
     "next step did not enter artifact validation mode"
   );
+  const reopenedRepairState = {
+    meta: {
+      goalContract: { revision: 9 },
+      artifactProgress: { reopenedGoalRevision: 9, reopenedMutationRevision: 4 },
+      projectVerification: { mutationRevision: 4 },
+    },
+  };
+  assert(
+    reopenedArtifactRepairPending(reopenedRepairState),
+    "a fresh same-task correction was cleared before any source mutation"
+  );
+  reopenedRepairState.meta.projectVerification.mutationRevision = 5;
+  assert(
+    !reopenedArtifactRepairPending(reopenedRepairState),
+    "a source mutation did not satisfy the revision-scoped repair obligation"
+  );
+  reopenedRepairState.meta.projectVerification.mutationRevision = 4;
+  reopenedRepairState.meta.goalContract.revision = 10;
+  assert(
+    !reopenedArtifactRepairPending(reopenedRepairState),
+    "an old correction obligation leaked into a different goal revision"
+  );
   artifactState.meta.artifactProgress.needsRepair = true;
   artifactState.meta.artifactProgress.outputEmbedded = true;
   artifactState.meta.artifactProgress.usedValidationTools = ["read_file"];
@@ -513,6 +610,27 @@ try {
     ) === "Completed and verified MEDIA_ROUTINE_READINESS.md.",
     "verified completion rewrote a result that already named the exact contract output"
   );
+  const portablePathState = {
+    commandCwd: workspace,
+    meta: {
+      artifactProgress: {
+        complete: true,
+        exactOutputPaths: [path.join(workspace, "reports", "fluorescence-dose-response-analysis.pdf")],
+        preflight: { defectCount: 0 },
+        preflightFingerprint: "passed",
+        defectCount: 0,
+        needsRepair: false,
+        needsCommand: false,
+        needsSourceRead: false,
+      },
+    },
+  };
+  const portableCompletion = canonicalizeVerifiedArtifactCompletion(portablePathState, "");
+  assert(
+    portableCompletion.includes("reports/fluorescence-dose-response-analysis.pdf") &&
+      !portableCompletion.includes(workspace),
+    "verified completion leaked an absolute private workspace path"
+  );
   artifactState.meta.artifactProgress.needsRepair = true;
   artifactState.meta.artifactProgress.defectCount = 2;
   assert(
@@ -656,6 +774,48 @@ try {
     },
     { meta: {}, stepsCompleted: 0 }
   );
+  const migratedDefaultBudget = createStepBudgetState(
+    {
+      provider: "localllm",
+      maxSteps: 30,
+      dynamicSteps: "auto",
+      dynamicStepExtensionLimit: 1,
+      dynamicStepExtensionLimitExplicit: false,
+      scsActive: false,
+    },
+    {
+      meta: {
+        stepBudget: {
+          initialMaxSteps: 30,
+          currentMaxSteps: 40,
+          hardCap: 60,
+          extensionLimit: 1,
+          extensionsUsed: 1,
+        },
+      },
+      stepsCompleted: 40,
+    }
+  );
+  assert(
+    migratedDefaultBudget.extensionLimit === 3 && migratedDefaultBudget.extensionsUsed === 1,
+    "resumed non-explicit step budget did not adopt the current bounded default"
+  );
+  assert(
+    shouldEvaluateResumeBoundary(
+      { resume: "existing-session" },
+      { stepsCompleted: 40 },
+      migratedDefaultBudget
+    ),
+    "a resumed session at its consumed boundary did not request bounded capacity before the loop"
+  );
+  assert(
+    !shouldEvaluateResumeBoundary(
+      { resume: "existing-session" },
+      { stepsCompleted: migratedDefaultBudget.hardCap },
+      { ...migratedDefaultBudget, currentMaxSteps: migratedDefaultBudget.hardCap }
+    ),
+    "a resumed session attempted to exceed its dynamic hard cap"
+  );
   const progressDecision = decideStepBudgetExtension({
     config: { scsActive: false },
     budget: normalBudget,
@@ -699,6 +859,65 @@ try {
   });
   assert(!blockedDecision.approved && /permission|approval|blocked/i.test(blockedDecision.reason), "budget gate did not deny blocker loops");
 
+  const repairBudget = createStepBudgetState(
+    {
+      provider: "localllm",
+      maxSteps: 30,
+      dynamicSteps: "on",
+      dynamicStepExtensionLimit: 2,
+      scsActive: false,
+    },
+    { meta: {}, stepsCompleted: 0 }
+  );
+  const repairDecision = decideStepBudgetExtension({
+    config: { scsActive: false, commandCwd: "/tmp/workspace" },
+    budget: repairBudget,
+    step: 29,
+    state: {
+      messages: [
+        toolMessage({
+          toolName: "run_command",
+          ok: false,
+          exitCode: 1,
+          args: { command: "python -m unittest discover -s tests" },
+          stderr: "AssertionError: expected calibrated values",
+        }),
+        toolMessage({
+          toolName: "apply_patch",
+          ok: false,
+          reason: "Patch search text was not found in analysis.py.",
+        }),
+        toolMessage({
+          toolName: "read_file",
+          ok: true,
+          args: { path: "analysis.py" },
+          path: "analysis.py",
+        }),
+        toolMessage({
+          toolName: "read_file",
+          ok: false,
+          blocked: true,
+          category: "repeated-read-only-call",
+          reason: "The same static discovery call already ran once.",
+        }),
+      ],
+    },
+    events: [
+      { type: "file.changed", data: { path: "analysis.py" } },
+      ...Array.from({ length: 30 }, (_, index) => ({
+        type: index % 2 === 0 ? "snapshot.captured" : "model.requested",
+        data: {},
+      })),
+      { type: "tool.completed", data: { toolName: "run_command", exitCode: 1 } },
+      { type: "tool.failed", data: { toolName: "apply_patch" } },
+      { type: "tool.blocked", data: { toolName: "read_file" } },
+    ],
+  });
+  assert(
+    repairDecision.approved && repairDecision.extraSteps > 0,
+    `budget gate denied an active repair after concrete file progress: ${repairDecision.reason}`
+  );
+
   const repeatedDiscoveryMessages = [
     "ls -la ../Musia",
     "ls -la ../LALACHAN",

package/scripts/smoke-integration-production-mount.js

@@ -543,6 +543,7 @@ async function verifyPackagedBinAndScriptClosure() {
   assert.equal(packageJson.bin?.["aginti-integration"], "bin/aginti-integration.js");
   assert.equal(packageJson.files.includes("bin/"), true);
   for (const requiredFile of [
+    "scripts/check-js-syntax.js",
     "scripts/eval-provider-attribution.js",
     "scripts/smoke-context-budget-recovery.js",
     "scripts/smoke-integration-production-mount.js",
@@ -553,11 +554,7 @@ async function verifyPackagedBinAndScriptClosure() {
     packageJson.scripts?.["smoke:integration-production-mount"],
     "node scripts/smoke-integration-production-mount.js"
   );
-  assert.equal(packageJson.scripts.check.includes("node --check bin/aginti-integration.js"), true);
-  assert.equal(
-    packageJson.scripts.check.includes("node --check scripts/smoke-integration-production-mount.js"),
-    true
-  );
+  assert.equal(packageJson.scripts.check, "node scripts/check-js-syntax.js");
   for (const relativePath of referencedRunnablePaths(packageJson)) {
     const stat = await fs.stat(path.join(REPOSITORY_ROOT, relativePath));
     assert.equal(stat.isFile(), true, `packaged script reference is missing: ${relativePath}`);
@@ -1131,5 +1128,6 @@ async function main() {
 
 main().catch((error) => {
   process.stderr.write(`integration production mount smoke: failed (${String(error?.code || error?.name || "ERROR")})\n`);
+  process.stderr.write(`${String(error?.stack || error?.message || error)}\n`);
   process.exitCode = 1;
 });

package/scripts/smoke-integration-retained-event-ledger-bundle.js

@@ -601,7 +601,7 @@ async function runCore() {
       cancellationAttestation: runtimeFixture.cancellationAttestation,
       hardenedSandboxAttestation: runtimeFixture.hardenedSandboxAttestation,
     });
-    const realRuntimeProof = realRuntimeAuthority.getIntegrationRuntimeProof();
+    const realRuntimeProof = await realRuntimeAuthority.getIntegrationRuntimeProof();
     assert.equal(realRuntimeProof.repositoryProofDigest, runtimeFixture.repositoryAttestation.digest);
     assert.equal(
       realRuntimeProof.eventAppendProofDigest,