@hassangameryt/freeflow 0.7.1 → 0.7.3

package/pi-extension/dist/settings/settings-ui.js

@@ -11,8 +11,8 @@ import {
   setSessionCoreOverride,
 } from "../runtime/runtime-context.js";
 import { PiSettingsComponent } from "./settings-tui.js";
-import { supportsPiSessionModelStateApi } from "../cognitive-routing/pi-session-control.js";
 import { isPiFlowHost } from "../runtime/runtime-identity.js";
+import { isWorkerProfile, workersForDelegation } from "../cognitive-routing-v2/types.js";
 const DEFAULT_FREEFLOW_ENABLED = true;
 const DEFAULT_CONTEXT_VIRTUALIZATION_ENABLED = false;
 const DEFAULT_CONVERSATION_HISTORY_ENABLED = false;
@@ -102,7 +102,7 @@ function effectiveItemValue(item) {
 function formatCoreValue(value) {
   if (typeof value === "boolean") return booleanValue(value);
   if (isRecord(value) && typeof value.provider === "string" && typeof value.model === "string") {
-    const effort = typeof value.thinkingLevel === "string" ? ` · ${value.thinkingLevel}` : "";
+    const effort = typeof value.thinking === "string" ? ` · ${value.thinking}` : "";
     return `${value.provider}/${value.model}${effort}`;
   }
   return String(value ?? "");
@@ -192,6 +192,68 @@ function createScopedBooleanItem(options) {
   item.displaySuffix = coreDisplaySuffix(item);
   return item;
 }
+function createScopedDelegationItem(options) {
+  const path = ["cognitiveRouting", "delegation"];
+  const repositoryValue = getPath(options.rawConfig, path);
+  const inheritedValue = ["executor", "helper", "both"].includes(repositoryValue) ? repositoryValue : "executor";
+  const inheritedSource = 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 =
+    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) ? 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) ? localValue : undefined,
+        };
+  item.displaySuffix = coreDisplaySuffix(item);
+  return item;
+}
 function resolveSettingsCoreView(rawConfig, layers) {
   const localConfig = layers?.local.valid && isRecord(layers.local.parsed) ? layers.local.parsed : {};
   const fallbackCore = {
@@ -248,7 +310,7 @@ function createSessionBooleanItem(options) {
   item.displaySuffix = coreDisplaySuffix(item);
   return item;
 }
-function sessionFreeflowItems(state, cognitiveRoutingController) {
+function sessionFreeflowItems(state, cognitiveRoutingController, ctx) {
   const sessionOverrides = state.sessionOverrides;
   const configured = state.configuredCoreConfig;
   const configuredSources = state.configuredSources;
@@ -290,47 +352,76 @@ function sessionFreeflowItems(state, cognitiveRoutingController) {
   contextVirtualizationItem.inactive = freeflowInactive;
   conversationHistoryItem.inactive = freeflowInactive;
   const cognitiveRoutingState = cognitiveRoutingController?.state();
-  const cognitiveRoutingProfile =
-    cognitiveRoutingState?.controlMode === "manual-standard"
-      ? "standard"
-      : cognitiveRoutingState?.controlMode === "manual-reasoning"
-        ? "reasoning"
-        : "auto";
+  const delegation = state.cognitiveRouting?.delegation ?? "executor";
+  const heldProfile = cognitiveRoutingState?.controlMode.startsWith("manual-")
+    ? cognitiveRoutingState.activeProfile
+    : undefined;
+  const availableProfiles = ["coordinator", ...workersForDelegation(delegation)];
+  if (heldProfile === "coordinator" || isWorkerProfile(heldProfile)) availableProfiles.push(heldProfile);
+  const manualProfiles = [...new Set(availableProfiles)];
+  const cognitiveRoutingProfile = heldProfile && manualProfiles.includes(heldProfile) ? heldProfile : "auto";
   const cognitiveRoutingItem = 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", "standard", "reasoning"],
-        valueLabels: {
-          auto: "automatic",
-          standard: "manual · standard",
-          reasoning: "manual · reasoning",
-        },
-        valueDescriptions: {
-          auto: "Release the manual hold without forcing a model transition.",
-          standard: "Hold the standard profile until /freeflow profile auto.",
-          reasoning: "Hold the reasoning 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,
+            ctx,
+            sessionProfiles,
+          }),
+        )
+      : [];
+  const cognitiveRoutingPresets = 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,
     },
@@ -363,8 +454,8 @@ function isCognitiveRoutingProfile(value) {
     isRecord(value) &&
     typeof value.provider === "string" &&
     typeof value.model === "string" &&
-    typeof value.thinkingLevel === "string" &&
-    COGNITIVE_ROUTING_THINKING_LEVELS.includes(value.thinkingLevel)
+    typeof value.thinking === "string" &&
+    COGNITIVE_ROUTING_THINKING_LEVELS.includes(value.thinking)
   );
 }
 function cognitiveRoutingThinkingLevels(model, registry) {
@@ -413,12 +504,14 @@ function cognitiveRoutingProfileDisplay(value) {
   return isCognitiveRoutingProfile(value) ? formatCoreValue(value) : "not configured";
 }
 function cognitiveRoutingSettingsSource(source) {
+  if (source === "session") return "session";
   if (source === "repository") return "repository";
   if (source === "personal" || source === "local") return "local";
   return "builtin";
 }
 function cognitiveRoutingProfileDisplaySuffix(source, scope) {
   if (!source) return undefined;
+  if (source === "session") return "(session override)";
   if (source === "personal" && scope === "repository") return "(effective personal)";
   return `(${source})`;
 }
@@ -437,7 +530,16 @@ function cognitiveRoutingConfirmStep(summary) {
     selectedKey: "__save__",
   };
 }
-function createCognitiveRoutingProfileWizard(currentValue, models, allowInherit) {
+function createCognitiveRoutingProfileWizard(
+  currentValue,
+  models,
+  allowInherit,
+  inheritChoice = {
+    label: "Inherit repository preset",
+    description: "Remove the personal override without changing the repository preset.",
+    summary: "inherit repository preset",
+  },
+) {
   const currentProfile = isCognitiveRoutingProfile(currentValue) ? currentValue : undefined;
   const currentModelKey = currentProfile
     ? cognitiveRoutingModelKey(currentProfile.provider, currentProfile.model)
@@ -448,8 +550,8 @@ function createCognitiveRoutingProfileWizard(currentValue, models, allowInherit)
           {
             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,
           },
         ]
       : []),
@@ -483,12 +585,11 @@ function createCognitiveRoutingProfileWizard(currentValue, models, allowInherit)
       if (selectedValues.length === 1) {
         const selected = selectedValues[0];
         if (selected === LOCAL_INHERIT) {
-          return cognitiveRoutingConfirmStep("inherit repository preset");
+          return cognitiveRoutingConfirmStep(inheritChoice.summary);
         }
         const model = selected;
         if (!model?.key || model.thinkingLevels.length === 0) return undefined;
-        const currentEffort =
-          currentProfile && currentModelKey === model.key ? currentProfile.thinkingLevel : undefined;
+        const currentEffort = currentProfile && currentModelKey === model.key ? currentProfile.thinking : undefined;
         return {
           title: `Choose effort · ${model.label}`,
           choices: model.thinkingLevels.map((level) => ({
@@ -514,7 +615,7 @@ function createCognitiveRoutingProfileWizard(currentValue, models, allowInherit)
       return {
         provider: model.provider,
         model: model.model,
-        thinkingLevel: selectedValues[1],
+        thinking: selectedValues[1],
       };
     },
   };
@@ -523,120 +624,71 @@ function cognitiveRoutingProfileItem(options) {
   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),
   };
 }
-function cognitiveRoutingSessionStartItem(options) {
-  const path = ["cognitiveRouting", "sessionStart", options.setting];
-  const defaultValue = options.setting === "control" ? "automatic" : "reasoning";
-  const values = options.setting === "control" ? ["automatic", "manual"] : ["standard", "reasoning"];
-  const labels = Object.fromEntries(values.map((value) => [value, value]));
-  const descriptions =
-    options.setting === "control"
-      ? {
-          automatic: "Start the new session in Reasoning; automatic delegation may use Standard during execution.",
-          manual: "Hold the selected profile for the new session until the user changes it.",
-        }
-      : {
-          standard: "Start a new manual session with the configured Standard preset.",
-          reasoning: "Start a new manual session with the configured Reasoning preset.",
-        };
-  const repositoryValue = getPath(options.rawConfig, path);
-  const localValue = getPath(options.localConfig, path);
-  const isValidValue = (value) => values.includes(value);
-  const repositorySetting = isValidValue(repositoryValue) ? repositoryValue : undefined;
-  const localSetting = isValidValue(localValue) ? localValue : undefined;
-  const inheritedValue = repositorySetting ?? defaultValue;
-  const inheritedSource = repositorySetting ? "repository" : "builtin";
-  const configuredSource =
-    options.capabilityState?.sessionStartSources?.[options.setting] ?? (repositorySetting ? "repository" : undefined);
-  const effectiveSessionStartControl =
-    options.capabilityState?.sessionStart?.control ??
-    getPath(options.localConfig, ["cognitiveRouting", "sessionStart", "control"]) ??
-    getPath(options.rawConfig, ["cognitiveRouting", "sessionStart", "control"]) ??
-    "automatic";
-  const effectiveValue =
-    options.setting === "profile" && effectiveSessionStartControl === "automatic"
-      ? "reasoning"
-      : (options.capabilityState?.sessionStart?.[options.setting] ?? inheritedValue);
-  const effectiveSource = cognitiveRoutingSettingsSource(configuredSource);
-  const label = options.setting === "control" ? "Session start control" : "Manual session-start profile";
-  const description =
-    options.setting === "control"
-      ? "Choose automatic or manual control for new sessions only; changing this does not alter the active session."
-      : "Choose the profile for manual session starts; automatic sessions always start in Reasoning.";
-  const item =
-    options.scope === "local"
-      ? {
-          id: `freeflow.cognitiveRouting.sessionStart.${options.setting}`,
-          label,
-          description: `${description} Choose inherit to use the repository value; use /freeflow settings repo to edit shared defaults.`,
-          path,
-          kind: "enum",
-          value: localSetting ?? LOCAL_INHERIT,
-          values: [LOCAL_INHERIT, ...values],
-          valueLabels: { inherit: "Inherit repository", ...labels },
-          valueDescriptions: {
-            inherit: `Use ${inheritedValue} from ${inheritedSource}.`,
-            ...descriptions,
-          },
-          format: (value) => String(value),
-          configScope: "local",
-          configValues: { inherit: undefined },
-          effectiveValue,
-          effectiveSource,
-          inheritedValue,
-          inheritedSource,
-        }
-      : {
-          id: `freeflow.cognitiveRouting.sessionStart.${options.setting}`,
-          label,
-          description: `${description} This edits shared .freeflow/config.json.`,
-          path,
-          kind: "enum",
-          value: inheritedValue,
-          values,
-          valueLabels: labels,
-          valueDescriptions: descriptions,
-          format: (value) => String(value),
-          defaultValue,
-          configScope: "repository",
-          effectiveValue,
-          effectiveSource,
-          localOverrideValue: localSetting,
-        };
-  item.displaySuffix = coreDisplaySuffix(item);
-  return item;
-}
 function isCognitiveRoutingRuntimeAvailable(pi) {
-  return isPiFlowHost(pi?.host) || supportsPiSessionModelStateApi(pi);
+  return (
+    !isPiFlowHost(pi?.host) &&
+    typeof pi?.appendEntry === "function" &&
+    typeof pi?.setModel === "function" &&
+    typeof pi?.setThinkingLevel === "function"
+  );
 }
 function freeflowItems(rawConfig, options = {}) {
-  const scope = options.scope ?? "repository";
+  const scope = options.scope === "local" ? "local" : "repository";
   const layers = options.layers;
   const { localConfig, core, sources } = resolveSettingsCoreView(rawConfig, layers);
   const freeflowItem = createScopedBooleanItem({
@@ -689,7 +741,7 @@ function freeflowItems(rawConfig, options = {}) {
       label: "Enabled",
       description: cognitiveRoutingRuntimeDisabled
         ? "Requires a host model-state control API; configuration is read-only on this host."
-        : "Allow Cognitive Routing to own the session model lease and switch the configured profiles.",
+        : "Allow Cognitive Routing to manage explicit assignments and request native profile transitions.",
       path: ["cognitiveRouting", "enabled"],
       effectiveValue: cognitiveRoutingState?.enabled ?? false,
       effectiveSource: cognitiveRoutingSettingsSource(cognitiveRoutingState?.enabledSource),
@@ -697,7 +749,31 @@ function freeflowItems(rawConfig, options = {}) {
     });
     cognitiveRoutingEnabledItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
     cognitiveRoutingEnabledItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
-    const cognitiveRoutingProfiles = ["standard", "reasoning"].map((name) =>
+    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,
+      localConfig,
+      id: "freeflow.cognitiveRouting.projection",
+      label: "Context projection",
+      description:
+        "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),
+      defaultValue: false,
+    });
+    cognitiveRoutingProjectionItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
+    cognitiveRoutingProjectionItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
+    const cognitiveRoutingProfiles = ["coordinator", "helper", "executor"].map((name) =>
       cognitiveRoutingProfileItem({
         name: name,
         scope,
@@ -707,16 +783,7 @@ function freeflowItems(rawConfig, options = {}) {
         ctx: options.ctx,
       }),
     );
-    const cognitiveRoutingSessionStart = ["control", "profile"].map((setting) =>
-      cognitiveRoutingSessionStartItem({
-        setting,
-        scope,
-        rawConfig,
-        localConfig,
-        capabilityState: cognitiveRoutingState,
-      }),
-    );
-    for (const item of [...cognitiveRoutingProfiles, ...cognitiveRoutingSessionStart]) {
+    for (const item of cognitiveRoutingProfiles) {
       item.inactive ||= freeflowInactive || cognitiveRoutingRuntimeDisabled;
       item.runtimeInactive = cognitiveRoutingRuntimeDisabled;
     }
@@ -734,12 +801,17 @@ function freeflowItems(rawConfig, options = {}) {
       label: "Cognitive Routing",
       description: cognitiveRoutingRuntimeDisabled
         ? "Cognitive Routing configuration is visible for inspection but requires a host model-state control API."
-        : "Configure the Standard and Reasoning 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",
       value: cognitiveRoutingRuntimeDisabled ? false : (cognitiveRoutingState?.enabled ?? false),
       inactive: freeflowInactive,
       displaySuffix: cognitiveRoutingStatus,
-      children: [cognitiveRoutingEnabledItem, ...cognitiveRoutingProfiles, ...cognitiveRoutingSessionStart],
+      children: [
+        cognitiveRoutingEnabledItem,
+        cognitiveRoutingDelegationItem,
+        ...cognitiveRoutingProfiles,
+        cognitiveRoutingProjectionItem,
+      ],
     };
   })();
   return [
@@ -761,6 +833,7 @@ function pruneKnownDefaults(config) {
     { 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) {
     if (valuesEqual(getPath(config, item.path), item.value)) {
@@ -834,7 +907,7 @@ async function updateConfig(cwd, item, value, scope = item.configScope ?? "repos
   await writeFile(join(cwd, ".freeflow/config.json"), `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }
 function isCognitiveRoutingProfileItem(item) {
-  return item.id === "freeflow.cognitiveRouting.standard" || item.id === "freeflow.cognitiveRouting.reasoning";
+  return ["coordinator", "helper", "executor"].some((profile) => item.id === `freeflow.cognitiveRouting.${profile}`);
 }
 function valueForDisplay(item) {
   let value;
@@ -874,10 +947,11 @@ function refreshSettingsDerivedState(items) {
   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.standard"),
-    findSettingsItem(items, "freeflow.cognitiveRouting.reasoning"),
-  ];
+  const cognitiveRoutingDelegationItem = findSettingsItem(items, "freeflow.cognitiveRouting.delegation");
+  const delegation = cognitiveRoutingDelegationItem ? effectiveItemValue(cognitiveRoutingDelegationItem) : "executor";
+  const cognitiveRoutingProfiles = ["coordinator", ...workersForDelegation(delegation)].map((profile) =>
+    findSettingsItem(items, `freeflow.cognitiveRouting.${profile}`),
+  );
   if (cognitiveRoutingGroup && cognitiveRoutingEnabledItem) {
     const enabled = effectiveItemValue(cognitiveRoutingEnabledItem) === true;
     const profilesConfigured = cognitiveRoutingProfiles.every((item) =>
@@ -1152,7 +1226,7 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
   let reconcileCognitiveRouting = settingsScope === "session";
   const items =
     settingsScope === "session"
-      ? sessionFreeflowItems(state, cognitiveRoutingController)
+      ? sessionFreeflowItems(state, cognitiveRoutingController, ctx)
       : freeflowItems(raw, {
           scope: settingsScope,
           layers,
@@ -1195,8 +1269,61 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
         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);
+        const override =
+          value === undefined || value === LOCAL_INHERIT
+            ? null
+            : {
+                provider: value.provider,
+                modelId: value.model,
+                thinking: value.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/src/cognitive-routing-v2/budget.ts

@@ -0,0 +1,42 @@
+// A local planning estimate, not a provider token count or an output allocation.
+// In particular, base64 and native usage/metadata are not model text.
+export function estimateRequest(systemPrompt: string, tools: readonly any[], messages: readonly any[], model: any) {
+  const text = (value: string) => Math.ceil(value.length / 3);
+  const content = (value: any): number =>
+    typeof value === "string"
+      ? text(value)
+      : Array.isArray(value)
+        ? value.reduce(
+            (sum, b) =>
+              sum +
+              (b.type === "image"
+                ? 1200
+                : b.type === "toolCall"
+                  ? text(b.name + JSON.stringify(b.arguments ?? {}))
+                  : b.type === "thinking"
+                    ? text(b.thinking ?? "")
+                    : text(b.text ?? "")),
+            0,
+          )
+        : 0;
+  const estimatedTokens =
+    text(systemPrompt) +
+    text(JSON.stringify(tools.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters })))) +
+    messages.reduce((sum, m) => sum + 8 + content(m.content), 0);
+  const window = model?.contextWindow ?? 0;
+  const outputReserve = Math.min(4096, Math.max(1, Math.floor(window / 10)));
+  const maximumInputTokens = Math.max(0, window - outputReserve);
+  const estimateMethod =
+    "Planning estimate: text characters / 3, 1200 tokens/image, schemas and message framing; output headroom is not the provider allocation";
+  const warnings =
+    estimatedTokens > maximumInputTokens
+      ? [
+          {
+            ref: "",
+            code: "budget_estimate",
+            detail: `Estimated input ${estimatedTokens} exceeds planning allowance ${maximumInputTokens}. Actual output allocation and image tokenization are provider-dependent; fit is unconfirmed. Use native compaction or revise explicitly if the provider rejects the request.`,
+          },
+        ]
+      : [];
+  return { estimatedTokens, maximumInputTokens, outputReserve, estimateMethod, warnings };
+}