@hassangameryt/freeflow 0.7.2 → 0.8.0

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

@@ -1,183 +0,0 @@
-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);
-      },
-    );
-  }
-}

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

@@ -1,441 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { replay } from "../../dist/cognitive-routing-v2/state.js";
-import { fixture, response } from "../fixtures/routing-native.js";
-
-for (const projection of [false, true])
-  test(`native delegate/read/return/close with projection=${projection}`, { timeout: 30000 }, async () => {
-    let ref;
-    const result = await fixture((n, body, manager) => {
-      if (n === 1) {
-        assert.equal(body.model, "gpt-4o");
-        assert.equal(
-          body.tools.find((t) => t.name === "freeflow_delegate")?.parameters?.type,
-          "object",
-          "provider function schema has an object root",
-        );
-        return [
-          {
-            name: "freeflow_delegate",
-            args: { operation: "assign", contract: "Read evidence.txt and return the exact observed body." },
-          },
-        ];
-      }
-      if (n === 2) {
-        assert.equal(body.model, "gpt-4.1-mini");
-        return [{ name: "read", args: { path: "evidence.txt" } }];
-      }
-      if (n === 3) {
-        assert.equal(body.model, "gpt-4.1-mini");
-        const e = manager.getBranch().find((e) => e.message?.role === "toolResult" && e.message.toolName === "read");
-        assert.ok(e, "real read result exists");
-        ref = `ctx:${e.id}`;
-        if (projection) assert.match(JSON.stringify(body), new RegExp(ref));
-        return [
-          ...(projection ? [{ name: "freeflow_project", args: { operation: "add", refs: [ref] } }] : []),
-          {
-            name: "freeflow_return",
-            args: { operation: "submit", report: "Read observed EXACT_EVIDENCE_BODY_81.", outcome: "completed" },
-          },
-        ];
-      }
-      if (n === 4) {
-        assert.equal(body.model, "gpt-4o");
-        assert.match(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
-        return [
-          {
-            name: "freeflow_unit",
-            args: {
-              operation: "close",
-              outcome: "accepted",
-              assessment: "Actual captured read body supports the fixture assignment.",
-            },
-          },
-        ];
-      }
-      return [];
-    }, projection);
-    assert.equal(result.requests.length, 5, JSON.stringify(result.contexts.at(-1), null, 2));
-    assert.equal(result.state.unitId, undefined);
-    assert.equal([...result.state.units.values()][0].state, "closed");
-    const assignments = [...result.state.assignments.values()];
-    assert.equal(assignments.length, 1);
-    assert.equal(assignments[0].state, "returned");
-    const read = result.entries.find((e) => e.message?.role === "toolResult" && e.message.toolName === "read");
-    assert.match(JSON.stringify(read.message), /EXACT_EVIDENCE_BODY_81/);
-  });
-
-test(
-  "saved report survives bad selection and payload-free retry; post-return writes are blocked",
-  { timeout: 30000 },
-  async () => {
-    let ref, reportId;
-    const report = "SUBSTANTIVE_SAVED_REPORT_902";
-    const result = await fixture((n, body, manager) => {
-      if (n === 1)
-        return [
-          {
-            name: "freeflow_delegate",
-            args: { operation: "assign", contract: "Read evidence and return it; no unrelated writes." },
-          },
-        ];
-      if (n === 2) return [{ name: "read", args: { path: "evidence.txt" } }];
-      if (n === 3) {
-        ref = "ctx:" + manager.getBranch().find((e) => e.message?.toolName === "read").id;
-        return [
-          { name: "freeflow_project", args: { operation: "add", refs: [ref, "ctx:missing"] } },
-          {
-            name: "freeflow_return",
-            args: { operation: "submit", report, outcome: "partial", limitations: ["Bad reference unresolved"] },
-          },
-        ];
-      }
-      if (n === 4) {
-        assert.equal(body.model, "gpt-4.1-mini");
-        const s = replay(manager.getBranch());
-        reportId = s.assessment.handoffId;
-        assert.equal(s.handoffs.get(reportId).text, report);
-        assert.equal(s.handoffs.get(reportId).state, "blocked");
-        return [{ name: "write", args: { path: "forbidden.txt", content: "must not happen" } }];
-      }
-      if (n === 5) {
-        const write = manager.getBranch().find((e) => e.message?.toolName === "write");
-        assert.ok(write?.message.isError, "post-return task call rejected");
-        return [
-          {
-            name: "freeflow_project",
-            args: {
-              operation: "remove",
-              refs: ["ctx:missing"],
-              reason: "Reference was invalid; no missing unique evidence.",
-            },
-          },
-          { name: "freeflow_return", args: { operation: "retry" } },
-        ];
-      }
-      if (n === 6) {
-        assert.equal(body.model, "gpt-4o");
-        assert.match(JSON.stringify(body), new RegExp(report));
-        assert.match(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
-        const s = replay(manager.getBranch());
-        assert.equal(s.assessment.handoffId, reportId);
-        assert.equal(s.handoffs.get(reportId).reportRevision, 1);
-        return [
-          {
-            name: "freeflow_unit",
-            args: {
-              operation: "close",
-              outcome: "accepted",
-              assessment: "Actual evidence received; saved report preserved.",
-            },
-          },
-        ];
-      }
-      return [];
-    });
-    assert.equal(result.requests.length, 7);
-    assert.equal(result.state.assignments.size, 1);
-  },
-);
-
-test("native projection omits an unselected sibling body but preserves its exchange", { timeout: 30000 }, async () => {
-  await fixture(
-    (n, body, manager) => {
-      if (n === 1)
-        return [
-          {
-            name: "freeflow_delegate",
-            args: { operation: "assign", contract: "Read both files; select only evidence.txt." },
-          },
-        ];
-      if (n === 2)
-        return [
-          { name: "read", args: { path: "evidence.txt" } },
-          { name: "read", args: { path: "unselected.txt" } },
-        ];
-      if (n === 3) {
-        assert.match(JSON.stringify(body), /UNSELECTED_PRIVATE_BODY_93/);
-        const e = manager
-          .getBranch()
-          .find(
-            (e) =>
-              e.message?.role === "toolResult" && JSON.stringify(e.message.content).includes("EXACT_EVIDENCE_BODY_81"),
-          );
-        return [
-          { name: "freeflow_project", args: { operation: "add", refs: ["ctx:" + e.id] } },
-          {
-            name: "freeflow_return",
-            args: { operation: "submit", report: "Selected the requested evidence.", outcome: "completed" },
-          },
-        ];
-      }
-      if (n > 4) {
-        assert.equal(body.model, "gpt-4o");
-        assert.match(
-          JSON.stringify(body),
-          /EXACT_EVIDENCE_BODY_81/,
-          "D-002 retains admitted active evidence during attention",
-        );
-        return [];
-      }
-      assert.equal(body.model, "gpt-4o");
-      assert.match(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
-      assert.doesNotMatch(JSON.stringify(body), /UNSELECTED_PRIVATE_BODY_93/);
-      assert.match(JSON.stringify(body), /Executor result omitted/);
-      return [];
-    },
-    true,
-    async ({ session, manager, requests }) => {
-      const before = replay(manager.getBranch()).assessment.handoffId;
-      await session.reload();
-      await session.prompt("A new question unrelated to the pending assessment.");
-      await session.waitForIdle();
-      const state = replay(manager.getBranch());
-      assert.equal(state.assessment.handoffId, before);
-      assert.equal(state.assessment.view, "suspended");
-      const last = JSON.stringify(requests.at(-1));
-      assert.match(last, /EXACT_EVIDENCE_BODY_81/, "suspension pauses historical restoration, not active membership");
-      assert.match(last, /suspended/);
-    },
-  );
-});
-
-test("bundled CLI loads the package entrypoint and completes the real routing loop", { timeout: 30000 }, async () => {
-  const { spawn } = await import("node:child_process");
-  const { fileURLToPath } = await import("node:url");
-  const { readFile } = await import("node:fs/promises");
-  const root = await mkdtemp(join(tmpdir(), "freeflow-v2-cli-")),
-    cwd = join(root, "cwd"),
-    agentDir = join(root, "agent");
-  try {
-    await mkdir(join(cwd, ".freeflow"), { recursive: true });
-    await mkdir(agentDir);
-    await writeFile(
-      join(cwd, ".freeflow/config.json"),
-      JSON.stringify({
-        cognitiveRouting: {
-          enabled: true,
-          projection: false,
-          profiles: {
-            coordinator: { provider: "openai", model: "gpt-4o", thinking: "off" },
-            executor: { provider: "openai", model: "gpt-4.1-mini", thinking: "off" },
-          },
-        },
-      }),
-    );
-    await writeFile(
-      join(agentDir, "models.json"),
-      JSON.stringify({ providers: { openai: { baseUrl: "https://fixture.invalid/v1" } } }),
-    );
-    await writeFile(
-      join(agentDir, "auth.json"),
-      JSON.stringify({ openai: { type: "api_key", key: "fixture-not-real" } }),
-    );
-    await writeFile(
-      join(agentDir, "settings.json"),
-      JSON.stringify({
-        defaultProvider: "openai",
-        defaultModel: "gpt-4o",
-        defaultThinkingLevel: "off",
-        compaction: { enabled: false },
-        retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
-      }),
-    );
-    const capture = join(root, "requests.json");
-    const extension = join(root, "transport.mjs");
-    await writeFile(
-      extension,
-      `import {writeFileSync} from 'node:fs';\n${response.toString()}\nexport default function(){const models=[];globalThis.fetch=async(url,init)=>{if(!String(url).startsWith('https://fixture.invalid/'))throw new Error('Unexpected network '+url);const body=JSON.parse(String(init.body));models.push(body.model);writeFileSync(${JSON.stringify(capture)},JSON.stringify(models));const n=models.length;if(n>4)throw new Error('Unexpected extra request');const steps=[[{name:'freeflow_delegate',args:{operation:'assign',contract:'Return the observed fixture result.'}}],[{name:'freeflow_return',args:{operation:'submit',report:'Fixture result ready.',outcome:'completed'}}],[{name:'freeflow_unit',args:{operation:'close',outcome:'accepted',assessment:'Received the saved report.'}}],[]];return response(n,steps[n-1]);};}`,
-    );
-    const cli = fileURLToPath(new URL("./bundle/cli.js", import.meta.resolve("@earendil-works/pi-coding-agent")));
-    const packageEntry = fileURLToPath(new URL("../../freeflow/index.js", import.meta.url));
-    const args = [
-      cli,
-      "-p",
-      "--mode",
-      "json",
-      "--no-extensions",
-      "--no-skills",
-      "--no-context-files",
-      "--no-prompt-templates",
-      "--no-themes",
-      "-e",
-      extension,
-      "-e",
-      packageEntry,
-      "Run the fixture.",
-    ];
-    const child = spawn(process.execPath, args, {
-      cwd,
-      env: {
-        PATH: process.env.PATH,
-        HOME: root,
-        PI_CODING_AGENT_DIR: agentDir,
-        PI_OFFLINE: "1",
-        PI_TELEMETRY: "0",
-        PI_SKIP_VERSION_CHECK: "1",
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-    });
-    let output = "";
-    child.stdout.on("data", (d) => (output += d));
-    child.stderr.on("data", (d) => (output += d));
-    const timer = setTimeout(() => child.kill("SIGKILL"), 20000);
-    const code = await new Promise((resolve, reject) => {
-      child.on("error", reject);
-      child.on("close", resolve);
-    });
-    clearTimeout(timer);
-    assert.equal(code, 0, output.slice(-12000));
-    assert.deepEqual(JSON.parse(await readFile(capture, "utf8")), ["gpt-4o", "gpt-4.1-mini", "gpt-4o", "gpt-4o"]);
-    assert.match(output, /"status":"closed"/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-for (const withUI of [false, true])
-  test(
-    `manual hold and reload preserve outstanding assignment; replacement stays in unit (ui=${withUI})`,
-    { timeout: 30000 },
-    async () => {
-      let originalAssignment, unit;
-      await fixture(
-        (n, body, manager) => {
-          if (n === 1)
-            return [
-              {
-                name: "freeflow_delegate",
-                args: { operation: "assign", contract: "Initial assignment; wait for amended direction." },
-              },
-            ];
-          if (n === 2) {
-            const s = replay(manager.getBranch());
-            originalAssignment = s.assignmentId;
-            unit = s.unitId;
-            return [];
-          }
-          if (n === 3) {
-            assert.equal(body.model, "gpt-4o");
-            return [
-              {
-                name: "freeflow_delegate",
-                args: {
-                  operation: "replace",
-                  contract: "Return the revised result.",
-                  reason: "User explicitly amended the outstanding assignment.",
-                },
-              },
-            ];
-          }
-          if (n === 4) {
-            assert.equal(body.model, "gpt-4.1-mini");
-            const s = replay(manager.getBranch());
-            assert.equal(s.unitId, unit);
-            assert.notEqual(s.assignmentId, originalAssignment);
-            assert.equal(s.assignments.get(originalAssignment).state, "superseded");
-            return [
-              {
-                name: "freeflow_return",
-                args: { operation: "submit", report: "Revised result.", outcome: "completed" },
-              },
-            ];
-          }
-          if (n === 5)
-            return [
-              {
-                name: "freeflow_unit",
-                args: { operation: "close", outcome: "accepted", assessment: "Revised result received." },
-              },
-            ];
-          return [];
-        },
-        false,
-        async ({ session, manager, requests, notices }) => {
-          await session.prompt("/freeflow profile coordinator");
-          assert.equal(replay(manager.getBranch()).control, "manual");
-          await session.reload();
-          assert.equal(replay(manager.getBranch()).control, "manual");
-          assert.equal(replay(manager.getBranch()).assignmentId, originalAssignment);
-          await session.prompt("/freeflow profile auto");
-          assert.equal(replay(manager.getBranch()).control, "automatic", JSON.stringify(notices));
-          await session.prompt("Replace the old assignment with the revised result.");
-          await session.waitForIdle();
-          assert.equal(requests.length, 6);
-          assert.equal(replay(manager.getBranch()).unitId, undefined);
-        },
-        withUI,
-      );
-    },
-  );
-
-test(
-  "native compaction and attention preserve the original assessment and restore exact selected evidence",
-  { timeout: 30000 },
-  async () => {
-    let handoff, ref;
-    await fixture(
-      (n, body, manager) => {
-        if (n === 1)
-          return [
-            {
-              name: "freeflow_delegate",
-              args: { operation: "assign", contract: "Read the evidence, select it and return." },
-            },
-          ];
-        if (n === 2) return [{ name: "read", args: { path: "evidence.txt" } }];
-        if (n === 3) {
-          ref = "ctx:" + manager.getBranch().find((e) => e.message?.toolName === "read").id;
-          return [
-            { name: "freeflow_project", args: { operation: "add", refs: [ref] } },
-            {
-              name: "freeflow_return",
-              args: { operation: "submit", report: "Review the selected source.", outcome: "completed" },
-            },
-          ];
-        }
-        if (n === 4) {
-          handoff = replay(manager.getBranch()).assessment.handoffId;
-          assert.match(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
-          return [];
-        }
-        if (n === 5) {
-          assert.doesNotMatch(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
-          return [{ name: "freeflow_unit", args: { operation: "assess" } }];
-        }
-        if (n === 6) {
-          assert.match(JSON.stringify(body), /EXACT_EVIDENCE_BODY_81/);
-          assert.equal(replay(manager.getBranch()).assessment.handoffId, handoff);
-          return [
-            {
-              name: "freeflow_unit",
-              args: {
-                operation: "close",
-                outcome: "accepted",
-                assessment: "Exact selected source recovered after native compaction.",
-              },
-            },
-          ];
-        }
-        return [];
-      },
-      true,
-      async ({ session, manager, requests }) => {
-        await session.compact("Use the deterministic fixture summary.");
-        assert.ok(manager.getEntries().some((e) => e.type === "compaction"));
-        assert.ok(
-          !manager.buildContextEntries().some((e) => "ctx:" + e.id === ref),
-          "source is no longer in ordinary active context",
-        );
-        assert.equal(replay(manager.getBranch()).assessment.handoffId, handoff);
-        await session.prompt("Return to the saved assessment.");
-        await session.waitForIdle();
-        assert.equal(requests.length, 7);
-        assert.equal(replay(manager.getBranch()).unitId, undefined);
-      },
-    );
-  },
-);