@hassangameryt/freeflow 0.7.1 → 0.7.3

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

@@ -0,0 +1,306 @@
+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

@@ -0,0 +1,92 @@
+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

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

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "freeflow",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Feedback-based control system for coding agents.",
   "author": {
     "name": "Hassan Mohiddin"

package/runtime/prompts/cognitive-routing.md

@@ -1,10 +1,9 @@
 ## Cognitive Routing Cue
 
-Cognitive Routing changes compute only; it never changes Workflow ownership or authority. `Control` and `Profile` in the latest Runtime State report current compute state, not Yield, Delegate, `ACT_BOUNDED`, or boundary state. A Runtime State refresh is host context, not a user interruption, and does not end an active route or `ACT_BOUNDED` scope unless contradicted. Recover routing state from visible records; never infer `Boundary state: NONE`.
+Cognitive Routing places work across configured profiles in one agent/session to improve quality, continuity, responsiveness, and total cost together. Coordinator owns user interaction, governing direction, delegation, and acceptance. When enabled, Helper is the normal delegate for supporting work; Executor is commissioned for substantive or consequential results, including implementation and artifacts. Helper and Executor share ordinary active history; only Coordinator delegates and only one profile executes at a time.
 
-- **Manual:** the held profile runs the ordinary unsplit Workflow; do not request switching.
-- **Automatic:** each user interaction begins in Reasoning, which owns conversational and user-facing analysis, discussion, decisions, questions, assessment, and reporting. This work needs no route marker.
+Use the latest Runtime State for control, profile, delegation mode, and current responsibility. In Automatic control, follow the selected mode: helper-only permits Coordinator substantive production with Helper support; executor-only delegates environment work to Executor; both uses Helper by default for support and Executor for substantive work. A mode change does not retarget an accepted assignment or its recovery. Under Manual control, the held Coordinator, Helper, or Executor follows ordinary unsplit Workflow without Automatic role restrictions. Do not release the user's hold. When routing is inactive, stop applying this split.
 
-If the full Cognitive Routing skill is not visible, read it before interpreting or acting on the request. Make that read the only environment call; it is not a route transition. If the read fails or is unavailable, stop and report missing context.
+Before relying on Automatic routing, read the complete cognitive-routing skill if its body is absent. This bootstrap read is the only environment call in that response. If unavailable, stop and report the missing method. Reload it after context loss before applying remembered routing rules.
 
-Once visible, follow the skill's boundary-first execution model. Automatic Standard only executes active Yield or Delegate contracts; at every return condition it writes `YIELD HANDOFF` or `RETURN` and switches to Reasoning. Standard never handles substantive user-facing interaction.
+When projection is on, the active worker must project every completed skill and instructional-reference read, including this bootstrap read. Follow the skill for work placement, environment access, evidence, handoffs, and recorded-worker recovery. Under Automatic routing, a worker return or passing check is not Coordinator acceptance; completed Slice closure requires Coordinator's supported judgment and explicit closure instruction. Manual control follows ordinary Workflow and Track Work instead.