@hassangameryt/freeflow 0.7.1 → 0.7.3

package/pi-extension/tests/context-virtualization/runtime.test.js

@@ -208,9 +208,23 @@ test("mutation persistence failure returns an error without publishing projectio
   assert.match(next.messages[0].content.at(-1).text, /ctx:tool-1/);
 });
 
-test("disabled projection bypasses stored state and adds no marker", async () => {
+test("disabled projection keeps original content and the stable reference marker", async () => {
   const { runtime } = createFixture();
   const result = await runtime.project([toolMessage()], false);
-  assert.equal(result.changed, false);
-  assert.deepEqual(result.messages[0].content, [{ type: "text", text: "secret raw output" }]);
+  assert.equal(result.changed, true);
+  assert.deepEqual(result.messages[0].content.slice(0, -1), [{ type: "text", text: "secret raw output" }]);
+  assert.match(result.messages[0].content.at(-1).text, /context-ref: ctx:tool-1/);
+});
+
+test("unavailable decoration leaves the already projected view intact", () => {
+  const { runtime } = createFixture();
+  runtime.setContext({
+    sessionManager: {
+      getBranch() {
+        throw Error("unavailable");
+      },
+    },
+  });
+  const current = [{ role: "custom", customType: "blocked", content: "Only this safe view" }];
+  assert.equal(runtime.decorate(current), current);
 });

package/pi-extension/tests/fixtures/routing-native.js

@@ -0,0 +1,191 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  createAgentSession,
+  DefaultResourceLoader,
+  ModelRuntime,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import freeflow from "../../dist/index.js";
+import { replay } from "../../dist/cognitive-routing-v2/state.js";
+
+export function response(n, calls = [], text = "fixture response") {
+  const output = [
+    {
+      type: "message",
+      id: `msg-${n}`,
+      role: "assistant",
+      status: "completed",
+      content: [{ type: "output_text", text, annotations: [] }],
+    },
+    ...calls.map((c, i) => ({
+      type: "function_call",
+      id: `fc_${n}_${i}`,
+      call_id: `call-${n}-${i}`,
+      name: c.name,
+      arguments: JSON.stringify(c.args),
+    })),
+  ];
+  const events = [{ type: "response.created", response: { id: `r-${n}`, status: "in_progress", output: [] } }];
+  output.forEach((item, i) => {
+    events.push({
+      type: "response.output_item.added",
+      output_index: i,
+      item: item.type === "message" ? { ...item, content: [] } : { ...item, arguments: "" },
+    });
+    if (item.type === "message")
+      events.push({ type: "response.output_text.delta", output_index: i, content_index: 0, delta: text });
+    else
+      events.push(
+        { type: "response.function_call_arguments.delta", output_index: i, delta: item.arguments },
+        { type: "response.function_call_arguments.done", output_index: i, arguments: item.arguments },
+      );
+    events.push({ type: "response.output_item.done", output_index: i, item });
+  });
+  events.push({
+    type: "response.completed",
+    response: {
+      id: `r-${n}`,
+      status: "completed",
+      output,
+      usage: { input_tokens: 10, output_tokens: 10, total_tokens: 20 },
+    },
+  });
+  return new Response(events.map((e) => `data: ${JSON.stringify(e)}\n\n`).join("") + "data: [DONE]\n\n", {
+    status: 200,
+    headers: { "content-type": "text/event-stream" },
+  });
+}
+
+export async function fixture(script, projection = true, after, withUI = true, options = {}) {
+  const root = await mkdtemp(join(tmpdir(), "freeflow-v2-native-"));
+  const cwd = join(root, "cwd"),
+    agentDir = join(root, "agent");
+  await mkdir(join(cwd, ".freeflow"), { recursive: true });
+  await mkdir(agentDir);
+  await writeFile(
+    join(cwd, ".freeflow/config.json"),
+    JSON.stringify({
+      cognitiveRouting: options.cognitiveRouting ?? {
+        enabled: true,
+        projection,
+        profiles: {
+          coordinator: { provider: "openai", model: "gpt-4o", thinking: "off" },
+          executor: { provider: "openai", model: "gpt-4.1-mini", thinking: "off" },
+        },
+      },
+    }),
+  );
+  await writeFile(join(cwd, "evidence.txt"), "EXACT_EVIDENCE_BODY_81");
+  await writeFile(join(cwd, "unselected.txt"), "UNSELECTED_PRIVATE_BODY_93");
+  await writeFile(join(cwd, "recovery.txt"), "FRESH_RECOVERY_BODY_57");
+  await writeFile(join(cwd, "@recovery.txt"), "LITERAL_AT_FILE_BODY_68");
+  await writeFile(
+    join(agentDir, "models.json"),
+    JSON.stringify({ providers: { openai: { baseUrl: "https://fixture.invalid/v1" } } }),
+  );
+  const priorFetch = globalThis.fetch,
+    offline = process.env.PI_OFFLINE;
+  process.env.PI_OFFLINE = "1";
+  const requests = [],
+    errors = [],
+    contexts = [],
+    transportFailures = [],
+    notices = [];
+  let session;
+  const manager = SessionManager.create(cwd, join(root, "sessions"));
+  globalThis.fetch = async (url, init) => {
+    assert.match(String(url), /^https:\/\/fixture\.invalid\//, "no unexpected network destination");
+    const body = JSON.parse(String(init.body));
+    requests.push(body);
+    assert.ok(requests.length <= (options.maxRequests ?? 15), "bounded fixture request count");
+    try {
+      const calls = await script(requests.length, body, manager, requests);
+      return options.response ? options.response(requests.length, calls) : response(requests.length, calls);
+    } catch (error) {
+      transportFailures.push(error);
+      throw error;
+    }
+  };
+  try {
+    const modelRuntime = await ModelRuntime.create({
+      authPath: join(agentDir, "auth.json"),
+      modelsPath: join(agentDir, "models.json"),
+      modelsStorePath: join(agentDir, "models-store.json"),
+      allowModelNetwork: false,
+    });
+    await modelRuntime.setRuntimeApiKey("openai", "fixture-not-a-real-key");
+    const settingsManager = SettingsManager.inMemory({
+      compaction: { enabled: false, keepRecentTokens: 1, reserveTokens: 1 },
+      retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
+      ...options.settings,
+    });
+    const loader = new DefaultResourceLoader({
+      cwd,
+      agentDir,
+      settingsManager,
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+      extensionFactories: [
+        freeflow,
+        ...(options.extensions ?? []),
+        (pi) => {
+          pi.on("context", (event) => {
+            contexts.push(structuredClone(event.messages));
+          });
+          pi.on("session_before_compact", () => ({
+            compaction: {
+              summary: "Fixture compacted prior work; evidence must come from canonical sources.",
+              firstKeptEntryId: manager.getLeafId(),
+              tokensBefore: 100,
+            },
+          }));
+        },
+      ],
+    });
+    await loader.reload();
+    assert.deepEqual(loader.getExtensions().errors, []);
+    ({ session } = await createAgentSession({
+      cwd,
+      agentDir,
+      modelRuntime,
+      model: modelRuntime.getModel("openai", "gpt-4o"),
+      thinkingLevel: "off",
+      settingsManager,
+      sessionManager: manager,
+      resourceLoader: loader,
+    }));
+    // Public retained bindings make Pi emit session_start again on SDK reload, including headless mode.
+    await session.bindExtensions({
+      mode: "print",
+      onError: (e) => errors.push(e),
+      ...(withUI ? { uiContext: { notify: (...args) => notices.push(args), setStatus: () => {} } } : {}),
+    });
+    await options.onSession?.(session);
+    await options.beforePrompt?.({ session, manager, requests, contexts, cwd, notices });
+    await session.prompt("Complete the fixture assignment.");
+    await session.waitForIdle();
+    assert.deepEqual(errors, [], "extension lifecycle errors");
+    if (after) await after({ session, manager, requests, contexts, cwd, notices });
+    assert.deepEqual(errors, [], "post-lifecycle errors");
+    assert.deepEqual(transportFailures, [], "scripted provider assertions must not be swallowed as provider errors");
+    assert.notEqual(
+      session.messages.at(-1)?.stopReason,
+      "error",
+      `fixture completes without provider failure: ${session.messages.at(-1)?.errorMessage ?? ""}`,
+    );
+    return { requests, state: replay(manager.getBranch()), entries: manager.getEntries(), contexts };
+  } finally {
+    session?.dispose();
+    globalThis.fetch = priorFetch;
+    if (offline === undefined) delete process.env.PI_OFFLINE;
+    else process.env.PI_OFFLINE = offline;
+    await rm(root, { recursive: true, force: true });
+  }
+}

package/pi-extension/tests/integration/mode-free-core.test.js

@@ -14,7 +14,7 @@ import {
   runtimeContext,
   setSessionCoreOverride,
 } from "../../dist/runtime/runtime-context.js";
-import { PIFLOW_HOST } from "../cognitive-routing/host-fixture.js";
+import { PIFLOW_HOST } from "../fixtures/pi-host.js";
 
 function context(cwd) {
   const notifications = [];
@@ -138,8 +138,9 @@ test("Pi exposes base skills without mode or Skills controls", async () => {
     const { handlers, commands } = loadExtension();
     const ctx = context(cwd);
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.equal(resources.skillPaths.length, 25);
+    assert.equal(resources.skillPaths.length, 27);
     assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/workflow/SKILL.md")));
+    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/skills/tdd/SKILL.md")));
     assert.ok(!resources.skillPaths.some((path) => path.endsWith("/skills/mode-contract/SKILL.md")));
 
     const freeflowCommand = commands.find((command) => command.name === "freeflow");
@@ -180,9 +181,10 @@ test("mandatory prompt readiness gates Runtime State, discovery, and direct skil
     const { handlers, commands, sentMessages } = loadExtension(extension);
     const ctx = context(cwd);
     const before = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(before.systemPrompt, "base prompt");
+    assert.ok(before.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(before.systemPrompt, /guidance is dormant/);
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.deepEqual(resources.skillPaths, []);
+    assert.equal(resources.skillPaths.length, 27);
 
     const discuss = commands.find((command) => command.name === "discuss");
     assert.ok(discuss);