@hassangameryt/freeflow 0.7.3 → 0.9.0

package/pi-extension/tests/provider-support/astra.test.js

@@ -1,306 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtemp, rm, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { AstraAdapter, requestKey } from "../../dist/provider-support/astra/adapter.js";
-import { ENTRY_TYPE, assemble } from "../../dist/provider-support/astra/history.js";
-
-const model = {
-  id: "gpt-6-astra",
-  provider: "openai-codex",
-  api: "openai-codex-responses",
-  baseUrl: "https://chatgpt.com/backend-api",
-};
-const u = (text) => ({ role: "user", content: text });
-const a = (text) => ({ role: "assistant", content: text });
-const request = (input, effort = "low") => ({
-  model: model.id,
-  store: false,
-  input,
-  instructions: "stable",
-  reasoning: { effort, summary: "auto" },
-  prompt_cache_key: "unchanged-key",
-  tools: [],
-});
-function fixture(manager = SessionManager.inMemory("/tmp/astra-fixture")) {
-  const status = [];
-  const pi = { appendEntry: (type, data) => manager.appendCustomEntry(type, data) };
-  const ctx = { model, sessionManager: manager, ui: { setStatus: (...args) => status.push(args) } };
-  return { pi, ctx, manager, status, adapter: new AstraAdapter(pi) };
-}
-const updates = (p) =>
-  p.input.flatMap((item, index) =>
-    item.type === "configuration_update" ? [{ index, effort: item.reasoning.effort }] : [],
-  );
-
-test("native ancestry records replay Low High Low with original anchors and unchanged selected effort", async () => {
-  const f = fixture(),
-    h = [u("one")];
-  await f.adapter.adapt(request(h), f.ctx);
-  h.push(a("one"), u("two"));
-  const high = await f.adapter.adapt(request(h, "high"), f.ctx);
-  assert.equal(high.reasoning.effort, "low");
-  assert.deepEqual(updates(high), [{ index: 2, effort: "high" }]);
-  h.push(a("two"), u("three"));
-  const low = await new AstraAdapter(f.pi).adapt(request(h), f.ctx);
-  assert.deepEqual(low.input.slice(0, high.input.length), high.input);
-  assert.deepEqual(updates(low), [
-    { index: 2, effort: "high" },
-    { index: 5, effort: "low" },
-  ]);
-  const count = f.manager.getEntries().length;
-  assert.deepEqual(await f.adapter.adapt(request(h), f.ctx), low);
-  assert.equal(f.manager.getEntries().length, count, "retry writes no duplicate record");
-  assert.equal(low.prompt_cache_key, "unchanged-key");
-  assert.ok(f.manager.getEntries().every((e) => !JSON.stringify(e.data).includes('"content"')));
-});
-
-test("first High is baseline; tool-loop switch occurs after completed results, not before an old user", async () => {
-  const f = fixture(),
-    h = [u("one")];
-  await f.adapter.adapt(request(h, "high"), f.ctx);
-  h.push(
-    { type: "reasoning", encrypted_content: "opaque-signed-value", summary: [] },
-    { type: "function_call", call_id: "call_1", name: "read", arguments: "{}" },
-    { type: "function_call_output", call_id: "call_1", output: "body" },
-  );
-  const p = await f.adapter.adapt(request(h, "low"), f.ctx);
-  assert.equal(p.reasoning.effort, "high");
-  assert.deepEqual(updates(p), [{ index: 4, effort: "low" }]);
-  assert.deepEqual(p.input.slice(0, 4), h);
-});
-
-test("changed/omitted/expanded input safely rebases; restored compatible branch recovers its own updates", async () => {
-  const f = fixture();
-  const h = [u("source")];
-  await f.adapter.adapt(request(h), f.ctx);
-  h.push(a("one"), u("two"));
-  const high = await f.adapter.adapt(request(h, "high"), f.ctx);
-  const changed = [u("different")];
-  const p = await f.adapter.adapt(request(changed, "high"), f.ctx);
-  assert.equal(p.reasoning.effort, "low");
-  assert.deepEqual(updates(p), [{ index: 0, effort: "high" }]);
-  const restored = await f.adapter.adapt(request([...h, a("two"), u("three")], "high"), f.ctx);
-  assert.deepEqual(restored.input.slice(0, high.input.length), high.input);
-});
-
-test("same payload effort toggles never manufacture adjacent updates; fallback retains desired effort", async () => {
-  const f = fixture(),
-    h = [u("one")];
-  await f.adapter.adapt(request(h), f.ctx);
-  const high = await f.adapter.adapt(request(h, "high"), f.ctx);
-  assert.deepEqual(updates(high), [{ index: 1, effort: "high" }]);
-  const original = request(h, "low");
-  assert.equal(await f.adapter.adapt(original, f.ctx), original);
-  assert.equal(original.reasoning.effort, "low");
-  assert.deepEqual(updates(original), []);
-});
-
-test("unsupported requests and existing native updates pass through without persistence", async () => {
-  const f = fixture();
-  for (const change of [
-    (p) => (p.model = "gpt-5.6-luna"),
-    (p) => (p.previous_response_id = "resp_x"),
-    (p) => (p.conversation = "c"),
-    (p) => (p.context_management = []),
-    (p) => (p.truncation = "auto"),
-    (p) => (p.reasoning.mode = "pro"),
-    (p) => p.input.push({ type: "configuration_update", reasoning: { effort: "high" } }),
-    (p) => (p.reasoning.effort = "off"),
-    (p) => (p.store = true),
-  ]) {
-    const p = request([u("one")]);
-    change(p);
-    assert.equal(await f.adapter.adapt(p, f.ctx), p);
-  }
-  assert.equal(requestKey(request([]), { ...model, provider: "proxy" }), undefined);
-  assert.equal(requestKey(request([]), { ...model, baseUrl: "https://example.com" }), undefined);
-  assert.ok(
-    requestKey(request([]), {
-      ...model,
-      provider: "openai",
-      api: "openai-responses",
-      baseUrl: "https://api.openai.com/v1",
-    }),
-  );
-  assert.equal(f.manager.getEntries().length, 0);
-});
-
-test("append failure before or after mutation keeps original request and latches fallback", async () => {
-  for (const after of [false, true]) {
-    const f = fixture();
-    await f.adapter.adapt(request([u("one")]), f.ctx);
-    const real = f.pi.appendEntry;
-    f.pi.appendEntry = (...args) => {
-      if (after) real(...args);
-      throw Error("disk fault");
-    };
-    const original = request([u("one"), a("one"), u("two")], "high");
-    assert.equal(await f.adapter.adapt(original, f.ctx), original);
-    f.pi.appendEntry = real;
-    assert.equal(await f.adapter.adapt(original, f.ctx), original);
-    assert.ok(f.status.some((x) => x[1]?.includes("native effort")));
-  }
-});
-
-test("corrupt effective-effort metadata cannot silently pin the wrong effort", async () => {
-  const f = fixture();
-  await f.adapter.adapt(request([u("one")]), f.ctx);
-  f.manager.getEntries().find((e) => e.customType === ENTRY_TYPE).data.effective = "high";
-  const original = request([u("one"), a("one"), u("two")], "high");
-  assert.equal(await f.adapter.adapt(original, f.ctx), original);
-});
-
-test("selected ancestry, new sessions, model changes and compaction isolate effort histories", async () => {
-  const f = fixture();
-  f.manager.appendModelChange(model.provider, model.id);
-  await f.adapter.adapt(request([u("one")]), f.ctx);
-  const baseLeaf = f.manager.getLeafId();
-  await f.adapter.adapt(request([u("one"), a("one"), u("two")], "high"), f.ctx);
-  f.manager.branch(baseLeaf);
-  const branch = await f.adapter.adapt(request([u("one"), a("other"), u("sibling")], "medium"), f.ctx);
-  assert.deepEqual(updates(branch), [{ index: 2, effort: "medium" }]);
-  f.manager.appendModelChange("openai-codex", "gpt-5.6-luna");
-  f.manager.appendModelChange(model.provider, model.id);
-  const reset = await f.adapter.adapt(request([u("new")], "high"), f.ctx);
-  assert.equal(reset.reasoning.effort, "low");
-  assert.deepEqual(updates(reset), [{ index: 0, effort: "high" }]);
-  assert.deepEqual(
-    reset.input.filter((x) => x.type !== "configuration_update"),
-    [u("new")],
-  );
-  f.adapter.setCompacting(true);
-  const summary = request([u("summary")], "low");
-  assert.equal(await f.adapter.adapt(summary, f.ctx), summary);
-  f.adapter.setCompacting(false);
-  const other = fixture();
-  assert.equal((await f.adapter.adapt(request([u("new")], "medium"), other.ctx)).reasoning.effort, "medium");
-});
-
-test("persisted labeled fork and reload preserve an anchored effort transition", async () => {
-  const root = await mkdtemp(join(tmpdir(), "astra-persist-"));
-  try {
-    const manager = SessionManager.create(root, root),
-      f = fixture(manager);
-    manager.appendMessage({ role: "user", content: "one", timestamp: 1 });
-    await f.adapter.adapt(request([u("one")]), f.ctx);
-    manager.appendMessage({
-      role: "assistant",
-      content: [{ type: "text", text: "one" }],
-      api: model.api,
-      provider: model.provider,
-      model: model.id,
-      usage: {
-        input: 1,
-        output: 1,
-        cacheRead: 0,
-        cacheWrite: 0,
-        totalTokens: 2,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-      },
-      stopReason: "stop",
-      timestamp: 2,
-    });
-    manager.appendLabelChange(manager.getLeafId(), "before effort change");
-    const h = [u("one"), a("one"), u("two")];
-    const high = await f.adapter.adapt(request(h, "high"), f.ctx);
-    assert.ok((await readFile(manager.getSessionFile(), "utf8")).includes(ENTRY_TYPE));
-    const forkFile = manager.createBranchedSession(manager.getLeafId());
-    assert.ok(forkFile, "native fork file created");
-    const reloaded = fixture(SessionManager.open(forkFile));
-    const p = await reloaded.adapter.adapt(request([...h, a("two"), u("three")], "low"), reloaded.ctx);
-    assert.deepEqual(p.input.slice(0, high.input.length), high.input);
-    assert.equal(p.reasoning.effort, "low");
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("queued request from a replaced session passes through without a native append", async () => {
-  const f = fixture(),
-    p = request([u("old")], "high");
-  const pending = f.adapter.adapt(p, f.ctx);
-  f.adapter.reset();
-  assert.equal(await pending, p);
-  assert.equal(f.manager.getEntries().length, 0);
-});
-
-for (const returnEffort of ["high", "low"]) {
-  test(`model round trip preserves original Low anchor through ${returnEffort} return and reload`, async () => {
-    const f = fixture();
-    f.manager.appendModelChange(model.provider, model.id);
-    const h = [u("start")];
-    await f.adapter.adapt(request(h, "high"), f.ctx);
-    h.push(a("first"), u("low"));
-    const low = await f.adapter.adapt(request(h), f.ctx);
-    f.manager.appendModelChange(model.provider, "gpt-5.6-luna");
-    const luna = request(h);
-    luna.model = "gpt-5.6-luna";
-    assert.equal(await f.adapter.adapt(luna, { ...f.ctx, model: { ...model, id: luna.model } }), luna);
-    f.manager.appendModelChange(model.provider, model.id);
-    h.push(a("second"), u("return"));
-    const resumed = await new AstraAdapter(f.pi).adapt(request(h, returnEffort), f.ctx);
-    assert.equal(resumed.reasoning.effort, "high");
-    assert.deepEqual(resumed.input.slice(0, low.input.length), low.input);
-    h.push(a("third"), u("low again"));
-    const again = await f.adapter.adapt(request(h), f.ctx);
-    assert.deepEqual(again.input.slice(0, resumed.input.length), resumed.input);
-    assert.equal(updates(again)[0].index, 2);
-  });
-}
-
-test("legacy model-generation records survive a round trip without rewriting persisted metadata", async () => {
-  const root = await mkdtemp(join(tmpdir(), "astra-legacy-"));
-  try {
-    const f = fixture(SessionManager.create(root, root));
-    f.manager.appendMessage({ role: "user", content: "legacy", timestamp: 1 });
-    f.manager.appendMessage({
-      role: "assistant",
-      content: [{ type: "text", text: "legacy" }],
-      api: model.api,
-      provider: model.provider,
-      model: model.id,
-      usage: {
-        input: 1,
-        output: 1,
-        cacheRead: 0,
-        cacheWrite: 0,
-        totalTokens: 2,
-        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-      },
-      stopReason: "stop",
-      timestamp: 2,
-    });
-    const oldGeneration = f.manager.appendModelChange(model.provider, model.id);
-    const key = requestKey(request([]), model);
-    const h = [u("legacy")];
-    const first = assemble(request(h, "high"), key, oldGeneration, f.manager.getLeafId(), []);
-    f.manager.appendCustomEntry(ENTRY_TYPE, first.record);
-    h.push(a("one"), u("two"));
-    const second = assemble(request(h), key, oldGeneration, f.manager.getLeafId(), [first.record]);
-    f.manager.appendCustomEntry(ENTRY_TYPE, second.record);
-    const saved = JSON.stringify(f.manager.getEntries());
-    f.manager.appendModelChange(model.provider, "gpt-5.6-luna");
-    f.manager.appendModelChange(model.provider, model.id);
-    const loaded = fixture(SessionManager.open(f.manager.getSessionFile()));
-    const resumed = await loaded.adapter.adapt(request([...h, a("two"), u("three")]), loaded.ctx);
-    assert.equal(resumed.reasoning.effort, "high");
-    assert.deepEqual(resumed.input.slice(0, second.payload.input.length), second.payload.input);
-    assert.equal(JSON.stringify(f.manager.getEntries().slice(0, JSON.parse(saved).length)), saved);
-    const again = fixture(SessionManager.open(loaded.manager.getSessionFile()));
-    const reloaded = await again.adapter.adapt(request([...h, a("two"), u("three"), a("three"), u("four")]), again.ctx);
-    assert.deepEqual(reloaded.input.slice(0, resumed.input.length), resumed.input);
-    assert.equal(JSON.stringify(again.manager.getEntries().slice(0, JSON.parse(saved).length)), saved);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test("session reset clears adapter status without changing the next requested effort", async () => {
-  const f = fixture();
-  await f.adapter.adapt(request([u("one")]), f.ctx);
-  f.adapter.reset(f.ctx);
-  assert.deepEqual(f.status.at(-1), ["freeflow-astra-effort", undefined]);
-});

package/pi-extension/tests/provider-support/cli.test.js

@@ -1,92 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtemp, mkdir, writeFile, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
-import { response } from "../fixtures/routing-native.js";
-
-test(
-  "bundled Pi CLI loads Freeflow adapter and changes effort inside a native tool loop",
-  { timeout: 30000 },
-  async () => {
-    const root = await mkdtemp(join(tmpdir(), "astra-cli-")),
-      agentDir = join(root, "agent");
-    try {
-      await mkdir(agentDir);
-      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-6-astra",
-          defaultThinkingLevel: "low",
-          transport: "sse",
-          compaction: { enabled: false },
-          retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
-        }),
-      );
-      const capture = join(root, "requests.json"),
-        extension = join(root, "fixture.mjs");
-      await writeFile(
-        extension,
-        `import {writeFileSync} from 'node:fs';\n${response.toString()}\nexport default function(pi){pi.registerTool({name:'probe_raise_effort',label:'Probe effort',description:'Fixture only',parameters:{type:'object',properties:{}},execute:async()=>{pi.setThinkingLevel('high');return {content:[{type:'text',text:'Changed desired effort.'}]};}});const bodies=[];globalThis.fetch=async(url,init)=>{if(String(url)!=='https://api.openai.com/v1/responses')throw Error('Unexpected network');const body=JSON.parse(String(init.body));bodies.push(body);writeFileSync(${JSON.stringify(capture)},JSON.stringify(bodies));if(bodies.length>2)throw Error('Unexpected extra request');return response(bodies.length,bodies.length===1?[{name:'probe_raise_effort',args:{}}]:[],'OK');};}`,
-      );
-      const cli = fileURLToPath(new URL("./bundle/cli.js", import.meta.resolve("@earendil-works/pi-coding-agent")));
-      const entry = fileURLToPath(new URL("../../freeflow/index.js", import.meta.url));
-      const child = spawn(
-        process.execPath,
-        [
-          cli,
-          "-p",
-          "--mode",
-          "json",
-          "--no-extensions",
-          "--no-skills",
-          "--no-context-files",
-          "--no-prompt-templates",
-          "--no-themes",
-          "-e",
-          extension,
-          "-e",
-          entry,
-          "Run the effort fixture.",
-        ],
-        {
-          cwd: root,
-          env: {
-            PATH: process.env.PATH,
-            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(-4000));
-      const bodies = JSON.parse(await readFile(capture, "utf8"));
-      assert.equal(bodies.length, 2);
-      assert.equal(bodies[1].reasoning.effort, "low");
-      const updates = bodies[1].input.filter((i) => i.type === "configuration_update");
-      assert.deepEqual(updates, [{ type: "configuration_update", reasoning: { effort: "high" } }]);
-      assert.ok(bodies[1].input.some((i) => i.type === "function_call_output"));
-      assert.match(output, /OK/);
-    } finally {
-      await rm(root, { recursive: true, force: true });
-    }
-  },
-);

package/pi-extension/tests/provider-support/native.test.js

@@ -1,183 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { mkdtemp, mkdir, rm, readFile } 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 { registerProviderSupport } from "../../dist/provider-support/index.js";
-import { ENTRY_TYPE } from "../../dist/provider-support/astra/history.js";
-import { response } from "../fixtures/routing-native.js";
-
-async function native(extension, run) {
-  const root = await mkdtemp(join(tmpdir(), "astra-native-")),
-    agentDir = join(root, "agent");
-  await mkdir(agentDir);
-  const previousFetch = globalThis.fetch,
-    requests = [],
-    errors = [];
-  let session;
-  globalThis.fetch = async (url, init) => {
-    assert.match(String(url), /^https:\/\/api\.openai\.com\/v1\/responses$/);
-    requests.push(JSON.parse(String(init.body)));
-    assert.ok(requests.length <= 12);
-    return response(requests.length, [], "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-only-key");
-    const settings = SettingsManager.inMemory({
-      transport: "sse",
-      compaction: { enabled: false, keepRecentTokens: 1, reserveTokens: 1 },
-      retry: { enabled: false, maxRetries: 0, provider: { maxRetries: 0 } },
-    });
-    const manager = SessionManager.create(root, join(root, "sessions"));
-    let cancelCompaction = false;
-    const loader = new DefaultResourceLoader({
-      cwd: root,
-      agentDir,
-      settingsManager: settings,
-      noExtensions: true,
-      noSkills: true,
-      noPromptTemplates: true,
-      noThemes: true,
-      noContextFiles: true,
-      systemPrompt: "Reply OK.",
-      extensionFactories: [
-        extension,
-        (pi) =>
-          pi.on("session_before_compact", () =>
-            cancelCompaction
-              ? { cancel: true }
-              : {
-                  compaction: {
-                    summary: "Older material summarized.",
-                    firstKeptEntryId: manager.getLeafId(),
-                    tokensBefore: 100,
-                  },
-                },
-          ),
-      ],
-    });
-    await loader.reload();
-    assert.deepEqual(loader.getExtensions().errors, []);
-    ({ session } = await createAgentSession({
-      cwd: root,
-      agentDir,
-      modelRuntime: runtime,
-      model: runtime.getModel("openai", "gpt-6-astra"),
-      thinkingLevel: "low",
-      settingsManager: settings,
-      sessionManager: manager,
-      resourceLoader: loader,
-      tools: [],
-    }));
-    await session.bindExtensions({ mode: "print", onError: (e) => errors.push(e) });
-    const prompt = async (text, effort) => {
-      if (effort) session.setThinkingLevel(effort);
-      await session.prompt(text);
-      await session.waitForIdle();
-      assert.equal(session.messages.at(-1)?.stopReason, "stop");
-      assert.deepEqual(errors, []);
-      return requests.at(-1);
-    };
-    await run({
-      session,
-      manager,
-      requests,
-      prompt,
-      root,
-      cancelCompaction: () => {
-        cancelCompaction = true;
-      },
-    });
-    assert.deepEqual(errors, []);
-  } finally {
-    session?.dispose();
-    globalThis.fetch = previousFetch;
-    await rm(root, { recursive: true, force: true });
-  }
-}
-const updates = (p) =>
-  p.input.flatMap((x, i) => (x.type === "configuration_update" ? [{ index: i, effort: x.reasoning.effort }] : []));
-
-test("real Pi request dispatch, reload, native tree navigation and compaction", { timeout: 30000 }, async () => {
-  await native(registerProviderSupport, async ({ session, manager, requests, prompt }) => {
-    await prompt("first", "low");
-    const high = await prompt("second", "high");
-    assert.equal(high.reasoning.effort, "low");
-    assert.equal(session.thinkingLevel, "high");
-    assert.deepEqual(updates(high), [{ index: 3, effort: "high" }]);
-    await session.reload();
-    const low = await prompt("third", "low");
-    assert.deepEqual(low.input.slice(0, high.input.length), high.input);
-    assert.deepEqual(updates(low), [
-      { index: 3, effort: "high" },
-      { index: 6, effort: "low" },
-    ]);
-    const branchPoint = manager
-      .getBranch()
-      .find((e) => e.message?.role === "user" && e.message.content?.some?.((b) => b.text === "second"));
-    assert.ok(branchPoint);
-    // Native tree navigation selects real ancestry; the discarded later Low update must not survive.
-    await session.navigateTree(branchPoint.id, { summarize: false });
-    const sibling = await prompt("sibling", "medium");
-    assert.ok(updates(sibling).every((x) => x.effort !== "low"));
-    await session.compact();
-    const compacted = await prompt("after summary", "high");
-    assert.equal(compacted.reasoning.effort, "high");
-    assert.deepEqual(updates(compacted), []);
-    const persisted = await readFile(manager.getSessionFile(), "utf8");
-    assert.ok(persisted.includes(ENTRY_TYPE));
-    assert.ok(!manager.getBranch().some((e) => e.customType === "freeflow-routing-v2"));
-    assert.equal(requests.length, 5);
-  });
-});
-
-test(
-  "the Freeflow extension adapts Astra without repository activation or Cognitive Routing",
-  { timeout: 30000 },
-  async () => {
-    await native(freeflow, async ({ session, manager, prompt }) => {
-      await prompt("one", "low");
-      const p = await prompt("two", "high");
-      assert.equal(p.reasoning.effort, "low");
-      assert.equal(session.thinkingLevel, "high");
-      assert.ok(updates(p).some((x) => x.effort === "high"));
-      assert.ok(manager.getBranch().some((e) => e.customType === ENTRY_TYPE));
-      assert.ok(!manager.getBranch().some((e) => e.customType === "freeflow-routing-v2"));
-      assert.ok(!(p.tools ?? []).some((t) => t.name.startsWith("freeflow_")));
-    });
-  },
-);
-
-test(
-  "rapid native effort changes coalesce and cancelled compaction releases adaptation",
-  { timeout: 30000 },
-  async () => {
-    await native(registerProviderSupport, async ({ session, prompt, cancelCompaction }) => {
-      await prompt("first", "low");
-      session.setThinkingLevel("high");
-      session.setThinkingLevel("max");
-      session.setThinkingLevel("medium");
-      const medium = await prompt("second");
-      assert.deepEqual(updates(medium), [{ index: 3, effort: "medium" }]);
-      cancelCompaction();
-      await assert.rejects(session.compact(), /cancelled/);
-      const high = await prompt("third", "high");
-      assert.equal(high.reasoning.effort, "low");
-      assert.equal(updates(high).at(-1).effort, "high");
-    });
-  },
-);