@hassangameryt/freeflow 0.7.1 → 0.7.3

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

@@ -6,11 +6,12 @@ import { tmpdir } from "node:os";
 import test from "node:test";
 
 import freeflowExtension from "../../dist/index.js";
-import { PIFLOW_HOST } from "../cognitive-routing/host-fixture.js";
+import { PIFLOW_HOST } from "../fixtures/pi-host.js";
 
-function context(cwd) {
+function context(cwd, systemPrompt = "") {
   return {
     cwd,
+    getSystemPrompt: () => systemPrompt,
     sessionManager: {
       getEntries: () => [],
       getBranch: () => [],
@@ -65,20 +66,55 @@ function lastRuntimeState(messages) {
 }
 
 test("re-entry recovery is stable and capability-neutral", async () => {
-  const [core, cognitiveRouting, conversationHistory] = await Promise.all([
+  const [core, cognitiveRouting, conversationHistory, routingSkill] = await Promise.all([
     readFile(join(process.cwd(), "runtime", "prompts", "core.md"), "utf8"),
     readFile(join(process.cwd(), "runtime", "prompts", "cognitive-routing.md"), "utf8"),
     readFile(join(process.cwd(), "runtime", "prompts", "conversation-history.md"), "utf8"),
+    readFile(join(process.cwd(), "capabilities", "cognitive-routing", "SKILL.md"), "utf8"),
   ]);
 
+  assert.match(core, /## Load The Selected Method/);
+  assert.match(core, /Before applying a selected skill, read its current body/);
   assert.match(core, /## Recover After Context Loss/);
   assert.match(core, /latest Freeflow Runtime State/);
-  assert.doesNotMatch(cognitiveRouting, /When Cognitive Routing is active and its skill is absent/);
-  assert.match(cognitiveRouting, /A Runtime State refresh is host context, not a user interruption/);
+  assert.match(core, /recovery is not a bypass/);
+  assert.match(core, /evidence of prior approval; check that the approval still applies/);
+  assert.match(core, /choose or retain the current owner/);
+  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, /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,
-    /`Control` and `Profile` in the latest Runtime State report current compute state, not Yield, Delegate, `ACT_BOUNDED`, or boundary state/,
+    /Under Manual control, the held Coordinator, Helper, or Executor follows ordinary unsplit Workflow/,
   );
+  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,
+    /For the current returned assessment, Coordinator uses `freeflow_unit\(operation: "recover"\)`/,
+  );
+  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/,
@@ -98,8 +134,10 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
     const order = [
       "# Freeflow Stable Guidance",
       "## Shared Terms",
+      "## Load The Selected Method",
       "## Recover After Context Loss",
       "## Three Nested Loops",
+      "## Evidence And Judgment",
       "## Workflow Cue",
       "## Action Selection Cue",
       "## Supported Exit",
@@ -112,6 +150,18 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
       order,
       [...order].sort((a, b) => a - b),
     );
+    assert.match(
+      prompt,
+      /Before applying a selected skill, read its current body when its exact method is absent from context/,
+    );
+    assert.match(prompt, /Verification establishes what direct evidence proves at the observed boundary/);
+    assert.match(
+      prompt,
+      /Review judges whether work or an artifact is aligned, correct, suitable, and sufficiently evidenced/,
+    );
+    assert.match(prompt, /Interpret requested intent, not sentence form/);
+    assert.match(prompt, /answer the question before any action that depends on it/);
+    assert.match(prompt, /An unresolved question does not automatically suspend independent, clearly authorized work/);
     assert.doesNotMatch(prompt, /## Mode\b|strict-workflow|conversation mode|workflow mode/);
     assert.doesNotMatch(prompt, /Skills prompt/);
     assert.doesNotMatch(prompt, /# Workflow\n/);
@@ -124,6 +174,8 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
     assert.match(runtimeState.content, /Context Virtualization: active/);
     assert.match(runtimeState.content, /Conversation History: active/);
     assert.match(runtimeState.content, /Cognitive Routing: inactive/);
+    assert.match(runtimeState.content, /Control: `unavailable`/);
+    assert.match(runtimeState.content, /Projection: `disabled`/);
     assert.doesNotMatch(runtimeState.content, /Default mode|Active mode|Interaction Contract|Skills/);
 
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
@@ -137,6 +189,46 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
   }
 });
 
+test("subagents retain reference definitions while optional capabilities stay inactive", async () => {
+  const cwd = await configuredRepo({
+    contextVirtualization: true,
+    conversationHistory: true,
+    cognitiveRouting: {
+      enabled: true,
+      profiles: {
+        coordinator: { provider: "test", model: "coordinator", thinking: "high" },
+        executor: { provider: "test", model: "executor", thinking: "max" },
+      },
+    },
+  });
+  try {
+    const { handlers, activeToolNames } = loadExtension(freeflowExtension, null);
+    const ctx = context(cwd, "<!-- freeflow-subagent-capabilities: disabled -->");
+    await handlers.get("session_start")({ type: "session_start" }, ctx);
+
+    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.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.equal(resources.skillPaths.filter((path) => path.includes("/capabilities/")).length, 3);
+
+    const providerContext = await handlers.get("context")({ messages: [] }, ctx);
+    const runtimeState = lastRuntimeState(providerContext.messages);
+    assert.match(runtimeState.content, /Freeflow: active/);
+    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"));
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
 test("provider context reuses the before-agent surface until the next provider turn", async () => {
   const cwd = await configuredRepo({ contextVirtualization: true });
   try {
@@ -152,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 {
@@ -197,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 {
@@ -217,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/);
@@ -233,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 {
@@ -244,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 {
@@ -261,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 {
@@ -282,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 {
@@ -299,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(
@@ -310,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 {
@@ -333,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);
@@ -343,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

@@ -8,7 +8,7 @@ import { promisify } from "node:util";
 
 import freeflowExtension from "../../dist/index.js";
 import { resetSessionOverrides, setSessionCoreOverride } from "../../dist/runtime/runtime-context.js";
-import { PIFLOW_HOST } from "../cognitive-routing/host-fixture.js";
+import { PIFLOW_HOST } from "../fixtures/pi-host.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -51,12 +51,12 @@ function context(cwd, options = {}) {
   };
 }
 
-function loadExtension() {
+function loadExtension(host = PIFLOW_HOST, runtimeApi = {}) {
   const handlers = new Map();
   const commands = [];
   const tools = [];
   const pi = {
-    host: PIFLOW_HOST,
+    host,
     registerTool(tool) {
       tools.push(tool);
     },
@@ -77,6 +77,7 @@ function loadExtension() {
     },
     setActiveTools() {},
   };
+  Object.assign(pi, runtimeApi);
   freeflowExtension(pi);
   return { handlers, commands, pi };
 }
@@ -263,14 +264,22 @@ test("Cognitive Routing preset cancellation preserves the previous repository va
     cognitiveRouting: {
       enabled: true,
       profiles: {
-        standard: { provider: "test", model: "model-a", thinkingLevel: "low" },
-        reasoning: { provider: "test", model: "model-b", thinkingLevel: "high" },
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
       },
     },
   });
   const original = await readFile(join(cwd, ".freeflow/config.json"), "utf8");
   try {
-    const { commands } = loadExtension();
+    const { commands } = loadExtension(
+      {},
+      {
+        setModel() {
+          return true;
+        },
+        setThinkingLevel() {},
+      },
+    );
     const command = freeflowCommand(commands);
     const settings = context(cwd, { isIdle: () => true });
     settings.modelRegistry = cognitiveRoutingModelRegistry();
@@ -281,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");
@@ -300,13 +309,21 @@ test("Cognitive Routing settings refresh after enabling the capability", async (
     cognitiveRouting: {
       enabled: false,
       profiles: {
-        standard: { provider: "test", model: "model-a", thinkingLevel: "low" },
-        reasoning: { provider: "test", model: "model-b", thinkingLevel: "high" },
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
       },
     },
   });
   try {
-    const { commands } = loadExtension();
+    const { commands } = loadExtension(
+      {},
+      {
+        setModel() {
+          return true;
+        },
+        setThinkingLevel() {},
+      },
+    );
     const command = freeflowCommand(commands);
     const settings = context(cwd, { isIdle: () => true });
     settings.modelRegistry = cognitiveRoutingModelRegistry();
@@ -322,13 +339,63 @@ 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 \(5\) configured/);
+      assert.match(component.render(120).join("\n"), /Cognitive Routing\s+enabled \(6\) configured/);
+      component.handleInput("\u001b");
+      return result;
+    };
+    await command.definition.handler("settings repo", settings);
+    const saved = JSON.parse(await readFile(join(cwd, ".freeflow/config.json"), "utf8"));
+    assert.equal(saved.cognitiveRouting.enabled, true);
+    assert.equal(settings.reloads.length, 1);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("Cognitive Routing settings can disable projection without disabling routing", async () => {
+  const cwd = await configuredRepo({
+    cognitiveRouting: {
+      enabled: true,
+      projection: true,
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
+      },
+    },
+  });
+  try {
+    const { commands } = loadExtension(
+      {},
+      {
+        setModel() {
+          return true;
+        },
+        setThinkingLevel() {},
+      },
+    );
+    const command = freeflowCommand(commands);
+    const settings = context(cwd, { isIdle: () => true });
+    settings.modelRegistry = cognitiveRoutingModelRegistry();
+    settings.ui.custom = async (factory) => {
+      let result;
+      const component = factory({ requestRender() {} }, theme, {}, (value) => {
+        result = value;
+      });
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      for (let index = 0; index < 5; index += 1) component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      await component.waitForWrites();
+      component.handleInput("\u001b");
       component.handleInput("\u001b");
       return result;
     };
     await command.definition.handler("settings repo", settings);
     const saved = JSON.parse(await readFile(join(cwd, ".freeflow/config.json"), "utf8"));
     assert.equal(saved.cognitiveRouting.enabled, true);
+    assert.equal(saved.cognitiveRouting.projection ?? false, false);
     assert.equal(settings.reloads.length, 1);
   } finally {
     await rm(cwd, { recursive: true, force: true });

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