@hassangameryt/freeflow 0.7.2 → 0.7.3

package/pi-extension/src/settings/settings-ui.ts

@@ -22,10 +22,12 @@ import {
 import { isPiFlowHost } from "../runtime/runtime-identity.js";
 import type {
   CognitiveRoutingCapabilityState,
+  CognitiveRoutingDelegationMode,
   CognitiveRoutingProfile,
   CognitiveRoutingProfileName,
   CognitiveRoutingThinkingLevel,
 } from "../cognitive-routing-v2/config.js";
+import { isWorkerProfile, workersForDelegation } from "../cognitive-routing-v2/types.js";
 
 const DEFAULT_FREEFLOW_ENABLED = true;
 const DEFAULT_CONTEXT_VIRTUALIZATION_ENABLED = false;
@@ -67,13 +69,26 @@ type SettingsItem = {
   transient?: boolean;
 };
 
+type SessionRoutingPair = {
+  provider: string;
+  modelId: string;
+  thinking: CognitiveRoutingThinkingLevel;
+};
+
 type CognitiveRoutingSettingsController = {
   state(): { effective: boolean; controlMode: string; activeProfile?: string };
+  sessionProfileOverrides(): Partial<Record<CognitiveRoutingProfileName, SessionRoutingPair>>;
   setManualProfile(
-    profile: "executor" | "coordinator",
+    profile: CognitiveRoutingProfileName,
     mechanism?: string,
   ): Promise<{ status: string; reason?: string }>;
   setAutomaticControl(mechanism?: string): Promise<{ status: string; reason?: string }>;
+  setSessionProfileOverride(
+    profile: CognitiveRoutingProfileName,
+    override: SessionRoutingPair | null,
+    mechanism?: string,
+  ): Promise<{ status: string; reason?: string }>;
+  resetSessionProfileOverrides(mechanism?: string): Promise<{ status: string; reason?: string }>;
 };
 
 type AfterChangeOptions = {
@@ -293,6 +308,79 @@ function createScopedBooleanItem(options: ScopedBooleanItemOptions): SettingsIte
   return item;
 }
 
+function createScopedDelegationItem(options: {
+  scope: Exclude<ConfigScope, "session">;
+  rawConfig: Record<string, unknown>;
+  localConfig: Record<string, unknown>;
+  effectiveValue: CognitiveRoutingDelegationMode;
+  effectiveSource: ConfigSource;
+}): SettingsItem {
+  const path = ["cognitiveRouting", "delegation"];
+  const repositoryValue = getPath(options.rawConfig, path);
+  const inheritedValue: CognitiveRoutingDelegationMode = ["executor", "helper", "both"].includes(
+    repositoryValue as string,
+  )
+    ? (repositoryValue as CognitiveRoutingDelegationMode)
+    : "executor";
+  const inheritedSource: ConfigSource = repositoryValue === undefined ? "builtin" : "repository";
+  const localValue = getPath(options.localConfig, path);
+  const descriptions = {
+    executor: "Coordinator delegates assignments to Executor.",
+    helper: "Coordinator delegates supporting assignments to Helper and keeps production implementation.",
+    both: "Coordinator chooses Helper or Executor for each assignment.",
+  };
+  const item: SettingsItem =
+    options.scope === "local"
+      ? {
+          id: "freeflow.cognitiveRouting.delegation",
+          label: "Delegation method",
+          description:
+            "Choose enabled workers for automatic routing. Inherit uses the repository value; this setting does not rank model presets.",
+          path,
+          kind: "enum",
+          value: ["executor", "helper", "both"].includes(localValue as string) ? localValue : LOCAL_INHERIT,
+          values: [LOCAL_INHERIT, "executor", "helper", "both"],
+          valueLabels: {
+            inherit: "Inherit repository",
+            executor: "Executor only",
+            helper: "Helper only",
+            both: "Helper and Executor",
+          },
+          valueDescriptions: {
+            inherit: `Use ${inheritedValue} from ${inheritedSource}.`,
+            ...descriptions,
+          },
+          configScope: "local",
+          configValues: { inherit: undefined, executor: "executor", helper: "helper", both: "both" },
+          effectiveValue: options.effectiveValue,
+          effectiveSource: options.effectiveSource,
+          inheritedValue,
+          inheritedSource,
+        }
+      : {
+          id: "freeflow.cognitiveRouting.delegation",
+          label: "Delegation method",
+          description: "Choose enabled workers for automatic routing. This edits shared .freeflow/config.json.",
+          path,
+          kind: "enum",
+          value: inheritedValue,
+          values: ["executor", "helper", "both"],
+          valueLabels: {
+            executor: "Executor only",
+            helper: "Helper only",
+            both: "Helper and Executor",
+          },
+          valueDescriptions: descriptions,
+          defaultValue: "executor",
+          configScope: "repository",
+          effectiveValue: options.effectiveValue,
+          effectiveSource: options.effectiveSource,
+          localOverrideValue: ["executor", "helper", "both"].includes(localValue as string) ? localValue : undefined,
+        };
+  item.displaySuffix = coreDisplaySuffix(item);
+  return item;
+}
+
 function resolveSettingsCoreView(
   rawConfig: Record<string, unknown>,
   layers?: Awaited<ReturnType<typeof readFreeflowConfigLayers>>,
@@ -371,6 +459,7 @@ function createSessionBooleanItem(options: {
 function sessionFreeflowItems(
   state: Awaited<ReturnType<typeof readCapabilityState>>,
   cognitiveRoutingController?: CognitiveRoutingSettingsController,
+  ctx?: any,
 ): SettingsItem[] {
   const sessionOverrides = state.sessionOverrides as Record<string, boolean>;
   const configured = state.configuredCoreConfig;
@@ -424,48 +513,79 @@ function sessionFreeflowItems(
   conversationHistoryItem.inactive = freeflowInactive;
 
   const cognitiveRoutingState = cognitiveRoutingController?.state();
+  const delegation = state.cognitiveRouting?.delegation ?? "executor";
+  const heldProfile = cognitiveRoutingState?.controlMode.startsWith("manual-")
+    ? cognitiveRoutingState.activeProfile
+    : undefined;
+  const availableProfiles: CognitiveRoutingProfileName[] = ["coordinator", ...workersForDelegation(delegation)];
+  if (heldProfile === "coordinator" || isWorkerProfile(heldProfile)) availableProfiles.push(heldProfile);
+  const manualProfiles = [...new Set(availableProfiles)];
   const cognitiveRoutingProfile =
-    cognitiveRoutingState?.controlMode === "manual-executor"
-      ? "executor"
-      : cognitiveRoutingState?.controlMode === "manual-coordinator"
-        ? "coordinator"
-        : "auto";
+    heldProfile && manualProfiles.includes(heldProfile as CognitiveRoutingProfileName) ? heldProfile : "auto";
   const cognitiveRoutingItem: SettingsItem | undefined = state.cognitiveRouting
     ? {
         id: "freeflow.cognitiveRouting.profile",
         label: "Cognitive Routing",
-        description: "Hold a profile manually or release the hold for automatic model control.",
+        description: "Hold an enabled profile manually or release the hold for automatic model control.",
         kind: "enum",
         value: cognitiveRoutingProfile,
-        values: ["auto", "executor", "coordinator"],
-        valueLabels: {
-          auto: "automatic",
-          executor: "manual · executor",
-          coordinator: "manual · coordinator",
-        },
-        valueDescriptions: {
-          auto: "Release the manual hold and return to Coordinator reconciliation.",
-          executor: "Hold the executor profile until /freeflow profile auto.",
-          coordinator: "Hold the coordinator profile until /freeflow profile auto.",
-        },
+        values: ["auto", ...manualProfiles],
+        valueLabels: Object.fromEntries([
+          ["auto", "automatic"],
+          ...manualProfiles.map((profile) => [profile, `manual · ${profile}`]),
+        ]),
+        valueDescriptions: Object.fromEntries([
+          ["auto", "Release the manual hold and return to Coordinator reconciliation."],
+          ...manualProfiles.map((profile) => [profile, `Hold the ${profile} profile until /freeflow profile auto.`]),
+        ]),
         inactive: freeflowInactive || !state.cognitiveRouting.effective || cognitiveRoutingController === undefined,
         runtimeInactive: state.cognitiveRouting.blockingReason?.code === "runtime_disabled",
         displaySuffix: cognitiveRoutingState?.effective ? cognitiveRoutingProfile : "unavailable",
       }
     : undefined;
 
+  const sessionProfiles = cognitiveRoutingController?.sessionProfileOverrides();
+  const profileItems =
+    state.cognitiveRouting && cognitiveRoutingController
+      ? manualProfiles.map((name) =>
+          cognitiveRoutingProfileItem({
+            name,
+            scope: "session",
+            rawConfig: {},
+            localConfig: {},
+            capabilityState: state.cognitiveRouting as CognitiveRoutingCapabilityState,
+            ctx,
+            sessionProfiles,
+          }),
+        )
+      : [];
+  const cognitiveRoutingPresets: SettingsItem | undefined = profileItems.length
+    ? {
+        id: "freeflow.cognitiveRouting.presets",
+        label: "Cognitive Routing presets",
+        description: "Temporarily choose complete model/effort pairs for profiles enabled in this Pi session.",
+        kind: "group",
+        value: profileItems.some((item) => item.value !== LOCAL_INHERIT && item.value !== undefined),
+        displaySuffix: `${profileItems.filter((item) => item.value !== LOCAL_INHERIT && item.value !== undefined).length}/${profileItems.length} session overrides`,
+        inactive: freeflowInactive || !state.cognitiveRouting?.effective || cognitiveRoutingController === undefined,
+        children: profileItems,
+      }
+    : undefined;
+
   return [
     freeflowItem,
     ...(cognitiveRoutingItem ? [cognitiveRoutingItem] : []),
+    ...(cognitiveRoutingPresets ? [cognitiveRoutingPresets] : []),
     {
       id: "freeflow.session.reset",
       label: "Reset session overrides",
-      description: "Clear Freeflow, Context Virtualization, and Conversation History overrides for this Pi session.",
+      description:
+        "Clear Freeflow, Context Virtualization, Conversation History, and routing profile overrides for this Pi session.",
       kind: "enum",
       value: "available",
       values: ["reset"],
       valueLabels: { reset: "Reset all session overrides" },
-      valueDescriptions: { reset: "Return every session setting to its configured value." },
+      valueDescriptions: { reset: "Return every session setting and routing preset to its configured value." },
       format: () => "available",
       transient: true,
     },
@@ -574,6 +694,7 @@ function cognitiveRoutingProfileDisplay(value: unknown): string {
 }
 
 function cognitiveRoutingSettingsSource(source: unknown): ConfigSource {
+  if (source === "session") return "session";
   if (source === "repository") return "repository";
   if (source === "personal" || source === "local") return "local";
   return "builtin";
@@ -581,6 +702,7 @@ function cognitiveRoutingSettingsSource(source: unknown): ConfigSource {
 
 function cognitiveRoutingProfileDisplaySuffix(source: unknown, scope: ConfigScope): string | undefined {
   if (!source) return undefined;
+  if (source === "session") return "(session override)";
   if (source === "personal" && scope === "repository") return "(effective personal)";
   return `(${source})`;
 }
@@ -605,6 +727,11 @@ function createCognitiveRoutingProfileWizard(
   currentValue: unknown,
   models: CognitiveRoutingModelOption[],
   allowInherit: boolean,
+  inheritChoice: { label: string; description: string; summary: string } = {
+    label: "Inherit repository preset",
+    description: "Remove the personal override without changing the repository preset.",
+    summary: "inherit repository preset",
+  },
 ): SettingsWizard {
   const currentProfile = isCognitiveRoutingProfile(currentValue) ? currentValue : undefined;
   const currentModelKey = currentProfile
@@ -616,8 +743,8 @@ function createCognitiveRoutingProfileWizard(
           {
             key: LOCAL_INHERIT,
             value: LOCAL_INHERIT,
-            label: "Inherit repository preset",
-            description: "Remove the personal override without changing the repository preset.",
+            label: inheritChoice.label,
+            description: inheritChoice.description,
           },
         ]
       : []),
@@ -652,7 +779,7 @@ function createCognitiveRoutingProfileWizard(
       if (selectedValues.length === 1) {
         const selected = selectedValues[0];
         if (selected === LOCAL_INHERIT) {
-          return cognitiveRoutingConfirmStep("inherit repository preset");
+          return cognitiveRoutingConfirmStep(inheritChoice.summary);
         }
         const model = selected as CognitiveRoutingModelOption;
         if (!model?.key || model.thinkingLevels.length === 0) return undefined;
@@ -695,36 +822,65 @@ function cognitiveRoutingProfileItem(options: {
   localConfig: Record<string, unknown>;
   capabilityState: CognitiveRoutingCapabilityState | undefined;
   ctx: any;
+  sessionProfiles?: Partial<Record<CognitiveRoutingProfileName, SessionRoutingPair>>;
 }): SettingsItem {
   const path = ["cognitiveRouting", "profiles", options.name];
   const repositoryProfile = getPath(options.rawConfig, path);
   const localProfile = getPath(options.localConfig, path);
-  const effectiveProfile = options.capabilityState?.profiles?.[options.name] ?? repositoryProfile;
+  const configuredProfile = options.capabilityState?.profiles?.[options.name] ?? repositoryProfile;
+  const sessionPair = options.sessionProfiles?.[options.name];
+  const sessionProfile = sessionPair
+    ? { provider: sessionPair.provider, model: sessionPair.modelId, thinking: sessionPair.thinking }
+    : undefined;
+  const effectiveProfile = sessionProfile ?? configuredProfile;
   const localValue = isCognitiveRoutingProfile(localProfile) ? localProfile : LOCAL_INHERIT;
-  const value = options.scope === "local" ? localValue : repositoryProfile;
-  const source =
+  const value =
+    options.scope === "session"
+      ? (sessionProfile ?? LOCAL_INHERIT)
+      : options.scope === "local"
+        ? localValue
+        : repositoryProfile;
+  const configuredSource =
     options.capabilityState?.profileSources?.[options.name] ??
     (isCognitiveRoutingProfile(repositoryProfile) ? "repository" : undefined);
+  const source = options.scope === "session" ? (sessionProfile ? "session" : configuredSource) : configuredSource;
   const models = cognitiveRoutingModelOptions(options.ctx);
-  const inactive = options.scope === "local" && models.length === 0 && localValue !== LOCAL_INHERIT;
+  const inactive = options.scope !== "repository" && models.length === 0 && value !== LOCAL_INHERIT;
+  const inheritChoice =
+    options.scope === "session"
+      ? {
+          label: "Inherit configured preset",
+          description: "Remove the session override without changing local or repository configuration.",
+          summary: "inherit configured preset",
+        }
+      : undefined;
 
   return {
     id: `freeflow.cognitiveRouting.${options.name}`,
     label: `${options.name.charAt(0).toUpperCase()}${options.name.slice(1)} preset`,
     description:
-      "Choose an authenticated available model and one effort supported by that model. Confirming writes the complete preset; cancel leaves it unchanged.",
+      options.scope === "session"
+        ? "Temporarily choose the model and effort for this profile in the current Pi session only."
+        : "Choose an authenticated available model and one effort supported by that model. Confirming writes the complete preset; cancel leaves it unchanged.",
     path,
     kind: "string",
     value,
-    format: cognitiveRoutingProfileDisplay,
+    format: (current) => {
+      const inherits = current === LOCAL_INHERIT || (options.scope === "session" && current === undefined);
+      return inherits
+        ? options.scope === "session"
+          ? "inherit configured preset"
+          : "inherit repository preset"
+        : cognitiveRoutingProfileDisplay(current);
+    },
     configScope: options.scope,
     effectiveValue: effectiveProfile,
     effectiveSource: cognitiveRoutingSettingsSource(source),
-    inheritedValue: repositoryProfile,
-    inheritedSource: "repository",
+    inheritedValue: options.scope === "session" ? configuredProfile : repositoryProfile,
+    inheritedSource: cognitiveRoutingSettingsSource(configuredSource ?? "builtin"),
     inactive,
     displaySuffix: cognitiveRoutingProfileDisplaySuffix(source, options.scope),
-    wizard: () => createCognitiveRoutingProfileWizard(value, models, options.scope === "local"),
+    wizard: () => createCognitiveRoutingProfileWizard(value, models, options.scope !== "repository", inheritChoice),
   };
 }
 
@@ -747,7 +903,7 @@ function freeflowItems(
     runtimeAvailable?: boolean;
   } = {},
 ): SettingsItem[] {
-  const scope = options.scope ?? "repository";
+  const scope: Exclude<ConfigScope, "session"> = options.scope === "local" ? "local" : "repository";
   const layers = options.layers;
   const { localConfig, core, sources } = resolveSettingsCoreView(rawConfig, layers);
 
@@ -812,6 +968,16 @@ function freeflowItems(
     cognitiveRoutingEnabledItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
     cognitiveRoutingEnabledItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
 
+    const cognitiveRoutingDelegationItem = createScopedDelegationItem({
+      scope,
+      rawConfig,
+      localConfig,
+      effectiveValue: cognitiveRoutingState?.delegation ?? "executor",
+      effectiveSource: cognitiveRoutingSettingsSource(cognitiveRoutingState?.delegationSource),
+    });
+    cognitiveRoutingDelegationItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
+    cognitiveRoutingDelegationItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
+
     const cognitiveRoutingProjectionItem = createScopedBooleanItem({
       scope,
       rawConfig,
@@ -819,7 +985,7 @@ function freeflowItems(
       id: "freeflow.cognitiveRouting.projection",
       label: "Context projection",
       description:
-        "Select Executor evidence for Coordinator; disable projection to keep ordinary Pi context in both profiles.",
+        "Select worker evidence for Coordinator; disable projection to keep ordinary Pi context in all enabled profiles.",
       path: ["cognitiveRouting", "projection"],
       effectiveValue: cognitiveRoutingState?.projection ?? false,
       effectiveSource: cognitiveRoutingSettingsSource(cognitiveRoutingState?.projectionSource),
@@ -828,7 +994,7 @@ function freeflowItems(
     cognitiveRoutingProjectionItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
     cognitiveRoutingProjectionItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
 
-    const cognitiveRoutingProfiles = ["executor", "coordinator"].map((name) =>
+    const cognitiveRoutingProfiles = ["coordinator", "helper", "executor"].map((name) =>
       cognitiveRoutingProfileItem({
         name: name as CognitiveRoutingProfileName,
         scope,
@@ -856,12 +1022,17 @@ function freeflowItems(
       label: "Cognitive Routing",
       description: cognitiveRoutingRuntimeDisabled
         ? "Cognitive Routing configuration is visible for inspection but requires a host model-state control API."
-        : "Configure the Executor and Coordinator profiles and choose whether Freeflow may manage model state for this repository.",
+        : "Configure Coordinator, Helper, and Executor profiles plus the workers available for delegation.",
       kind: "group" as const,
       value: cognitiveRoutingRuntimeDisabled ? false : (cognitiveRoutingState?.enabled ?? false),
       inactive: freeflowInactive,
       displaySuffix: cognitiveRoutingStatus,
-      children: [cognitiveRoutingEnabledItem, ...cognitiveRoutingProfiles, cognitiveRoutingProjectionItem],
+      children: [
+        cognitiveRoutingEnabledItem,
+        cognitiveRoutingDelegationItem,
+        ...cognitiveRoutingProfiles,
+        cognitiveRoutingProjectionItem,
+      ],
     } satisfies SettingsItem;
   })();
 
@@ -885,6 +1056,7 @@ function pruneKnownDefaults(config: Record<string, unknown>) {
     { path: ["enabled"], value: DEFAULT_FREEFLOW_ENABLED },
     { path: ["contextVirtualization"], value: DEFAULT_CONTEXT_VIRTUALIZATION_ENABLED },
     { path: ["conversationHistory"], value: DEFAULT_CONVERSATION_HISTORY_ENABLED },
+    { path: ["cognitiveRouting", "delegation"], value: "executor" },
   ];
 
   for (const item of defaultPaths) {
@@ -971,7 +1143,7 @@ async function updateConfig(
 }
 
 function isCognitiveRoutingProfileItem(item: SettingsItem): boolean {
-  return item.id === "freeflow.cognitiveRouting.executor" || item.id === "freeflow.cognitiveRouting.coordinator";
+  return ["coordinator", "helper", "executor"].some((profile) => item.id === `freeflow.cognitiveRouting.${profile}`);
 }
 
 function valueForDisplay(item: SettingsItem): string {
@@ -1015,10 +1187,13 @@ function refreshSettingsDerivedState(items: SettingsItem[]) {
   const freeflowInactive = freeflowItem ? effectiveItemValue(freeflowItem) !== true : false;
   const cognitiveRoutingGroup = findSettingsItem(items, "freeflow.cognitiveRouting");
   const cognitiveRoutingEnabledItem = findSettingsItem(items, "freeflow.cognitiveRouting.enabled");
-  const cognitiveRoutingProfiles = [
-    findSettingsItem(items, "freeflow.cognitiveRouting.executor"),
-    findSettingsItem(items, "freeflow.cognitiveRouting.coordinator"),
-  ];
+  const cognitiveRoutingDelegationItem = findSettingsItem(items, "freeflow.cognitiveRouting.delegation");
+  const delegation = (
+    cognitiveRoutingDelegationItem ? effectiveItemValue(cognitiveRoutingDelegationItem) : "executor"
+  ) as CognitiveRoutingDelegationMode;
+  const cognitiveRoutingProfiles = ["coordinator", ...workersForDelegation(delegation)].map((profile) =>
+    findSettingsItem(items, `freeflow.cognitiveRouting.${profile}`),
+  );
 
   if (cognitiveRoutingGroup && cognitiveRoutingEnabledItem) {
     const enabled = effectiveItemValue(cognitiveRoutingEnabledItem) === true;
@@ -1336,7 +1511,7 @@ export async function handleFreeflowCommand(
   let reconcileCognitiveRouting = settingsScope === "session";
   const items =
     settingsScope === "session"
-      ? sessionFreeflowItems(state, cognitiveRoutingController)
+      ? sessionFreeflowItems(state, cognitiveRoutingController, ctx)
       : freeflowItems(raw, {
           scope: settingsScope,
           layers,
@@ -1368,7 +1543,7 @@ export async function handleFreeflowCommand(
           value === "auto"
             ? await cognitiveRoutingController.setAutomaticControl("profile-settings")
             : await cognitiveRoutingController.setManualProfile(
-                value as "executor" | "coordinator",
+                value as CognitiveRoutingProfileName,
                 "profile-settings",
               );
         if ((result.status !== "automatic" && result.status !== "active") || result.reason) {
@@ -1382,8 +1557,63 @@ export async function handleFreeflowCommand(
         return { changed: true, reloadRequired: false };
       }
       if (item.id === "freeflow.session.reset") {
-        const result = await resetSessionOverrides(ctx, pi);
-        return { changed: result.changed, reloadRequired: result.reloadRequired };
+        const routingResult = cognitiveRoutingController
+          ? await cognitiveRoutingController.resetSessionProfileOverrides("Reset session overrides")
+          : { status: "unchanged" };
+        if (routingResult.status === "blocked" || routingResult.reason) {
+          ctx.ui.notify(
+            `Cognitive Routing session presets could not be reset: ${routingResult.reason ?? routingResult.status}.`,
+            "warning",
+          );
+          return { changed: false, reloadRequired: false };
+        }
+        try {
+          const result = await resetSessionOverrides(ctx, pi);
+          return {
+            changed: result.changed || routingResult.status !== "unchanged",
+            reloadRequired: result.reloadRequired,
+          };
+        } catch (error) {
+          ctx.ui.notify(
+            `Routing presets were reset, but core/context session overrides could not be reset: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+            "warning",
+          );
+          return {
+            changed: routingResult.status !== "unchanged",
+            reloadRequired: false,
+          };
+        }
+      }
+      if (item.configScope === "session" && isCognitiveRoutingProfileItem(item)) {
+        if (!cognitiveRoutingController) {
+          ctx.ui.notify("Cognitive Routing is unavailable for this session.", "warning");
+          return { changed: false, reloadRequired: false };
+        }
+        const profile = item.id.split(".").at(-1) as CognitiveRoutingProfileName;
+        const override =
+          value === undefined || value === LOCAL_INHERIT
+            ? null
+            : {
+                provider: (value as CognitiveRoutingProfile).provider,
+                modelId: (value as CognitiveRoutingProfile).model,
+                thinking: (value as CognitiveRoutingProfile).thinking,
+              };
+        const result = await cognitiveRoutingController.setSessionProfileOverride(
+          profile,
+          override,
+          "Session profile settings",
+        );
+        if (result.status === "blocked" || result.reason) {
+          ctx.ui.notify(
+            `Cognitive Routing session preset could not be applied: ${result.reason ?? result.status}.`,
+            "warning",
+          );
+          return { changed: false, reloadRequired: false };
+        }
+        await afterChange(false);
+        return { changed: result.status !== "unchanged", reloadRequired: false };
       }
       if (item.configScope === "session") {
         const keyById = {

package/pi-extension/tests/cache-reuse/history.test.js

@@ -0,0 +1,117 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { RequestHistory } from "../../dist/runtime/request-history.js";
+const state = (text) => ({ role: "custom", customType: "freeflow-runtime-state", content: text, display: false });
+const communication = (text) => ({
+  role: "custom",
+  customType: "freeflow-routing-communication",
+  content: text,
+  display: false,
+});
+const user = (text) => ({ role: "user", content: [{ type: "text", text }], timestamp: 1 });
+function fixture(manager = SessionManager.inMemory("/tmp/freeflow-cache")) {
+  const pi = { appendEntry: (type, data) => manager.appendCustomEntry(type, data) };
+  return { manager, pi, ctx: { sessionManager: manager, ui: { setStatus() {} } }, history: new RequestHistory(pi) };
+}
+test("generated state stays at its original position and changed state appends", async () => {
+  const f = fixture(),
+    one = await f.history.assemble([state("enabled"), user("one")], "ordinary", f.ctx);
+  const two = await f.history.assemble([user("one"), state("disabled"), user("two")], "ordinary", f.ctx);
+  assert.deepEqual(two.slice(0, one.length), one);
+  assert.equal(two.at(-1).content, "disabled");
+  const count = f.manager.getEntries().length;
+  assert.deepEqual(await f.history.assemble([state("disabled"), user("one"), user("two")], "ordinary", f.ctx), two);
+  assert.equal(f.manager.getEntries().length, count);
+  const reload = new RequestHistory(f.pi);
+  const three = await reload.assemble([state("disabled"), user("one"), user("two"), user("three")], "ordinary", f.ctx);
+  assert.deepEqual(three.slice(0, two.length), two);
+});
+test("view changes never import excluded bodies or stale required communication", async () => {
+  const f = fixture();
+  await f.history.assemble([user("SECRET"), state("worker"), communication("required report")], "ordinary", f.ctx);
+  const coordinator = await f.history.assemble([user("selected"), state("coordinator")], "coordinator", f.ctx);
+  assert.ok(!JSON.stringify(coordinator).includes("SECRET"));
+  const reduced = await f.history.assemble([user("new visible"), state("worker")], "ordinary", f.ctx);
+  assert.ok(!JSON.stringify(reduced).includes("SECRET"));
+  assert.ok(!JSON.stringify(reduced).includes("required report"));
+});
+test("context persistence failure returns the current qualified view without old bodies", async () => {
+  const f = fixture();
+  await f.history.assemble([user("old"), state("first")], "ordinary", f.ctx);
+  f.pi.appendEntry = () => {
+    throw Error("disk");
+  };
+  const current = [user("current"), state("second")];
+  assert.equal(await f.history.assemble(current, "ordinary", f.ctx), current);
+});
+
+test("changing only the view label retains the exact permitted prefix", async () => {
+  const f = fixture();
+  const first = await f.history.assemble([user("common"), state("ordinary")], "ordinary", f.ctx);
+  const next = await f.history.assemble([user("common"), state("coordinator")], "coordinator", f.ctx);
+  assert.deepEqual(next.slice(0, first.length), first);
+});
+
+test("native labeled forks preserve generated-state positions", async () => {
+  const root = await mkdtemp(join(tmpdir(), "freeflow-cache-fork-"));
+  try {
+    const manager = SessionManager.create(root, root),
+      f = fixture(manager);
+    const id = manager.appendMessage(user("one"));
+    manager.appendLabelChange(id, "named");
+    const first = await f.history.assemble([user("one"), state("enabled")], "ordinary", f.ctx);
+    manager.appendMessage({
+      role: "assistant",
+      content: [{ type: "text", text: "done" }],
+      timestamp: 2,
+      stopReason: "stop",
+    });
+    const path = manager.createBranchedSession(manager.getLeafId());
+    const nextFixture = fixture(SessionManager.open(path));
+    const next = await nextFixture.history.assemble(
+      [user("one"), user("two"), state("disabled")],
+      "ordinary",
+      nextFixture.ctx,
+    );
+    assert.deepEqual(next.slice(0, first.length), first);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("budget notices see assembled historical overhead and clear without rewriting old notices", async () => {
+  const f = fixture();
+  let length;
+  const first = await f.history.assemble([user("one"), state("enabled")], "ordinary", f.ctx, (messages) => {
+    length = messages.length;
+    return { role: "custom", customType: "freeflow-routing-budget", content: "Large input", display: false };
+  });
+  assert.equal(length, 2);
+  const next = await f.history.assemble([user("one"), user("two"), state("enabled")], "ordinary", f.ctx, (messages) => {
+    length = messages.length;
+  });
+  assert.equal(length, 4);
+  assert.deepEqual(next.slice(0, first.length), first);
+  assert.match(next.at(-1).content, /warning cleared/);
+});
+
+test("ending a restoration obligation retains already admitted communication until context changes", async () => {
+  const f = fixture();
+  const first = await f.history.assemble(
+    [user("one"), communication("accepted report"), state("active")],
+    "ordinary",
+    f.ctx,
+  );
+  const closed = await f.history.assemble([user("one"), user("two"), state("closed")], "ordinary", f.ctx);
+  assert.deepEqual(closed.slice(0, first.length), first);
+  const again = await f.history.assemble(
+    [user("one"), user("two"), communication("accepted report"), state("closed")],
+    "ordinary",
+    f.ctx,
+  );
+  assert.equal(again.filter((message) => message.content === "accepted report").length, 1);
+});