@hassangameryt/freeflow 0.7.1 → 0.7.2

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

@@ -5,6 +5,7 @@ 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 {
@@ -15,7 +16,7 @@ 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";
 
 const execFileAsync = promisify(execFile);
 
@@ -153,7 +154,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 +188,90 @@ 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(
+        returning.parameters.oneOf.map((branch) => branch.properties.operation.enum[0]),
+        ["submit", "retry"],
+      );
+      assert.equal(loaded.activeToolNames().includes("freeflow_project"), scenario.exposesProjection);
+
+      const providerContext = await loaded.handlers.get("context")({ messages: [] }, ctx);
+      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[0].content,
+        new RegExp("Projection: `" + (scenario.projection ? "manual-bypass" : "disabled") + "`"),
+      );
+      assert.equal(loaded.activeToolNames().includes("freeflow_project"), false);
+    } finally {
+      await rm(cwd, { recursive: true, force: 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 +284,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 +300,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,7 +329,8 @@ 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().some((name) => name.startsWith("freeflow_delegate") || name === "freeflow_return"));
     const before = await handlers.get("before_agent_start")({ systemPrompt: "base" }, ctx);
     assert.doesNotMatch(before.systemPrompt, /Cognitive Routing/);
   } finally {
@@ -250,8 +343,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 +366,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 \(4\) active/);
       assert.doesNotMatch(rootText, /PiFlow only/);
       return undefined;
     };
@@ -296,14 +389,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 +409,6 @@ test("Pi statusline shows the configured Cognitive Routing profile while activat
       cognitiveRouting: {
         enabled: true,
         effective: true,
-        sessionStart: { profile: "reasoning" },
         blockingReason: null,
       },
     },
@@ -324,7 +416,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 +431,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 +453,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 +469,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 +486,16 @@ 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 executor", label: "executor", description: "Hold Executor manually" },
+    { 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,7 +505,7 @@ 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();
@@ -408,8 +515,9 @@ test("Pi exposes 25 base skills without a mode skill or compatibility aliases",
       assert.ok(match, `unexpected skill path: ${path}`);
       return match[1];
     });
