@hassangameryt/freeflow 0.7.1 → 0.7.3

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

@@ -0,0 +1,577 @@
+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("source locators retain native occurrence identity and accept optional adapter labels", () => {
+  const state = initialState();
+  const assistantWith = (id, name, args) =>
+    entry(id, null, assistant("Observed", [{ type: "toolCall", id, name, arguments: args }]));
+  const result = (id, toolName) =>
+    entry(`${id}-result`, id, {
+      role: "toolResult",
+      toolCallId: id,
+      toolName,
+      content: [{ type: "text", text: "RESULT_BODY" }],
+    });
+  const entries = [
+    assistantWith("read-1", "read", { path: "same.txt", offset: 1, limit: 20 }),
+    result("read-1", "read"),
+    assistantWith("read-2", "read", { path: "same.txt", offset: 1, limit: 20 }),
+    result("read-2", "read"),
+    assistantWith("bash-1", "bash", { command: `printf "bad${String.fromCharCode(0)}${"x".repeat(220)}"` }),
+    result("bash-1", "bash"),
+    assistantWith("unknown-1", "write", { path: "out.txt" }),
+    result("unknown-1", "write"),
+    entry(
+      "ambiguous",
+      null,
+      assistant("Ambiguous", [
+        { type: "toolCall", id: "dup", name: "read", arguments: { path: "one.txt" } },
+        { type: "toolCall", id: "dup", name: "read", arguments: { path: "two.txt" } },
+      ]),
+    ),
+    entry("ambiguous-result", "ambiguous", {
+      role: "toolResult",
+      toolCallId: "dup",
+      toolName: "read",
+      content: [{ type: "text", text: "RESULT_BODY" }],
+    }),
+  ];
+  for (const source of entries)
+    state.authors.set(source.id, { profile: "executor", executionId: "e", assignmentId: "a" });
+  const sources = new Sources(entries, state);
+  assert.deepEqual(sources.locator("ctx:read-1-result"), {
+    callRef: "ctx:read-1",
+    toolCallId: "read-1",
+  });
+  assert.notEqual(sources.locator("ctx:read-1-result").callRef, sources.locator("ctx:read-2-result").callRef);
+  assert.deepEqual(sources.locator("ctx:bash-1-result"), {
+    callRef: "ctx:bash-1",
+    toolCallId: "bash-1",
+  });
+  assert.deepEqual(sources.locator("ctx:unknown-1-result"), {
+    callRef: "ctx:unknown-1",
+    toolCallId: "unknown-1",
+  });
+  assert.equal(sources.locator("ctx:ambiguous-result"), undefined);
+
+  const adapted = new Sources(entries, state, undefined, () => ({
+    label: `adapter${String.fromCharCode(0)}${"x".repeat(220)}`,
+  }));
+  const adaptedLocator = adapted.locator("ctx:bash-1-result");
+  assert.equal(adaptedLocator.truncated, true);
+  assert.ok(adaptedLocator.label.length <= 160);
+  assert.doesNotMatch(adaptedLocator.label, /\u0000/);
+});
+
+test("registered projection accepts a known eligible ref without inspection first", async () => {
+  await fixture((n, _body, manager) => {
+    if (n === 1) return call("freeflow_delegate", { operation: "assign", contract: "Read evidence and return." });
+    if (n === 2) return call("read", { path: "evidence.txt" });
+    if (n === 3) {
+      const ref = `ctx:${manager.getBranch().find((e) => e.message?.toolName === "read").id}`;
+      return call("freeflow_project", { operation: "add", refs: [ref] });
+    }
+    if (n === 4) {
+      const projects = manager.getBranch().filter((e) => e.message?.toolName === "freeflow_project");
+      assert.equal(projects.length, 1);
+      assert.deepEqual(
+        projects[0].message.details.items.map((item) => item.status),
+        ["added"],
+      );
+      assert.equal(projects[0].message.details.selected.length, 1);
+      return [
+        { name: "freeflow_return", args: { operation: "submit", report: "Evidence ready.", outcome: "completed" } },
+      ];
+    }
+    return [];
+  });
+});
+
+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 + 2].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"],
+  );
+  assert.deepEqual(
+    attempted.unresolved.map((p) => p.detail),
+    [
+      "Routing control messages are not task evidence. Use ctx:control#text if its visible assistant text is the intended evidence.",
+      "Routing control receipts are not task evidence; saved communication is delivered separately.",
+    ],
+  );
+  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",
+  );
+});