@hassangameryt/freeflow 0.7.2 → 0.7.3

package/pi-extension/tests/cache-reuse/native.test.js

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fixture } from "../fixtures/routing-native.js";
+const profiles = Object.fromEntries(
+  ["coordinator", "helper", "executor"].map((p) => [
+    p,
+    { provider: "openai", model: "gpt-6-astra", thinking: p === "coordinator" ? "high" : "low" },
+  ]),
+);
+for (const projection of [false, true])
+  test(`native routing preserves per-view prefixes with projection=${projection}`, { timeout: 30000 }, async () => {
+    const last = new Map();
+    let ref;
+    const result = await fixture(
+      (n, body, manager) => {
+        const runtimeItems = body.input.filter((x) => JSON.stringify(x).includes("# Cognitive Routing Runtime State"));
+        const current = JSON.stringify(runtimeItems.at(-1));
+        const profile = current.includes("Profile: coordinator") ? "coordinator" : "worker";
+        const view = projection ? profile : "ordinary";
+        const previous = last.get(view);
+        if (previous) {
+          assert.deepEqual(body.tools, previous.tools, "fixed routing tool definitions");
+          assert.deepEqual(
+            body.input.slice(0, previous.input.length),
+            previous.input,
+            `prior ${view} prefix survives request ${n}`,
+          );
+        }
+        last.set(view, body);
+        if (n === 1)
+          return [
+            {
+              name: "freeflow_delegate",
+              args: { operation: "assign", worker: "helper", contract: "Read evidence.txt and select its result." },
+            },
+          ];
+        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 [
+            ...(projection ? [{ name: "freeflow_project", args: { operation: "add", refs: [ref] } }] : []),
+            { name: "freeflow_return", args: { operation: "submit", report: "Evidence read.", outcome: "completed" } },
+          ];
+        }
+        if (n === 4)
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "close", outcome: "accepted", assessment: "Exact evidence observed." },
+            },
+          ];
+        if (n === 5)
+          return [
+            {
+              name: "freeflow_delegate",
+              args: { operation: "assign", worker: "executor", contract: "Read evidence.txt and return." },
+            },
+          ];
+        if (n === 6) return [{ name: "read", args: { path: "evidence.txt" } }];
+        if (n === 7) {
+          const latest = manager
+            .getBranch()
+            .filter((e) => e.message?.toolName === "read")
+            .at(-1);
+          return [
+            ...(projection
+              ? [{ name: "freeflow_project", args: { operation: "add", refs: ["ctx:" + latest.id] } }]
+              : []),
+            {
+              name: "freeflow_return",
+              args: { operation: "submit", report: "Executor evidence read.", outcome: "completed" },
+            },
+          ];
+        }
+        if (n === 8)
+          return [
+            {
+              name: "freeflow_unit",
+              args: { operation: "close", outcome: "accepted", assessment: "Second exact result checked." },
+            },
+          ];
+        return [];
+      },
+      projection,
+      undefined,
+      false,
+      { cognitiveRouting: { enabled: true, projection, delegation: "both", profiles } },
+    );
+    assert.equal(result.requests.length, 9);
+    assert.ok(result.entries.some((e) => e.customType === "freeflow-request-history-v1"));
+  });

package/pi-extension/tests/cache-reuse/settings.test.js

