@hassangameryt/freeflow 0.7.0 → 0.7.2

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

@@ -1,1142 +0,0 @@
-import assert from "node:assert/strict";
-import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import test from "node:test";
-import freeflowExtension from "../../dist/index.js";
-import { PIFLOW_HOST } from "./host-fixture.js";
-
-function createExtensionHost(
-  { rejectReturnRestore = false, rejectAcquire = false } = {},
-  extension = freeflowExtension,
-) {
-  const handlers = new Map();
-  const tools = [];
-  const commands = [];
-  const shortcuts = [];
-  const entries = [];
-  const operations = [];
-  let activeToolNames;
-  let shouldRejectAcquire = rejectAcquire;
-  const state = {
-    model: { provider: "faux", id: "return" },
-    thinkingLevel: "medium",
-  };
-  const pi = {
-    host: PIFLOW_HOST,
-    registerTool(tool) {
-      tools.push(tool);
-    },
-    registerCommand(name, definition) {
-      commands.push({ name, definition });
-    },
-    registerShortcut(shortcut, definition) {
-      shortcuts.push({ shortcut, definition });
-    },
-    on(event, handler) {
-      handlers.set(event, handler);
-    },
-    appendEntry(customType, data) {
-      entries.push({ type: "custom", customType, data });
-    },
-    appendEntryDurable(customType, data) {
-      operations.push("prepare");
-      entries.push({ type: "custom", customType, data });
-    },
-    async acquireModelStateControl() {
-      operations.push("acquire");
-      if (shouldRejectAcquire) return { status: "busy" };
-      return {
-        status: "acquired",
-        lease: {
-          async setState(request) {
-            operations.push("setState");
-            if (rejectReturnRestore && request.modelId === "return") return { status: "rejected" };
-            state.model = { provider: request.provider, id: request.modelId };
-            state.thinkingLevel = request.thinkingLevel;
-            entries.push({
-              type: "model_state_change",
-              provider: request.provider,
-              modelId: request.modelId,
-              thinkingLevel: request.thinkingLevel,
-              correlationId: request.correlationId,
-            });
-            return { status: "applied" };
-          },
-          async release() {
-            operations.push("release");
-            return { status: "released" };
-          },
-        },
-      };
-    },
-    getAllTools() {
-      return tools.map((tool) => ({ name: tool.name }));
-    },
-    getActiveTools() {
-      return tools.map((tool) => tool.name);
-    },
-    setActiveTools(names) {
-      activeToolNames = [...names];
-    },
-    sendUserMessage() {},
-  };
-  extension(pi);
-  return {
-    commands,
-    entries,
-    handlers,
-    operations,
-    pi,
-    shortcuts,
-    state,
-    tools,
-    activeToolNames: () => activeToolNames ?? [],
-    setRejectAcquire(value) {
-      shouldRejectAcquire = value;
-    },
-  };
-}
-
-function createContext(cwd, host) {
-  return {
-    cwd,
-    mode: "print",
-    hasUI: false,
-    model: host.state.model,
-    thinkingLevel: host.state.thinkingLevel,
-    modelRegistry: {
-      find(provider, modelId) {
-        if (provider !== "faux" || !["standard", "reasoning", "return"].includes(modelId)) return undefined;
-        return { provider, id: modelId };
-      },
-      async getApiKeyAndHeaders() {
-        return { ok: true };
-      },
-      clampThinkingLevel(_model, level) {
-        return level;
-      },
-    },
-    modelStateProvenance: {},
-    sessionManager: {
-      getEntries() {
-        return host.entries;
-      },
-      getBranch() {
-        return host.entries;
-      },
-      buildContextEntries() {
-        return host.entries;
-      },
-    },
-    ui: {
-      notify() {},
-      setStatus() {},
-    },
-  };
-}
-
-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(
-    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);
-  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.filter((entry) => entry.modelId).at(-1).modelId, "standard");
-
-    await automatic.definition.handler(ctx);
-    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.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, "automatic control selects the Reasoning profile");
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("explicit startup model provenance suppresses lifecycle activation", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-suppressed-"));
-  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);
-  ctx.modelStateProvenance = { explicitModel: true };
-  try {
-    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
-    assert.deepEqual(host.operations, []);
-    assert.deepEqual(host.entries, []);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "return" }, thinkingLevel: "medium" });
-
-    const before = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(before.message, undefined);
-    assert.doesNotMatch(before.systemPrompt, /## Cognitive Routing Cue/);
-    const resources = await host.handlers.get("resources_discover")({ cwd }, ctx);
-    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/capabilities/cognitive-routing/SKILL.md")));
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-    const providerContext = await host.handlers.get("context")({ messages: [] }, ctx);
-    assert.match(providerContext.messages.at(-1).content, /Cognitive Routing: unavailable/);
-    assert.match(providerContext.messages.at(-1).content, /Control: `unavailable`/);
-    assert.match(providerContext.messages.at(-1).content, /Profile: `unavailable`/);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("Cognitive Routing activation failure hides model-facing routing surfaces", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-activation-failure-"));
-  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({ rejectAcquire: true });
-  const ctx = createContext(cwd, host);
-  try {
-    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
-    const before = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(before.message, undefined);
-    assert.doesNotMatch(before.systemPrompt, /## Cognitive Routing Cue/);
-    const resources = await host.handlers.get("resources_discover")({ cwd }, ctx);
-    assert.ok(!resources.skillPaths.some((path) => path.endsWith("/capabilities/cognitive-routing/SKILL.md")));
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-    const providerContext = await host.handlers.get("context")({ messages: [] }, ctx);
-    assert.match(providerContext.messages.at(-1).content, /Cognitive Routing: unavailable/);
-    assert.match(providerContext.messages.at(-1).content, /Control: `unavailable`/);
-    assert.match(providerContext.messages.at(-1).content, /Profile: `unavailable`/);
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("Cognitive Routing retries activation after a transient failure", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-activation-retry-"));
-  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({ rejectAcquire: true });
-  const ctx = createContext(cwd, host);
-  try {
-    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
-    const first = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.doesNotMatch(first.systemPrompt, /## Cognitive Routing Cue/);
-    host.setRejectAcquire(false);
-    const second = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.match(second.systemPrompt, /## Cognitive Routing Cue/);
-    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: `reasoning`/);
-    assert.ok(host.operations.includes("setState"));
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("missing Cognitive Routing prompt prevents lifecycle activation", async () => {
-  const root = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-prompt-missing-"));
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-prompt-missing-repo-"));
-  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" },
-        },
-      },
-    }),
-  );
-  try {
-    await cp(join(process.cwd(), "pi-extension", "dist"), join(root, "pi-extension", "dist"), { recursive: true });
-    await cp(join(process.cwd(), "runtime", "prompts"), join(root, "runtime", "prompts"), { recursive: true });
-    await symlink(join(process.cwd(), "node_modules"), join(root, "node_modules"), "dir");
-    await rm(join(root, "runtime", "prompts", "cognitive-routing.md"));
-    const extension = (
-      await import(
-        `${pathToFileURL(join(root, "pi-extension", "dist", "index.js")).href}?missing-routing=${Date.now()}`
-      )
-    ).default;
-    const host = createExtensionHost({}, extension);
-    const ctx = createContext(cwd, host);
-    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
-    const before = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-
-    assert.deepEqual(host.operations, []);
-    assert.doesNotMatch(before.systemPrompt, /## Cognitive Routing Cue/);
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-    const providerContext = await host.handlers.get("context")({ messages: [] }, ctx);
-    assert.match(providerContext.messages.at(-1).content, /Cognitive Routing: unavailable/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("new empty sessions do not persist Cognitive Routing state until the first prompt", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-lazy-start-"));
-  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);
-
-    assert.deepEqual(host.operations, []);
-    assert.deepEqual(host.entries, []);
-
-    const beforeAgentStart = await host.handlers.get("before_agent_start")(
-      { prompt: "hello", systemPrompt: "base prompt" },
-      ctx,
-    );
-    assert.deepEqual(host.operations.slice(0, 3), ["prepare", "acquire", "setState"]);
-    assert.equal(host.entries[0].customType, "freeflow-cognitive-routing-intent");
-    assert.match(beforeAgentStart.systemPrompt, /## Cognitive Routing Cue/);
-    assert.doesNotMatch(beforeAgentStart.systemPrompt, /^# Automatic Routing Kernel$/m);
-    assert.equal(beforeAgentStart.message, undefined);
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("new sessions honor each configured Cognitive Routing startup combination", async () => {
-  const combinations = [
-    ["automatic", "standard", "reasoning"],
-    ["automatic", "reasoning", "reasoning"],
-    ["manual", "standard", "standard"],
-    ["manual", "reasoning", "reasoning"],
-  ];
-
-  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(
-      join(cwd, ".freeflow", "config.json"),
-      JSON.stringify({
-        cognitiveRouting: {
-          enabled: true,
-          sessionStart: { control, profile },
-          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")({ prompt: "hello", systemPrompt: "base prompt" }, ctx);
-
-      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, expectedProfile);
-      assert.equal(activation.data.control, control);
-    } finally {
-      await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-      await rm(cwd, { recursive: true, force: true });
-    }
-  }
-});
-
-test("editing session-start settings does not activate the current empty session", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-session-start-current-session-"));
-  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);
-  ctx.mode = "tui";
-  ctx.hasUI = true;
-  ctx.isIdle = () => true;
-  ctx.ui.custom = async (factory) => {
-    let result;
-    const theme = {
-      fg(_color, text) {
-        return text;
-      },
-      bold(text) {
-        return text;
-      },
-    };
-    const component = factory({ requestRender() {} }, theme, {}, (value) => {
-      result = value;
-    });
-    component.handleInput("\u001b[B");
-    component.handleInput("\r");
-    for (let index = 0; index < 3; index += 1) component.handleInput("\u001b[B");
-    component.handleInput("\r");
-    component.handleInput("\u001b[B");
-    component.handleInput("\u001b[B");
-    component.handleInput("\r");
-    await component.waitForWrites();
-    component.handleInput("\u001b");
-    component.handleInput("\u001b");
-    return result;
-  };
-
-  try {
-    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
-    host.operations.length = 0;
-    await host.commands.find((command) => command.name === "freeflow").definition.handler("settings", ctx);
-
-    assert.deepEqual(host.operations, []);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "return" }, thinkingLevel: "medium" });
-    assert.equal(host.entries.filter((entry) => entry.modelId).length, 0);
-    const saved = JSON.parse(await readFile(join(cwd, ".freeflow", "local.json"), "utf8"));
-    assert.equal(saved.cognitiveRouting.sessionStart.control, "manual");
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("child extension activation does not deactivate the parent routing controller", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-child-activation-"));
-  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 parent = createExtensionHost();
-  const parentContext = createContext(cwd, parent);
-  const child = createExtensionHost();
-  const childContext = createContext(cwd, child);
-  childContext.modelStateProvenance = { explicitModel: true, explicitThinking: true };
-  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: "reasoning" }, thinkingLevel: "max" });
-
-    await child.handlers.get("session_start")({ type: "session_start", reason: "startup" }, childContext);
-
-    assert.deepEqual(parent.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-    assert.equal(
-      parent.entries.some((entry) => entry.kind === "closing"),
-      false,
-    );
-  } finally {
-    await child.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, childContext);
-    await parent.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, parentContext);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("registered profile commands create manual holds and release them without a model entry", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-command-"));
-  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 command = host.commands.find(({ name }) => name === "freeflow");
-    assert.ok(command);
-    assert.deepEqual(
-      command.definition.getArgumentCompletions("profile r").map(({ value }) => value),
-      ["profile reasoning"],
-    );
-
-    await command.definition.handler("profile reasoning", ctx);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-    assert.deepEqual(host.operations, ["prepare", "acquire", "setState", "prepare", "setState"]);
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-
-    await command.definition.handler("profile auto", ctx);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-    assert.deepEqual(host.operations, ["prepare", "acquire", "setState", "prepare", "setState", "prepare"]);
-    assert.equal(host.entries.at(-1).customType, "freeflow-cognitive-routing-control");
-    assert.ok(host.activeToolNames().includes("freeflow_switch_profile"));
-
-    const switchTool = host.tools.find((tool) => tool.name === "freeflow_switch_profile");
-    const switchResult = await switchTool.execute(
-      "call-1",
-      { target: "standard", reason: "Return to the standard profile." },
-      undefined,
-      undefined,
-      ctx,
-    );
-    assert.deepEqual(switchResult.details.result, {
-      status: "active",
-      changed: true,
-      from: "reasoning",
-      to: "standard",
-      profile: "standard",
-    });
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
-    assert.deepEqual(host.operations, [
-      "prepare",
-      "acquire",
-      "setState",
-      "prepare",
-      "setState",
-      "prepare",
-      "prepare",
-      "setState",
-    ]);
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("settled runs preserve automatic reasoning and manual holds", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-settled-"));
-  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")({ prompt: "hello", systemPrompt: "base prompt" }, ctx);
-    const switchTool = host.tools.find((tool) => tool.name === "freeflow_switch_profile");
-    await switchTool.execute(
-      "call-1",
-      { target: "reasoning", reason: "Need a deeper analysis." },
-      undefined,
-      undefined,
-      ctx,
-    );
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-
-    const callsBeforeSettledAutomatic = host.operations.length;
-    await host.handlers.get("agent_settled")({ type: "agent_settled" }, ctx);
-    assert.equal(host.operations.length, callsBeforeSettledAutomatic);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-
-    const command = host.commands.find(({ name }) => name === "freeflow");
-    await command.definition.handler("profile reasoning", ctx);
-    const callsBeforeSettledManual = host.operations.length;
-    await host.handlers.get("agent_settled")({ type: "agent_settled" }, ctx);
-    assert.equal(host.operations.length, callsBeforeSettledManual);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("reload preserves a manual reasoning hold after lease rotation", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-reload-manual-"));
-  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);
-  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);
-
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "return" }, thinkingLevel: "medium" });
-    await host.handlers.get("session_start")({ type: "session_start", reason: "reload" }, ctx);
-
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-
-    const operationsBeforeCompaction = [...host.operations];
-    await host.handlers.get("session_compact")({ type: "session_compact" }, ctx);
-    assert.deepEqual(host.operations, operationsBeforeCompaction);
-    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);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("tree navigation retains the current profile without a supported branch choice", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-tree-"));
-  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 standardBranch = [...host.entries];
-    const command = host.commands.find(({ name }) => name === "freeflow");
-    await command.definition.handler("profile reasoning", ctx);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "reasoning" }, thinkingLevel: "max" });
-
-    ctx.sessionManager.getBranch = () => standardBranch;
-    await host.handlers.get("session_tree")(
-      { type: "session_tree", newLeafId: "standard", oldLeafId: "reasoning" },
-      ctx,
-    );
-
-    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);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("compaction reconciles without changing an active routing pair", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-compact-"));
-  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")({ prompt: "hello", systemPrompt: "base prompt" }, ctx);
-    const operationsBeforeCompaction = [...host.operations];
-    await host.handlers.get("session_compact")({ type: "session_compact" }, ctx);
-
-    assert.deepEqual(host.operations, operationsBeforeCompaction);
-    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);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("reload with disabled configuration stays inactive after successful cleanup", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-reload-disabled-"));
-  await mkdir(join(cwd, ".freeflow"));
-  const configPath = join(cwd, ".freeflow", "config.json");
-  await writeFile(
-    configPath,
-    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("session_shutdown")({ type: "session_shutdown", reason: "reload" }, ctx);
-    await writeFile(configPath, JSON.stringify({ cognitiveRouting: { enabled: false } }));
-    const operationsBeforeDisabledStart = [...host.operations];
-
-    await host.handlers.get("session_start")({ type: "session_start", reason: "reload" }, ctx);
-
-    assert.deepEqual(host.operations, operationsBeforeDisabledStart);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "return" }, thinkingLevel: "medium" });
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("session replacement restores the pair before releasing routing ownership", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-replacement-"));
-  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")({ prompt: "hello", systemPrompt: "base prompt" }, ctx);
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "new" }, ctx);
-
-    assert.deepEqual(host.operations, ["prepare", "acquire", "setState", "prepare", "setState", "release"]);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "return" }, thinkingLevel: "medium" });
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("reload recovery stays inactive after an unmatched closing intent", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-reload-failure-"));
-  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({ rejectReturnRestore: true });
-  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")({ prompt: "hello", systemPrompt: "base prompt" }, ctx);
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "reload" }, ctx);
-    assert.deepEqual(host.operations, ["prepare", "acquire", "setState", "prepare", "setState", "release"]);
-    assert.equal(host.entries.at(-1).customType, "freeflow-cognitive-routing-intent");
-    assert.equal(host.entries.at(-1).data.kind, "closing");
-
-    await host.handlers.get("session_start")({ type: "session_start", reason: "reload" }, ctx);
-    assert.deepEqual(host.operations, [
-      "prepare",
-      "acquire",
-      "setState",
-      "prepare",
-      "setState",
-      "release",
-      "prepare",
-      "acquire",
-      "setState",
-      "release",
-    ]);
-    assert.equal(host.entries.at(-1).data.phase, "prepared");
-    assert.ok(!host.activeToolNames().includes("freeflow_switch_profile"));
-  } finally {
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "test-cleanup" }, ctx);
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-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(
-    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);
-    const beforeAgentStart = host.handlers.get("before_agent_start");
-    const first = await beforeAgentStart({ systemPrompt: "base prompt" }, ctx);
-
-    assert.equal(first.message, undefined);
-    assert.match(first.systemPrompt, /## Cognitive Routing Cue/);
-    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"),
-    );
-    assert.doesNotMatch(first.systemPrompt, /^# Cognitive Routing$/m);
-    assert.doesNotMatch(first.systemPrompt, /^# Automatic Routing Kernel$/m);
-
-    const contextHandler = host.handlers.get("context");
-    const firstContext = await contextHandler({ messages: [] }, ctx);
-    assert.equal(firstContext.messages.length, 1);
-    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: `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);
-    assert.equal((second.systemPrompt.match(/## Cognitive Routing Cue/g) ?? []).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 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"));
-  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);
-    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: "standard", reason: "Use Standard for bounded execution." },
-      undefined,
-      undefined,
-      ctx,
-    );
-    assert.equal(result.details.result.to, "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 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(
-    join(cwd, ".freeflow", "config.json"),
-    JSON.stringify({
-      skills: { enabled: false },
-      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);
-    const result = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(result.message, undefined);
-    assert.doesNotMatch(result.systemPrompt, /## Cognitive Routing Cue/);
-    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, /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 });
-  }
-});
-
-test("Pi lifecycle prepares, activates, restores, and releases Cognitive Routing ownership", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-cognitive-routing-extension-"));
-  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);
-    assert.deepEqual(host.operations, []);
-
-    const beforeAgentStart = await host.handlers.get("before_agent_start")(
-      { prompt: "hello", systemPrompt: "base prompt" },
-      ctx,
-    );
-    assert.deepEqual(host.operations.slice(0, 3), ["prepare", "acquire", "setState"]);
-    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/);
-    assert.doesNotMatch(beforeAgentStart.systemPrompt, /^# Cognitive Routing$/m);
-    assert.doesNotMatch(beforeAgentStart.systemPrompt, /^# Automatic Routing Kernel$/m);
-    assert.equal(beforeAgentStart.message, undefined);
-
-    const switchTool = host.tools.find((tool) => tool.name === "freeflow_switch_profile");
-    await switchTool.execute(
-      "call-1",
-      { target: "standard", reason: "Use Standard for the bounded execution pass." },
-      undefined,
-      undefined,
-      ctx,
-    );
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "standard" }, thinkingLevel: "high" });
-
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "reload" }, ctx);
-
-    assert.deepEqual(host.operations, [
-      "prepare",
-      "acquire",
-      "setState",
-      "prepare",
-      "setState",
-      "prepare",
-      "setState",
-      "release",
-    ]);
-    assert.deepEqual(host.state, { model: { provider: "faux", id: "return" }, thinkingLevel: "medium" });
-    assert.equal(host.entries.at(-1).type, "model_state_change");
-    assert.equal(host.entries.at(-1).modelId, "return");
-
-    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: "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 {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});