@hassangameryt/freeflow 0.7.1 → 0.7.2

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

@@ -0,0 +1,484 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fixture } from "../fixtures/routing-native.js";
+import { Sources } from "../../dist/session-sources/sources.js";
+import { initialState } from "../../dist/cognitive-routing-v2/state.js";
+import { prepareView, changeSelection } from "../../dist/cognitive-routing-v2/projection.js";
+import { RoutingRuntime } from "../../dist/cognitive-routing-v2/runtime.js";
+
+const call = (name, args) => [{ name, args }];
+const receipt = (m, name) =>
+  m
+    .getBranch()
+    .filter((e) => e.message?.toolName === name)
+    .at(-1).message.details;
+const model = {
+  id: "receiver",
+  provider: "fixture",
+  api: "fixture",
+  input: ["text"],
+  contextWindow: 100000,
+  maxTokens: 1000,
+};
+const assistant = (text, calls = []) => ({
+  role: "assistant",
+  content: [{ type: "text", text }, ...calls],
+  model: "receiver",
+  provider: "fixture",
+  api: "fixture",
+  timestamp: 1,
+  stopReason: calls.length ? "toolUse" : "stop",
+});
+const entry = (id, parentId, message) => ({ type: "message", id, parentId, message });
+function prepare(state, entries, messages = entries.map((e) => e.message), view = "executor") {
+  return prepareView({
+    state,
+    sources: new Sources(entries, state),
+    messages,
+    view,
+    projection: true,
+    model,
+    pair: { provider: "fixture", modelId: "receiver", thinking: "off" },
+    systemPrompt: "",
+    tools: [],
+    runtimeMessage: RoutingRuntime.prototype.runtimeMessage.call(
+      { projectionEnabled: true, token: "test", evidenceFacts: () => ({ selected: [] }) },
+      state,
+    ),
+    instance: "test",
+  });
+}
+
+test("provenance covers old sources and complete exchanges, with stable prefixes and unchanged originals", () => {
+  const state = initialState();
+  const entries = Array.from({ length: 40 }, (_, i) =>
+    entry(`m${i}`, i ? `m${i - 1}` : null, assistant(`Observation ${i}`)),
+  );
+  for (const [i, e] of entries.entries())
+    state.authors.set(e.id, {
+      profile: i % 2 ? "executor" : "coordinator",
+      assignmentId: i % 2 ? "earlier-assignment" : undefined,
+    });
+  entries.push(entry("unknown", "m39", assistant("Imported observation")));
+  entries.push(
+    entry(
+      "calls",
+      "unknown",
+      assistant("Read observations", [{ type: "toolCall", id: "c", name: "read", arguments: { path: "x" } }]),
+    ),
+  );
+  entries.push(
+    entry("result", "calls", {
+      role: "toolResult",
+      toolCallId: "c",
+      toolName: "read",
+      content: [{ type: "text", text: "FULL_RESULT" }],
+    }),
+  );
+  state.authors.set("calls", { profile: "executor", assignmentId: "current" });
+  state.authors.set("result", { profile: "executor", assignmentId: "current" });
+  const before = JSON.stringify(entries);
+  const prepared = prepare(state, entries);
+  const annotations = prepared.messages.filter((m) => m.customType === "freeflow-routing-v2-refs");
+  for (let i = 0; i < 40; i++)
+    assert.ok(
+      annotations.some((m) => m.content.includes(`ctx:m${i} | producer: ${i % 2 ? "executor" : "coordinator"}`)),
+    );
+  assert.ok(annotations.some((m) => m.content.includes("ctx:unknown | producer: unknown/common")));
+  const callIndex = prepared.messages.findIndex((m) => m.role === "assistant" && m.content.some((b) => b.id === "c"));
+  assert.equal(prepared.messages[callIndex + 1].toolCallId, "c", "no annotation splits a call/result exchange");
+  assert.match(prepared.messages[callIndex - 1].content, /ctx:result.*producer: executor/);
+  const extended = prepare(state, [...entries, entry("later", "result", assistant("Later observation"))]);
+  assert.deepEqual(
+    extended.messages.slice(0, prepared.messages.length - 1),
+    prepared.messages.slice(0, -1),
+    "appends leave old provenance stable",
+  );
+  assert.equal(JSON.stringify(entries), before);
+});
+
+test("new control selections are rejected while old selections and mixed assistant text remain usable", () => {
+  const state = initialState();
+  const entries = [
+    entry(
+      "control",
+      null,
+      assistant("Substantive executor finding", [
+        { type: "toolCall", id: "c", name: "freeflow_project", arguments: { operation: "inspect" } },
+      ]),
+    ),
+    entry("receipt", "control", {
+      role: "toolResult",
+      toolCallId: "c",
+      toolName: "freeflow_project",
+      content: [{ type: "text", text: '{"status":"unchanged"}' }],
+    }),
+  ];
+  for (const e of entries) state.authors.set(e.id, { profile: "executor", assignmentId: "a" });
+  const sources = new Sources(entries, state);
+  for (const s of sources.byRef.values()) state.exposure.set(s.ref, s.hash);
+  const empty = { revision: 0, selected: [], unresolved: [], withdrawals: [] };
+  const attempted = changeSelection(
+    empty,
+    { operation: "add", refs: ["ctx:control", "ctx:receipt", "ctx:control#text"] },
+    sources,
+    state,
+  );
+  assert.deepEqual(attempted.selected, ["ctx:control#text"]);
+  assert.deepEqual(
+    attempted.unresolved.map((p) => p.code),
+    ["routing_source", "routing_source"],
+  );
+  const prior = { ...empty, revision: 1, selected: ["ctx:receipt"] };
+  assert.equal(changeSelection(prior, { operation: "add", refs: ["ctx:receipt"] }, sources, state), prior);
+  state.assignmentId = "a";
+  state.selections.set("a", attempted);
+  const projected = prepare(
+    state,
+    entries,
+    entries.map((e) => e.message),
+    "coordinator",
+  );
+  assert.ok(
+    projected.messages.some(
+      (m) => m.customType === "freeflow-routing-v2-refs" && m.content.includes("ctx:control#text | producer: executor"),
+    ),
+  );
+  assert.ok(projected.messages.some((m) => m.customType === "freeflow-assistant-text"));
+  state.selections.set("a", prior);
+  assert.ok(
+    prepare(
+      state,
+      entries,
+      entries.map((e) => e.message),
+      "coordinator",
+    ).messages.some((m) => m.toolName === "freeflow_project"),
+  );
+});
+
+test("restoration preserves full report metadata and deduplicates by accepted occurrence", () => {
+  const state = initialState();
+  state.profile = "coordinator";
+  state.assignmentId = "a";
+  state.assignments.set("a", { id: "a", state: "returned", contract: "CONTRACT", delegateHandoffId: "d" });
+  state.handoffs.set("d", { id: "d", kind: "delegate", toolCallId: "dc" });
+  const h = {
+    id: "h",
+    assignmentId: "a",
+    kind: "return",
+    state: "configured",
+    toolCallId: "rc",
+    text: "SAME_REPORT",
+    outcome: "partial",
+    limitations: ["UNRUN_INTEGRATION"],
+    reportRevision: 2,
+  };
+  state.handoffs.set("h", h);
+  state.assessment = { handoffId: "h", view: "active", problems: [] };
+  const restored = JSON.stringify(prepare(state, [], [], "coordinator").messages);
+  for (const value of ["SAME_REPORT", "UNRUN_INTEGRATION", "partial", "report:h:2", "assignment:a"])
+    assert.ok(restored.includes(value));
+  const old = {
+    role: "toolResult",
+    toolName: "freeflow_return",
+    toolCallId: "other",
+    content: [{ type: "text", text: JSON.stringify({ report: h.text, outcome: "completed", limitations: [] }) }],
+  };
+  const oldResult = prepare(state, [], [old], "coordinator");
+  assert.ok(
+    oldResult.messages.some(
+      (m) => m.customType === "freeflow-routing-communication" && m.content.includes("SAME_REPORT"),
+    ),
+    "equal text from another call cannot satisfy current report",
+  );
+  const incomplete = { ...old, toolCallId: "rc" };
+  const corrected = prepare(state, [], [incomplete], "coordinator");
+  assert.equal(JSON.stringify(corrected.messages).split("SAME_REPORT").length - 1, 1);
+  assert.ok(JSON.stringify(corrected.messages).includes("UNRUN_INTEGRATION"));
+});
+
+for (const projection of [false, true])
+  test(`native report arrives complete without inspection and survives close, projection ${projection}`, async () => {
+    await fixture((n, body, m) => {
+      if (n === 1) return call("freeflow_delegate", { operation: "assign", contract: "Return a partial report." });
+      if (n === 2)
+        return call("freeflow_return", {
+          operation: "submit",
+          report: "REPORT_DIRECT_91",
+          outcome: "partial",
+          limitations: ["LIMIT_DIRECT_92"],
+        });
+      if (n === 3) {
+        const r = receipt(m, "freeflow_return");
+        assert.equal(r.outcome, "partial");
+        assert.deepEqual(r.limitations, ["LIMIT_DIRECT_92"]);
+        assert.match(r.assignmentRef, /^assignment:/);
+        assert.match(r.reportRef, /^report:.*:1$/);
+        for (const text of ["REPORT_DIRECT_91", "LIMIT_DIRECT_92", r.reportRef])
+          assert.ok(JSON.stringify(body).includes(text));
+        return call("freeflow_unit", {
+          operation: "close",
+          outcome: "deferred",
+          assessment: "Partial result acknowledged.",
+        });
+      }
+      if (n === 4)
+        for (const text of ["REPORT_DIRECT_91", "LIMIT_DIRECT_92"]) assert.ok(JSON.stringify(body).includes(text));
+      return [];
+    }, projection);
+  });
+
+test("native inspection snapshots distinguish page/scope totals, exclude controls and explain invalid work refs", async () => {
+  let first;
+  await fixture((n, body, m) => {
+    if (n === 1) return call("freeflow_delegate", { operation: "assign", contract: "Read observations." });
+    if (n === 2) return Array.from({ length: 35 }, () => ({ name: "read", args: { path: "evidence.txt" } }));
+    if (n === 3) return call("freeflow_project", { operation: "inspect", scope: "history" });
+    if (n === 4) {
+      first = receipt(m, "freeflow_project");
+      assert.equal(first.pageCounts.candidates, 30);
+      assert.ok(first.scopeCounts.candidates > 30);
+      assert.equal(first.scopeCounts.eligible, first.scopeCounts.candidates);
+      assert.ok(first.candidates.every((c) => c.producer === "executor" && !c.toolName?.startsWith("freeflow_")));
+      return call("freeflow_project", { operation: "inspect", scope: "history", cursor: first.nextCursor });
+    }
+    if (n === 5) {
+      const second = receipt(m, "freeflow_project");
+      assert.deepEqual(second.scopeCounts, first.scopeCounts);
+      assert.equal(
+        new Set([...first.candidates, ...second.candidates].map((c) => c.ref)).size,
+        first.scopeCounts.candidates,
+      );
+      return call("freeflow_return", { operation: "submit", report: "Done", outcome: "completed" });
+    }
+    if (n === 6)
+      return call("freeflow_unit", {
+        operation: "inspect",
+        view: "detail",
+        ref: receipt(m, "freeflow_return").handoff,
+      });
+    if (n === 7) {
+      assert.equal(receipt(m, "freeflow_unit").code, "invalid_work_ref");
+      return call("freeflow_unit", {
+        operation: "inspect",
+        view: "detail",
+        ref: receipt(m, "freeflow_return").assignmentRef,
+      });
+    }
+    if (n === 8) {
+      assert.equal(receipt(m, "freeflow_unit").report, "Done");
+      return call("freeflow_unit", { operation: "close", outcome: "accepted", assessment: "Read work assessed." });
+    }
+    return [];
+  });
+});
+
+test("native compaction restores report limitations and revision into the same assessment", async () => {
+  let saved;
+  await fixture(
+    (n, body, m) => {
+      if (n === 1)
+        return call("freeflow_delegate", { operation: "assign", contract: "Return a report for assessment." });
+      if (n === 2)
+        return call("freeflow_return", {
+          operation: "submit",
+          report: "COMPACT_REPORT_61",
+          outcome: "partial",
+          limitations: ["COMPACT_LIMIT_62"],
+        });
+      if (n === 3) {
+        saved = receipt(m, "freeflow_return");
+        return [];
+      }
+      if (n === 4) return call("freeflow_unit", { operation: "assess" });
+      if (n === 5) {
+        const wire = JSON.stringify(body);
+        for (const value of ["COMPACT_REPORT_61", "COMPACT_LIMIT_62", "partial", saved.assignmentRef, saved.reportRef])
+          assert.ok(wire.includes(value), value);
+      }
+      return [];
+    },
+    true,
+    async ({ session }) => {
+      await session.compact();
+      await session.prompt("Resume assessment of the existing saved report.");
+      await session.waitForIdle();
+    },
+  );
+});
+
+test("native retry delivers the unchanged complete report without a follow-up inspect", async () => {
+  let saved;
+  await fixture((n, body, m) => {
+    if (n === 1) return call("freeflow_delegate", { operation: "assign", contract: "Return available findings." });
+    if (n === 2) return call("freeflow_project", { operation: "add", refs: ["ctx:unavailable"] });
+    if (n === 3)
+      return call("freeflow_return", {
+        operation: "submit",
+        report: "RETRY_REPORT_11",
+        outcome: "partial",
+        limitations: ["RETRY_LIMIT_12"],
+      });
+    if (n === 4) {
+      saved = receipt(m, "freeflow_return");
+      assert.equal(saved.ready, false);
+      return call("freeflow_project", {
+        operation: "remove",
+        refs: ["ctx:unavailable"],
+        reason: "Original capture unavailable; retain limitation.",
+      });
+    }
+    if (n === 5) return call("freeflow_return", { operation: "retry" });
+    if (n === 6) {
+      const retried = receipt(m, "freeflow_return");
+      for (const key of ["report", "reportRef", "reportRevision", "assignmentRef", "outcome", "limitations"])
+        assert.deepEqual(retried[key], saved[key]);
+      assert.equal(retried.reportUnchanged, true);
+      for (const value of ["RETRY_REPORT_11", "RETRY_LIMIT_12", saved.reportRef])
+        assert.ok(JSON.stringify(body).includes(value));
+      return call("freeflow_unit", { operation: "close", outcome: "deferred", assessment: "Partial report assessed." });
+    }
+    return [];
+  });
+});
+
+test("empty new assignment advertises earlier evidence and selected receipts retain its producer", async () => {
+  let ref, oldAssignment;
+  await fixture((n, body, m) => {
+    if (n === 1 || n === 5)
+      return call("freeflow_delegate", {
+        operation: "assign",
+        contract: n === 1 ? "Read an observation." : "Reuse the earlier observation.",
+      });
+    if (n === 2) return call("read", { path: "evidence.txt" });
+    if (n === 3) {
+      ref = `ctx:${m.getBranch().find((e) => e.message?.toolName === "read").id}`;
+      return call("freeflow_return", { operation: "submit", report: "Observation captured.", outcome: "completed" });
+    }
+    if (n === 4)
+      return call("freeflow_unit", { operation: "close", outcome: "accepted", assessment: "Supported result." });
+    if (n === 6) return call("freeflow_project", { operation: "inspect" });
+    if (n === 7) {
+      const r = receipt(m, "freeflow_project");
+      assert.equal(r.count, 0);
+      assert.ok(r.otherAssignments > 0);
+      assert.match(r.historyHint, /scope history/);
+      return call("freeflow_project", { operation: "inspect", scope: "history" });
+    }
+    if (n === 8) {
+      const candidate = receipt(m, "freeflow_project").candidates.find((c) => c.ref === ref);
+      assert.equal(candidate.producer, "executor");
+      assert.equal(candidate.eligible, true);
+      oldAssignment = candidate.assignment;
+      return call("freeflow_project", { operation: "add", refs: [ref] });
+    }
+    if (n === 9) {
+      const selected = receipt(m, "freeflow_project").evidence.selected[0];
+      assert.equal(selected.producer, "executor");
+      assert.equal(selected.assignment, oldAssignment);
+      return call("freeflow_return", {
+        operation: "submit",
+        report: "Earlier evidence selected.",
+        outcome: "completed",
+      });
+    }
+    if (n === 10) {
+      const wire = JSON.stringify(body);
+      assert.ok(wire.includes(`${ref} | producer: executor`));
+      assert.ok(wire.includes("EXACT_EVIDENCE_BODY_81"));
+      return call("freeflow_unit", { operation: "inspect", view: "detail", ref: "assignment:absent" });
+    }
+    if (n === 11) {
+      assert.equal(receipt(m, "freeflow_unit").code, "work_unavailable");
+      return call("freeflow_unit", { operation: "close", outcome: "accepted", assessment: "Supported result." });
+    }
+    return [];
+  });
+});
+
+test("normal inspection hides delivery gaps while selected inspection preserves their diagnostics", async () => {
+  let ref;
+  const result = await fixture(
+    (n, body, m) => {
+      if (n === 1) return call("freeflow_delegate", { operation: "assign", contract: "Read and inspect evidence." });
+      if (n === 2) return call("read", { path: "evidence.txt" });
+      if (n === 3) {
+        ref = `ctx:${m.getBranch().find((e) => e.message?.content?.some?.((b) => b.type === "toolCall" && b.name === "read")).id}`;
+        return call("freeflow_project", { operation: "inspect", scope: "assignment" });
+      }
+      if ([4, 5, 6].includes(n)) {
+        const r = receipt(m, "freeflow_project");
+        assert.ok(r.candidates.every((c) => c.eligible && c.targetReady));
+        assert.ok(r.candidates.every((c) => !Object.hasOwn(c, "preview")));
+        assert.ok(!JSON.stringify(r).includes("EXACT_EVIDENCE_BODY_81"), "inspection does not repeat source text");
+        assert.equal(
+          r.candidates.find((c) => c.ref === ref),
+          undefined,
+          "incompatible whole message is not a candidate",
+        );
+        assert.ok(
+          r.candidates.some((c) => c.ref === `${ref}#text`),
+          "usable visible text remains offered",
+        );
+        assert.equal(r.scopeCounts.candidates, r.scopeCounts.targetReady);
+        assert.equal(r.pageCounts.candidates, r.pageCounts.targetReady);
+        if (n === 4) return call("freeflow_project", { operation: "inspect", scope: "active" });
+        if (n === 5) return call("freeflow_project", { operation: "inspect", scope: "history" });
+        return call("freeflow_project", { operation: "add", refs: [ref] });
+      }
+      if (n === 7) {
+        const r = receipt(m, "freeflow_project");
+        assert.equal(r.ready, false);
+        assert.ok(r.problems.some((p) => p.code === "target_representation"));
+        return call("freeflow_project", { operation: "inspect", scope: "selected" });
+      }
+      if (n === 8) {
+        const r = receipt(m, "freeflow_project");
+        assert.deepEqual(r.selected, [ref]);
+        const selected = r.candidates.find((c) => c.ref === ref);
+        assert.equal(Object.hasOwn(selected, "preview"), false);
+        assert.equal(selected.targetReady, false);
+        assert.ok(selected.limitations.some((p) => p.code === "target_representation"));
+        assert.equal(r.scopeCounts.candidates, 1);
+        assert.equal(r.scopeCounts.targetReady, 0);
+      }
+      return [];
+    },
+    true,
+    undefined,
+    true,
+    {
+      extensions: [
+        (pi) =>
+          pi.on("message_end", (e) => {
+            if (
+              e.message.role === "assistant" &&
+              e.message.content.some((b) => b.type === "toolCall" && b.name === "read")
+            )
+              return {
+                message: {
+                  ...e.message,
+                  content: [
+                    ...e.message.content,
+                    {
+                      type: "thinking",
+                      thinking: "Fixture signed reasoning",
+                      thinkingSignature: JSON.stringify({
+                        type: "reasoning",
+                        id: "rs_candidate",
+                        summary: [{ type: "summary_text", text: "Fixture signed reasoning" }],
+                      }),
+                    },
+                  ],
+                },
+              };
+          }),
+      ],
+    },
+  );
+  assert.deepEqual(
+    [...result.state.selections.values()].at(-1).selected,
+    [ref],
+    "inspection does not silently withdraw evidence",
+  );
+});

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