@@ -0,0 +1,211 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import freeflow from "../../dist/index.js";
+import { response } from "../fixtures/routing-native.js";
+
+test(
+  "native Freeflow settings retain the exact prefix; archive and restore change only real evidence",
+  { timeout: 30000 },
+  async () => {
+    const root = await mkdtemp(join(tmpdir(), "freeflow-settings-cache-")),
+      agentDir = join(root, "agent");
+    await mkdir(agentDir);
+    await mkdir(join(root, ".freeflow"));
+    const config = join(root, ".freeflow/config.json");
+    await writeFile(config, JSON.stringify({ enabled: true }));
+    await writeFile(join(root, "evidence.txt"), "PRIVATE_RAW_EVIDENCE_716");
+    let session, action, ref;
+    const requests = [],
+      errors = [],
+      prior = globalThis.fetch;
+    const manager = SessionManager.create(root, join(root, "sessions"));
+    globalThis.fetch = async (url, init) => {
+      assert.equal(String(url), "https://api.openai.com/v1/responses");
+      const body = JSON.parse(String(init.body));
+      requests.push(body);
+      assert.ok(requests.length <= 20);
+      let calls = [];
+      if (action === "read") {
+        action = undefined;
+        calls = [{ name: "read", args: { path: "evidence.txt" } }];
+      }
+      if (action === "archive") {
+        action = undefined;
+        calls = [
+          {
+            name: "freeflow_context",
+            args: { operation: "archive", targets: [{ ref, retained: "The completed evidence was checked." }] },
+          },
+        ];
+      }
+      if (action === "restore") {
+        action = undefined;
+        calls = [{ name: "freeflow_context", args: { operation: "restore", refs: [ref] } }];
+      }
+      if (action === "denied") {
+        action = undefined;
+        calls = [
+          { name: "freeflow_context", args: { operation: "search", query: "private" } },
+          { name: "freeflow_delegate", args: { operation: "assign", contract: "Must not execute" } },
+        ];
+      }
+      return response(requests.length, calls, "OK");
+    };
+    try {
+      const runtime = await ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: null,
+        modelsStorePath: join(agentDir, "models.json"),
+        allowModelNetwork: false,
+      });
+      await runtime.setRuntimeApiKey("openai", "fixture-key");
+      const settings = SettingsManager.inMemory({
+        transport: "sse",
+        compaction: { enabled: false },
+        retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
+      });
+      const loader = new DefaultResourceLoader({
+        cwd: root,
+        agentDir,
+        settingsManager: settings,
+        noExtensions: true,
+        noSkills: true,
+        noPromptTemplates: true,
+        noThemes: true,
+        noContextFiles: true,
+        systemPrompt: "Synthetic fixture.",
+        extensionFactories: [freeflow],
+      });
+      await loader.reload();
+      ({ session } = await createAgentSession({
+        cwd: root,
+        agentDir,
+        modelRuntime: runtime,
+        model: runtime.getModel("openai", "gpt-6-astra"),
+        thinkingLevel: "high",
+        settingsManager: settings,
+        sessionManager: manager,
+        resourceLoader: loader,
+      }));
+      await session.bindExtensions({ mode: "print", onError: (e) => errors.push(e) });
+      const prompt = async () => {
+        await session.prompt("Continue the synthetic fixture.");
+        await session.waitForIdle();
+        assert.equal(session.messages.at(-1).stopReason, "stop");
+        assert.deepEqual(errors, []);
+        return requests.at(-1);
+      };
+      action = "read";
+      await prompt();
+      const read = manager.getBranch().find((e) => e.message?.toolName === "read");
+      ref = "ctx:" + read.id;
+      const original = JSON.stringify(read);
+      let previous = requests.at(-1);
+      const stable = async () => {
+        const body = await prompt();
+        assert.deepEqual(body.tools, previous.tools);
+        assert.deepEqual(body.input.slice(0, previous.input.length), previous.input);
+        previous = body;
+      };
+      await session.prompt("/freeflow disable");
+      await stable();
+      action = "denied";
+      await stable();
+      assert.ok(
+        manager
+          .getBranch()
+          .filter((e) => ["freeflow_context", "freeflow_delegate"].includes(e.message?.toolName))
+          .every((e) => e.message.isError),
+      );
+      assert.ok(!manager.getBranch().some((e) => e.customType === "freeflow-routing-v2"));
+      await session.prompt("/freeflow enable");
+      await stable();
+      await writeFile(config, JSON.stringify({ enabled: true, conversationHistory: true }));
+      await session.reload();
+      await stable();
+      await writeFile(
+        config,
+        JSON.stringify({ enabled: true, conversationHistory: true, contextVirtualization: true }),
+      );
+      await session.reload();
+      await stable();
+      await writeFile(join(root, ".freeflow/local.json"), JSON.stringify({ enabled: true }));
+      await session.reload();
+      await stable();
+      const routing = {
+        enabled: true,
+        projection: false,
+        profiles: {
+          coordinator: { provider: "openai", model: "gpt-6-astra", thinking: "high" },
+          executor: { provider: "openai", model: "gpt-6-astra", thinking: "low" },
+        },
+      };
+      await writeFile(
+        config,
+        JSON.stringify({
+          enabled: true,
+          conversationHistory: true,
+          contextVirtualization: true,
+          cognitiveRouting: routing,
+        }),
+      );
+      await session.reload();
+      await stable();
+      await session.prompt("/freeflow profile executor");
+      await stable();
+      await session.prompt("/freeflow profile auto");
+      await stable();
+      routing.profiles.executor.thinking = "medium";
+      await writeFile(
+        config,
+        JSON.stringify({
+          enabled: true,
+          conversationHistory: true,
+          contextVirtualization: true,
+          cognitiveRouting: routing,
+        }),
+      );
+      await session.reload();
+      await stable();
+      routing.projection = true;
+      await writeFile(config, JSON.stringify({ enabled: true, cognitiveRouting: routing }));
+      await session.reload();
+      await stable();
+      routing.projection = false;
+      await writeFile(
+        config,
+        JSON.stringify({
+          enabled: true,
+          conversationHistory: true,
+          contextVirtualization: true,
+          cognitiveRouting: routing,
+        }),
+      );
+      await session.reload();
+      await stable();
+      action = "archive";
+      const archived = await prompt();
+      assert.ok(!JSON.stringify(archived).includes("PRIVATE_RAW_EVIDENCE_716"));
+      assert.deepEqual(archived.tools, previous.tools);
+      action = "restore";
+      const restored = await prompt();
+      assert.ok(JSON.stringify(restored).includes("PRIVATE_RAW_EVIDENCE_716"));
+      assert.deepEqual(restored.tools, previous.tools);
+      assert.equal(JSON.stringify(manager.getEntry(read.id)), original, "canonical evidence untouched");
+    } finally {
+      session?.dispose();
+      globalThis.fetch = prior;
+      await rm(root, { recursive: true, force: true });
+    }
+  },
+);

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

@@ -49,6 +49,92 @@ function prepare(state, entries, messages = entries.map((e) => e.message), view
   });
 }
 
+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) =>
@@ -87,7 +173,7 @@ test("provenance covers old sources and complete exchanges, with stable prefixes
   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/);
+  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),
@@ -129,6 +215,13 @@ test("new control selections are rejected while old selections and mixed assista
     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";