@hassangameryt/freeflow 0.6.0 → 0.7.1

package/pi-extension/tests/cognitive-routing/commands.test.js

@@ -89,7 +89,7 @@ test("releases manual ownership through auto without a model transition", async
 
   assert.equal(await handleCognitiveRoutingProfileCommand("profile auto", context, controller), true);
   assert.equal(calls, 1);
-  assert.match(context.notifications[0].message, /automatic control is active/);
+  assert.match(context.notifications[0].message, /automatic Reasoning control is active/);
 });
 
 test("rejects manual profile changes while Pi is running", async () => {

package/pi-extension/tests/cognitive-routing/controller.test.js

@@ -103,21 +103,21 @@ test("prepares activation before acquiring and applying the host pair", async ()
   });
   assert.deepEqual(host.calls[0][2].target, {
     provider: "faux",
-    modelId: "standard",
-    thinkingLevel: "high",
+    modelId: "reasoning",
+    thinkingLevel: "max",
   });
-  assert.equal(controller.state().activeProfile, "standard");
+  assert.equal(controller.state().activeProfile, "reasoning");
 });
 
 test("activates each configured session-start control and profile combination", async () => {
   const combinations = [
-    ["automatic", "standard", "automatic"],
-    ["automatic", "reasoning", "automatic"],
-    ["manual", "standard", "manual-standard"],
-    ["manual", "reasoning", "manual-reasoning"],
+    ["automatic", "standard", "automatic", "reasoning"],
+    ["automatic", "reasoning", "automatic", "reasoning"],
+    ["manual", "standard", "manual-standard", "standard"],
+    ["manual", "reasoning", "manual-reasoning", "reasoning"],
   ];
 
-  for (const [control, profile, expectedControlMode] of combinations) {
+  for (const [control, profile, expectedControlMode, expectedProfile] of combinations) {
     const host = createHost({ onAcquire: appliedLease });
     const controller = new CognitiveRoutingController({
       capabilityState: {
@@ -136,9 +136,9 @@ test("activates each configured session-start control and profile combination",
     const result = await controller.activate();
 
     assert.equal(result.status, "active");
-    assert.equal(controller.state().activeProfile, profile);
+    assert.equal(controller.state().activeProfile, expectedProfile);
     assert.equal(controller.state().controlMode, expectedControlMode);
-    assert.equal(host.calls[2][1].modelId, profile);
+    assert.equal(host.calls[2][1].modelId, expectedProfile);
   }
 });
 
@@ -201,14 +201,14 @@ test("does not persist or reapply an automatic request for the active profile",
   await controller.activate();
   const callsBefore = host.calls.length;
 
-  const result = await controller.switchAutomaticProfile("standard", "Keep the current profile.");
+  const result = await controller.switchAutomaticProfile("reasoning", "Keep the current profile.");
 
   assert.deepEqual(result, {
     status: "active",
     changed: false,
-    from: "standard",
-    to: "standard",
-    profile: "standard",
+    from: "reasoning",
+    to: "reasoning",
+    profile: "reasoning",
   });
   assert.equal(host.calls.length, callsBefore);
 });
@@ -226,19 +226,19 @@ test("switches profiles through the automatic owner with bounded agent evidence"
   });
   await controller.activate();
 
-  const result = await controller.switchAutomaticProfile("reasoning", "Need a deeper analysis.");
+  const result = await controller.switchAutomaticProfile("standard", "Need a lighter execution pass.");
 
   assert.deepEqual(result, {
     status: "active",
     changed: true,
-    from: "standard",
-    to: "reasoning",
-    profile: "reasoning",
+    from: "reasoning",
+    to: "standard",
+    profile: "standard",
   });
   assert.equal(controller.state().controlMode, "automatic");
   assert.equal(host.calls.at(-1)[0], "setState");
   assert.equal(host.calls[3][2].source, "agent");
-  assert.equal(host.calls[3][2].reason, "Need a deeper analysis.");
+  assert.equal(host.calls[3][2].reason, "Need a lighter execution pass.");
 });
 
 test("blocks an automatic switch while a manual hold owns the controller", async () => {
@@ -285,6 +285,21 @@ test("releases manual control as a durable control-only entry without switching
   );
 });
 
+test("releases a manual Standard hold by switching to automatic Reasoning", async () => {
+  const host = createHost({ onAcquire: appliedLease });
+  const controller = new CognitiveRoutingController({ capabilityState, pi: host.pi, ctx: host.ctx });
+  await controller.activate();
+  await controller.setManualProfile("standard");
+
+  const result = await controller.setAutomaticControl("profile-command");
+
+  assert.deepEqual(result, { status: "automatic" });
+  assert.equal(controller.state().activeProfile, "reasoning");
+  assert.equal(controller.state().controlMode, "automatic");
+  assert.equal(host.calls.at(-1)[0], "setState");
+  assert.equal(host.calls.at(-1)[1].modelId, "reasoning");
+});
+
 test("does not acquire or switch when durable activation preparation fails", async () => {
   let acquireCalls = 0;
   const host = createHost({
@@ -422,7 +437,7 @@ test("serializes deactivation behind an in-flight activation", async () => {
       lease: {
         async setState(request) {
           calls.push(["setState", request]);
-          if (request.modelId === "standard") {
+          if (request.modelId === "reasoning") {
             resolveTransition();
             await new Promise((resolve) => {
               releaseTransition = resolve;
@@ -1003,14 +1018,14 @@ test("writes v2 mechanism, causal, and baseline metadata before transitions", as
     pi: host.pi,
     ctx: host.ctx,
     idFactory: (() => {
-      const ids = ["epoch-1", "activation-correlation", "profile-correlation"];
+      const ids = ["epoch-1", "activation-correlation", "standard-correlation", "automatic-reasoning-correlation"];
       return () => ids.shift();
     })(),
   });
 
   await controller.activate();
-  await controller.switchAutomaticProfile("reasoning", "Need a deeper analysis.");
-  await controller.setAutomaticControl();
+  await controller.switchAutomaticProfile("standard", "Need a lighter execution pass.");
+  await controller.setAutomaticControl("profile-command");
 
   const intents = host.sessionEntries.filter(
     (entry) => entry.type === "custom" && entry.customType === COGNITIVE_ROUTING_INTENT_ENTRY,
@@ -1025,10 +1040,10 @@ test("writes v2 mechanism, causal, and baseline metadata before transitions", as
     branchId: null,
     epoch: "epoch-1",
     correlationId: "activation-correlation",
-    target: { provider: "faux", modelId: "standard", thinkingLevel: "high" },
+    target: { provider: "faux", modelId: "reasoning", thinkingLevel: "max" },
     returnTarget: { provider: "faux", modelId: "return", thinkingLevel: "medium" },
     fromPair: { provider: "faux", modelId: "return", thinkingLevel: "medium" },
-    profile: "standard",
+    profile: "reasoning",
   });
   assert.deepEqual(intents[1].data, {
     version: 2,
@@ -1037,30 +1052,44 @@ test("writes v2 mechanism, causal, and baseline metadata before transitions", as
     control: "automatic",
     source: "agent",
     mechanism: "agent-tool",
-    decisionCorrelationId: "profile-correlation",
+    decisionCorrelationId: "standard-correlation",
+    fromControl: "automatic",
     branchId: null,
     epoch: "epoch-1",
-    correlationId: "profile-correlation",
-    profile: "reasoning",
-    target: { provider: "faux", modelId: "reasoning", thinkingLevel: "max" },
+    correlationId: "standard-correlation",
+    profile: "standard",
+    target: { provider: "faux", modelId: "standard", thinkingLevel: "high" },
     returnTarget: { provider: "faux", modelId: "return", thinkingLevel: "medium" },
-    fromPair: { provider: "faux", modelId: "standard", thinkingLevel: "high" },
-    fromProfile: "standard",
-    reason: "Need a deeper analysis.",
+    fromPair: { provider: "faux", modelId: "reasoning", thinkingLevel: "max" },
+    fromProfile: "reasoning",
+    reason: "Need a lighter execution pass.",
   });
-
-  const control = host.sessionEntries.find(
-    (entry) => entry.type === "custom" && entry.customType === COGNITIVE_ROUTING_CONTROL_ENTRY,
-  );
-  assert.deepEqual(control.data, {
+  assert.deepEqual(intents[2].data, {
     version: 2,
+    phase: "prepared",
+    kind: "profile",
     control: "automatic",
     source: "user",
     mechanism: "profile-command",
-    reason: "manual hold release",
+    decisionCorrelationId: "automatic-reasoning-correlation",
+    fromControl: "automatic",
     branchId: null,
     epoch: "epoch-1",
+    correlationId: "automatic-reasoning-correlation",
+    profile: "reasoning",
+    target: { provider: "faux", modelId: "reasoning", thinkingLevel: "max" },
+    returnTarget: { provider: "faux", modelId: "return", thinkingLevel: "medium" },
+    fromPair: { provider: "faux", modelId: "standard", thinkingLevel: "high" },
+    fromProfile: "standard",
+    reason: "automatic control selects the Reasoning profile",
   });
+
+  assert.equal(
+    host.sessionEntries.some(
+      (entry) => entry.type === "custom" && entry.customType === COGNITIVE_ROUTING_CONTROL_ENTRY,
+    ),
+    false,
+  );
 });
 
 test("fails closed before a profile transition when no current baseline is observable", async () => {
@@ -1072,7 +1101,7 @@ test("fails closed before a profile transition when no current baseline is obser
   host.ctx.model = undefined;
   host.ctx.thinkingLevel = undefined;
 
-  const result = await controller.switchAutomaticProfile("reasoning", "Need a deeper analysis.");
+  const result = await controller.switchAutomaticProfile("standard", "Need a deeper analysis.");
 
   assert.deepEqual(result, { status: "inactive", reason: "current_state_unavailable" });
   assert.equal(host.calls.length, callsBefore);
@@ -1094,6 +1123,6 @@ test("restores the return target without guessing a missing closing baseline", a
     (entry) => entry.type === "custom" && entry.customType === COGNITIVE_ROUTING_INTENT_ENTRY,
   );
   assert.equal(closingIntent.data.fromPair, undefined);
-  assert.equal(closingIntent.data.fromProfile, "standard");
+  assert.equal(closingIntent.data.fromProfile, "reasoning");
   assert.equal(host.sessionEntries.at(-1).type, "model_state_change");
 });

package/pi-extension/tests/cognitive-routing/extension-lifecycle.test.js

@@ -137,7 +137,7 @@ function createContext(cwd, host) {
   };
 }
 
-test("registered shortcuts cycle manual holds and automatic profiles", async () => {
+test("registered shortcuts cycle manual holds and establish automatic Reasoning", async () => {
   const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-shortcuts-"));
   await mkdir(join(cwd, ".freeflow"));
   await writeFile(
@@ -157,38 +157,29 @@ test("registered shortcuts cycle manual holds and automatic profiles", async ()
   ctx.isIdle = () => true;
   try {
     await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
+    await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
     const cycle = host.shortcuts.find(({ shortcut }) => shortcut === "ctrl+shift+r");
     const automatic = host.shortcuts.find(({ shortcut }) => shortcut === "ctrl+shift+a");
     assert.ok(cycle);
     assert.ok(automatic);
 
     await cycle.definition.handler(ctx);
-    assert.equal(host.entries.at(-1).modelId, "reasoning");
+    assert.equal(host.entries.filter((entry) => entry.modelId).at(-1).modelId, "standard");
+
     await automatic.definition.handler(ctx);
-    assert.equal(host.entries.at(-1).customType, "freeflow-cognitive-routing-control");
     assert.equal(host.entries.filter((entry) => entry.modelId).at(-1).modelId, "reasoning");
+    const modelEntriesAfterAutomatic = host.entries.filter((entry) => entry.modelId).length;
+
     await automatic.definition.handler(ctx);
-    assert.equal(host.entries.at(-1).modelId, "standard");
-    await automatic.definition.handler(ctx);
-    assert.equal(host.entries.at(-1).modelId, "reasoning");
+    assert.equal(host.entries.filter((entry) => entry.modelId).at(-1).modelId, "reasoning");
+    assert.equal(host.entries.filter((entry) => entry.modelId).length, modelEntriesAfterAutomatic);
+
     const automaticIntent = host.entries
       .filter((entry) => entry.customType === "freeflow-cognitive-routing-intent")
       .at(-1);
     assert.equal(automaticIntent.data.source, "user");
     assert.equal(automaticIntent.data.mechanism, "profile-shortcut");
-    assert.equal(automaticIntent.data.reason, "Cycle automatic profile to reasoning.");
-    assert.deepEqual(host.operations, [
-      "prepare",
-      "acquire",
-      "setState",
-      "prepare",
-      "setState",
-      "prepare",
-      "prepare",
-      "setState",
-      "prepare",
-      "setState",
-    ]);
+    assert.equal(automaticIntent.data.reason, "automatic control selects the Reasoning profile");
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -295,7 +286,7 @@ test("Cognitive Routing retries activation after a transient failure", async ()
     const providerContext = await host.handlers.get("context")({ messages: [] }, ctx);
     assert.match(providerContext.messages.at(-1).content, /Cognitive Routing: active/);
     assert.match(providerContext.messages.at(-1).content, /Control: `automatic`/);
-    assert.match(providerContext.messages.at(-1).content, /Profile: `standard`/);
+    assert.match(providerContext.messages.at(-1).content, /Profile: `reasoning`/);
     assert.ok(host.operations.includes("setState"));
   } finally {
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
@@ -385,13 +376,13 @@ test("new empty sessions do not persist Cognitive Routing state until the first
 
 test("new sessions honor each configured Cognitive Routing startup combination", async () => {
   const combinations = [
-    ["automatic", "standard"],
-    ["automatic", "reasoning"],
-    ["manual", "standard"],
-    ["manual", "reasoning"],
+    ["automatic", "standard", "reasoning"],
+    ["automatic", "reasoning", "reasoning"],
+    ["manual", "standard", "standard"],
+    ["manual", "reasoning", "reasoning"],
   ];
 
-  for (const [control, profile] of combinations) {
+  for (const [control, profile, expectedProfile] of combinations) {
     const cwd = await mkdtemp(join(tmpdir(), `freeflow-cognitive-routing-start-${control}-${profile}-`));
     await mkdir(join(cwd, ".freeflow"));
     await writeFile(
@@ -414,11 +405,11 @@ test("new sessions honor each configured Cognitive Routing startup combination",
       await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
       await host.handlers.get("before_agent_start")({ prompt: "hello", systemPrompt: "base prompt" }, ctx);
 
-      assert.equal(host.entries.filter((entry) => entry.modelId).at(-1).modelId, profile);
+      assert.equal(host.entries.filter((entry) => entry.modelId).at(-1).modelId, expectedProfile);
       const activation = host.entries.find(
         (entry) => entry.customType === "freeflow-cognitive-routing-intent" && entry.data.kind === "activation",
       );
-      assert.equal(activation.data.profile, profile);
+      assert.equal(activation.data.profile, expectedProfile);
       assert.equal(activation.data.control, control);
     } finally {
       await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
@@ -461,7 +452,7 @@ test("editing session-start settings does not activate the current empty session
     const component = factory({ requestRender() {} }, theme, {}, (value) => {
       result = value;
     });
-    for (let index = 0; index < 5; index += 1) component.handleInput("\u001b[B");
+    component.handleInput("\u001b[B");
     component.handleInput("\r");
     for (let index = 0; index < 3; index += 1) component.handleInput("\u001b[B");
     component.handleInput("\r");
@@ -513,11 +504,11 @@ test("child extension activation does not deactivate the parent routing controll
   try {
     await parent.handlers.get("session_start")({ type: "session_start", reason: "startup" }, parentContext);
     await parent.handlers.get("before_agent_start")({ prompt: "hello", systemPrompt: "base prompt" }, parentContext);
-    assert.deepEqual(parent.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
+    assert.deepEqual(parent.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
 
     await child.handlers.get("session_start")({ type: "session_start", reason: "startup" }, childContext);
 
-    assert.deepEqual(parent.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
+    assert.deepEqual(parent.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
     assert.equal(
       parent.entries.some((entry) => entry.kind === "closing"),
       false,
@@ -548,6 +539,7 @@ test("registered profile commands create manual holds and release them without a
   const ctx = createContext(cwd, host);
   try {
     await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
+    await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
     const command = host.commands.find(({ name }) => name === "freeflow");
     assert.ok(command);
     assert.deepEqual(
@@ -665,6 +657,7 @@ test("reload preserves a manual reasoning hold after lease rotation", async () =
   ctx.isIdle = () => true;
   try {
     await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
+    await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
     await host.commands.find(({ name }) => name === "freeflow").definition.handler("profile reasoning", ctx);
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "reload" }, ctx);
 
@@ -705,6 +698,7 @@ test("tree navigation retains the current profile without a supported branch cho
   const ctx = createContext(cwd, host);
   try {
     await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
+    await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
     const standardBranch = [...host.entries];
     const command = host.commands.find(({ name }) => name === "freeflow");
     await command.definition.handler("profile reasoning", ctx);
@@ -748,7 +742,7 @@ test("compaction reconciles without changing an active routing pair", async () =
     await host.handlers.get("session_compact")({ type: "session_compact" }, ctx);
 
     assert.deepEqual(host.operations, operationsBeforeCompaction);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
+    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
     assert.ok(host.activeToolNames().includes("freeflow_switch_profile"));
   } finally {
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
@@ -865,7 +859,7 @@ test("reload recovery stays inactive after an unmatched closing intent", async (
   }
 });
 
-test("Pi delivers a compact Cognitive Routing cue and volatile state per turn", async () => {
+test("Pi delivers stable Cognitive Routing cues and refreshes runtime state only when needed", async () => {
   const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-compact-delivery-"));
   await mkdir(join(cwd, ".freeflow"));
   await writeFile(
@@ -889,14 +883,17 @@ test("Pi delivers a compact Cognitive Routing cue and volatile state per turn",
 
     assert.equal(first.message, undefined);
     assert.match(first.systemPrompt, /## Cognitive Routing Cue/);
-    assert.match(
-      first.systemPrompt,
-      /governs compute placement across Freeflow methods.*skill has not been read in the current context.*read it before applying another Freeflow skill or taking task Act/s,
-    );
-    assert.match(
-      first.systemPrompt,
-      /every authorized execution-bearing bounded activity is Reasoning-led.*Standard takes task Act only inside delegation/s,
-    );
+    assert.match(first.systemPrompt, /each user interaction begins in Reasoning/);
+    assert.match(first.systemPrompt, /If the full Cognitive Routing skill is not visible/);
+    assert.match(first.systemPrompt, /Make that read the only environment call/);
+    assert.match(first.systemPrompt, /it is not a route transition/);
+    assert.match(first.systemPrompt, /YIELD/);
+    assert.match(first.systemPrompt, /Delegate/);
+    assert.match(first.systemPrompt, /ACT_BOUNDED/);
+    assert.match(first.systemPrompt, /Automatic Standard only executes active Yield or Delegate contracts/);
+    assert.match(first.systemPrompt, /writes `YIELD HANDOFF` or `RETURN` and switches to Reasoning/);
+    assert.match(first.systemPrompt, /Standard never handles substantive user-facing interaction/);
+    assert.doesNotMatch(first.systemPrompt, /TASK ACT|OBSERVE/);
     assert.ok(
       first.systemPrompt.indexOf("## Action Selection Cue") < first.systemPrompt.indexOf("## Cognitive Routing Cue"),
     );
@@ -909,7 +906,22 @@ test("Pi delivers a compact Cognitive Routing cue and volatile state per turn",
     assert.equal(firstContext.messages[0].customType, "freeflow-runtime-state");
     assert.match(firstContext.messages[0].content, /Cognitive Routing: active/);
     assert.match(firstContext.messages[0].content, /Control: `automatic`/);
-    assert.match(firstContext.messages[0].content, /Profile: `standard`/);
+    assert.match(firstContext.messages[0].content, /Profile: `reasoning`/);
+
+    const unchangedContext = await contextHandler({ messages: firstContext.messages }, ctx);
+    assert.equal(unchangedContext, undefined);
+
+    await host.handlers.get("session_tree")({ type: "session_tree", reason: "branch" }, ctx);
+    const branchContext = await contextHandler({ messages: firstContext.messages }, ctx);
+    assert.ok(branchContext);
+    assert.equal(branchContext.messages.length, 1);
+    assert.match(branchContext.messages[0].content, /Profile: `reasoning`/);
+
+    await host.handlers.get("session_compact")({ type: "session_compact", reason: "compaction" }, ctx);
+    const compactContext = await contextHandler({ messages: branchContext.messages }, ctx);
+    assert.ok(compactContext);
+    assert.equal(compactContext.messages.length, 1);
+    assert.match(compactContext.messages[0].content, /Profile: `reasoning`/);
 
     const second = await beforeAgentStart({ systemPrompt: "base prompt" }, ctx);
     assert.equal(second.message, undefined);
@@ -920,6 +932,65 @@ test("Pi delivers a compact Cognitive Routing cue and volatile state per turn",
   }
 });
 
+test("Pi preserves runtime state after a no-op profile switch", async () => {
+  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-no-op-state-"));
+  await mkdir(join(cwd, ".freeflow"));
+  await writeFile(
+    join(cwd, ".freeflow", "config.json"),
+    JSON.stringify({
+      cognitiveRouting: {
+        enabled: true,
+        profiles: {
+          standard: { provider: "faux", model: "standard", thinkingLevel: "high" },
+          reasoning: { provider: "faux", model: "reasoning", thinkingLevel: "max" },
+        },
+      },
+    }),
+  );
+  const host = createExtensionHost();
+  const ctx = createContext(cwd, host);
+  try {
+    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
+    await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
+
+    const contextHandler = host.handlers.get("context");
+    const reasoningContext = await contextHandler({ messages: [] }, ctx);
+    const runtimeStateMessages = reasoningContext.messages.filter(
+      (message) =>
+        message.customType === "freeflow-runtime-state" ||
+        message.customType === "freeflow-cognitive-routing-runtime-state",
+    );
+    assert.equal(runtimeStateMessages.length, 1);
+    assert.equal(runtimeStateMessages[0].customType, "freeflow-runtime-state");
+
+    const switchTool = host.tools.find((tool) => tool.name === "freeflow_switch_profile");
+    const result = await switchTool.execute(
+      "call-no-op-volatile-state",
+      { target: "reasoning", reason: "Remain on Reasoning for this check." },
+      undefined,
+      undefined,
+      ctx,
+    );
+    assert.equal(result.details.result.status, "active");
+    assert.equal(result.details.result.changed, false);
+
+    await host.handlers.get("tool_result")({ type: "tool_result", toolName: "freeflow_switch_profile" }, ctx);
+    const unchangedContext = await contextHandler({ messages: reasoningContext.messages }, ctx);
+    assert.equal(unchangedContext, undefined);
+    assert.equal(
+      reasoningContext.messages.filter(
+        (message) =>
+          message.customType === "freeflow-runtime-state" ||
+          message.customType === "freeflow-cognitive-routing-runtime-state",
+      ).length,
+      1,
+    );
+  } finally {
+    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
 test("Pi refreshes volatile Cognitive Routing state after a profile switch", async () => {
   const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-volatile-state-"));
   await mkdir(join(cwd, ".freeflow"));
@@ -942,31 +1013,31 @@ test("Pi refreshes volatile Cognitive Routing state after a profile switch", asy
     await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
 
     const contextHandler = host.handlers.get("context");
-    const standardContext = await contextHandler({ messages: [] }, ctx);
-    assert.match(standardContext.messages[0].content, /Profile: `standard`/);
+    const reasoningContext = await contextHandler({ messages: [] }, ctx);
+    assert.match(reasoningContext.messages[0].content, /Profile: `reasoning`/);
 
     const switchTool = host.tools.find((tool) => tool.name === "freeflow_switch_profile");
     const result = await switchTool.execute(
       "call-volatile-state",
-      { target: "reasoning", reason: "Need a deeper analysis." },
+      { target: "standard", reason: "Use Standard for bounded execution." },
       undefined,
       undefined,
       ctx,
     );
-    assert.equal(result.details.result.to, "reasoning");
+    assert.equal(result.details.result.to, "standard");
 
-    const reasoningContext = await contextHandler({ messages: standardContext.messages }, ctx);
-    assert.equal(reasoningContext.messages.length, 1);
-    assert.match(reasoningContext.messages[0].content, /Control: `automatic`/);
-    assert.match(reasoningContext.messages[0].content, /Profile: `reasoning`/);
-    assert.doesNotMatch(reasoningContext.messages[0].content, /Profile: `standard`/);
+    const standardContext = await contextHandler({ messages: reasoningContext.messages }, ctx);
+    assert.equal(standardContext.messages.length, 1);
+    assert.match(standardContext.messages[0].content, /Control: `automatic`/);
+    assert.match(standardContext.messages[0].content, /Profile: `standard`/);
+    assert.doesNotMatch(standardContext.messages[0].content, /Profile: `reasoning`/);
   } finally {
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
     await rm(cwd, { recursive: true, force: true });
   }
 });
 
-test("Pi keeps Cognitive Routing behind the Skills parent gate", async () => {
+test("Pi rejects the removed Skills configuration instead of gating Cognitive Routing", async () => {
   const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-skills-gate-"));
   await mkdir(join(cwd, ".freeflow"));
   await writeFile(
@@ -992,8 +1063,8 @@ test("Pi keeps Cognitive Routing behind the Skills parent gate", async () => {
     assert.doesNotMatch(result.systemPrompt, /^# Cognitive Routing$/m);
     assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
     const providerContext = await host.handlers.get("context")({ messages: [] }, ctx);
-    assert.match(providerContext.messages[0].content, /Skills: inactive/);
-    assert.match(providerContext.messages[0].content, /Cognitive Routing: inactive/);
+    assert.match(providerContext.messages[0].content, /Freeflow: config error/);
+    assert.doesNotMatch(providerContext.messages[0].content, /Skills:/);
   } finally {
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
     await rm(cwd, { recursive: true, force: true });
@@ -1026,7 +1097,7 @@ test("Pi lifecycle prepares, activates, restores, and releases Cognitive Routing
       ctx,
     );
     assert.deepEqual(host.operations.slice(0, 3), ["prepare", "acquire", "setState"]);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
+    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
     assert.equal(host.entries[0].customType, "freeflow-cognitive-routing-intent");
     assert.ok(host.activeToolNames().includes("freeflow_switch_profile"));
     assert.match(beforeAgentStart.systemPrompt, /## Cognitive Routing Cue/);
@@ -1037,12 +1108,12 @@ test("Pi lifecycle prepares, activates, restores, and releases Cognitive Routing
     const switchTool = host.tools.find((tool) => tool.name === "freeflow_switch_profile");
     await switchTool.execute(
       "call-1",
-      { target: "reasoning", reason: "Continue the unresolved architecture decision." },
+      { target: "standard", reason: "Use Standard for the bounded execution pass." },
       undefined,
       undefined,
       ctx,
     );
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
+    assert.deepEqual(host.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
 
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "reload" }, ctx);
 
@@ -1062,7 +1133,7 @@ test("Pi lifecycle prepares, activates, restores, and releases Cognitive Routing
 
     await host.handlers.get("session_start")({ type: "session_start", reason: "reload" }, ctx);
     assert.deepEqual(host.operations.slice(-3), ["prepare", "acquire", "setState"]);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
+    assert.deepEqual(host.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
     assert.ok(host.activeToolNames().includes("freeflow_switch_profile"));
     await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
   } finally {