@@ -0,0 +1,183 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fixture, response } from "../fixtures/routing-native.js";
+import { replay } from "../../dist/cognitive-routing-v2/state.js";
+import { RoutingRuntime } from "../../dist/cognitive-routing-v2/runtime.js";
+import { Sources } from "../../dist/session-sources/sources.js";
+import { initialState } from "../../dist/cognitive-routing-v2/state.js";
+
+test("delivery identity uses observed ancestry, not unseen storage or an older retained user", () => {
+  const state = initialState();
+  const entries = ["old", "delivered", "queued"].map((id, i) => ({
+    id,
+    parentId: i ? ["old", "delivered"][i - 1] : null,
+    type: "message",
+    message: { role: "user", content: id, timestamp: i },
+  }));
+  state.executions.set("observed", { basisUserEntryId: "delivered" });
+  const read = (branch, active) =>
+    RoutingRuntime.prototype.lastDeliveredUser.call({ stateData: () => state }, new Sources(branch, state), active);
+  assert.equal(read(entries, []), "delivered", "unseen queued entry is not delivered");
+  assert.equal(read(entries, [entries[0].message]), "delivered", "older retained user does not regress delivery");
+  assert.equal(read(entries, [entries[2].message]), "queued", "newly represented user advances delivery");
+  assert.equal(read(entries.slice(0, 1), []), null, "a basis outside selected ancestry is not inherited");
+  assert.equal(read(entries.slice(0, 1), [entries[0].message]), "old");
+});
+
+test("reload and explicit resume after compaction keep the outstanding assignment", { timeout: 30000 }, async () => {
+  let assignmentId, basis;
+  const result = await fixture(
+    (n, body, manager) => {
+      if (n === 1)
+        return [
+          {
+            name: "freeflow_delegate",
+            args: { operation: "assign", contract: "Read and preserve this assignment through a technical pause." },
+          },
+        ];
+      if (n === 2) {
+        const state = replay(manager.getBranch());
+        assignmentId = state.assignmentId;
+        basis = state.assignments.get(assignmentId).basisUserEntryId;
+        return [{ name: "read", args: { path: "evidence.txt" } }];
+      }
+      if (n === 4) {
+        const state = replay(manager.getBranch());
+        assert.equal(body.model, "gpt-4.1-mini");
+        assert.equal(state.assignmentId, assignmentId);
+        assert.equal(state.assignments.size, 1);
+        assert.equal(state.resumeBasis.get(assignmentId), basis);
+        assert.doesNotMatch(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+        return [{ name: "read", args: { path: "unselected.txt" } }];
+      }
+      if (n === 5)
+        assert.equal(
+          manager
+            .getBranch()
+            .filter((e) => e.message?.toolName === "read")
+            .at(-1).message.isError,
+          false,
+        );
+      return [];
+    },
+    true,
+    async ({ session, manager }) => {
+      await session.compact();
+      assert.equal(
+        manager.buildSessionContext().messages.some((m) => m.role === "user"),
+        false,
+      );
+      await session.reload();
+      await session.prompt("/freeflow resume");
+      await session.waitForIdle();
+    },
+  );
+  assert.equal(result.requests.length, 5);
+});
+
+for (const projection of [false, true]) {
+  for (const newInput of [false, true]) {
+    test(
+      `native overflow compaction preserves input identity; projection=${projection}, new input=${newInput}`,
+      { timeout: 30000 },
+      async () => {
+        let session, assignmentId, basis;
+        const result = await fixture(
+          async (n, body, manager) => {
+            const call = (name, args) => [{ name, args }];
+            if (n === 1)
+              return call("freeflow_delegate", {
+                operation: "assign",
+                contract: "Read evidence, then continue the same assignment after recovery.",
+              });
+            if (n === 2) {
+              const state = replay(manager.getBranch());
+              assignmentId = state.assignmentId;
+              basis = state.assignments.get(assignmentId).basisUserEntryId;
+              return call("read", { path: "evidence.txt" });
+            }
+            // The fixture returns one actual provider overflow here. Pi owns the
+            // compaction and automatic retry, not a manually invoked routing hook.
+            if (n === 3) return [];
+            if (n === 4) {
+              assert.ok(manager.getEntries().some((e) => e.type === "compaction"));
+              assert.equal(
+                manager.buildSessionContext().messages.some((m) => m.role === "user"),
+                false,
+              );
+              const state = replay(manager.getBranch());
+              assert.equal(state.assignmentId, assignmentId);
+              assert.equal(state.assignments.size, 1);
+              assert.equal([...state.executions.values()].at(-1).basisUserEntryId, basis);
+              assert.doesNotMatch(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+              assert.match(JSON.stringify(body), /Read evidence, then continue the same assignment after recovery/);
+              if (newInput) await session.steer("Stop further task reads; report the partial result.");
+              return call("read", { path: "unselected.txt" });
+            }
+            if (n === 5) {
+              assert.equal(
+                manager
+                  .getBranch()
+                  .filter((e) => e.message?.toolName === "read")
+                  .at(-1).message.isError,
+                false,
+              );
+              if (newInput) {
+                assert.match(JSON.stringify(body), /New delivered user input requires Coordinator attention/);
+                assert.notEqual([...replay(manager.getBranch()).executions.values()].at(-1).basisUserEntryId, basis);
+                return call("read", { path: "evidence.txt" });
+              }
+              return call("freeflow_return", {
+                operation: "submit",
+                report: "Same assignment completed after compaction.",
+                outcome: "completed",
+              });
+            }
+            if (newInput && n === 6) {
+              assert.equal(
+                manager
+                  .getBranch()
+                  .filter((e) => e.message?.toolName === "read")
+                  .at(-1).message.isError,
+                true,
+              );
+              return call("freeflow_return", {
+                operation: "submit",
+                report: "Stopped for genuine new input.",
+                outcome: "partial",
+              });
+            }
+            assert.equal(body.model, "gpt-4o");
+            assert.equal(replay(manager.getBranch()).assignments.get(assignmentId).state, "returned");
+            return [];
+          },
+          projection,
+          async ({ manager }) => {
+            assert.equal(manager.getEntries().filter((e) => e.type === "compaction").length, 1);
+          },
+          true,
+          {
+            onSession: (s) => {
+              session = s;
+            },
+            settings: { compaction: { enabled: true, keepRecentTokens: 1, reserveTokens: 1 } },
+            response: (n, calls) =>
+              n === 3
+                ? new Response(
+                    JSON.stringify({
+                      error: {
+                        message: "Your input exceeds the context window of this model.",
+                        type: "invalid_request_error",
+                        code: "context_length_exceeded",
+                      },
+                    }),
+                    { status: 400, headers: { "content-type": "application/json" } },
+                  )
+                : response(n, calls),
+          },
+        );
+        assert.equal(result.requests.length, newInput ? 7 : 6);
+      },
+    );
+  }
+}