@lazyingart/agintiflow 0.20.292 → 0.20.296

package/docs/supervision-campaign-ledger.md

@@ -470,3 +470,82 @@ block, passed the exact hidden contract and all 13 visible tests, and left a
 clean target repository at `ef3c099`. Focused regressions and the complete npm
 suite pass. These runtime and skill fixes are released in AgInTiFlow
 `0.20.292`.
+
+### Retained storage live authority poisoning
+
+`retained-storage-live-poison-047` exercised the native integration storage
+authority after independent audit addenda, using a dictated but realistic
+operator prompt. The defect was an AgInTiFlow core integration-storage
+authority gap: live retained handles and named bindings were mostly checked,
+but the public limitation record omitted the generic `resolveBeneath:false`
+fact, and protected file success paths could return after cleanup awaits
+without one final permanent-poison check.
+
+The storage authority now reports `procfsRequired:true`,
+`resolveBeneath:false`, and `noXdev:false` truthfully across retained
+directory/file/lock limitation records. Live retained owner, mode, fstat, and
+named-binding divergence remains `INTEGRATION_STORAGE_POISONED`, not an
+availability failure, and protected read/write/sync paths check permanent
+poison again immediately before returning success.
+
+External verification used the module-mocked retained-storage smoke for live
+fstat, owner, mode, named-binding, concurrent poison, close/admission, cleanup,
+and residual-FD adversaries. Retained durable-common, retained file-lock,
+production-mount, integration authorities, runtime authority,
+session-persistence, syntax, and whitespace checks passed on the working tree.
+
+### Authoritative read-only routine first
+
+`authoritative-readonly-routine-001` reproduced the LabCanvas status failure
+from sessions `web-agent-labcanvas-cb6fe7cd-3464-42f7-99e4-b24c376e0115` and
+`web-agent-labcanvas-6d0b04bc-79e8-4fd8-87b4-4d8e651dcd72`. The first session
+had no selected routine and spent 25 model requests and 23 tools on broad
+workspace/private-store exploration. The second session received a disclosed
+canonical read-only routine, but AgInTiFlow still kept
+`requiredProjectCommands` empty, then continued through 32 model requests and
+32 tools after the status snapshot.
+
+The defect was an AgInTiFlow core execution-contract/SCS handoff gap, with a
+separate upstream routine-disclosure improvement already handled by
+AgenticApp. AgInTiFlow now promotes an authoritative read-only routine's first
+safe command into the exact required command batch, records an observed
+nonzero status snapshot as read-only evidence instead of a failed verifier,
+retains forbidden raw/private evidence scopes, and closes the following turn to
+`finish` once normal SCS evidence is sufficient.
+
+The focused regression uses a weak status prompt and a project-neutral
+`sample-status` routine. It proves the first model turn sees only the exact
+status command plus `finish`, a JSON status command exiting 1 still satisfies
+the read-only evidence contract, the second turn is finish-only, and no
+private/raw exploratory command is dispatched. `npm run smoke:progressive-tools`,
+`npm run smoke:scs-evidence`, `npm run smoke:truthful-completion`, and
+`npm run check` pass on the working tree.
+
+Fresh compact retest `web-agent-labcanvas-2ebe5aef-83c8-4134-abcd-bec630a4ecb9`
+reduced the flow to 6 model requests and 5 tool starts and used the canonical
+compact status command, but both valid `finish` calls were rejected because the
+human-facing status said `Still retrying: echomind_daily_pdf` and named a
+`next attempt`. That was still an AgInTiFlow core completion-semantic defect:
+the validator treated an observed external retry state as the agent promising
+unfinished work. The completion predicate now rejects pending work only when it
+is tied to the current task/report/validation/change or an agent-promised
+future action. Read-only status answers may truthfully report external
+pending/retrying/next-attempt state after sufficient evidence exists.
+
+Installed retest `web-agent-labcanvas-5e6eb6b6-fb8d-419d-a549-aa4098252064`
+then proved the next core gap. AgInTiFlow ran the same canonical compact
+health command exactly once and avoided raw/private exploration, but the
+finish-only verified-completion turns kept returning empty content and no tool
+calls with `finishReason=length` at the inherited 768-token output cap. After
+the bounded empty-response repair was exhausted, the runtime emitted the
+generic verified fallback `Evidence: command` instead of summarizing the
+authoritative JSON status snapshot.
+
+That defect is still AgInTiFlow core completion-loop behavior, not AgenticApp
+or a WeChat-specific routine. Verified-completion turns now have their own
+final-answer output floor and explicit finish-only instruction. If a provider
+still returns empty final responses after verified evidence exists, the
+fallback derives a concise public answer from the successful bounded command
+output. JSON status snapshots summarize visible delivered/retrying schedule
+states, ingress reachability, queue counts, and top-level health while keeping
+the original SCS checks for genuinely unfinished agent work.

