@hassangameryt/freeflow 0.7.1 → 0.7.3

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

@@ -5,8 +5,10 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import { promisify } from "node:util";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
 
 import freeflowExtension from "../../dist/index.js";
+import { handleFreeflowCommand } from "../../dist/settings/settings-ui.js";
 import {
   readCapabilityState,
   readFreeflowConfigLayers,
@@ -15,7 +17,8 @@ import {
   setFreeflowStatus,
   setSessionCoreOverride,
 } from "../../dist/runtime/runtime-context.js";
-import { PIFLOW_HOST } from "../cognitive-routing/host-fixture.js";
+import { PIFLOW_HOST } from "../fixtures/pi-host.js";
+import { matches } from "../../dist/cognitive-routing-v2/schemas.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -153,7 +156,7 @@ test("keeps Runtime State before the latest user message during context refreshe
     const conversation = [
       { role: "user", content: "release 0.6.1" },
       { role: "assistant", content: "delegating" },
-      { role: "toolResult", toolName: "freeflow_switch_profile", content: [] },
+      { role: "toolResult", toolName: "freeflow_delegate", content: [] },
     ];
     const first = await handlers.get("context")({ messages: conversation }, ctx);
     const firstUserIndex = first.messages.findIndex((message) => message.role === "user");
@@ -187,6 +190,136 @@ test("keeps Runtime State before the latest user message during context refreshe
   }
 });
 
