@hassangameryt/freeflow 0.7.2 → 0.7.3

package/pi-extension/tests/integration/prompt-architecture.test.js

@@ -83,27 +83,38 @@ test("re-entry recovery is stable and capability-neutral", async () => {
   assert.match(core, /apply its method and gather or produce evidence/);
   assert.match(core, /read the complete `full` record/);
   assert.match(core, /Make material gaps, contradictions, deferrals, and user-owned decisions explicit/);
-  assert.match(cognitiveRouting, /Before relying on automatic routing, read the complete cognitive-routing skill/);
+  assert.match(cognitiveRouting, /Before relying on Automatic routing, read the complete cognitive-routing skill/);
   assert.match(cognitiveRouting, /This bootstrap read is the only environment call/);
   assert.match(cognitiveRouting, /If unavailable, stop and report the missing method/);
   // The approved compact cue keeps bootstrap/control boundaries; the loaded
   // method owns detailed role and handoff policy. Keep both obligations checked.
   assert.match(
     cognitiveRouting,
-    /Under Manual or inactive routing, stop applying the automatic split and follow ordinary Workflow/,
+    /Under Manual control, the held Coordinator, Helper, or Executor follows ordinary unsplit Workflow/,
   );
-  assert.match(cognitiveRouting, /Use the latest Runtime State for control, profile, and current responsibility/);
-  assert.match(cognitiveRouting, /Coordinator and Executor in one agent\/session/);
-  assert.match(routingSkill, /Automatic delegation, role restrictions, and projection are bypassed/);
-  assert.match(routingSkill, /Put the actual contract inside `freeflow_delegate/);
-  assert.match(routingSkill, /submits the actual report and stops ordinary task work/);
+  assert.match(cognitiveRouting, /When routing is inactive, stop applying this split/);
+  assert.match(
+    cognitiveRouting,
+    /Use the latest Runtime State for control, profile, delegation mode, and current responsibility/,
+  );
+  assert.match(cognitiveRouting, /configured profiles in one agent\/session/);
+  assert.match(routingSkill, /Automatic role restrictions, delegation, and projection do not apply/);
+  assert.match(routingSkill, /Put the actual contract in `freeflow_delegate/);
+  assert.match(routingSkill, /A worker return ends its ordinary task work/);
   assert.match(cognitiveRouting, /project every completed skill and instructional-reference read/);
-  assert.match(routingSkill, /Attach recovery to the existing responsibility/);
   assert.match(
     routingSkill,
-    /Returned work may use an attached recovery-only phase only if the runtime actually exposes it; otherwise inspect saved communication and stop if insufficient/,
+    /For the current returned assessment, Coordinator uses `freeflow_unit\(operation: "recover"\)`/,
   );
-  assert.match(routingSkill, /Do not simulate recovery by replacing the assignment or report/);
+  assert.match(routingSkill, /freeflow_unit\(operation: "recover"\)/);
+  assert.match(
+    routingSkill,
+    /Preserve the unit, assignment, original report, outcome, revision, selections, and assessment/,
+  );
+  assert.match(routingSkill, /read only exact admitted task paths/);
+  assert.match(routingSkill, /freeflow_return\(operation: "supplement"\)/);
+  assert.match(routingSkill, /Deliver the supplement or cancel recovery before `assess`/);
+  assert.match(routingSkill, /Do not simulate recovery by replacing an assignment\/report or opening a new unit/);
   assert.doesNotMatch(
     conversationHistory,
     /Current user direction, live source truth, and present runtime state remain authoritative/,
@@ -178,7 +189,7 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
   }
 });
 
