@hassangameryt/freeflow 0.7.1 → 0.7.3

package/pi-extension/tests/cognitive-routing-v2/recovery.test.js

@@ -0,0 +1,1034 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { access, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fixture } from "../fixtures/routing-native.js";
+import { replay } from "../../dist/cognitive-routing-v2/state.js";
+import { RoutingRuntime } from "../../dist/cognitive-routing-v2/runtime.js";
+
+for (const recoveryWorker of ["executor", "helper"]) {
+  const cognitiveRouting =
+    recoveryWorker === "helper"
+      ? {
+          enabled: true,
+          delegation: "helper",
+          projection: true,
+          profiles: {
+            coordinator: { provider: "openai", model: "gpt-4o", thinking: "off" },
+            helper: { provider: "openai", model: "gpt-4.1-mini", thinking: "off" },
+          },
+        }
+      : undefined;
+  test(
+    `attached ${recoveryWorker} recovery reuses omitted evidence, gates exact native reads, and blocks returned work`,
+    { timeout: 30000 },
+    async () => {
+      let assignmentId, baseReportId, baseReportRevision, omittedRef, supplementRef, recoveryRef, cwd;
+      const originalInvoke = RoutingRuntime.prototype.invoke;
+      const replayed = new Set();
+      RoutingRuntime.prototype.invoke = async function (name, id, input, signal, ctx) {
+        const intercepted =
+          name === "freeflow_unit" && input.operation === "recover"
+            ? { ...input, request: `${input.request} [accepted]` }
+            : name === "freeflow_return" && input.operation === "supplement"
+              ? { ...input, report: `${input.report} [accepted]` }
+              : input;
+        const first = await originalInvoke.call(this, name, id, intercepted, signal, ctx);
+        const key = `${name}:${input.operation}`;
+        if (
+          ((name === "freeflow_unit" && input.operation === "recover") ||
+            (name === "freeflow_return" && input.operation === "supplement")) &&
+          !replayed.has(key)
+        ) {
+          replayed.add(key);
+          this.receipts.clear();
+          const repeated = await originalInvoke.call(this, name, id, intercepted, signal, ctx);
+          assert.deepEqual(repeated, first, "same accepted operation returns the recorded receipt");
+          this.receipts.clear();
+          const changed = await originalInvoke.call(
+            this,
+            name,
+            id,
+            { ...intercepted, [input.operation === "recover" ? "request" : "report"]: "CHANGED_PAYLOAD" },
+            signal,
+            ctx,
+          );
+          assert.equal(changed.details.code, "operation_conflict");
+        }
+        return first;
+      };
+      try {
+        await fixture(
+          async (n, body, manager) => {
+            if (n === 1)
+              return [
+                { name: "freeflow_delegate", args: { operation: "assign", contract: "Read two files and report." } },
+              ];
+            if (n === 2) {
+              assert.equal(replay(manager.getBranch()).profile, recoveryWorker);
+              return [
+                { name: "read", args: { path: "evidence.txt" } },
+                { name: "read", args: { path: "unselected.txt" } },
+              ];
+            }
+            if (n === 3) {
+              const reads = manager.getBranch().filter((e) => e.message?.toolName === "read" && !e.message.isError);
+              omittedRef = `ctx:${reads[1].id}`;
+              return [
+                { name: "freeflow_project", args: { operation: "add", refs: [`ctx:${reads[0].id}`] } },
+                {
+                  name: "freeflow_return",
+                  args: { operation: "submit", report: "BASE_REPORT_UNCHANGED_41", outcome: "completed" },
+                },
+              ];
+            }
+            if (n === 4) {
+              const state = replay(manager.getBranch());
+              assignmentId = state.assignmentId;
+              baseReportId = state.assignments.get(assignmentId).returnHandoffId;
+              baseReportRevision = state.handoffs.get(baseReportId).reportRevision;
+              const wire = JSON.stringify(body);
+              assert.match(wire, /BASE_REPORT_UNCHANGED_41/);
+              assert.match(wire, /EXACT_EVIDENCE_BODY_81/);
+              assert.doesNotMatch(wire, /UNSELECTED_PRIVATE_BODY_93/);
+              return [
+                {
+                  name: "freeflow_unit",
+                  args: {
+                    operation: "recover",
+                    request: "Select the omitted result and read the approved third file only.",
+                    paths: ["recovery.txt"],
+                  },
+                },
+              ];
+            }
+            if (n === 5) {
+              assert.equal(body.model, "gpt-4.1-mini");
+              assert.equal(replay(manager.getBranch()).profile, recoveryWorker);
+              assert.match(
+                JSON.stringify(body),
+                /Select the omitted result and read the approved third file only\. \[accepted\]/,
+              );
+              return [
+                { name: "read", args: { path: "recovery.txt" } },
+                { name: "read", args: { path: "@recovery.txt" } },
+                { name: "read", args: { path: "evidence.txt" } },
+                { name: "write", args: { path: "recovery-write.txt", content: "forbidden" } },
+                { name: "bash", args: { command: "touch recovery-bash.txt" } },
+              ];
+            }
+            if (n === 6) {
+              const recent = manager
+                .getBranch()
+                .filter((e) => ["read", "write", "bash"].includes(e.message?.toolName))
+                .slice(-5);
+              const allowed = recent.find(
+                (e) =>
+                  e.message.toolName === "read" &&
+                  !e.message.isError &&
+                  JSON.stringify(e.message).includes("FRESH_RECOVERY_BODY_57"),
+              );
+              assert.ok(allowed, "the exact approved native read executes");
+              assert.equal(
+                recent.filter((e) => e !== allowed).every((e) => e.message.isError),
+                true,
+              );
+              await assert.rejects(access(join(cwd, "recovery-write.txt")));
+              await assert.rejects(access(join(cwd, "recovery-bash.txt")));
+              assert.equal(await readFile(join(cwd, "@recovery.txt"), "utf8"), "LITERAL_AT_FILE_BODY_68");
+              assert.equal(
+                recent.some((e) => JSON.stringify(e.message).includes("LITERAL_AT_FILE_BODY_68")),
+                false,
+                "Pi never reaches either @-transformed or literal resource for a rejected alias",
+              );
+              return [
+                {
+                  name: "freeflow_project",
+                  args: { operation: "add", refs: [omittedRef, `ctx:${allowed.id}`, "ctx:missing"] },
+                },
+                {
+                  name: "freeflow_return",
+                  args: { operation: "supplement", report: "RECOVERY_SUPPLEMENT_73", outcome: "completed" },
+                },
+              ];
+            }
+            if (n === 7) return [{ name: "read", args: { path: "recovery.txt" } }];
+            if (n === 8) {
+              const postSupplement = manager
+                .getBranch()
+                .filter((e) => e.message?.toolName === "read")
+                .at(-1);
+              assert.equal(postSupplement.message.isError, true, "a saved supplement ends recovery read permission");
+              assert.equal(postSupplement.message.content[0].text, "worker_task_phase_ended");
+              return [
+                {
+                  name: "freeflow_project",
+                  args: {
+                    operation: "remove",
+                    refs: ["ctx:missing"],
+                    reason: "Fixture removes the unresolved request.",
+                  },
+                },
+                { name: "freeflow_return", args: { operation: "retry" } },
+              ];
+            }
+            assert.equal(body.model, "gpt-4o");
+            const wire = JSON.stringify(body);
+            const state = replay(manager.getBranch());
+            if (n === 14) {
+              assert.equal(state.assessment.view, "suspended");
+              assert.equal(state.assessment.suspensionReason, "user-attention");
+              assert.doesNotMatch(wire, /EXACT_EVIDENCE_BODY_81/);
+              assert.match(wire, /NEW_USER_ATTENTION_29/);
+              return [{ name: "freeflow_unit", args: { operation: "assess" } }];
+            }
+            for (const value of [
+              "BASE_REPORT_UNCHANGED_41",
+              "RECOVERY_SUPPLEMENT_73 [accepted]",
+              "EXACT_EVIDENCE_BODY_81",
+              "UNSELECTED_PRIVATE_BODY_93",
+              "FRESH_RECOVERY_BODY_57",
+            ])
+              assert.ok(wire.includes(value), `missing ${value}`);
+            assert.match(wire, new RegExp(`producer: ${recoveryWorker}`));
+            if (n === 15) {
+              assert.equal(state.assessment.view, "active");
+              return [];
+            }
+            assert.equal(state.assignmentId, assignmentId);
+            assert.equal(state.assignments.get(assignmentId).state, "returned");
+            assert.equal(state.assignments.get(assignmentId).returnHandoffId, baseReportId);
+            assert.equal(state.handoffs.get(baseReportId).text, "BASE_REPORT_UNCHANGED_41");
+            assert.equal(state.handoffs.get(baseReportId).outcome, "completed");
+            assert.equal(state.handoffs.get(baseReportId).reportRevision, baseReportRevision);
+            assert.equal(state.assessment.handoffId, baseReportId);
+            assert.equal(state.assessment.view, "active");
+            assert.equal(state.recoveryId, undefined);
+            const completedRecovery = [...state.recoveries.values()].at(-1);
+            assert.equal(completedRecovery.state, "completed");
+            supplementRef = `supplement:${completedRecovery.id}:${completedRecovery.supplementRevision}`;
+            recoveryRef = `recovery:${completedRecovery.id}`;
+            assert.equal(
+              state.selections.get(assignmentId).selected.includes(omittedRef),
+              true,
+              "the originally omitted result is selected",
+            );
+            for (const marker of ["EXACT_EVIDENCE_BODY_81", "UNSELECTED_PRIVATE_BODY_93"])
+              assert.equal(
+                manager
+                  .getBranch()
+                  .filter(
+                    (e) =>
+                      e.message?.toolName === "read" &&
+                      !e.message.isError &&
+                      JSON.stringify(e.message).includes(marker),
+                  ).length,
+                1,
+                `${marker} was not replayed`,
+              );
+            if (n === 9)
+              return [{ name: "freeflow_unit", args: { operation: "inspect", view: "detail", ref: supplementRef } }];
+            if (n === 10) {
+              const detail = manager
+                .getBranch()
+                .filter((e) => e.message?.toolName === "freeflow_unit")
+                .at(-1).message.details;
+              assert.equal(detail.supplement, "RECOVERY_SUPPLEMENT_73 [accepted]");
+              assert.equal(detail.report, "BASE_REPORT_UNCHANGED_41");
+              assert.equal(detail.reportRef, `report:${baseReportId}:${baseReportRevision}`);
+              return [{ name: "freeflow_unit", args: { operation: "inspect", view: "detail", ref: recoveryRef } }];
+            }
+            const detail = manager
+              .getBranch()
+              .filter((e) => e.message?.toolName === "freeflow_unit")
+              .at(-1).message.details;
+            assert.equal(detail.recovery.state, "completed");
+            assert.equal(detail.supplementRef, supplementRef);
+            return [];
+          },
+          true,
+          async ({ session, manager, requests }) => {
+            await session.prompt("/freeflow resume");
+            await session.waitForIdle();
+            assert.equal(requests.length, 12);
+            await session.compact();
+            assert.equal(
+              manager.buildSessionContext().messages.some((message) => message.role === "user"),
+              false,
+            );
+            await session.reload();
+            await session.prompt("/freeflow resume");
+            await session.waitForIdle();
+            await session.prompt("NEW_USER_ATTENTION_29");
+            await session.waitForIdle();
+            assert.equal(requests.length, 15);
+          },
+          true,
+          { beforePrompt: (fixtureState) => (cwd = fixtureState.cwd), cognitiveRouting },
+        );
+      } finally {
+        RoutingRuntime.prototype.invoke = originalInvoke;
+      }
+    },
+  );
+}
+
+for (const returnedWorker of ["executor", "helper"]) {
+  const cognitiveRouting =
+    returnedWorker === "helper"
+      ? {
+          enabled: true,
+          delegation: "helper",
+          projection: true,
+          profiles: {
+            coordinator: { provider: "openai", model: "gpt-4o", thinking: "off" },
+            helper: { provider: "openai", model: "gpt-4.1-mini", thinking: "off" },
+          },
+        }
+      : undefined;
+  test(`a blocked ${returnedWorker} return denies ordinary work before retry`, { timeout: 30000 }, async () => {
+    let assignmentId;
+    const result = await fixture(
+      (n, body, manager) => {
+        if (n === 1)
+          return [
+            { name: "freeflow_delegate", args: { operation: "assign", contract: "Return with a delivery gap." } },
+          ];
+        if (n === 2) {
+          const state = replay(manager.getBranch());
+          assignmentId = state.assignmentId;
+          assert.equal(state.profile, returnedWorker);
+          return [
+            { name: "freeflow_project", args: { operation: "add", refs: ["ctx:missing"] } },
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "RETURNED_WORKER_REPORT_67", outcome: "completed" },
+            },
+          ];
+        }
+        if (n === 3) {
+          const state = replay(manager.getBranch());
+          assert.equal(state.profile, returnedWorker);
+          assert.equal(state.assignments.get(assignmentId).state, "returned");
+          assert.equal(state.handoffs.get(state.assignments.get(assignmentId).returnHandoffId).state, "blocked");
+          return [{ name: "read", args: { path: "evidence.txt" } }];
+        }
+        if (n === 4) {
+          const denied = manager
+            .getBranch()
+            .filter((entry) => entry.message?.toolName === "read")
+            .at(-1);
+          assert.equal(denied.message.isError, true);
+          assert.equal(denied.message.content[0].text, "worker_task_phase_ended");
+          return [
+            {
+              name: "freeflow_project",
+              args: { operation: "remove", refs: ["ctx:missing"], reason: "Resolve the fixture delivery gap." },
+            },
+            { name: "freeflow_return", args: { operation: "retry" } },
+          ];
+        }
+        assert.equal(body.model, "gpt-4o");
+        const state = replay(manager.getBranch());
+        assert.equal(state.assignmentId, assignmentId);
+        assert.equal(state.assignments.get(assignmentId).state, "returned");
+        assert.equal(state.handoffs.get(state.assignments.get(assignmentId).returnHandoffId).state, "configured");
+        assert.match(JSON.stringify(body), /RETURNED_WORKER_REPORT_67/);
+        return [];
+      },
+      true,
+      undefined,
+      true,
+      { cognitiveRouting, maxRequests: 7 },
+    );
+    assert.equal(result.requests.length, 5);
+  });
+}
+
+test(
+  "partial recovery supplement delivers communication while evidence remains suspended",
+  { timeout: 30000 },
+  async () => {
+    let baseReportId;
+    await fixture((n, body, manager) => {
+      if (n === 1)
+        return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return a base report." } }];
+      if (n === 2)
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "FALLBACK_BASE_REPORT_19", outcome: "completed" },
+          },
+        ];
+      if (n === 3) {
+        const state = replay(manager.getBranch());
+        baseReportId = state.assignments.get(state.assignmentId).returnHandoffId;
+        return [
+          {
+            name: "freeflow_unit",
+            args: { operation: "recover", request: "Report unavailable evidence honestly." },
+          },
+        ];
+      }
+      if (n === 4)
+        return [
+          { name: "freeflow_project", args: { operation: "add", refs: ["ctx:missing"] } },
+          {
+            name: "freeflow_return",
+            args: { operation: "supplement", report: "FALLBACK_SUPPLEMENT_23", outcome: "partial" },
+          },
+        ];
+      assert.equal(body.model, "gpt-4o");
+      const wire = JSON.stringify(body);
+      assert.match(wire, /FALLBACK_BASE_REPORT_19/);
+      assert.match(wire, /FALLBACK_SUPPLEMENT_23/);
+      assert.match(wire, /source_unavailable|Exact source is unavailable/);
+      const state = replay(manager.getBranch());
+      assert.equal(state.assessment.handoffId, baseReportId);
+      assert.equal(state.assessment.view, "suspended");
+      assert.equal(state.assessment.suspensionReason, "delivery-gap");
+      assert.equal(state.recoveryId, undefined);
+      assert.equal([...state.recoveries.values()].at(-1).state, "completed");
+      return [];
+    });
+  },
+);
+
+test(
+  "recovery cancellation preserves the report and restores the same assessment explicitly",
+  { timeout: 30000 },
+  async () => {
+    let baseReportId;
+    await fixture(
+      (n, _body, manager) => {
+        if (n === 1)
+          return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return a base report." } }];
+        if (n === 2)
+          return [
+            { name: "freeflow_return", args: { operation: "submit", report: "CANCEL_BASE_31", outcome: "completed" } },
+          ];
+        if (n === 3) {
+          const state = replay(manager.getBranch());
+          baseReportId = state.assignments.get(state.assignmentId).returnHandoffId;
+          return [{ name: "freeflow_unit", args: { operation: "recover", request: "Wait for cancellation." } }];
+        }
+        if (n === 4) return [];
+        if (n === 5)
+          return [{ name: "freeflow_unit", args: { operation: "cancel-recovery", reason: "No longer needed." } }];
+        if (n === 6) {
+          const state = replay(manager.getBranch());
+          assert.equal(state.recoveryId, undefined);
+          assert.equal([...state.recoveries.values()].at(-1).state, "cancelled");
+          assert.equal(state.handoffs.get(baseReportId).text, "CANCEL_BASE_31");
+          assert.equal(state.assessment.handoffId, baseReportId);
+          assert.equal(state.assessment.view, "suspended");
+          return [{ name: "freeflow_unit", args: { operation: "assess" } }];
+        }
+        assert.equal(replay(manager.getBranch()).assessment.view, "active");
+        return [];
+      },
+      true,
+      async ({ session }) => {
+        await session.prompt("Cancel the evidence recovery without changing the report.");
+        await session.waitForIdle();
+      },
+    );
+  },
+);
+
+test(
+  "fresh user recovery uses its own input basis without a changed-direction warning",
+  { timeout: 30000 },
+  async () => {
+    await fixture(
+      (n, body) => {
+        if (n === 1) return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return once." } }];
+        if (n === 2)
+          return [{ name: "freeflow_return", args: { operation: "submit", report: "base", outcome: "completed" } }];
+        if (n === 3) return [];
+        if (n === 4)
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "recover", request: "Recover evidence for this assessment." },
+            },
+          ];
+        if (n === 5) {
+          const wire = JSON.stringify(body);
+          assert.equal(body.model, "gpt-4.1-mini");
+          assert.match(wire, /Recovery request: Recover evidence for this assessment\./);
+          assert.doesNotMatch(wire, /Current input differs from the active Executor responsibility/);
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "supplement", report: "fresh-basis supplement", outcome: "completed" },
+            },
+          ];
+        }
+        return [];
+      },
+      true,
+      async ({ session }) => {
+        await session.prompt("Please recover omitted evidence now.");
+        await session.waitForIdle();
+      },
+    );
+  },
+);
+
+test("assessment waits for recovery cancellation before resuming", { timeout: 30000 }, async () => {
+  let selection;
+  await fixture(
+    (n, body, manager) => {
+      if (n === 1) return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return once." } }];
+      if (n === 2)
+        return [{ name: "freeflow_return", args: { operation: "submit", report: "base", outcome: "completed" } }];
+      if (n === 3) return [{ name: "freeflow_unit", args: { operation: "recover", request: "Recover later." } }];
+      if (n === 4) {
+        const state = replay(manager.getBranch());
+        selection = structuredClone(state.selections.get(state.assignmentId));
+        return [];
+      }
+      if (n === 5) {
+        const wire = JSON.stringify(body);
+        assert.match(
+          wire,
+          /Finish and deliver the recovery supplement or cancel recovery before using freeflow_unit assess/,
+        );
+        assert.doesNotMatch(wire, /Use freeflow_unit assess to restore the assessment/);
+        return [{ name: "freeflow_unit", args: { operation: "assess" } }];
+      }
+      if (n === 6) {
+        const state = replay(manager.getBranch());
+        const result = manager
+          .getBranch()
+          .filter((entry) => entry.message?.toolName === "freeflow_unit")
+          .at(-1).message;
+        assert.equal(result.details.code, "recovery_outstanding");
+        assert.equal(state.assessment.view, "suspended");
+        assert.equal(state.assessment.suspensionReason, "user-attention");
+        assert.equal(state.recoveries.get(state.recoveryId).state, "reading");
+        assert.deepEqual(state.selections.get(state.assignmentId), selection);
+        return [{ name: "freeflow_unit", args: { operation: "cancel-recovery", reason: "No longer needed." } }];
+      }
+      if (n === 7) {
+        const state = replay(manager.getBranch());
+        const wire = JSON.stringify(body);
+        assert.equal(state.recoveryId, undefined);
+        assert.equal(state.assessment.view, "suspended");
+        assert.match(wire, /Use freeflow_unit assess to restore the assessment/);
+        assert.doesNotMatch(
+          JSON.stringify(
+            body.input.filter((item) => JSON.stringify(item).includes("# Cognitive Routing Runtime State")).at(-1),
+          ),
+          /Finish and deliver the recovery supplement or cancel recovery/,
+        );
+        return [{ name: "freeflow_unit", args: { operation: "assess" } }];
+      }
+      const state = replay(manager.getBranch());
+      assert.equal(state.assessment.view, "active");
+      assert.equal(state.recoveryId, undefined);
+      return [];
+    },
+    true,
+    async ({ session }) => {
+      await session.prompt("Assess before the open recovery is settled.");
+      await session.waitForIdle();
+    },
+  );
+});
+
+test("cancelled unit closure atomically abandons attached recovery", { timeout: 30000 }, async () => {
+  let baseReportId, selectionSnapshot;
+  await fixture(
+    (n, _body, manager) => {
+      if (n === 1) return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return once." } }];
+      if (n === 2)
+        return [{ name: "freeflow_return", args: { operation: "submit", report: "close-base", outcome: "completed" } }];
+      if (n === 3) {
+        const state = replay(manager.getBranch());
+        baseReportId = state.assignments.get(state.assignmentId).returnHandoffId;
+        return [{ name: "freeflow_unit", args: { operation: "recover", request: "Recover later." } }];
+      }
+      if (n === 4) return [];
+      if (n === 5) {
+        selectionSnapshot = structuredClone([...replay(manager.getBranch()).selections]);
+        return [
+          {
+            name: "freeflow_unit",
+            args: { operation: "close", outcome: "cancelled", assessment: "Stop unit and recovery." },
+          },
+        ];
+      }
+      const state = replay(manager.getBranch());
+      const recovery = [...state.recoveries.values()].at(-1);
+      assert.equal(state.unitId, undefined);
+      assert.equal(state.assignmentId, undefined);
+      assert.equal(state.pendingId, undefined);
+      assert.equal(state.recoveryId, undefined);
+      assert.equal(recovery.state, "cancelled");
+      assert.equal(recovery.cancellationReason, "Stop unit and recovery.");
+      assert.equal(state.handoffs.get(baseReportId).text, "close-base");
+      assert.deepEqual([...state.selections], selectionSnapshot);
+      return [];
+    },
+    true,
+    async ({ session }) => {
+      await session.prompt("Cancel the unit and its recovery.");
+      await session.waitForIdle();
+    },
+  );
+});
+
+test("projection-off recovery can read packaged instructions and resume assessment", { timeout: 30000 }, async () => {
+  const packageRoot = process.cwd();
+  await fixture(
+    (n, body, manager) => {
+      if (n === 1)
+        return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return a base report." } }];
+      if (n === 2)
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "NO_PROJECTION_BASE_43", outcome: "completed" },
+          },
+        ];
+      if (n === 3)
+        return [
+          { name: "freeflow_unit", args: { operation: "recover", request: "Read the packaged Workflow method." } },
+        ];
+      if (n === 4)
+        return [{ name: "read", args: { path: join(packageRoot, "skills/workflow/SKILL.md"), offset: 1, limit: 8 } }];
+      if (n === 5) {
+        const read = manager
+          .getBranch()
+          .filter((e) => e.message?.toolName === "read")
+          .at(-1);
+        assert.equal(read.message.isError, false);
+        assert.match(JSON.stringify(read.message), /name: workflow|# Workflow/);
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "supplement", report: "PACKAGED_METHOD_READ_47", outcome: "completed" },
+          },
+        ];
+      }
+      assert.equal(body.model, "gpt-4o");
+      const state = replay(manager.getBranch());
+      assert.equal(state.assessment.view, "active");
+      assert.equal(state.recoveryId, undefined);
+      assert.match(JSON.stringify(body), /NO_PROJECTION_BASE_43/);
+      assert.match(JSON.stringify(body), /PACKAGED_METHOD_READ_47/);
+      return [];
+    },
+    false,
+    undefined,
+    true,
+  );
+});
+
+test(
+  "new input during recovery blocks further reads and a supplement preserves user attention",
+  { timeout: 30000 },
+  async () => {
+    let active, assignmentId, baseReportId;
+    await fixture(
+      async (n, body, manager) => {
+        if (n === 1)
+          return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return a base report." } }];
+        if (n === 2)
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "INTERRUPTED_RECOVERY_BASE_59", outcome: "completed" },
+            },
+          ];
+        if (n === 3) {
+          const state = replay(manager.getBranch());
+          assignmentId = state.assignmentId;
+          baseReportId = state.assignments.get(assignmentId).returnHandoffId;
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "recover", request: "Read only recovery.txt.", paths: ["recovery.txt"] },
+            },
+          ];
+        }
+        if (n === 4) {
+          assert.equal(body.model, "gpt-4.1-mini");
+          await active.steer("NEW_RECOVERY_ATTENTION_61");
+          return [{ name: "read", args: { path: "recovery.txt" } }];
+        }
+        if (n === 5) {
+          const state = replay(manager.getBranch());
+          assert.equal(state.assessment.view, "suspended");
+          assert.equal(state.assessment.suspensionReason, "user-attention");
+          assert.match(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+          return [{ name: "read", args: { path: "recovery.txt" } }];
+        }
+        if (n === 6) {
+          const lastRead = manager
+            .getBranch()
+            .filter((entry) => entry.message?.toolName === "read")
+            .at(-1);
+          assert.equal(lastRead.message.isError, true, "new input revokes recovery-read permission");
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "supplement", report: "INTERRUPTED_RECOVERY_SUPPLEMENT_67", outcome: "partial" },
+            },
+          ];
+        }
+        assert.equal(body.model, "gpt-4o");
+        assert.match(JSON.stringify(body), /NEW_RECOVERY_ATTENTION_61/);
+        assert.match(JSON.stringify(body), /INTERRUPTED_RECOVERY_SUPPLEMENT_67/);
+        const state = replay(manager.getBranch());
+        assert.equal(state.assignmentId, assignmentId);
+        assert.equal(state.assignments.get(assignmentId).state, "returned");
+        assert.equal(state.assignments.get(assignmentId).returnHandoffId, baseReportId);
+        assert.equal(state.handoffs.get(baseReportId).text, "INTERRUPTED_RECOVERY_BASE_59");
+        assert.equal(state.assessment.handoffId, baseReportId);
+        assert.equal(state.assessment.view, "suspended");
+        assert.equal(state.assessment.suspensionReason, "user-attention");
+        assert.equal(state.recoveryId, undefined);
+        assert.equal([...state.recoveries.values()].at(-1).state, "completed");
+        return [];
+      },
+      true,
+      undefined,
+      true,
+      { onSession: (session) => (active = session) },
+    );
+  },
+);
+
+test("manual hold and navigation preserve an unchanged recovery for explicit resume", { timeout: 30000 }, async () => {
+  let assignmentId, baseReportId, recoveryId, requestHandoffId;
+  await fixture(
+    (n, body, manager) => {
+      if (n === 1)
+        return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Return a base report." } }];
+      if (n === 2)
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "submit", report: "MANUAL_RECOVERY_BASE_71", outcome: "completed" },
+          },
+        ];
+      if (n === 3) {
+        const state = replay(manager.getBranch());
+        assignmentId = state.assignmentId;
+        baseReportId = state.assignments.get(assignmentId).returnHandoffId;
+        return [{ name: "freeflow_unit", args: { operation: "recover", request: "Resume this lookup unchanged." } }];
+      }
+      if (n === 4) {
+        const state = replay(manager.getBranch());
+        recoveryId = state.recoveryId;
+        requestHandoffId = state.recoveries.get(recoveryId).requestHandoffId;
+        assert.equal(state.recoveries.get(recoveryId).state, "reading");
+        return [];
+      }
+      if (n === 5) {
+        const state = replay(manager.getBranch());
+        assert.equal(body.model, "gpt-4.1-mini");
+        assert.equal(state.recoveryId, recoveryId);
+        assert.equal(state.recoveries.get(recoveryId).state, "reading");
+        assert.equal(state.assignmentId, assignmentId);
+        assert.equal(state.assignments.get(assignmentId).state, "returned");
+        return [
+          {
+            name: "freeflow_return",
+            args: { operation: "supplement", report: "MANUAL_RECOVERY_SUPPLEMENT_73", outcome: "completed" },
+          },
+        ];
+      }
+      const state = replay(manager.getBranch());
+      assert.equal(body.model, "gpt-4o");
+      assert.equal(state.control, "automatic");
+      assert.equal(state.assignmentId, assignmentId);
+      assert.equal(state.assignments.get(assignmentId).returnHandoffId, baseReportId);
+      assert.equal(state.handoffs.get(baseReportId).text, "MANUAL_RECOVERY_BASE_71");
+      assert.equal(state.assessment.handoffId, baseReportId);
+      assert.equal(state.assessment.view, "active");
+      assert.equal(state.recoveries.get(recoveryId).state, "completed");
+      assert.equal(state.recoveries.size, 1);
+      assert.equal(state.assignments.size, 1);
+      return [];
+    },
+    true,
+    async ({ session, manager, requests }) => {
+      const reads = manager.getEntries().filter((entry) => entry.message?.toolName === "read").length;
+      await session.prompt("/freeflow profile executor");
+      const configured = manager
+        .getEntries()
+        .find(
+          (entry) =>
+            entry.data?.data?.type === "handoff-state" &&
+            entry.data.data.handoffId === requestHandoffId &&
+            entry.data.data.state === "configured",
+        );
+      await session.navigateTree(configured.id, { summarize: false });
+      const before = requests.length;
+      await session.prompt("/freeflow resume");
+      assert.equal(requests.length, before, "resume cannot release a manual hold");
+      let state = replay(manager.getBranch());
+      assert.equal(state.control, "manual");
+      assert.equal(state.profile, "executor");
+      assert.equal(state.recoveryId, recoveryId);
+      assert.equal(state.recoveries.get(recoveryId).state, "reading");
+      await session.prompt("/freeflow profile auto");
+      state = replay(manager.getBranch());
+      assert.equal(state.control, "automatic");
+      assert.equal(state.profile, "coordinator");
+      await session.prompt("/freeflow resume");
+      await session.waitForIdle();
+      assert.equal(requests.length, before + 2);
+      assert.equal(
+        manager.getEntries().filter((entry) => entry.message?.toolName === "read").length,
+        reads,
+        "navigation and resume do not replay task reads",
+      );
+    },
+  );
+});
+
+test(
+  "resume after attention restores saved-return correction without reopening task work",
+  { timeout: 30000 },
+  async () => {
+    let reportId;
+    await fixture(
+      (n, body, manager) => {
+        if (n === 1)
+          return [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Read and report." } }];
+        if (n === 2) return [{ name: "read", args: { path: "evidence.txt" } }];
+        if (n === 3)
+          return [
+            { name: "freeflow_project", args: { operation: "add", refs: ["ctx:missing"] } },
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "ORIGINAL_SAVED_REPORT", outcome: "partial" },
+            },
+          ];
+        if (n === 4) {
+          reportId = replay(manager.getBranch()).pendingId;
+          return [];
+        }
+        if (n === 5) {
+          assert.equal(body.model, "gpt-4o");
+          return [];
+        }
+        if (n === 6) {
+          assert.equal(body.model, "gpt-4.1-mini");
+          return [{ name: "read", args: { path: "unselected.txt" } }];
+        }
+        if (n === 7) {
+          assert.equal(
+            manager
+              .getBranch()
+              .filter((e) => e.message?.toolName === "read")
+              .at(-1).message.isError,
+            true,
+          );
+          return [
+            {
+              name: "freeflow_project",
+              args: {
+                operation: "remove",
+                refs: ["ctx:missing"],
+                reason: "Invalid reference; evidence gap remains disclosed.",
+              },
+            },
+            { name: "freeflow_return", args: { operation: "retry" } },
+          ];
+        }
+        assert.equal(body.model, "gpt-4o");
+        assert.match(JSON.stringify(body), /ORIGINAL_SAVED_REPORT/);
+        assert.match(JSON.stringify(body), /evidence gap remains disclosed/);
+        const state = replay(manager.getBranch());
+        assert.equal(state.assessment.handoffId, reportId);
+        assert.equal(state.handoffs.get(reportId).reportRevision, 1);
+        assert.equal(state.assessment.view, "active");
+        return [];
+      },
+      true,
+      async ({ session, requests }) => {
+        await session.prompt("Explain the saved return's problem.");
+        await session.waitForIdle();
+        await session.prompt("/freeflow resume");
+        await session.waitForIdle();
+        assert.equal(requests.length, 8);
+      },
+    );
+  },
+);
+
+const normal = (n) =>
+  n === 1
+    ? [{ name: "freeflow_delegate", args: { operation: "assign", contract: "Read evidence.txt and report." } }]
+    : n === 2
+      ? [{ name: "read", args: { path: "evidence.txt" } }]
+      : n === 3
+        ? [{ name: "freeflow_return", args: { operation: "submit", report: "Read completed.", outcome: "completed" } }]
+        : [];
+
+for (const cut of ["delegate-accepted", "executor-configured", "executor-call", "read-result", "return-accepted"]) {
+  test(`native navigation reconciles valid ${cut} without replaying work`, { timeout: 30000 }, async () => {
+    await fixture(normal, false, async ({ session, manager, requests }) => {
+      const chosen = manager
+        .getEntries()
+        .find((e) =>
+          cut === "executor-configured"
+            ? e.data?.data?.type === "handoff-state" && e.data.data.state === "configured"
+            : cut === "executor-call"
+              ? e.message?.role === "assistant" && e.message.content?.some((b) => b.name === "read")
+              : cut === "read-result"
+                ? e.message?.toolName === "read"
+                : e.data?.data?.type === cut,
+        );
+      const reads = manager.getEntries().filter((e) => e.message?.toolName === "read").length;
+      await session.navigateTree(chosen.id, { summarize: false });
+      const before = requests.length;
+      await session.prompt("Explain the saved state at this point.");
+      await session.waitForIdle();
+      assert.equal(requests.length, before + 1);
+      assert.equal(requests.at(-1).model, "gpt-4o");
+      assert.equal(manager.getEntries().filter((e) => e.message?.toolName === "read").length, reads);
+      assert.equal(replay(manager.getBranch()).profile, "coordinator");
+    });
+  });
+}
+
+test(
+  "explicit resume continues the same assignment after Coordinator handles new input",
+  { timeout: 30000 },
+  async () => {
+    let assignment, unit;
+    await fixture(
+      (n, body, manager) => {
+        if (n <= 2) return normal(n);
+        if (n === 3) {
+          const s = replay(manager.getBranch());
+          assignment = s.assignmentId;
+          unit = s.unitId;
+          return [];
+        }
+        if (n === 4) {
+          assert.equal(body.model, "gpt-4o");
+          return [];
+        }
+        if (n === 5) {
+          assert.equal(body.model, "gpt-4.1-mini");
+          const s = replay(manager.getBranch());
+          assert.equal(s.assignmentId, assignment);
+          assert.equal(s.unitId, unit);
+          assert.equal(s.assignments.size, 1);
+          assert.match(JSON.stringify(body), /Do not edit files/);
+          assert.doesNotMatch(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+          return [{ name: "read", args: { path: "unselected.txt" } }];
+        }
+        if (n === 6) {
+          const read = manager
+            .getBranch()
+            .filter((e) => e.message?.toolName === "read")
+            .at(-1);
+          assert.equal(read.message.isError, false);
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "Resumed read completed; no edits.", outcome: "completed" },
+            },
+          ];
+        }
+        assert.equal(body.model, "gpt-4o");
+        return [];
+      },
+      false,
+      async ({ session, manager, requests }) => {
+        await session.prompt("Do not edit files. Explain the current partial result.");
+        await session.waitForIdle();
+        await session.prompt("/freeflow resume");
+        await session.waitForIdle();
+        assert.equal(requests.length, 7);
+        assert.equal(replay(manager.getBranch()).assignments.get(assignment).state, "returned");
+      },
+    );
+  },
+);
+
+test("current manual hold survives navigation and resume cannot release it", { timeout: 30000 }, async () => {
+  await fixture(normal, false, async ({ session, manager, requests }) => {
+    const old = manager.getEntries().find((e) => e.data?.data?.type === "delegate-accepted");
+    await session.prompt("/freeflow profile executor");
+    await session.navigateTree(old.id, { summarize: false });
+    const before = requests.length;
+    await session.prompt("/freeflow resume");
+    assert.equal(requests.length, before);
+    const s = replay(manager.getBranch());
+    assert.equal(s.control, "manual");
+    assert.equal(s.profile, "executor");
+    assert.equal(session.model.id, "gpt-4.1-mini");
+  });
+});
+
+test(
+  "late steering keeps the captured Executor request coherent and blocks dependent task tools",
+  { timeout: 30000 },
+  async () => {
+    let active;
+    await fixture(
+      async (n, body, manager) => {
+        if (n === 1) return normal(n);
+        if (n === 2) {
+          await active.steer("Stop further reads and explain the current result.");
+          return normal(n);
+        }
+        if (n === 3) {
+          assert.equal(body.model, "gpt-4.1-mini");
+          assert.match(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+          assert.ok(
+            body.tools.some((t) => t.name === "freeflow_delegate"),
+            "stable catalog retains definitions; runtime gates still deny wrong-role effects",
+          );
+          assert.deepEqual(body.tools.find((t) => t.name === "freeflow_unit").parameters.properties.operation.enum, [
+            "inspect",
+            "assess",
+            "recover",
+            "cancel-recovery",
+            "close",
+          ]);
+          return [{ name: "read", args: { path: "unselected.txt" } }];
+        }
+        if (n === 4) {
+          assert.equal(
+            manager
+              .getBranch()
+              .filter((e) => e.message?.toolName === "read")
+              .at(-1).message.isError,
+            true,
+          );
+          return [
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "Stopped for the newer instruction.", outcome: "partial" },
+            },
+          ];
+        }
+        assert.equal(body.model, "gpt-4o");
+        assert.ok(
+          body.tools.some((t) => t.name === "freeflow_return") && body.tools.some((t) => t.name === "freeflow_project"),
+        );
+        assert.match(JSON.stringify(body), /Stop further reads/);
+        return [];
+      },
+      false,
+      undefined,
+      true,
+      {
+        onSession: (session) => {
+          active = session;
+        },
+      },
+    );
+  },
+);