+test("new routing tools and projection state follow the configured contract", async () => {
+  const cases = [
+    { projection: false, expectedMode: "disabled", exposesProjection: false },
+    // Projection can be effective while the Coordinator correctly lacks Executor-only tools.
+    { projection: true, expectedMode: "enabled", exposesProjection: false },
+  ];
+
+  for (const scenario of cases) {
+    const cwd = await configuredRepo({
+      cognitiveRouting: {
+        enabled: true,
+        projection: scenario.projection,
+        profiles: {
+          coordinator: { provider: "test", model: "model-a", thinking: "low" },
+          executor: { provider: "test", model: "model-b", thinking: "high" },
+        },
+      },
+    });
+    try {
+      let liveContext;
+      const loaded = loadExtension(freeflowExtension, null, {
+        appendEntry(customType, data) {
+          liveContext.sessionManager.appendCustomEntry(customType, data);
+        },
+        async setModel(model) {
+          liveContext.model = model;
+          return true;
+        },
+        setThinkingLevel(level) {
+          liveContext.thinkingLevel = level;
+        },
+      });
+      const ctx = context(cwd);
+      liveContext = ctx;
+      ctx.model = { provider: "test", id: "return" };
+      ctx.thinkingLevel = "medium";
+      ctx.modelRegistry = cognitiveRoutingModelRegistry();
+      ctx.isIdle = () => true;
+      ctx.sessionManager = SessionManager.create(cwd, join(cwd, "sessions"));
+      // Reconciliation needs genuine persisted ancestry, not a fake mutable branch array.
+      ctx.sessionManager.appendMessage({
+        role: "assistant",
+        content: [{ type: "text", text: "fixture seed" }],
+        timestamp: 1,
+        stopReason: "stop",
+      });
+      await loaded.handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
+      await loaded.handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
+
+      const toolNames = loaded.tools.map((tool) => tool.name);
+      assert.deepEqual(
+        toolNames.filter((name) =>
+          ["freeflow_delegate", "freeflow_return", "freeflow_unit", "freeflow_project"].includes(name),
+        ),
+        ["freeflow_delegate", "freeflow_return", "freeflow_unit", "freeflow_project"],
+      );
+      const delegate = loaded.tools.find((tool) => tool.name === "freeflow_delegate");
+      const returning = loaded.tools.find((tool) => tool.name === "freeflow_return");
+      assert.deepEqual(
+        delegate.parameters.oneOf.map((branch) => branch.properties.operation.enum[0]),
+        ["assign", "replace"],
+      );
+      assert.deepEqual(delegate.parameters.properties.worker.enum, ["helper", "executor"]);
+      assert.equal(
+        delegate.parameters.oneOf.every((branch) => !branch.required.includes("worker")),
+        true,
+      );
+      assert.deepEqual(
+        returning.parameters.oneOf.map((branch) => branch.properties.operation.enum[0]),
+        ["submit", "supplement", "retry"],
+      );
+      assert.equal(loaded.activeToolNames().includes("freeflow_project"), true);
+
+      const providerContext = await loaded.handlers.get("context")({ messages: [] }, ctx);
+      assert.match(providerContext.messages[0].content, /Delegation: `executor`/);
+      assert.match(providerContext.messages[0].content, new RegExp("Projection: `" + scenario.expectedMode + "`"));
+
+      await loaded.commands.find((command) => command.name === "freeflow").definition.handler("profile executor", ctx);
+      const manualContext = await loaded.handlers.get("context")({ messages: [] }, ctx);
+      assert.match(
+        manualContext.messages.findLast((message) => message.customType === "freeflow-runtime-state").content,
+        new RegExp("Projection: `" + (scenario.projection ? "manual-bypass" : "disabled") + "`"),
+      );
+      assert.equal(loaded.activeToolNames().includes("freeflow_project"), true);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  }
+});
+
+test("Pi describes strict evidence-selection operation shapes", () => {
+  const { tools } = loadExtension();
+  const project = tools.find((tool) => tool.name === "freeflow_project");
+  assert.ok(project);
+  assert.deepEqual(
+    project.parameters.oneOf.map((branch) => branch.properties.operation.enum[0]),
+    ["inspect", "add", "remove"],
+  );
+  assert.deepEqual(Object.keys(project.parameters.oneOf[1].properties), ["operation", "refs"]);
+  assert.deepEqual(Object.keys(project.parameters.oneOf[2].properties), ["operation", "refs", "reason"]);
+  assert.match(project.description, /reason is remove-only/i);
+  assert.match(project.promptGuidelines.join(" "), /reason is required only for remove and invalid for add\/inspect/i);
+  assert.match(
+    project.promptGuidelines.join(" "),
+    /for add.*never add refs marked not offered.*for remove.*currently selected or unresolved/i,
+  );
+  assert.match(project.promptGuidelines.join(" "), /add exact eligible visible refs directly/i);
+  assert.doesNotMatch(project.promptGuidelines.join(" "), /inspect first/i);
+  assert.match(project.parameters.properties.reason.description, /only for remove/i);
+  assert.match(project.parameters.oneOf[1].properties.refs.description, /never add a ref marked not offered/i);
+  assert.match(
+    project.parameters.oneOf[2].properties.refs.description,
+    /currently selected or unresolved.*non-selectable ref may be removed/i,
+  );
+  assert.match(
+    project.parameters.properties.refs.description,
+    /For add.*eligible.*For remove.*currently selected or unresolved/i,
+  );
+
+  assert.equal(
+    matches({ operation: "add", refs: ["ctx:example"], reason: "selection explanation" }, project.parameters),
+    false,
+  );
+  assert.equal(matches({ operation: "add", refs: ["ctx:example"] }, project.parameters), true);
+  assert.equal(
+    matches({ operation: "remove", refs: ["ctx:example"], reason: "selection explanation" }, project.parameters),
+    true,
+  );
+});
+
 test("Pi registers the remaining Freeflow commands without mode controls or retired router tools", () => {
   const { commands, shortcuts, tools } = loadExtension();
   const commandNames = commands.map((command) => command.name);
@@ -199,12 +332,14 @@ test("Pi registers the remaining Freeflow commands without mode controls or reti
   assert.ok(!commandNames.includes("discover"));
   assert.ok(!commandNames.includes("execute-plan"));
   assert.ok(!commandNames.includes("workflow"));
+  assert.deepEqual(shortcuts, []);
+  assert.ok(tools.some((tool) => tool.name === "freeflow_context"));
   assert.deepEqual(
-    shortcuts.map(({ shortcut }) => shortcut),
-    ["ctrl+shift+r", "ctrl+shift+a"],
+    toolNames.filter((name) => name.startsWith("freeflow_")),
+    ["freeflow_delegate", "freeflow_return", "freeflow_unit", "freeflow_project", "freeflow_context"],
   );
-  assert.ok(tools.some((tool) => tool.name === "freeflow_context"));
-  assert.ok(tools.some((tool) => tool.name === "freeflow_switch_profile"));
+  assert.ok(!toolNames.includes("freeflow_switch_profile"));
+  assert.ok(!toolNames.includes("freeflow_cognitive_routing_history"));
   assert.ok(freeflowCommand);
   assert.ok(!freeflowCommand.definition.getArgumentCompletions("").some((item) => item.value === "mode"));
   assert.deepEqual(freeflowCommand.definition.getArgumentCompletions("mode "), []);
@@ -213,22 +348,27 @@ test("Pi registers the remaining Freeflow commands without mode controls or reti
   );
 });
 
-test("unsupported Pi hosts keep Cognitive Routing unavailable while exposing its configuration", async () => {
+test("PiFlow keeps Cognitive Routing unavailable while exposing its configuration", async () => {
   const cwd = await configuredRepo({
     cognitiveRouting: {
       enabled: true,
       profiles: {
-        standard: { provider: "test", model: "standard", thinkingLevel: "high" },
-        reasoning: { provider: "test", model: "reasoning", thinkingLevel: "max" },
+        coordinator: { provider: "test", model: "coordinator", thinking: "high" },
+        executor: { provider: "test", model: "executor", thinking: "max" },
       },
     },
   });
   try {
-    const { commands, handlers, shortcuts, tools } = loadExtension(freeflowExtension, null);
+    const { commands, handlers, shortcuts, tools, activeToolNames } = loadExtension(freeflowExtension, PIFLOW_HOST);
     const freeflowCommand = commands.find((command) => command.name === "freeflow");
     assert.ok(freeflowCommand);
     assert.deepEqual(shortcuts, []);
+    assert.deepEqual(
+      tools.filter((tool) => tool.name.startsWith("freeflow_")).map((tool) => tool.name),
+      ["freeflow_delegate", "freeflow_return", "freeflow_unit", "freeflow_project", "freeflow_context"],
+    );
     assert.ok(!tools.some((tool) => tool.name === "freeflow_switch_profile"));
+    assert.ok(!tools.some((tool) => tool.name === "freeflow_cognitive_routing_history"));
     assert.ok(!freeflowCommand.definition.getArgumentCompletions("").some((item) => item.value === "profile"));
     const capabilityState = await readCapabilityState(cwd, undefined, undefined);
     assert.equal(capabilityState.cognitiveRouting.enabled, true);
@@ -237,9 +377,10 @@ test("unsupported Pi hosts keep Cognitive Routing unavailable while exposing its
 
     const ctx = context(cwd);
     await handlers.get("session_start")({ type: "session_start" }, ctx);
-    assert.match(ctx.statuses.at(-1).value, /cognitive blocked · host_unsupported/);
+    assert.match(ctx.statuses.at(-1).value, /cognitive blocked ·/);
+    assert.ok(activeToolNames().includes("freeflow_delegate"));
     const before = await handlers.get("before_agent_start")({ systemPrompt: "base" }, ctx);
-    assert.doesNotMatch(before.systemPrompt, /Cognitive Routing/);
+    assert.match(before.systemPrompt, /guidance is dormant/);
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -250,8 +391,8 @@ test("normal Pi settings expose active Cognitive Routing configuration", async (
     cognitiveRouting: {
       enabled: true,
       profiles: {
-        standard: { provider: "test", model: "model-a", thinkingLevel: "low" },
-        reasoning: { provider: "test", model: "model-b", thinkingLevel: "high" },
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
       },
     },
   });
@@ -273,7 +414,7 @@ test("normal Pi settings expose active Cognitive Routing configuration", async (
     settingsCtx.ui.custom = async (factory) => {
       const component = factory({ requestRender() {} }, testTheme, {}, () => {});
       const rootText = renderText(component);
-      assert.match(rootText, /Cognitive Routing\s+enabled \(5\) active/);
+      assert.match(rootText, /Cognitive Routing\s+enabled \(6\) active/);
       assert.doesNotMatch(rootText, /PiFlow only/);
       return undefined;
     };
@@ -284,6 +425,180 @@ test("normal Pi settings expose active Cognitive Routing configuration", async (
   }
 });
 
+test("Pi settings persist delegation mode without rewriting complete presets", async () => {
+  const initial = {
+    cognitiveRouting: {
+      enabled: true,
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        helper: { provider: "test", model: "model-b", thinking: "high" },
+        executor: { provider: "test", model: "model-b", thinking: "max" },
+      },
+    },
+  };
+  const cwd = await configuredRepo(initial);
+  try {
+    const { commands } = loadExtension(freeflowExtension, null, {
+      appendEntry() {},
+      async setModel() {
+        return true;
+      },
+      setThinkingLevel() {},
+    });
+    const command = commands.find((candidate) => candidate.name === "freeflow");
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+    settingsCtx.ui.custom = async (factory) => {
+      let result;
+      const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+        result = value;
+      });
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      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;
+    };
+    await command.definition.handler("settings repo", settingsCtx);
+    const saved = JSON.parse(await readFile(join(cwd, ".freeflow/config.json"), "utf8"));
+    assert.equal(saved.cognitiveRouting.delegation, "both");
+    assert.deepEqual(saved.cognitiveRouting.profiles, initial.cognitiveRouting.profiles);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("personal delegation override and inherit preserve repository mode and other local presets", async () => {
+  const repository = {
+    cognitiveRouting: {
+      enabled: true,
+      delegation: "helper",
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        helper: { provider: "test", model: "model-b", thinking: "high" },
+        executor: { provider: "test", model: "model-b", thinking: "max" },
+      },
+    },
+  };
+  const local = {
+    contextVirtualization: true,
+    cognitiveRouting: {
+      profiles: {
+        helper: { provider: "test", model: "model-b", thinking: "medium" },
+      },
+    },
+  };
+  const cwd = await configuredRepo(repository);
+  const repositoryPath = join(cwd, ".freeflow/config.json");
+  const localPath = join(cwd, ".freeflow/local.json");
+  await writeFile(localPath, JSON.stringify(local, null, 2), "utf8");
+  try {
+    const { commands, pi } = loadExtension(freeflowExtension, null, {
+      appendEntry() {},
+      async setModel() {
+        return true;
+      },
+      setThinkingLevel() {},
+    });
+    const command = commands.find((candidate) => candidate.name === "freeflow");
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+
+    const chooseDelegation = async (direction, commit = true) => {
+      settingsCtx.ui.custom = async (factory) => {
+        let result;
+        const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+          result = value;
+        });
+        component.handleInput("\u001b[B");
+        component.handleInput("\r");
+        component.handleInput("\u001b[B");
+        component.handleInput("\r");
+        component.handleInput(direction);
+        component.handleInput(commit ? "\r" : "\u001b");
+        if (commit) await component.waitForWrites();
+        component.handleInput("\u001b");
+        component.handleInput("\u001b");
+        return result;
+      };
+      await command.definition.handler("settings", settingsCtx);
+    };
+
+    await chooseDelegation("\u001b[B");
+    let saved = JSON.parse(await readFile(localPath, "utf8"));
+    assert.equal(saved.cognitiveRouting.delegation, "executor");
+    assert.deepEqual(saved.cognitiveRouting.profiles, local.cognitiveRouting.profiles);
+    assert.deepEqual(JSON.parse(await readFile(repositoryPath, "utf8")), repository);
+    assert.equal((await readCapabilityState(cwd, settingsCtx, pi.host)).cognitiveRouting.delegation, "executor");
+
+    await chooseDelegation("\u001b[A");
+    saved = JSON.parse(await readFile(localPath, "utf8"));
+    assert.equal(saved.cognitiveRouting.delegation, undefined);
+    assert.deepEqual(saved.cognitiveRouting.profiles, local.cognitiveRouting.profiles);
+    assert.equal((await readCapabilityState(cwd, settingsCtx, pi.host)).cognitiveRouting.delegation, "helper");
+
+    const beforeCancel = await readFile(localPath, "utf8");
+    await chooseDelegation("\u001b[B", false);
+    assert.equal(await readFile(localPath, "utf8"), beforeCancel);
+    assert.deepEqual(JSON.parse(await readFile(repositoryPath, "utf8")), repository);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("both mode session settings expose Helper and both existing profile presets", async () => {
+  const cwd = await configuredRepo({
+    cognitiveRouting: {
+      enabled: true,
+      delegation: "both",
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        helper: { provider: "test", model: "model-b", thinking: "high" },
+        executor: { provider: "test", model: "model-b", thinking: "max" },
+      },
+    },
+  });
+  try {
+    const { commands } = loadExtension(freeflowExtension, null, {
+      appendEntry() {},
+      async setModel() {
+        return true;
+      },
+      setThinkingLevel() {},
+    });
+    const command = commands.find((candidate) => candidate.name === "freeflow");
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+    settingsCtx.ui.custom = async (factory) => {
+      let result;
+      const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+        result = value;
+      });
+      component.handleInput("\u001b[B");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      const presets = component.render(180).join("\n");
+      assert.match(presets, /Coordinator preset/);
+      assert.match(presets, /Helper preset/);
+      assert.match(presets, /Executor preset/);
+      result = { changed: false };
+      return result;
+    };
+    await command.definition.handler("settings session", settingsCtx);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
 test("Pi statusline reports only dynamic Cognitive Routing and context state", () => {
   const ctx = context();
   setFreeflowStatus(
@@ -296,14 +611,14 @@ test("Pi statusline reports only dynamic Cognitive Routing and context state", (
       conversationHistory: { effective: false },
       cognitiveRouting: { enabled: true, effective: true, blockingReason: null },
     },
-    { effective: true, activeProfile: "reasoning", controlMode: "automatic" },
+    { effective: true, activeProfile: "executor", controlMode: "automatic" },
     readyFreeflowContext,
   );
-  assert.equal(ctx.statuses.at(-1).value, "freeflow: reasoning · automatic · context");
+  assert.equal(ctx.statuses.at(-1).value, "freeflow: executor · automatic · context");
   assert.doesNotMatch(ctx.statuses.at(-1).value, /interaction|workflow|mode|skills/i);
 });
 
-test("Pi statusline shows the configured Cognitive Routing profile while activation is pending", () => {
+test("Pi statusline defaults pending activation to the Coordinator profile", () => {
   const ctx = context();
   setFreeflowStatus(
     ctx,
@@ -316,7 +631,6 @@ test("Pi statusline shows the configured Cognitive Routing profile while activat
       cognitiveRouting: {
         enabled: true,
         effective: true,
-        sessionStart: { profile: "reasoning" },
         blockingReason: null,
       },
     },
@@ -324,7 +638,7 @@ test("Pi statusline shows the configured Cognitive Routing profile while activat
     readyFreeflowContext,
     { cognitiveRoutingStartupPending: true },
   );
-  assert.equal(ctx.statuses.at(-1).value, "freeflow: reasoning · pending");
+  assert.equal(ctx.statuses.at(-1).value, "freeflow: coordinator · pending");
 });
 
 test("Pi statusline keeps an inactive Cognitive Routing runtime blocked", () => {
@@ -339,20 +653,20 @@ test("Pi statusline keeps an inactive Cognitive Routing runtime blocked", () =>
       conversationHistory: { effective: false },
       cognitiveRouting: { enabled: true, effective: true, blockingReason: null },
     },
-    { effective: false, activeProfile: "standard", controlMode: "automatic" },
+    { effective: false, activeProfile: "coordinator", controlMode: "automatic" },
     readyFreeflowContext,
     { cognitiveRoutingStartupPending: true },
   );
   assert.equal(ctx.statuses.at(-1).value, "freeflow: cognitive blocked · runtime_inactive");
 });
 
-test("PiFlow empty configured sessions show a pending profile before first prompt", async () => {
+test("PiFlow keeps configured routing unavailable before the first prompt", async () => {
   const cwd = await configuredRepo({
     cognitiveRouting: {
       enabled: true,
       profiles: {
-        standard: { provider: "test", model: "model-a", thinkingLevel: "low" },
-        reasoning: { provider: "test", model: "model-b", thinkingLevel: "high" },
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
       },
     },
   });
@@ -361,7 +675,7 @@ test("PiFlow empty configured sessions show a pending profile before first promp
     const ctx = context(cwd);
     ctx.modelRegistry = cognitiveRoutingModelRegistry();
     await handlers.get("session_start")({ type: "session_start", reason: "startup" }, ctx);
-    assert.equal(ctx.statuses.at(-1).value, "freeflow: reasoning · automatic");
+    assert.match(ctx.statuses.at(-1).value, /cognitive blocked ·/);
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -377,8 +691,16 @@ test("Pi exposes bypass scope argument completions", () => {
   ]);
 });
 
-test("Pi describes the mode-free Freeflow argument surface", () => {
-  const { commands } = loadExtension();
+test("Pi describes the mode-free Freeflow argument surface and manual profile controls", () => {
+  const { commands } = loadExtension(
+    freeflowExtension,
+    {},
+    {
+      appendEntry() {},
+      setModel() {},
+      setThinkingLevel() {},
+    },
+  );
   const freeflowCommand = commands.find((command) => command.name === "freeflow");
   assert.ok(freeflowCommand);
   assert.deepEqual(freeflowCommand.definition.getArgumentCompletions(""), [
@@ -386,9 +708,17 @@ test("Pi describes the mode-free Freeflow argument surface", () => {
     { value: "status", label: "status", description: "Show effective Freeflow state" },
     { value: "context", label: "context", description: "Inspect Freeflow Context" },
     { value: "profile", label: "profile", description: "Hold or release Cognitive Routing profile control" },
+    { value: "resume", label: "resume", description: "Resume the current saved routing responsibility" },
     { value: "enable", label: "enable", description: "Enable Freeflow for this repository" },
     { value: "disable", label: "disable", description: "Disable Freeflow for this repository" },
   ]);
+  assert.deepEqual(freeflowCommand.definition.getArgumentCompletions("profile "), [
+    { value: "profile coordinator", label: "coordinator", description: "Hold Coordinator manually" },
+    { value: "profile helper", label: "helper", description: "Hold Helper manually when enabled" },
+    { value: "profile executor", label: "executor", description: "Hold Executor manually when enabled" },
+    { value: "profile auto", label: "auto", description: "Return to automatic Coordinator reconciliation" },
+    { value: "profile history", label: "history", description: "Read routing observations" },
+  ]);
   assert.deepEqual(freeflowCommand.definition.getArgumentCompletions("mode "), []);
   assert.deepEqual(freeflowCommand.definition.getArgumentCompletions("context "), [
     { value: "context status", label: "status", description: "Show Freeflow Context state" },
@@ -398,18 +728,21 @@ test("Pi describes the mode-free Freeflow argument surface", () => {
   ]);
 });
 
-test("Pi exposes 25 base skills without a mode skill or compatibility aliases", async () => {
+test("Pi exposes 24 base skills without TDD, a mode skill, or compatibility aliases", async () => {
   const cwd = await configuredRepo();
   try {
     const { handlers, commands, sentMessages, sentMessageOptions } = loadExtension();
     const resources = await handlers.get("resources_discover")({ cwd }, context(cwd));
-    const skillNames = resources.skillPaths.map((path) => {
-      const match = path.match(/[\\/]skills[\\/]([^\\/]+)\/SKILL\.md$/);
-      assert.ok(match, `unexpected skill path: ${path}`);
-      return match[1];
-    });
-    assert.equal(skillNames.length, 25);
+    const skillNames = resources.skillPaths
+      .filter((path) => path.includes("/skills/"))
+      .map((path) => {
+        const match = path.match(/[\\/]skills[\\/]([^\\/]+)\/SKILL\.md$/);
+        assert.ok(match, `unexpected skill path: ${path}`);
+        return match[1];
+      });
+    assert.equal(skillNames.length, 24);
     assert.ok(skillNames.includes("workflow"));
+    assert.ok(!skillNames.includes("tdd"));
     assert.ok(!skillNames.includes("mode-contract"));
     assert.ok(!skillNames.includes("discover"));
     assert.ok(!skillNames.includes("execute-plan"));
@@ -452,10 +785,11 @@ test("Pi keeps Freeflow inactive until repository activation exists", async () =
   try {
     const { handlers } = loadExtension();
     const resources = await handlers.get("resources_discover")({ cwd }, context(cwd));
-    assert.equal(resources.skillPaths.length, 1);
-    assert.match(resources.skillPaths[0], /setup-freeflow\/SKILL\.md$/);
+    assert.equal(resources.skillPaths.length, 27);
+    assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/setup-freeflow/SKILL.md")));
     const result = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, context(cwd));
-    assert.equal(result.systemPrompt, "base prompt");
+    assert.ok(result.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(result.systemPrompt, /guidance is dormant/);
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -480,10 +814,11 @@ test("Pi treats invalid configuration as inactive", async () => {
   try {
     const { handlers, commands } = loadExtension();
     const resources = await handlers.get("resources_discover")({ cwd }, context(cwd));
-    assert.equal(resources.skillPaths.length, 1);
-    assert.match(resources.skillPaths[0], /setup-freeflow\/SKILL\.md$/);
+    assert.equal(resources.skillPaths.length, 27);
+    assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/setup-freeflow/SKILL.md")));
     const result = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, context(cwd));
-    assert.equal(result.systemPrompt, "base prompt");
+    assert.ok(result.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(result.systemPrompt, /guidance is dormant/);
     const freeflowCommand = commands.find((command) => command.name === "freeflow");
     const statusCtx = context(cwd);
     await freeflowCommand.definition.handler("status", statusCtx);
@@ -578,8 +913,8 @@ test("Pi fails closed when an existing local override is invalid", async () => {
     assert.equal(state.enabled, false);
     const { handlers } = loadExtension();
     const resources = await handlers.get("resources_discover")({ cwd }, context(cwd));
-    assert.equal(resources.skillPaths.length, 1);
-    assert.match(resources.skillPaths[0], /setup-freeflow\/SKILL\.md$/);
+    assert.equal(resources.skillPaths.length, 27);
+    assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/setup-freeflow/SKILL.md")));
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -598,22 +933,23 @@ test("Pi local enablement overrides the repository master switch", async () => {
   }
 });
 
-test("Pi master Freeflow toggle suppresses core prompts, skills, and capabilities", async () => {
+test("Pi master Freeflow toggle makes features inactive while preserving their reference surface", async () => {
   const cwd = await configuredRepo({ enabled: false });
   try {
     const { handlers, activeToolNames } = loadExtension();
     const ctx = context(cwd);
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
-    assert.deepEqual(resources.skillPaths, []);
+    assert.equal(resources.skillPaths.length, 27);
     const result = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
-    assert.equal(result.systemPrompt, "base prompt");
+    assert.ok(result.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(result.systemPrompt, /guidance is dormant/);
     const providerContext = await handlers.get("context")({ messages: [] }, ctx);
     assert.match(lastRuntimeState(providerContext.messages).content, /Freeflow: inactive/);
     assert.doesNotMatch(
       lastRuntimeState(providerContext.messages).content,
       /Default mode|Active mode|Interaction Contract|Skills/,
     );
-    assert.ok(!activeToolNames().includes("freeflow_context"));
+    assert.ok(activeToolNames().includes("freeflow_context"));
   } finally {
     await rm(cwd, { recursive: true, force: true });
   }
@@ -738,13 +1074,23 @@ test("Pi Cognitive Routing settings preserve complete presets", async () => {
     cognitiveRouting: {
       enabled: true,
       profiles: {
-        standard: { provider: "test", model: "model-a", thinkingLevel: "low" },
-        reasoning: { provider: "test", model: "model-b", thinkingLevel: "high" },
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
       },
     },
   });
   try {
-    const { commands } = loadExtension();
+    const { commands } = loadExtension(
+      freeflowExtension,
+      {},
+      {
+        appendEntry() {},
+        async setModel() {
+          return true;
+        },
+        setThinkingLevel() {},
+      },
+    );
     const freeflowCommand = commands.find((command) => command.name === "freeflow");
     assert.ok(freeflowCommand);
     const settingsCtx = context(cwd);
@@ -757,11 +1103,10 @@ test("Pi Cognitive Routing settings preserve complete presets", async () => {
       });
       component.handleInput("\u001b[B");
       component.handleInput("\r");
-      component.handleInput("\u001b[B");
+      for (let index = 0; index < 4; index++) component.handleInput("\u001b[B");
       component.handleInput("\r");
-      component.handleInput("\u001b[B");
       component.handleInput("\r");
-      for (let index = 0; index < 4; index++) component.handleInput("\u001b[B");
+      for (let index = 0; index < 1; index++) component.handleInput("\u001b[B");
       component.handleInput("\r");
       component.handleInput("\r");
       await component.waitForWrites();
@@ -769,10 +1114,10 @@ test("Pi Cognitive Routing settings preserve complete presets", async () => {
     };
     await freeflowCommand.definition.handler("settings repo", settingsCtx);
     const saved = JSON.parse(await readFile(join(cwd, ".freeflow/config.json"), "utf8"));
-    assert.deepEqual(saved.cognitiveRouting.profiles.standard, {
+    assert.deepEqual(saved.cognitiveRouting.profiles.executor, {
       provider: "test",
       model: "model-b",
-      thinkingLevel: "max",
+      thinking: "max",
     });
     assert.equal(settingsCtx.reloads.length, 1);
   } finally {
@@ -780,6 +1125,256 @@ test("Pi Cognitive Routing settings preserve complete presets", async () => {
   }
 });
 
+test("Pi session settings expose both routing preset wizards without changing config files", async () => {
+  const cwd = await configuredRepo({
+    cognitiveRouting: {
+      enabled: true,
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
+      },
+    },
+  });
+  try {
+    const configPath = join(cwd, ".freeflow/config.json");
+    const localPath = join(cwd, ".freeflow/local.json");
+    const originalConfig = await readFile(configPath, "utf8");
+    const originalLocal = await readFile(localPath, "utf8").catch(() => undefined);
+    const { commands } = loadExtension(
+      freeflowExtension,
+      {},
+      {
+        async setModel() {
+          return true;
+        },
+        setThinkingLevel() {},
+      },
+    );
+    const freeflowCommand = commands.find((command) => command.name === "freeflow");
+    assert.ok(freeflowCommand);
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+    settingsCtx.ui.custom = async (factory) => {
+      let result;
+      const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+        result = value;
+      });
+      const rendered = component.render(180).join("\\n");
+      assert.match(rendered, /Cognitive Routing presets/);
+      component.handleInput("\u001b[B");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      const presetRendered = component.render(180).join("\\n");
+      assert.match(presetRendered, /Coordinator preset/);
+      assert.match(presetRendered, /Executor preset/);
+      result = { changed: false };
+      await component.waitForWrites();
+      return result;
+    };
+    await freeflowCommand.definition.handler("settings session", settingsCtx);
+    assert.equal(await readFile(configPath, "utf8"), originalConfig);
+    assert.equal(await readFile(localPath, "utf8").catch(() => undefined), originalLocal);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("Pi session preset wizard applies a complete pair without writing config", async () => {
+  const cwd = await configuredRepo({
+    cognitiveRouting: {
+      enabled: true,
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
+      },
+    },
+  });
+  try {
+    const configPath = join(cwd, ".freeflow/config.json");
+    const originalConfig = await readFile(configPath, "utf8");
+    const calls = [];
+    const controller = {
+      state: () => ({ effective: true, controlMode: "automatic", activeProfile: "coordinator" }),
+      sessionProfileOverrides: () => ({}),
+      setManualProfile: async () => ({ status: "active" }),
+      setAutomaticControl: async () => ({ status: "automatic" }),
+      setSessionProfileOverride: async (profile, override) => {
+        calls.push({ profile, override });
+        return { status: "active" };
+      },
+      resetSessionProfileOverrides: async () => ({ status: "unchanged" }),
+    };
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+    const pi = {
+      host: {},
+      appendEntry() {},
+      async setModel() {
+        return true;
+      },
+      setThinkingLevel() {},
+    };
+    settingsCtx.ui.custom = async (factory) => {
+      let finish;
+      const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+        finish = value;
+      });
+      component.handleInput("\u001b[B");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\r");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\r");
+      await component.waitForWrites();
+      finish?.({ changed: false });
+      return { changed: false };
+    };
+    await handleFreeflowCommand("settings session", settingsCtx, async () => {}, pi, controller);
+    assert.deepEqual(calls, [
+      {
+        profile: "coordinator",
+        override: { provider: "test", modelId: "model-a", thinking: "low" },
+      },
+    ]);
+    assert.equal(await readFile(configPath, "utf8"), originalConfig);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("both mode session wizard applies a Helper pair without writing config", async () => {
+  const cwd = await configuredRepo({
+    cognitiveRouting: {
+      enabled: true,
+      delegation: "both",
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        helper: { provider: "test", model: "model-b", thinking: "high" },
+        executor: { provider: "test", model: "model-b", thinking: "max" },
+      },
+    },
+  });
+  try {
+    const configPath = join(cwd, ".freeflow/config.json");
+    const originalConfig = await readFile(configPath, "utf8");
+    const calls = [];
+    const controller = {
+      state: () => ({ effective: true, controlMode: "automatic", activeProfile: "coordinator" }),
+      sessionProfileOverrides: () => ({}),
+      setManualProfile: async () => ({ status: "active" }),
+      setAutomaticControl: async () => ({ status: "automatic" }),
+      setSessionProfileOverride: async (profile, override) => {
+        calls.push({ profile, override });
+        return { status: "stored" };
+      },
+      resetSessionProfileOverrides: async () => ({ status: "unchanged" }),
+    };
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+    const pi = {
+      host: {},
+      appendEntry() {},
+      async setModel() {
+        return true;
+      },
+      setThinkingLevel() {},
+    };
+    settingsCtx.ui.custom = async (factory) => {
+      let finish;
+      const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+        finish = value;
+      });
+      component.handleInput("\u001b[B");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\r");
+      await component.waitForWrites();
+      finish?.({ changed: false });
+      return { changed: false };
+    };
+    await handleFreeflowCommand("settings session", settingsCtx, async () => {}, pi, controller);
+    assert.deepEqual(calls, [
+      {
+        profile: "helper",
+        override: { provider: "test", modelId: "model-a", thinking: "low" },
+      },
+    ]);
+    assert.equal(await readFile(configPath, "utf8"), originalConfig);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
+test("session reset preserves core overrides when routing reset fails", async () => {
+  const cwd = await configuredRepo({
+    cognitiveRouting: {
+      enabled: true,
+      profiles: {
+        coordinator: { provider: "test", model: "model-a", thinking: "low" },
+        executor: { provider: "test", model: "model-b", thinking: "high" },
+      },
+    },
+  });
+  try {
+    const configPath = join(cwd, ".freeflow/config.json");
+    const originalConfig = await readFile(configPath, "utf8");
+    const settingsCtx = context(cwd);
+    settingsCtx.isIdle = () => true;
+    settingsCtx.modelRegistry = cognitiveRoutingModelRegistry();
+    const pi = {
+      host: {},
+      appendEntry() {},
+      async setModel() {
+        return true;
+      },
+      setThinkingLevel() {},
+    };
+    await setSessionCoreOverride("contextVirtualization", true, settingsCtx, pi);
+    const controller = {
+      state: () => ({ effective: true, controlMode: "automatic", activeProfile: "coordinator" }),
+      sessionProfileOverrides: () => ({}),
+      setManualProfile: async () => ({ status: "active" }),
+      setAutomaticControl: async () => ({ status: "automatic" }),
+      setSessionProfileOverride: async () => ({ status: "stored" }),
+      resetSessionProfileOverrides: async () => ({ status: "blocked", reason: "fixture failure" }),
+    };
+    settingsCtx.ui.custom = async (factory) => {
+      let finish;
+      const component = factory({ requestRender() {} }, testTheme, {}, (value) => {
+        finish = value;
+      });
+      component.handleInput("\u001b[B");
+      component.handleInput("\u001b[B");
+      component.handleInput("\u001b[B");
+      component.handleInput("\r");
+      component.handleInput("\r");
+      await component.waitForWrites();
+      finish?.({ changed: false });
+      return { changed: false };
+    };
+    await handleFreeflowCommand("settings session", settingsCtx, async () => {}, pi, controller);
+    const state = await readCapabilityState(cwd, settingsCtx, pi.host);
+    assert.equal(state.contextVirtualization.effective, true);
+    assert.equal(state.sessionOverrides.contextVirtualization, true);
+    assert.equal(await readFile(configPath, "utf8"), originalConfig);
+    assert.match(settingsCtx.notifications.at(-1)?.message ?? "", /fixture failure/);
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
 test("Pi filters persisted Workflow and Cognitive Routing bootstrap entries without creating them", async () => {
   const cwd = await configuredRepo();
   try {
@@ -802,7 +1397,7 @@ test("Pi filters persisted Workflow and Cognitive Routing bootstrap entries with
   }
 });
 
-test("Pi preserves the host prompt when a mandatory prompt file is missing", async () => {
+test("Pi preserves the host prompt prefix and dormant contract when a mandatory file is missing", async () => {
   const root = await mkdtemp(join(tmpdir(), "freeflow-pi-missing-prompt-"));
   const cwd = await configuredRepo();
   try {
@@ -816,9 +1411,10 @@ test("Pi preserves the host prompt when a mandatory prompt file is missing", asy
     ).default;
     const { handlers } = loadExtension(extension);
     const before = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, context(cwd));
-    assert.equal(before.systemPrompt, "base prompt");
+    assert.ok(before.systemPrompt.startsWith("base prompt\n\n"));
+    assert.match(before.systemPrompt, /guidance is dormant/);
     const resources = await handlers.get("resources_discover")({ cwd }, context(cwd));
-    assert.deepEqual(resources.skillPaths, []);
+    assert.equal(resources.skillPaths.length, 27);
   } finally {
     await rm(cwd, { recursive: true, force: true });
     await rm(root, { recursive: true, force: true });
@@ -827,8 +1423,8 @@ test("Pi preserves the host prompt when a mandatory prompt file is missing", asy
 
 function cognitiveRoutingModelRegistry() {
   const models = [
-    { provider: "test", id: "model-a", name: "Model A", reasoning: true },
-    { provider: "test", id: "model-b", name: "Model B", reasoning: true },
+    { provider: "test", id: "model-a", name: "Model A", reasoning: true, contextWindow: 128000 },
+    { provider: "test", id: "model-b", name: "Model B", reasoning: true, contextWindow: 128000 },
   ];
   const supported = new Map([
     ["model-a", new Set(["off", "low", "medium", "high"])],