-test("subagents keep Freeflow core and base skills without optional capabilities", async () => {
+test("subagents retain reference definitions while optional capabilities stay inactive", async () => {
   const cwd = await configuredRepo({
     contextVirtualization: true,
     conversationHistory: true,
@@ -198,13 +209,13 @@ test("subagents keep Freeflow core and base skills without optional capabilities
     const before = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
     assert.match(before.systemPrompt, /# Freeflow Stable Guidance/);
     assert.match(before.systemPrompt, /# Freeflow Interaction Contract/);
-    assert.doesNotMatch(before.systemPrompt, /## Cognitive Routing Cue/);
-    assert.doesNotMatch(before.systemPrompt, /## Context Virtualization Cue/);
-    assert.doesNotMatch(before.systemPrompt, /## Conversation History Cue/);
+    assert.match(before.systemPrompt, /## Cognitive Routing Cue/);
+    assert.match(before.systemPrompt, /## Context Virtualization Cue/);
+    assert.match(before.systemPrompt, /## Conversation History Cue/);
 
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
     assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/action-selection/SKILL.md")));
-    assert.ok(!resources.skillPaths.some((path) => path.includes("/capabilities/")));
+    assert.equal(resources.skillPaths.filter((path) => path.includes("/capabilities/")).length, 3);
 
     const providerContext = await handlers.get("context")({ messages: [] }, ctx);
     const runtimeState = lastRuntimeState(providerContext.messages);
@@ -212,7 +223,7 @@ test("subagents keep Freeflow core and base skills without optional capabilities
     assert.match(runtimeState.content, /Context Virtualization: inactive/);
     assert.match(runtimeState.content, /Conversation History: inactive/);
     assert.match(runtimeState.content, /Cognitive Routing: inactive/);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -233,7 +244,7 @@ test("provider context reuses the before-agent surface until the next provider t
     assert.match(lastRuntimeState(sameTurn.messages).content, /Context Virtualization: active/);
 
     const next = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.doesNotMatch(next.systemPrompt, /## Context Virtualization Cue/);
+    assert.equal(next.systemPrompt, before.systemPrompt, "settings preserve the complete reference surface");
     assert.match(next.systemPrompt, /# Freeflow Interaction Contract/);
     assert.match(next.systemPrompt, /## Shared Terms/);
   } finally {
@@ -278,7 +289,7 @@ test("missing optional prompt fragments preserve the mandatory core surface", as
   }
 });
 
-test("missing child prompt removes only that capability from every model-facing surface", async () => {
+test("missing child prompt marks that capability unavailable while retaining its definitions", async () => {
   const root = await mkdtemp(join(tmpdir(), "freeflow-child-prompt-failure-"));
   const cwd = await configuredRepo({ contextVirtualization: true });
   try {
@@ -298,13 +309,13 @@ test("missing child prompt removes only that capability from every model-facing
     assert.doesNotMatch(before.systemPrompt, /## Context Virtualization Cue/);
     assert.match(before.systemPrompt, /# Freeflow Interaction Contract/);
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/capabilities/context-virtualization/SKILL.md")));
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(resources.skillPaths.some((path) => path.endsWith("/capabilities/context-virtualization/SKILL.md")));
+    assert.ok(activeToolNames().includes("freeflow_context"));
 
     await handlers.get("session_tree")({}, ctx);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
     await handlers.get("session_compact")({}, ctx);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
 
     const providerContext = await handlers.get("context")({ messages: [] }, ctx);
     assert.match(providerContext.messages.at(-1).content, /Context Virtualization: unavailable/);
@@ -314,9 +325,9 @@ test("missing child prompt removes only that capability from every model-facing
     assert.doesNotMatch(whitespaceBefore.systemPrompt, /## Context Virtualization Cue/);
     const whitespaceResources = await handlers.get("resources_discover")({ cwd }, ctx);
     assert.ok(
-      !whitespaceResources.skillPaths.some((path) => path.endsWith("/capabilities/context-virtualization/SKILL.md")),
+      whitespaceResources.skillPaths.some((path) => path.endsWith("/capabilities/context-virtualization/SKILL.md")),
     );
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
     const whitespaceContext = await handlers.get("context")({ messages: [] }, ctx);
     assert.match(whitespaceContext.messages.at(-1).content, /Context Virtualization: unavailable/);
   } finally {
@@ -325,7 +336,7 @@ test("missing child prompt removes only that capability from every model-facing
   }
 });
 
-test("missing mandatory Interaction Contract preserves the host prompt and hides base skills", async () => {
+test("missing mandatory Interaction Contract retains a dormant surface with unavailable state", async () => {
   const root = await mkdtemp(join(tmpdir(), "freeflow-interaction-contract-failure-"));
   const cwd = await configuredRepo();
   try {
@@ -342,19 +353,21 @@ test("missing mandatory Interaction Contract preserves the host prompt and hides
     const { handlers, activeToolNames } = loadExtension(extension);
     const ctx = context(cwd);
     await handlers.get("session_start")({}, ctx);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
     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);
     await handlers.get("session_tree")({}, ctx);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
 
     await writeFile(join(root, "runtime", "prompts", "interaction-contract.md"), " \n\t", "utf8");
     const whitespaceBefore = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(whitespaceBefore.systemPrompt, "base prompt");
+    assert.ok(whitespaceBefore.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(whitespaceBefore.systemPrompt, /guidance is dormant/);
     const whitespaceResources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.deepEqual(whitespaceResources.skillPaths, []);
+    assert.equal(whitespaceResources.skillPaths.length, 27);
     const whitespaceContext = await handlers.get("context")({ messages: [] }, ctx);
     assert.match(whitespaceContext.messages.at(-1).content, /Freeflow: unavailable/);
   } finally {
@@ -363,7 +376,7 @@ test("missing mandatory Interaction Contract preserves the host prompt and hides
   }
 });
 
-test("missing mandatory core prompt preserves the host prompt and hides base skills", async () => {
+test("missing mandatory core prompt retains a dormant surface with unavailable state", async () => {
   const root = await mkdtemp(join(tmpdir(), "freeflow-core-prompt-failure-"));
   const cwd = await configuredRepo({ contextVirtualization: true });
   try {
@@ -380,9 +393,10 @@ test("missing mandatory core prompt preserves the host prompt and hides base ski
     await handlers.get("session_start")({ type: "session_start" }, ctx);
 
     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 providerContext = await handlers.get("context")({ messages: [] }, ctx);
     assert.match(providerContext.messages.at(-1).content, /Freeflow: unavailable/);
     assert.doesNotMatch(
@@ -391,15 +405,16 @@ test("missing mandatory core prompt preserves the host prompt and hides base ski
     );
 
     await handlers.get("session_tree")({}, ctx);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
     await handlers.get("session_compact")({}, ctx);
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
 
     await writeFile(join(root, "runtime", "prompts", "core.md"), " \n\t", "utf8");
     const whitespaceBefore = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(whitespaceBefore.systemPrompt, "base prompt");
+    assert.ok(whitespaceBefore.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(whitespaceBefore.systemPrompt, /guidance is dormant/);
     const whitespaceResources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.deepEqual(whitespaceResources.skillPaths, []);
+    assert.equal(whitespaceResources.skillPaths.length, 27);
     const whitespaceContext = await handlers.get("context")({ messages: [] }, ctx);
     assert.match(whitespaceContext.messages.at(-1).content, /Freeflow: unavailable/);
   } finally {
@@ -414,7 +429,8 @@ test("Runtime State remains present while Freeflow is disabled without optional
     const { handlers } = loadExtension();
     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/);
     assert.equal(before.message, undefined);
 
     const providerContext = await handlers.get("context")({ messages: [] }, ctx);
@@ -424,7 +440,7 @@ test("Runtime State remains present while Freeflow is disabled without optional
     assert.doesNotMatch(runtimeState.content, /Default mode|Active mode|Interaction Contract|Skills/);
 
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.deepEqual(resources.skillPaths, []);
+    assert.equal(resources.skillPaths.length, 27);
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }

package/pi-extension/tests/integration/unaffected-regressions.test.js

@@ -290,7 +290,7 @@ test("Cognitive Routing preset cancellation preserves the previous repository va
       });
       component.handleInput("\u001b[B");
       component.handleInput("\r");
-      component.handleInput("\u001b[B");
+      for (let index = 0; index < 4; index += 1) component.handleInput("\u001b[B");
       component.handleInput("\r");
       component.handleInput("\u001b");
       component.handleInput("\u001b");
@@ -339,7 +339,7 @@ test("Cognitive Routing settings refresh after enabling the capability", async (
       component.handleInput("\r");
       await component.waitForWrites();
       component.handleInput("\u001b");
-      assert.match(component.render(120).join("\n"), /Cognitive Routing\s+enabled \(4\) configured/);
+      assert.match(component.render(120).join("\n"), /Cognitive Routing\s+enabled \(6\) configured/);
       component.handleInput("\u001b");
       return result;
     };
@@ -383,7 +383,7 @@ test("Cognitive Routing settings can disable projection without disabling routin
       });
       component.handleInput("\u001b[B");
       component.handleInput("\r");
-      for (let index = 0; index < 3; index += 1) component.handleInput("\u001b[B");
+      for (let index = 0; index < 5; index += 1) component.handleInput("\u001b[B");
       component.handleInput("\r");
       component.handleInput("\u001b[B");
       component.handleInput("\r");

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

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionState } from "../../dist/provider-support/astra/session-state.js";
+import { assemble, ENTRY_TYPE } from "../../dist/provider-support/astra/history.js";
+
+function fixture() {
+  const branch = [];
+  const append = (type, fields = {}) => {
+    const entry = { id: `entry-${branch.length}`, parentId: branch.at(-1)?.id ?? null, type, ...fields };
+    branch.push(entry);
+    return entry.id;
+  };
+  const reader = {
+    getBranch: () => branch,
+    getLeafId: () => branch.at(-1)?.id ?? null,
+    getSessionFile: () => undefined,
+  };
+  const store = new SessionState({ appendEntry: (customType, data) => append("custom", { customType, data }) }, reader);
+  return { branch, append, reader, store };
+}
+const payload = (effort = "high") => ({
+  model: "astra",
+  instructions: "same",
+  tools: [],
+  reasoning: { effort },
+  input: [{ role: "user", content: "same" }],
+});
+
+for (const boundary of ["compaction", "branch_summary"]) {
+  test(`${boundary} excludes pre-boundary history even with identical input`, async () => {
+    const f = fixture();
+    const old = assemble(payload(), "astra", f.store.generation(), f.reader.getLeafId(), []);
+    f.store.append(old.record);
+    const epoch = f.append(boundary);
+    f.append("model_change", { provider: "p", modelId: "luna" });
+    f.append("model_change", { provider: "p", modelId: "astra" });
+    assert.equal(f.store.generation(), epoch);
+    const current = assemble(payload("low"), "astra", epoch, f.reader.getLeafId(), await f.store.records());
+    assert.equal(current.baseline, "low");
+    assert.equal(current.record.parent, null);
+    // A persisted cross-boundary parent must not become valid through normalization.
+    f.store.append({ ...current.record, parent: old.record.id, baseline: "high", effective: "high" });
+    await assert.rejects(f.store.records(), /Invalid Astra history parent/);
+  });
+}
+
+test("unknown generation and invalid native ancestry are rejected, not normalized into eligibility", async () => {
+  const f = fixture();
+  const old = assemble(payload(), "astra", "unrelated-model-entry", null, []);
+  f.store.append(old.record);
+  await assert.rejects(f.store.records(), /generation unavailable/);
+  f.branch[0].parentId = "missing";
+  await assert.rejects(f.store.records(), /Invalid Astra session ancestry/);
+});
+
+test("changed envelope or earlier projected content cannot replay an old effort update", async () => {
+  const high = payload();
+  const first = assemble(high, "astra", "root", null, []);
+  const low = { ...payload("low"), input: [...high.input, { role: "user", content: "later" }] };
+  const second = assemble(low, "astra", "root", null, [first.record]);
+  for (const changed of [
+    { ...low, instructions: "different" },
+    { ...low, input: [{ role: "user", content: "structural omission" }] },
+  ]) {
+    const result = assemble(changed, "astra", "root", null, [first.record, second.record]);
+    assert.equal(result.record.parent, null);
+    assert.deepEqual(
+      result.payload.input.filter((x) => x.type !== "configuration_update"),
+      changed.input,
+    );
+  }
+  const differentModel = assemble(low, "other-model", "root", null, [first.record, second.record]);
+  assert.equal(differentModel.record.parent, null);
+  assert.equal(differentModel.baseline, "low");
+});

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]);
+});