@hassangameryt/freeflow 0.7.1 → 0.7.3

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

@@ -1,434 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import test from "node:test";
-import freeflowExtension from "../../dist/index.js";
-
-const profiles = {
-  standard: { provider: "faux", model: "standard", thinkingLevel: "high" },
-  reasoning: { provider: "faux", model: "reasoning", thinkingLevel: "max" },
-};
-
-function createNormalPiHost({
-  failInactivePersistence = false,
-  failTargetThinking = false,
-  emitNativeEvents = false,
-} = {}) {
-  let currentModel = {
-    provider: "faux",
-    id: "return",
-    reasoning: true,
-    thinkingLevelMap: { xhigh: "xhigh", max: "max" },
-  };
-  let currentThinkingLevel = "medium";
-  let activeToolNames;
-  const entries = [];
-  const tools = [];
-  const commands = [];
-  const shortcuts = [];
-  const handlers = new Map();
-  const calls = [];
-  const statuses = [];
-  const models = new Map([
-    ["faux/return", currentModel],
-    ["faux/standard", { provider: "faux", id: "standard", reasoning: true, thinkingLevelMap: { max: "max" } }],
-    ["faux/reasoning", { provider: "faux", id: "reasoning", reasoning: true, thinkingLevelMap: { max: "max" } }],
-  ]);
-
-  const appendNativeEntry = (entry) => entries.push({ type: entry.type, ...entry });
-  const pi = {
-    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) {
-      if (failInactivePersistence && customType === "freeflow-cognitive-routing-inactive") {
-        throw new Error("simulated inactive persistence failure");
-      }
-      entries.push({ type: "custom", customType, data });
-    },
-    async setModel(model) {
-      calls.push(["setModel", model.provider, model.id]);
-      const previousModel = currentModel;
-      currentModel = model;
-      appendNativeEntry({ type: "model_change", provider: model.provider, modelId: model.id });
-      if (emitNativeEvents) {
-        await handlers.get("model_select")?.({ type: "model_select", model, previousModel, source: "set" }, ctx);
-      }
-      return true;
-    },
-    setThinkingLevel(level) {
-      calls.push(["setThinkingLevel", level]);
-      if (failTargetThinking && level === "max") throw new Error("simulated target thinking failure");
-      currentThinkingLevel = level;
-      appendNativeEntry({ type: "thinking_level_change", thinkingLevel: level });
-    },
-    getAllTools() {
-      return tools.map((tool) => ({ name: tool.name }));
-    },
-    getActiveTools() {
-      return activeToolNames ?? tools.map((tool) => tool.name);
-    },
-    setActiveTools(names) {
-      activeToolNames = [...names];
-    },
-    sendUserMessage() {},
-  };
-
-  const ctx = {
-    cwd: undefined,
-    mode: "print",
-    hasUI: false,
-    get model() {
-      return currentModel;
-    },
-    get thinkingLevel() {
-      return currentThinkingLevel;
-    },
-    modelRegistry: {
-      find(provider, modelId) {
-        return models.get(`${provider}/${modelId}`);
-      },
-      async getApiKeyAndHeaders() {
-        return { ok: true };
-      },
-    },
-    modelStateProvenance: {},
-    isIdle: () => true,
-    sessionManager: {
-      getEntries: () => entries,
-      getBranch: () => entries,
-      buildContextEntries: () => entries,
-      getLeafId: () => entries.at(-1)?.id ?? null,
-    },
-    ui: {
-      notify() {},
-      setStatus(_key, value) {
-        statuses.push(value);
-      },
-    },
-  };
-
-  return { pi, ctx, entries, tools, commands, shortcuts, handlers, calls, statuses, models };
-}
-
-async function configure(cwd) {
-  await mkdir(join(cwd, ".freeflow"));
-  await writeFile(
-    join(cwd, ".freeflow", "config.json"),
-    JSON.stringify({ cognitiveRouting: { enabled: true, profiles } }),
-    "utf8",
-  );
-}
-
-async function start(host) {
-  freeflowExtension(host.pi);
-  await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, host.ctx);
-  return host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, host.ctx);
-}
-
-function switchTool(host) {
-  return host.tools.find((tool) => tool.name === "freeflow_switch_profile");
-}
-
-function runtimeMessages(host) {
-  return host.entries.filter((entry) => entry.customType === "freeflow-cognitive-routing-model-state");
-}
-
-test("normal Pi activates and switches Cognitive Routing through official APIs", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-lifecycle-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    const before = await start(host);
-
-    assert.match(before.systemPrompt, /## Cognitive Routing Cue/);
-    assert.equal(host.ctx.model.id, "reasoning");
-    assert.equal(host.ctx.thinkingLevel, "max");
-    assert.ok(host.pi.getActiveTools().includes("freeflow_switch_profile"));
-
-    const tool = switchTool(host);
-    assert.ok(tool);
-    assert.equal(tool.executionMode, "sequential");
-    const result = await tool.execute(
-      "normal-pi-switch",
-      { target: "standard", reason: "Use Standard for bounded execution." },
-      undefined,
-      undefined,
-      host.ctx,
-    );
-
-    assert.deepEqual(result.details.result, {
-      status: "active",
-      changed: true,
-      from: "reasoning",
-      to: "standard",
-      profile: "standard",
-    });
-    assert.equal(host.ctx.model.id, "standard");
-    assert.equal(host.ctx.thinkingLevel, "high");
-    assert.equal(runtimeMessages(host).at(-1).data.status, "applied");
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi ignores model events emitted by Freeflow-owned transitions", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-internal-events-"));
-  const host = createNormalPiHost({ emitNativeEvents: true });
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    const before = await start(host);
-
-    assert.equal(
-      host.entries.some((entry) => entry.customType === "freeflow-cognitive-routing-inactive"),
-      false,
-    );
-    assert.match(before.systemPrompt, /## Cognitive Routing Cue/);
-    assert.equal(host.ctx.model.id, "reasoning");
-    assert.equal(host.ctx.thinkingLevel, "max");
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi no-op profile switches preserve one runtime-state message", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-no-op-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    await start(host);
-    const contextHandler = host.handlers.get("context");
-    const first = await contextHandler({ messages: [] }, host.ctx);
-    const tool = switchTool(host);
-    const result = await tool.execute(
-      "normal-pi-no-op",
-      { target: "reasoning", reason: "Remain on the current profile." },
-      undefined,
-      undefined,
-      host.ctx,
-    );
-    assert.equal(result.details.result.changed, false);
-
-    await host.handlers.get("tool_result")({ type: "tool_result", toolName: "freeflow_switch_profile" }, host.ctx);
-    assert.equal(await contextHandler({ messages: first.messages }, host.ctx), undefined);
-    assert.equal(first.messages.filter((message) => message.customType === "freeflow-runtime-state").length, 1);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi supports manual and automatic profile shortcuts", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-shortcuts-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    await start(host);
-    const manual = host.shortcuts.find(({ shortcut }) => shortcut === "ctrl+shift+r");
-    const automatic = host.shortcuts.find(({ shortcut }) => shortcut === "ctrl+shift+a");
-    assert.ok(manual);
-    assert.ok(automatic);
-
-    await manual.definition.handler(host.ctx);
-    assert.equal(host.ctx.model.id, "standard");
-    assert.match(host.statuses.at(-1), /standard · manual hold/);
-
-    await automatic.definition.handler(host.ctx);
-    assert.equal(host.ctx.model.id, "reasoning");
-    assert.equal(host.ctx.thinkingLevel, "max");
-    assert.match(host.statuses.at(-1), /reasoning · automatic/);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi disables routing after a native model override and can reactivate explicitly", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-native-override-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    await start(host);
-    const previousModel = host.ctx.model;
-    const selectedModel = host.models.get("faux/standard");
-    await host.pi.setModel(selectedModel);
-    host.pi.setThinkingLevel("high");
-    await host.handlers.get("model_select")(
-      { type: "model_select", model: selectedModel, previousModel, source: "set" },
-      host.ctx,
-    );
-
-    assert.equal(host.pi.getActiveTools().includes("freeflow_switch_profile"), false);
-    assert.ok(host.entries.some((entry) => entry.customType === "freeflow-cognitive-routing-inactive"));
-    assert.match(host.statuses.at(-1), /cognitive/);
-
-    const automatic = host.shortcuts.find(({ shortcut }) => shortcut === "ctrl+shift+a");
-    await automatic.definition.handler(host.ctx);
-    assert.equal(host.ctx.model.id, "standard");
-    assert.equal(host.ctx.thinkingLevel, "high");
-    assert.equal(host.pi.getActiveTools().includes("freeflow_switch_profile"), true);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi honors explicit startup selection and supports explicit reactivation", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-startup-override-"));
-  const originalArgv = process.argv;
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    process.argv = [originalArgv[0], originalArgv[1], "--model", "faux/return"];
-    freeflowExtension(host.pi);
-    await host.handlers.get("session_start")({ type: "session_start", reason: "startup" }, host.ctx);
-    const before = await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, host.ctx);
-
-    assert.equal(host.ctx.model.id, "return");
-    assert.equal(host.ctx.thinkingLevel, "medium");
-    assert.ok(host.entries.some((entry) => entry.customType === "freeflow-cognitive-routing-inactive"));
-    assert.equal(host.pi.getActiveTools().includes("freeflow_switch_profile"), false);
-    assert.doesNotMatch(before.systemPrompt, /## Cognitive Routing Cue/);
-
-    const command = host.commands.find(({ name }) => name === "freeflow");
-    await command.definition.handler("profile standard", host.ctx);
-    assert.equal(host.ctx.model.id, "standard");
-    assert.equal(host.ctx.thinkingLevel, "high");
-  } finally {
-    process.argv = originalArgv;
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi uses documented startup arguments instead of host provenance", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-provenance-"));
-  const originalArgv = process.argv;
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  host.ctx.modelStateProvenance = { explicitModel: true, explicitThinking: true };
-  try {
-    await configure(cwd);
-    process.argv = [originalArgv[0], originalArgv[1]];
-    const before = await start(host);
-
-    assert.equal(host.ctx.model.id, "reasoning");
-    assert.equal(host.ctx.thinkingLevel, "max");
-    assert.match(before.systemPrompt, /## Cognitive Routing Cue/);
-  } finally {
-    process.argv = originalArgv;
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi disables routing after a native thinking-level override", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-native-thinking-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    await start(host);
-    const previousLevel = host.ctx.thinkingLevel;
-    host.pi.setThinkingLevel("low");
-    await host.handlers.get("thinking_level_select")(
-      { type: "thinking_level_select", level: "low", previousLevel },
-      host.ctx,
-    );
-
-    assert.equal(host.ctx.model.id, "reasoning");
-    assert.equal(host.ctx.thinkingLevel, "low");
-    assert.equal(host.pi.getActiveTools().includes("freeflow_switch_profile"), false);
-    assert.ok(host.entries.some((entry) => entry.customType === "freeflow-cognitive-routing-inactive"));
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi fails closed when native inactivity cannot be persisted", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-inactive-persistence-"));
-  const host = createNormalPiHost({ failInactivePersistence: true });
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    await start(host);
-    const previousModel = host.ctx.model;
-    const selectedModel = host.models.get("faux/standard");
-    await host.pi.setModel(selectedModel);
-    host.pi.setThinkingLevel("high");
-    await host.handlers.get("model_select")(
-      { type: "model_select", model: selectedModel, previousModel, source: "set" },
-      host.ctx,
-    );
-
-    assert.equal(host.pi.getActiveTools().includes("freeflow_switch_profile"), false);
-    assert.equal(
-      host.entries.some((entry) => entry.customType === "freeflow-cognitive-routing-inactive"),
-      false,
-    );
-    assert.match(host.statuses.at(-1), /cognitive blocked/);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi reload restores the active semantic profile", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-reload-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    await start(host);
-    const tool = switchTool(host);
-    await tool.execute(
-      "normal-pi-reload-switch",
-      { target: "standard", reason: "Use Standard for bounded execution." },
-      undefined,
-      undefined,
-      host.ctx,
-    );
-    await host.handlers.get("session_shutdown")({ type: "session_shutdown", reason: "reload" }, host.ctx);
-    assert.equal(host.ctx.model.id, "return");
-    assert.equal(host.ctx.thinkingLevel, "medium");
-
-    freeflowExtension(host.pi);
-    await host.handlers.get("session_start")({ type: "session_start", reason: "reload" }, host.ctx);
-    await host.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, host.ctx);
-    assert.equal(host.ctx.model.id, "standard");
-    assert.equal(host.ctx.thinkingLevel, "high");
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});
-
-test("normal Pi preserves Cognitive Routing skill and runtime surface without Conversation routing", async () => {
-  const cwd = await mkdtemp(join(tmpdir(), "freeflow-pi-normal-surface-"));
-  const host = createNormalPiHost();
-  host.ctx.cwd = cwd;
-  try {
-    await configure(cwd);
-    const before = await start(host);
-    assert.match(before.systemPrompt, /## Cognitive Routing Cue/);
-    assert.doesNotMatch(before.systemPrompt, /Conversation(?: Route| profile| selects)/);
-    const resources = await host.handlers.get("resources_discover")({}, host.ctx);
-    const routingSkillPath = resources.skillPaths.find((path) => path.endsWith("cognitive-routing/SKILL.md"));
-    assert.ok(routingSkillPath);
-    const state = await host.handlers.get("context")({ messages: [] }, host.ctx);
-    assert.match(state.messages.at(-1).content, /Control: `automatic`/);
-    assert.match(state.messages.at(-1).content, /Profile: `reasoning`/);
-    assert.doesNotMatch(state.messages.at(-1).content, /Conversation:/);
-  } finally {
-    await rm(cwd, { recursive: true, force: true });
-  }
-});

package/pi-extension/tests/cognitive-routing/pi-session-control.test.js

@@ -1,174 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import {
-  createPiSessionModelStateControl,
-  PI_SESSION_MODEL_STATE_ENTRY,
-} from "../../dist/cognitive-routing/pi-session-control.js";
-
-const fromPair = {
-  provider: "faux",
-  modelId: "standard",
-  thinkingLevel: "medium",
-};
-const targetPair = {
-  provider: "faux",
-  modelId: "reasoning",
-  thinkingLevel: "high",
-};
-
-function createHost({ failTargetThinking = false, failRollbackModel = false, failCommitPersistence = false } = {}) {
-  let currentModel = { provider: fromPair.provider, id: fromPair.modelId };
-  let currentThinkingLevel = fromPair.thinkingLevel;
-  const entries = [];
-  const calls = [];
-  const models = new Map([
-    ["faux/standard", currentModel],
-    ["faux/reasoning", { provider: targetPair.provider, id: targetPair.modelId }],
-  ]);
-
-  const pi = {
-    async setModel(model) {
-      calls.push(["setModel", model.provider, model.id]);
-      if (failRollbackModel && model.id === fromPair.modelId) return false;
-      currentModel = model;
-      return true;
-    },
-    setThinkingLevel(level) {
-      calls.push(["setThinkingLevel", level]);
-      currentThinkingLevel = level;
-      if (failTargetThinking && level === targetPair.thinkingLevel) {
-        throw new Error("simulated target thinking failure");
-      }
-    },
-    appendEntry(customType, data) {
-      calls.push(["appendEntry", customType, data]);
-      if (failCommitPersistence && data?.phase === "committed") {
-        throw new Error("simulated commit persistence failure");
-      }
-      entries.push({ type: "custom", customType, data });
-    },
-  };
-  const ctx = {
-    get model() {
-      return currentModel;
-    },
-    get thinkingLevel() {
-      return currentThinkingLevel;
-    },
-    modelRegistry: {
-      find(provider, modelId) {
-        return models.get(`${provider}/${modelId}`);
-      },
-    },
-  };
-
-  return { pi, ctx, entries, calls };
-}
-
-test("applies and commits a complete Pi session model-state transition", async () => {
-  const host = createHost();
-  const control = createPiSessionModelStateControl(host);
-  const acquisition = await control.acquireModelStateControl({ label: "Cognitive Routing" });
-
-  assert.equal(acquisition.status, "acquired");
-  const result = await acquisition.lease.setState({ ...targetPair, correlationId: "correlation-1" });
-
-  assert.deepEqual(result, { status: "applied" });
-  assert.deepEqual(
-    host.calls.map(([name]) => name),
-    ["appendEntry", "setModel", "setThinkingLevel", "appendEntry"],
-  );
-  assert.deepEqual(host.entries, [
-    {
-      type: "custom",
-      customType: PI_SESSION_MODEL_STATE_ENTRY,
-      data: {
-        version: 1,
-        phase: "prepared",
-        status: "prepared",
-        correlationId: "correlation-1",
-        fromPair,
-        target: targetPair,
-        origin: { source: "pi", operation: "session-model-state-control" },
-      },
-    },
-    {
-      type: "custom",
-      customType: PI_SESSION_MODEL_STATE_ENTRY,
-      data: {
-        version: 1,
-        phase: "committed",
-        status: "applied",
-        correlationId: "correlation-1",
-        fromPair,
-        target: targetPair,
-        origin: { source: "pi", operation: "session-model-state-control" },
-      },
-    },
-  ]);
-  assert.deepEqual(
-    { provider: host.ctx.model.provider, modelId: host.ctx.model.id, thinkingLevel: host.ctx.thinkingLevel },
-    targetPair,
-  );
-
-  await acquisition.lease.release();
-});
-
-test("rolls back a partially applied target and records an aborted transition", async () => {
-  const host = createHost({ failTargetThinking: true });
-  const control = createPiSessionModelStateControl(host);
-  const acquisition = await control.acquireModelStateControl({ label: "Cognitive Routing" });
-
-  assert.equal(acquisition.status, "acquired");
-  const result = await acquisition.lease.setState({ ...targetPair, correlationId: "correlation-rollback" });
-
-  assert.deepEqual(result, { status: "rejected" });
-  assert.deepEqual(
-    host.calls.map(([name]) => name),
-    ["appendEntry", "setModel", "setThinkingLevel", "setModel", "setThinkingLevel", "appendEntry"],
-  );
-  assert.deepEqual(
-    { provider: host.ctx.model.provider, modelId: host.ctx.model.id, thinkingLevel: host.ctx.thinkingLevel },
-    fromPair,
-  );
-  assert.equal(host.entries.at(-1).data.failure, "thinking-level-change-failed");
-
-  await acquisition.lease.release();
-});
-
-test("fails closed when rollback cannot restore the captured pair", async () => {
-  const host = createHost({ failTargetThinking: true, failRollbackModel: true });
-  const control = createPiSessionModelStateControl(host);
-  const acquisition = await control.acquireModelStateControl({ label: "Cognitive Routing" });
-
-  assert.equal(acquisition.status, "acquired");
-  const result = await acquisition.lease.setState({ ...targetPair, correlationId: "correlation-rollback-failed" });
-
-  assert.deepEqual(result, { status: "rejected" });
-  assert.deepEqual(
-    { provider: host.ctx.model.provider, modelId: host.ctx.model.id, thinkingLevel: host.ctx.thinkingLevel },
-    targetPair,
-  );
-  assert.equal(host.entries.at(-1).data.status, "rollback-failed");
-  assert.equal(host.entries.at(-1).data.failure, "rollback-failed");
-
-  await acquisition.lease.release();
-});
-
-test("restores the baseline when committed-marker persistence fails", async () => {
-  const host = createHost({ failCommitPersistence: true });
-  const control = createPiSessionModelStateControl(host);
-  const acquisition = await control.acquireModelStateControl({ label: "Cognitive Routing" });
-
-  assert.equal(acquisition.status, "acquired");
-  const result = await acquisition.lease.setState({ ...targetPair, correlationId: "correlation-commit-failed" });
-
-  assert.deepEqual(result, { status: "rejected" });
-  assert.deepEqual(
-    { provider: host.ctx.model.provider, modelId: host.ctx.model.id, thinkingLevel: host.ctx.thinkingLevel },
-    fromPair,
-  );
-  assert.equal(host.entries.at(-1).data.failure, "commit-persistence-failed");
-
-  await acquisition.lease.release();
-});

package/pi-extension/tests/cognitive-routing/pi-session-history.test.js

@@ -1,91 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { projectCognitiveRoutingHistory } from "../../dist/cognitive-routing/history.js";
-import { PI_SESSION_MODEL_STATE_ENTRY } from "../../dist/cognitive-routing/pi-session-control.js";
-
-const standard = { provider: "faux", modelId: "standard", thinkingLevel: "high" };
-const reasoning = { provider: "faux", modelId: "reasoning", thinkingLevel: "max" };
-
-const intent = {
-  version: 2,
-  phase: "prepared",
-  kind: "profile",
-  control: "automatic",
-  source: "agent",
-  mechanism: "agent-tool",
-  decisionCorrelationId: "correlation-1",
-  fromPair: standard,
-  fromProfile: "standard",
-  epoch: "epoch-1",
-  correlationId: "correlation-1",
-  profile: "reasoning",
-  target: reasoning,
-  returnTarget: { provider: "faux", modelId: "return", thinkingLevel: "medium" },
-  reason: "Need deeper analysis.",
-};
-
-test("projects a committed Pi session marker as the completed transition", () => {
-  const entries = [
-    { id: "root", type: "message", parentId: null, timestamp: "2026-08-25T12:00:00.000Z" },
-    {
-      id: "intent-1",
-      type: "custom",
-      parentId: "root",
-      timestamp: "2026-08-25T12:00:01.000Z",
-      customType: "freeflow-cognitive-routing-intent",
-      data: intent,
-    },
-    {
-      id: "commit-1",
-      type: "custom",
-      parentId: "intent-1",
-      timestamp: "2026-08-25T12:00:02.000Z",
-      customType: PI_SESSION_MODEL_STATE_ENTRY,
-      data: {
-        version: 1,
-        phase: "committed",
-        status: "applied",
-        correlationId: "correlation-1",
-        fromPair: standard,
-        target: reasoning,
-        origin: { source: "pi", operation: "session-model-state-control" },
-      },
-    },
-  ];
-
-  const result = projectCognitiveRoutingHistory(entries, {
-    branchEntries: entries,
-    current: { control: "automatic", profile: "reasoning" },
-  });
-
-  assert.deepEqual(result.events, [
-    {
-      id: "intent:intent-1",
-      timestamp: "2026-08-25T12:00:02.000Z",
-      jsonlPosition: 2,
-      entryId: "commit-1",
-      parentId: "intent-1",
-      branchAnchor: "commit-1",
-      classification: "semantic-switch",
-      decisionSource: "agent",
-      mechanism: "agent-tool",
-      outcome: "completed",
-      changed: true,
-      integrity: "valid",
-      from: "standard",
-      to: "reasoning",
-      control: "automatic",
-      reason: "Need deeper analysis.",
-      epoch: "epoch-1",
-      correlationId: "correlation-1",
-      decisionCorrelationId: "correlation-1",
-      hostOrigin: { source: "pi", operation: "session-model-state-control" },
-    },
-  ]);
-  assert.deepEqual(result.summary, {
-    latestSemanticEventId: "intent:intent-1",
-    latestCompletedEventId: "intent:intent-1",
-    unresolvedCount: 0,
-    anomalyCount: 0,
-  });
-});