package/package.json

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

@@ -9251,7 +9251,7 @@ try {
   const verifiedCompletionText = JSON.stringify(verifiedCompletionRequest?.messages || []);
   assert(
     verifiedCompletionRequest?.mode === "verified-completion" &&
-      verifiedCompletionRequest?.maxOutputTokens === 768,
+      verifiedCompletionRequest?.maxOutputTokens === 2048,
     "fresh passing evidence did not narrow the final response turn"
   );
   assert(

package/scripts/smoke-integration-storage-authority.js

@@ -538,6 +538,7 @@ async function main() {
     assert.equal(authority.attestation.limitations.preEnablePrimitive, true);
     assert.equal(authority.attestation.limitations.procfsRequired, true);
     assert.equal(authority.attestation.limitations.openat2ResolveBeneath, false);
+    assert.equal(authority.attestation.limitations.resolveBeneath, false);
     assert.equal(authority.attestation.limitations.noXdev, false);
 
     const identity = await authority.identity();

package/scripts/smoke-progressive-tool-selection.js

@@ -5501,6 +5501,55 @@ assertStrict.equal(
   undefined,
   "an explicit task artifact root still activated generic repository grounding"
 );
+const scopedPathWriteDescriptor = {
+  type: "function",
+  function: {
+    name: "write_file",
+    description: "Write one workspace file.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" },
+      },
+      required: ["path", "content"],
+      additionalProperties: false,
+    },
+  },
+};
+const scopedPathSurface = [
+  ...allTools.filter((item) => item.function.name !== "write_file"),
+  scopedPathWriteDescriptor,
+];
+const scopedPathTools = selectProgressiveTools(scopedPathSurface, {
+  config: {
+    provider: "deepseek",
+    progressiveTools: true,
+    scopedArtifactTask: true,
+    scopedArtifactRoot: scopedRuntime.scopedArtifactRoot,
+    commandCwd: "/workspace",
+  },
+  goal: scopedRuntimePrompt,
+  profile: "auto",
+  messages: [{ role: "user", content: scopedRuntimePrompt }],
+});
+const scopedWritePathPattern = scopedPathTools.find(
+  (item) => item.function.name === "write_file"
+)?.function?.parameters?.properties?.path?.pattern;
+assert(scopedWritePathPattern, "scoped artifact write tool omitted its path contract");
+const scopedWritePathRegex = new RegExp(scopedWritePathPattern);
+assert(
+  scopedWritePathRegex.test("output/wechat_worker/task/report.md"),
+  "scoped artifact write contract rejected its workspace-relative path"
+);
+assert(
+  scopedWritePathRegex.test("/workspace/output/wechat_worker/task/report.md"),
+  "scoped artifact write contract rejected the host-supplied exact absolute path"
+);
+assert(
+  !scopedWritePathRegex.test("/workspace/output/wechat_worker/other/report.md"),
+  "scoped artifact write contract accepted a sibling task path"
+);
 
 const longScopedTaskRoot = path.join(repoRoot, "output/wechat_worker/long-scoped-task");
 const longScopedScopeLine = `AGINTI_EVIDENCE_SCOPE_JSON: ${JSON.stringify({
@@ -7288,6 +7337,160 @@ async function runToolContractCase({
   }
 }
 
+function weakAuthoritativeRoutineGoal(command) {
+  return [
+    "AGINTI_EVIDENCE_SCOPE_JSON: {\"mode\":\"task\",\"request\":\"tell me phone and schedule status, read-only, dont send or change anything\"}",
+    "Matched established routines",
+    `- \`sample-status\` ready=true; commands=[${JSON.stringify(command)}, "node scripts/secondary-status.js --json"]; outputs=["status"]; guidance=For a read-only phone, message-intake, queue, or schedule question, run the canonical \`${command}\` command first. Treat the current status snapshot as authoritative. Do not inspect raw private stores, and do not send or mutate anything.`,
+    "Operating contract",
+    "- Forbidden evidence: raw/private ledgers are out of scope for this read-only answer.",
+  ].join("\n");
+}
+
+const authoritativeRoutineCommand = "node scripts/status.js status --json";
+const authoritativeRoutineGoal = weakAuthoritativeRoutineGoal(
+  authoritativeRoutineCommand
+);
+const authoritativeRoutineContract = completionTaskContract(
+  {
+    goal: authoritativeRoutineGoal,
+    taskProfile: "auto",
+  },
+  {
+    goal: authoritativeRoutineGoal,
+    meta: {
+      taskProfile: "auto",
+      goalContract: {
+        revision: 1,
+        currentRequest: authoritativeRoutineGoal,
+      },
+    },
+  }
+);
+assertStrict.deepEqual(
+  authoritativeRoutineContract.requiredProjectCommands,
+  [authoritativeRoutineCommand],
+  "authoritative read-only routine was not promoted to an exact required command"
+);
+assertStrict.deepEqual(
+  authoritativeRoutineContract.authoritativeRoutine?.forbiddenEvidenceScopes,
+  ["private", "raw"],
+  "authoritative read-only routine did not retain forbidden evidence scopes"
+);
+
+const hostedRequiredRoutineTools = selectProgressiveTools(allTools, {
+  config: {
+    provider: "deepseek",
+    toolSurfacePolicy: "full",
+    requiredProjectCommandPending: true,
+    requiredProjectCommand: authoritativeRoutineCommand,
+  },
+  goal: authoritativeRoutineGoal,
+  profile: "auto",
+});
+sameNames(
+  hostedRequiredRoutineTools,
+  ["run_command", "finish"],
+  "hosted/full policy did not constrain an authoritative routine first command"
+);
+assertStrict.deepEqual(
+  enumFor(hostedRequiredRoutineTools, "run_command", "command"),
+  [authoritativeRoutineCommand],
+  "authoritative routine command was not exposed as an exact enum"
+);
+
+let authoritativeRoutineStep = 0;
+const authoritativeRoutineRun = await runToolContractCase({
+  id: "authoritative-readonly-routine",
+  provider: "deepseek",
+  profile: "auto",
+  goal: authoritativeRoutineGoal,
+  allowShellTool: true,
+  maxSteps: 4,
+  toolCalls: [
+    contractCall("unused-authoritative", "finish", { result: "unused" }),
+  ],
+  expectSuccess: true,
+  setupWorkspace: async (workspace) => {
+    await fs.mkdir(path.join(workspace, "scripts"), { recursive: true });
+    await fs.writeFile(
+      path.join(workspace, "scripts", "status.js"),
+      [
+        "console.log(JSON.stringify({ phone: 'login-required', schedule: 'current', authoritative: true }));",
+        "process.exit(1);",
+        "",
+      ].join("\n"),
+      "utf8"
+    );
+  },
+  responseFactory: ({ payload }) => {
+    authoritativeRoutineStep += 1;
+    const offered = Array.isArray(payload.tools) ? names(payload.tools) : [];
+    if (authoritativeRoutineStep === 1) {
+      assertStrict.deepEqual(
+        offered,
+        ["run_command", "finish"],
+        "first authoritative routine turn exposed exploratory tools"
+      );
+      assertStrict.deepEqual(
+        enumFor(payload.tools, "run_command", "command"),
+        [authoritativeRoutineCommand],
+        "first authoritative routine turn did not constrain the exact command"
+      );
+      return assistantWithToolCalls([
+        contractCall("run-authoritative-status", "run_command", {
+          command: authoritativeRoutineCommand,
+        }),
+      ]);
+    }
+    assertStrict.deepEqual(
+      offered,
+      ["finish"],
+      "authoritative routine observation did not shrink the next turn to finish-only"
+    );
+    return assistantWithToolCalls([
+      contractCall("finish-authoritative-status", "finish", {
+        result: "The authoritative status snapshot says phone login is required and the schedule snapshot is current.",
+      }),
+    ]);
+  },
+});
+assertStrict.equal(
+  authoritativeRoutineRun.requests.length,
+  2,
+  "authoritative routine flow used more than two model requests"
+);
+assertStrict.equal(
+  authoritativeRoutineRun.events.filter(
+    (event) =>
+      event.type === "tool.started" &&
+      event.data?.toolName !== "finish"
+  ).length,
+  1,
+  "authoritative routine flow dispatched more than the canonical command"
+);
+assert(
+  authoritativeRoutineRun.events.some(
+    (event) =>
+      event.type === "tool.completed" &&
+      event.data?.toolName === "run_command" &&
+      event.data?.ok === false &&
+      event.data?.authoritativeReadOnlyRoutine === true &&
+      event.data?.authoritativeRoutineObserved === true
+  ),
+  "nonzero authoritative routine snapshot was not retained as observed evidence"
+);
+assert(
+  !authoritativeRoutineRun.events.some(
+    (event) =>
+      event.type === "tool.started" &&
+      /(?:^|[ /])(?:\\.private|private|raw|sqlite|jsonl)(?:$|[ /.-])/i.test(
+        String(event.data?.args?.command || "")
+      )
+  ),
+  "authoritative routine flow still dispatched private/raw exploratory commands"
+);
+
 const hiddenDryRun = await runToolContractCase({
   id: "native-hidden-dry-run",
   goal: "Create hidden-dry-run.txt containing unsafe if this tool dispatches.",
@@ -7647,6 +7850,7 @@ console.log(
         "finish-contract",
         "per-turn-contract-preserved",
         "schema-required-type-enum-extra",
+        "authoritative-readonly-routine-first",
         "native-hidden-dry-run-zero-dispatch",
         "text-fallback-unoffered-zero-dispatch",
         "strict-single-call-batch",

package/scripts/smoke-scs-evidence-visibility.js

@@ -637,11 +637,23 @@ assert.equal(
   "an incidental safety-clause 'cannot' was misclassified as a current external blocker"
 );
 assert.equal(finishResultClaimsIncompleteWork("Completed and verified the requested report."), false);
+assert.equal(
+  finishResultClaimsIncompleteWork(
+    "Read-only status: Still retrying: external_pdf (quality_retry_pending; next attempt at 10:14). Nothing was sent or changed."
+  ),
+  false,
+  "an external retry status was misclassified as unfinished agent work"
+);
 assert.equal(
   finishResultClaimsIncompleteWork("The task is paused. A corrected implementation will be written next."),
   true,
   "future work was accepted as a completed result"
 );
+assert.equal(
+  finishResultClaimsIncompleteWork("The requested report is pending and I will complete it next."),
+  true,
+  "agent-owned pending report work was accepted as complete"
+);
 
 const outputFilenameContract = deriveScsTaskContract({
   goal: "Save the complete cited report as `CLAIM_LEVEL_CITATION_RESEARCH.md` and include `negative evidence` in the report.",

package/scripts/smoke-truthful-completion.js

@@ -66,6 +66,34 @@ assert.equal(
   false,
   "a no-further-action completion statement was mistaken for future work"
 );
+assert.equal(
+  finishResultClaimsIncompleteWork(
+    "Read-only check done, nothing sent or changed. Still retrying: nightly_pdf (quality_retry_pending; next attempt at 10:14). Queues are otherwise healthy."
+  ),
+  false,
+  "external retry status in a read-only answer was mistaken for unfinished agent work"
+);
+assert.equal(
+  finishResultClaimsIncompleteWork(
+    "Schedule status: memo delivered, export retry pending, next attempt tomorrow. This is only a status report."
+  ),
+  false,
+  "external pending status in a read-only answer was mistaken for unfinished agent work"
+);
+assert.equal(
+  finishResultClaimsIncompleteWork(
+    "The current report is pending and I will finish it next."
+  ),
+  true,
+  "agent-owned pending report work was accepted as a completed result"
+);
+assert.equal(
+  finishResultClaimsIncompleteWork(
+    "Pending validation remains before this task is complete."
+  ),
+  true,
+  "agent-owned pending validation was accepted as a completed result"
+);
 
 const staleCompletionRepair =
   "The proposed completion was rejected because the requested action is not supported by concrete runtime evidence. Reason: Missing required git action(s): commit.";
@@ -173,7 +201,9 @@ async function runCase({
   responses,
   allowShellTool = false,
   allowFileTools = false,
+  allowDestructive = false,
   executionTier = "",
+  maxOutputTokens = undefined,
   resume = false,
   setup = null,
   scsActive = false,
@@ -215,6 +245,8 @@ async function runCase({
       commandCwd: workspace,
       sandboxMode: "host",
       packageInstallPolicy: "block",
+      ...(maxOutputTokens ? { maxOutputTokens } : {}),
+      allowDestructive,
       allowShellTool,
       allowFileTools,
       allowWrapperTools: false,
@@ -235,6 +267,8 @@ async function runCase({
     useDockerSandbox: false,
     sandboxMode: "host",
     packageInstallPolicy: "block",
+    ...(maxOutputTokens ? { maxOutputTokens } : {}),
+    allowDestructive,
     allowShellTool,
     allowFileTools,
     allowWrapperTools: false,
@@ -587,6 +621,141 @@ try {
   assert.match(futureWorkFinish.result.result, /verified the working directory/i);
   assert(futureWorkFinish.events.some((event) => event.type === "completion.evidence_rejected"));
 
+  const readOnlyExternalRetryStatus = await runCase({
+    id: "read-only-external-retry-status",
+    goal: "Execute the shell command pwd and report the status without changing anything.",
+    taskProfile: "shell",
+    allowShellTool: true,
+    responses: [
+      assistant("", [toolCall("external-status-proof", "run_command", { command: "pwd" })]),
+      assistant("", [
+        toolCall("finish-external-status", "finish", {
+          result:
+            "Read-only check done; nothing was sent or changed. Still retrying: nightly_pdf (quality_retry_pending; next attempt at 10:14). The requested command evidence is present.",
+        }),
+      ]),
+    ],
+  });
+  assert.equal(readOnlyExternalRetryStatus.calls.length, 2);
+  assert.equal(readOnlyExternalRetryStatus.result.stopped, undefined);
+  assert.match(readOnlyExternalRetryStatus.result.result, /Still retrying: nightly_pdf/);
+  assert(
+    readOnlyExternalRetryStatus.events.some(
+      (event) =>
+        event.type === "completion.candidate_assessed" &&
+        event.data?.claimsIncompleteWork === false
+    ),
+    "read-only external retry status was still marked claimsIncompleteWork=true"
+  );
+  assert(
+    !readOnlyExternalRetryStatus.events.some(
+      (event) => event.type === "completion.evidence_rejected"
+    ),
+    "read-only external retry status still triggered a completion repair"
+  );
+
+  const compactHealthCommand = "PYTHONPATH=src python -m agenticapp wechat health --compact --json";
+  const compactHealthGoal = [
+    "User request:",
+    "i was checking phone and schedulr tell me which daily things actually got delivered today and which still retrying, also can msg from me and msg from other people both reach agent. dont send chat or change anything, just inspect and answer short with evidence",
+    "",
+    "Matched established routines",
+    `- \`wechat-chatops\` ready=true; commands=[${JSON.stringify(compactHealthCommand)}, "python agentic_tools/wechat_gui_agent/scripts/wechat_android_ingress.py --status"]; outputs=["messages", "files", "task records"]; guidance=For a read-only phone, message-intake, queue, or schedule question, run the canonical compact health command first; it already includes both Android lanes. Use the raw Android status commands only when compact health marks a lane unknown or stale. Treat that current snapshot as authoritative and stop once it answers the request. Do not inspect raw chat text or private message ledgers or artifact directories, and do not send or mutate anything, unless the current request explicitly needs it.`,
+  ].join("\n");
+  const compactHealthFallback = await runCase({
+    id: "read-only-compact-health-empty-finish-fallback",
+    goal: compactHealthGoal,
+    taskProfile: "chatops",
+    allowShellTool: true,
+    allowDestructive: true,
+    maxOutputTokens: 768,
+    setup: async (workspace) => {
+      await fs.mkdir(path.join(workspace, "src", "agenticapp"), { recursive: true });
+      await fs.writeFile(path.join(workspace, "src", "agenticapp", "__init__.py"), "", "utf8");
+      await fs.writeFile(
+        path.join(workspace, "src", "agenticapp", "__main__.py"),
+        [
+          "import json",
+          "payload = {",
+          "  'ok': True,",
+          "  'operational': True,",
+          "  'degraded': True,",
+          "  'issues': ['wechat_login_required'],",
+          "  'phone_ingress': {",
+          "    'other_people': {'ok': True, 'fresh': True, 'reaches_agent': True, 'routes': 6},",
+          "    'self_authored': {'ok': True, 'fresh': True, 'reaches_agent': True, 'routes': 6, 'seeded_routes': 6},",
+          "  },",
+          "  'queues': {",
+          "    'wechat': {'ok': True, 'pending': 0, 'active': 0, 'recent_failure_count': 0, 'stale_count': 0},",
+          "    'wecom': {'ok': True, 'pending': 0, 'active': 0, 'recent_failure_count': 0, 'stale_count': 0},",
+          "  },",
+          "  'schedules': {",
+          "    'career_daily': {'delivered': True, 'retry_pending': False, 'running': True, 'status': 'delivered'},",
+          "    'echomind_daily_pdf': {'retry_pending': True, 'status': 'quality_retry_pending', 'next_attempt_at': '2026-08-31T02:47:35+00:00'},",
+          "    'memo_daily': {'delivered': True, 'required': True, 'retry_pending': False, 'status': 'delivered'},",
+          "  }",
+          "}",
+          "print(json.dumps(payload, indent=2, sort_keys=True))",
+          "",
+        ].join("\n"),
+        "utf8"
+      );
+    },
+    responses: [
+      assistant("", [toolCall("run-compact-health", "run_command", { command: compactHealthCommand })]),
+      reasoningOnly("The compact health JSON already answers the read-only status question, so I should produce a short final answer.", "length"),
+      reasoningOnly("I need to summarize delivered schedules, retrying schedules, phone ingress, and queues from the retained JSON.", "length"),
+    ],
+  });
+  assert.equal(
+    compactHealthFallback.calls.length,
+    3,
+    "empty finish-only verified completion burned extra model turns before fallback"
+  );
+  assert.equal(
+    compactHealthFallback.calls[1]?.max_tokens,
+    2048,
+    "verified-completion turn did not raise the installed 768-token cap"
+  );
+  assert.equal(
+    compactHealthFallback.calls[2]?.max_tokens,
+    2048,
+    "verified-completion retry did not retain the raised output cap"
+  );
+  assert.match(compactHealthFallback.result.result, /Delivered: .*career_daily.*memo_daily/i);
+  assert.match(compactHealthFallback.result.result, /Still retrying: .*echomind_daily_pdf.*next attempt 2026-08-31T02:47:35\+00:00/i);
+  assert.match(compactHealthFallback.result.result, /phone_ingress reaches the agent for: .*other_people.*self_authored/i);
+  assert.match(compactHealthFallback.result.result, /Queues: .*wechat pending 0 active 0.*wecom pending 0 active 0/i);
+  assert.match(compactHealthFallback.result.result, /Verified from runtime evidence/i);
+  assert.doesNotMatch(compactHealthFallback.result.result, /^Completed the requested work and verified it from runtime evidence\. Evidence: command/i);
+  assert.equal(
+    compactHealthFallback.events.filter(
+      (event) => event.type === "tool.started" && event.data?.toolName !== "finish"
+    ).length,
+    1,
+    "compact health fallback dispatched more than the authoritative command"
+  );
+  assert(
+    !compactHealthFallback.events.some(
+      (event) =>
+        event.type === "tool.started" &&
+        /(?:^|[ /])(?:\\.private|private|raw|sqlite|jsonl|artifact)(?:$|[ /.-])/i.test(
+          String(event.data?.args?.command || "")
+        )
+    ),
+    "compact health fallback explored forbidden private/raw evidence"
+  );
+  assert.equal(
+    compactHealthFallback.events.filter((event) => event.type === "completion.verified_fallback").length,
+    1,
+    "compact health empty response did not persist exactly one verified fallback"
+  );
+  assert.equal(
+    compactHealthFallback.events.filter((event) => event.type === "completion.empty_response_repair_requested").length,
+    0,
+    "finish-only reasoning repair still spent a separate empty-response repair turn"
+  );
+
   const wordCompletionWithoutArtifact = await runCase({
     id: "word-completion-without-artifact",
     goal: "Create an editable, phone-friendly project handoff from this folder.",