-    assert.equal(skillNames.length, 25);
+    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"));
@@ -738,13 +846,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);
@@ -759,9 +877,8 @@ test("Pi Cognitive Routing settings preserve complete presets", async () => {
       component.handleInput("\r");
       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 +886,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 {
@@ -827,8 +944,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"])],

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

@@ -6,11 +6,12 @@ import { tmpdir } from "node:os";
 import test from "node:test";
 
 import freeflowExtension from "../../dist/index.js";
-import { PIFLOW_HOST } from "../cognitive-routing/host-fixture.js";
+import { PIFLOW_HOST } from "../fixtures/pi-host.js";
 
-function context(cwd) {
+function context(cwd, systemPrompt = "") {
   return {
     cwd,
+    getSystemPrompt: () => systemPrompt,
     sessionManager: {
       getEntries: () => [],
       getBranch: () => [],
@@ -65,20 +66,44 @@ function lastRuntimeState(messages) {
 }
 
 test("re-entry recovery is stable and capability-neutral", async () => {
-  const [core, cognitiveRouting, conversationHistory] = await Promise.all([
+  const [core, cognitiveRouting, conversationHistory, routingSkill] = await Promise.all([
     readFile(join(process.cwd(), "runtime", "prompts", "core.md"), "utf8"),
     readFile(join(process.cwd(), "runtime", "prompts", "cognitive-routing.md"), "utf8"),
     readFile(join(process.cwd(), "runtime", "prompts", "conversation-history.md"), "utf8"),
+    readFile(join(process.cwd(), "capabilities", "cognitive-routing", "SKILL.md"), "utf8"),
   ]);
 
+  assert.match(core, /## Load The Selected Method/);
+  assert.match(core, /Before applying a selected skill, read its current body/);
   assert.match(core, /## Recover After Context Loss/);
   assert.match(core, /latest Freeflow Runtime State/);
-  assert.doesNotMatch(cognitiveRouting, /When Cognitive Routing is active and its skill is absent/);
-  assert.match(cognitiveRouting, /A Runtime State refresh is host context, not a user interruption/);
+  assert.match(core, /recovery is not a bypass/);
+  assert.match(core, /evidence of prior approval; check that the approval still applies/);
+  assert.match(core, /choose or retain the current owner/);
+  assert.match(core, /apply its method and gather or produce evidence/);
+  assert.match(core, /read the complete `full` record/);
+  assert.match(core, /Make material gaps, contradictions, deferrals, and user-owned decisions explicit/);
+  assert.match(cognitiveRouting, /Before relying on automatic routing, read the complete cognitive-routing skill/);
+  assert.match(cognitiveRouting, /This bootstrap read is the only environment call/);
+  assert.match(cognitiveRouting, /If unavailable, stop and report the missing method/);
+  // The approved compact cue keeps bootstrap/control boundaries; the loaded
+  // method owns detailed role and handoff policy. Keep both obligations checked.
   assert.match(
     cognitiveRouting,
-    /`Control` and `Profile` in the latest Runtime State report current compute state, not Yield, Delegate, `ACT_BOUNDED`, or boundary state/,
+    /Under Manual or inactive routing, stop applying the automatic split and follow ordinary Workflow/,
   );
+  assert.match(cognitiveRouting, /Use the latest Runtime State for control, profile, and current responsibility/);
+  assert.match(cognitiveRouting, /Coordinator and Executor in one agent\/session/);
+  assert.match(routingSkill, /Automatic delegation, role restrictions, and projection are bypassed/);
+  assert.match(routingSkill, /Put the actual contract inside `freeflow_delegate/);
+  assert.match(routingSkill, /submits the actual report and stops ordinary task work/);
+  assert.match(cognitiveRouting, /project every completed skill and instructional-reference read/);
+  assert.match(routingSkill, /Attach recovery to the existing responsibility/);
+  assert.match(
+    routingSkill,
+    /Returned work may use an attached recovery-only phase only if the runtime actually exposes it; otherwise inspect saved communication and stop if insufficient/,
+  );
+  assert.match(routingSkill, /Do not simulate recovery by replacing the assignment or report/);
   assert.doesNotMatch(
     conversationHistory,
     /Current user direction, live source truth, and present runtime state remain authoritative/,
@@ -98,8 +123,10 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
     const order = [
       "# Freeflow Stable Guidance",
       "## Shared Terms",
+      "## Load The Selected Method",
       "## Recover After Context Loss",
       "## Three Nested Loops",
+      "## Evidence And Judgment",
       "## Workflow Cue",
       "## Action Selection Cue",
       "## Supported Exit",
@@ -112,6 +139,18 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
       order,
       [...order].sort((a, b) => a - b),
     );
+    assert.match(
+      prompt,
+      /Before applying a selected skill, read its current body when its exact method is absent from context/,
+    );
+    assert.match(prompt, /Verification establishes what direct evidence proves at the observed boundary/);
+    assert.match(
+      prompt,
+      /Review judges whether work or an artifact is aligned, correct, suitable, and sufficiently evidenced/,
+    );
+    assert.match(prompt, /Interpret requested intent, not sentence form/);
+    assert.match(prompt, /answer the question before any action that depends on it/);
+    assert.match(prompt, /An unresolved question does not automatically suspend independent, clearly authorized work/);
     assert.doesNotMatch(prompt, /## Mode\b|strict-workflow|conversation mode|workflow mode/);
     assert.doesNotMatch(prompt, /Skills prompt/);
     assert.doesNotMatch(prompt, /# Workflow\n/);
@@ -124,6 +163,8 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
     assert.match(runtimeState.content, /Context Virtualization: active/);
     assert.match(runtimeState.content, /Conversation History: active/);
     assert.match(runtimeState.content, /Cognitive Routing: inactive/);
+    assert.match(runtimeState.content, /Control: `unavailable`/);
+    assert.match(runtimeState.content, /Projection: `disabled`/);
     assert.doesNotMatch(runtimeState.content, /Default mode|Active mode|Interaction Contract|Skills/);
 
     const resources = await handlers.get("resources_discover")({ cwd }, ctx);
@@ -137,6 +178,46 @@ test("composes the mandatory core fragments, optional capabilities, discovery, a
   }
 });
 
+test("subagents keep Freeflow core and base skills without optional capabilities", async () => {
+  const cwd = await configuredRepo({
+    contextVirtualization: true,
+    conversationHistory: true,
+    cognitiveRouting: {
+      enabled: true,
+      profiles: {
+        coordinator: { provider: "test", model: "coordinator", thinking: "high" },
+        executor: { provider: "test", model: "executor", thinking: "max" },
+      },
+    },
+  });
+  try {
+    const { handlers, activeToolNames } = loadExtension(freeflowExtension, null);
+    const ctx = context(cwd, "<!-- freeflow-subagent-capabilities: disabled -->");
+    await handlers.get("session_start")({ type: "session_start" }, ctx);
+
+    const before = await handlers.get("before_agent_start")({ systemPrompt: "base prompt" }, ctx);
+    assert.match(before.systemPrompt, /# Freeflow Stable Guidance/);
+    assert.match(before.systemPrompt, /# Freeflow Interaction Contract/);
+    assert.doesNotMatch(before.systemPrompt, /## Cognitive Routing Cue/);
+    assert.doesNotMatch(before.systemPrompt, /## Context Virtualization Cue/);
+    assert.doesNotMatch(before.systemPrompt, /## Conversation History Cue/);
+
+    const resources = await handlers.get("resources_discover")({ cwd }, ctx);
+    assert.ok(resources.skillPaths.some((path) => path.endsWith("/skills/action-selection/SKILL.md")));
+    assert.ok(!resources.skillPaths.some((path) => path.includes("/capabilities/")));
+
+    const providerContext = await handlers.get("context")({ messages: [] }, ctx);
+    const runtimeState = lastRuntimeState(providerContext.messages);
+    assert.match(runtimeState.content, /Freeflow: active/);
+    assert.match(runtimeState.content, /Context Virtualization: inactive/);
+    assert.match(runtimeState.content, /Conversation History: inactive/);
+    assert.match(runtimeState.content, /Cognitive Routing: inactive/);
+    assert.ok(!activeToolNames().includes("freeflow_context"));
+  } finally {
+    await rm(cwd, { recursive: true, force: true });
+  }
+});
+
 test("provider context reuses the before-agent surface until the next provider turn", async () => {
   const cwd = await configuredRepo({ contextVirtualization: true });
   try {