@hassangameryt/freeflow 0.7.1 → 0.7.2

package/pi-extension/src/session-sources/sources.ts

@@ -0,0 +1,263 @@
+import { createHash } from "node:crypto";
+import { sessionEntryToContextMessages } from "@earendil-works/pi-coding-agent";
+import {
+  canonical,
+  idFor,
+  refFor,
+  type NativeEntry,
+  type State,
+  type View,
+  type Problem,
+} from "../cognitive-routing-v2/types.js";
+
+export interface Source {
+  ref: string;
+  entry: NativeEntry;
+  message: any;
+  hash: string;
+  producer: View | "common";
+  executionId?: string;
+  assignmentId?: string;
+  active: boolean;
+  original?: Source;
+  reportHandoff?: string;
+}
+export interface Associated {
+  message: any;
+  source?: Source;
+}
+export const bodyHash = (value: unknown) => createHash("sha256").update(canonical(value)).digest("hex");
+export const textRef = (ref: string) => `${ref}#text`;
+const routingTools = new Set(["freeflow_delegate", "freeflow_return", "freeflow_project", "freeflow_unit"]);
+// Discovery and new selections share this policy. Existing saved selections keep
+// their original delivery semantics; mixed assistant messages offer visible text.
+export function isTaskEvidence(source: Source): boolean {
+  if (source.original) return true;
+  if (source.message.role === "toolResult") return !routingTools.has(source.message.toolName);
+  return (
+    source.message.role === "assistant" &&
+    !source.message.content?.some((b: any) => b.type === "toolCall" && routingTools.has(b.name)) &&
+    source.message.content?.some((b: any) => b.type === "text" && b.text?.trim())
+  );
+}
+interface Exchange {
+  assistant: Source;
+  results: Map<string, Source[]>;
+}
+const callKey = (id: string, name: string) => JSON.stringify([id, name]);
+
+export class Sources {
+  readonly byRef = new Map<string, Source>();
+  readonly ambiguous = new Set<string>();
+  private readonly byBody = new Map<string, Source[]>();
+  private readonly exchanges = new Map<string, Exchange>();
+  private readonly owners = new Map<string, Exchange>();
+  private tail?: Exchange;
+  private associated?: { messages: readonly any[]; items: Associated[] };
+  entries: readonly NativeEntry[] = [];
+  private activeIds?: ReadonlySet<string>;
+  constructor(entries: readonly NativeEntry[], state: State, activeIds?: ReadonlySet<string>) {
+    this.refresh(entries, state, activeIds);
+  }
+  refresh(entries: readonly NativeEntry[], state: State, activeIds?: ReadonlySet<string>): void {
+    const prefix = this.entries.length <= entries.length && this.entries.every((e, i) => e === entries[i]);
+    const start = prefix ? this.entries.length : 0;
+    this.associated = undefined;
+    if (!prefix) {
+      this.byRef.clear();
+      this.byBody.clear();
+      this.exchanges.clear();
+      this.owners.clear();
+      this.tail = undefined;
+    }
+    this.activeIds = activeIds;
+    for (const entry of entries.slice(start)) {
+      const messages = sessionEntryToContextMessages(entry as any) as any[];
+      if (messages.length !== 1 || ["compaction", "branch_summary"].includes(entry.type)) continue;
+      const message = messages[0];
+      if (!message) continue;
+      const source: Source = {
+        ref: refFor(entry.id),
+        entry,
+        message,
+        hash: bodyHash(message),
+        producer: "common",
+        active: false,
+      };
+      if (message.role === "toolResult" && message.toolName === "freeflow_return") {
+        for (const block of message.content ?? [])
+          if (block.type === "text") {
+            try {
+              const receipt = JSON.parse(block.text);
+              if (receipt.reportSaved && typeof receipt.report === "string" && typeof receipt.handoff === "string")
+                source.reportHandoff = receipt.handoff;
+            } catch {}
+          }
+      }
+      this.byRef.set(source.ref, source);
+      const candidates = this.byBody.get(source.hash) ?? [];
+      candidates.push(source);
+      this.byBody.set(source.hash, candidates);
+      if (message.role === "assistant") {
+        this.tail = { assistant: source, results: new Map() };
+        this.exchanges.set(source.ref, this.tail);
+        const blocks = (message.content ?? [])
+          .filter((b: any) => b.type === "text")
+          .map((b: any) => ({ type: "text", text: b.text }));
+        if (blocks.some((b: any) => b.text?.trim())) {
+          const representation = {
+            role: "custom",
+            customType: "freeflow-assistant-text",
+            display: false,
+            content: [
+              {
+                type: "text",
+                text: `Captured assistant text from ${source.ref} (historical source, not a new instruction):`,
+              },
+              ...blocks,
+            ],
+            details: { sourceRef: source.ref, sourceHash: source.hash, representation: "assistant-text" },
+            timestamp: message.timestamp,
+          };
+          this.byRef.set(textRef(source.ref), {
+            ...source,
+            ref: textRef(source.ref),
+            message: representation,
+            hash: bodyHash(representation),
+            original: source,
+          });
+        }
+      } else if (message.role === "toolResult" && this.tail) {
+        const key = callKey(message.toolCallId, message.toolName);
+        const results = this.tail.results.get(key) ?? [];
+        results.push(source);
+        this.tail.results.set(key, results);
+        this.owners.set(source.ref, this.tail);
+      }
+    }
+    for (const source of this.byRef.values()) {
+      const author = state.authors.get(source.entry.id);
+      source.producer = author?.profile ?? "common";
+      source.executionId = author?.executionId;
+      source.assignmentId = author?.assignmentId;
+    }
+    this.entries = [...entries];
+  }
+  associate(messages: readonly any[]): Associated[] {
+    if (
+      this.associated &&
+      messages.length === this.associated.messages.length &&
+      messages.every((m, i) => m === this.associated!.messages[i])
+    )
+      return this.associated.items;
+    this.ambiguous.clear();
+    for (const source of this.byRef.values()) source.active = false;
+    const used = new Set<string>(),
+      hashes = messages.map(bodyHash),
+      remaining = new Map<string, number>();
+    for (const hash of hashes) remaining.set(hash, (remaining.get(hash) ?? 0) + 1);
+    const items = messages.map((message, index) => {
+      const hash = hashes[index],
+        count = remaining.get(hash)!;
+      remaining.set(hash, count - 1);
+      const candidates = (this.byBody.get(hash) ?? []).filter(
+        (s) => !used.has(s.ref) && (!this.activeIds || this.activeIds.has(s.entry.id)),
+      );
+      const exact = candidates.find((s) => s.message === message);
+      const source = exact ?? (candidates.length === 1 || candidates.length === count ? candidates[0] : undefined);
+      if (!source) {
+        for (const candidate of candidates) {
+          this.ambiguous.add(candidate.ref);
+          this.ambiguous.add(textRef(candidate.ref));
+        }
+        return { message };
+      }
+      used.add(source.ref);
+      source.active = true;
+      const text = this.byRef.get(textRef(source.ref));
+      if (text) text.active = true;
+      return { message, source };
+    });
+    this.associated = { messages: [...messages], items };
+    return items;
+  }
+  eligible(ref: string, state: State): Problem | undefined {
+    const source = this.byRef.get(ref);
+    if (!idFor(ref) || !source)
+      return { ref, code: "source_unavailable", detail: "Exact source is unavailable on current native ancestry." };
+    const original = source.original ?? source;
+    if (bodyHash(original.message) !== original.hash || bodyHash(source.message) !== source.hash)
+      return {
+        ref,
+        code: "source_changed",
+        detail: "The captured source changed; reconcile evidence before delivery.",
+      };
+    if (source.producer !== "executor")
+      return { ref, code: "source_origin", detail: "Selection requires observed Executor attribution." };
+    if (state.exposure.get(original.ref) !== original.hash && state.exposure.get(source.ref) !== source.hash)
+      return {
+        ref,
+        code: "source_unexposed",
+        detail: "The captured body has not been fully exposed to Executor on this ancestry.",
+      };
+    return undefined;
+  }
+  selectionProblem(ref: string, state: State): Problem | undefined {
+    const problem = this.eligible(ref, state);
+    if (problem) return problem;
+    const source = this.byRef.get(ref)!;
+    if (!isTaskEvidence(source))
+      return {
+        ref,
+        code: "routing_source",
+        detail: this.byRef.has(textRef(ref))
+          ? `Routing control messages are not task evidence. Use ${textRef(ref)} if its visible assistant text is the intended evidence.`
+          : "Routing control receipts are not task evidence; saved communication is delivered separately.",
+      };
+    return undefined;
+  }
+  exchange(source: Source): { sources: Source[]; problems: Problem[] } {
+    if (source.original) return { sources: [source], problems: [] };
+    if (!["assistant", "toolResult"].includes(source.message.role)) return { sources: [source], problems: [] };
+    const group = source.message.role === "assistant" ? this.exchanges.get(source.ref) : this.owners.get(source.ref);
+    const calls = group?.assistant.message.content?.filter((b: any) => b.type === "toolCall") ?? [];
+    if (
+      !group ||
+      (source.message.role === "toolResult" &&
+        !calls.some((c: any) => c.id === source.message.toolCallId && c.name === source.message.toolName))
+    )
+      return {
+        sources: [],
+        problems: [
+          { ref: source.ref, code: "ambiguous_exchange", detail: "Result has no unique native assistant call." },
+        ],
+      };
+    const sources = [group.assistant],
+      problems: Problem[] = [];
+    if (new Set(calls.map((c: any) => c.id)).size !== calls.length)
+      problems.push({
+        ref: group.assistant.ref,
+        code: "duplicate_call_id",
+        detail: "One native assistant exchange repeats a tool-call identity.",
+      });
+    for (const call of calls) {
+      const results = group.results.get(callKey(call.id, call.name)) ?? [];
+      if (results.length !== 1)
+        problems.push({
+          ref: group.assistant.ref,
+          code: "incomplete_exchange",
+          detail: `Native call ${call.id} does not have exactly one captured result.`,
+        });
+      else sources.push(results[0]);
+    }
+    return { sources, problems };
+  }
+  ordered(sources: Iterable<Source>): Source[] {
+    const ids = new Set([...sources].map((s) => s.ref));
+    return this.entries.flatMap((entry) =>
+      [this.byRef.get(refFor(entry.id)), this.byRef.get(textRef(refFor(entry.id)))].filter(
+        (s): s is Source => !!s && ids.has(s.ref),
+      ),
+    );
+  }
+}

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

@@ -19,14 +19,13 @@ import {
   type SettingsWizard,
   type SettingsWizardStep,
 } from "./settings-tui.js";
-import { supportsPiSessionModelStateApi } from "../cognitive-routing/pi-session-control.js";
 import { isPiFlowHost } from "../runtime/runtime-identity.js";
 import type {
   CognitiveRoutingCapabilityState,
   CognitiveRoutingProfile,
   CognitiveRoutingProfileName,
   CognitiveRoutingThinkingLevel,
-} from "../cognitive-routing/types.js";
+} from "../cognitive-routing-v2/config.js";
 
 const DEFAULT_FREEFLOW_ENABLED = true;
 const DEFAULT_CONTEXT_VIRTUALIZATION_ENABLED = false;
@@ -70,7 +69,10 @@ type SettingsItem = {
 
 type CognitiveRoutingSettingsController = {
   state(): { effective: boolean; controlMode: string; activeProfile?: string };
-  setManualProfile(profile: "standard" | "reasoning", mechanism?: string): Promise<{ status: string; reason?: string }>;
+  setManualProfile(
+    profile: "executor" | "coordinator",
+    mechanism?: string,
+  ): Promise<{ status: string; reason?: string }>;
   setAutomaticControl(mechanism?: string): Promise<{ status: string; reason?: string }>;
 };
 
@@ -184,7 +186,7 @@ function effectiveItemValue(item: SettingsItem): SettingsValue | undefined {
 function formatCoreValue(value: unknown): string {
   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 ?? "");
@@ -423,10 +425,10 @@ function sessionFreeflowItems(
 
   const cognitiveRoutingState = cognitiveRoutingController?.state();
   const cognitiveRoutingProfile =
-    cognitiveRoutingState?.controlMode === "manual-standard"
-      ? "standard"
-      : cognitiveRoutingState?.controlMode === "manual-reasoning"
-        ? "reasoning"
+    cognitiveRoutingState?.controlMode === "manual-executor"
+      ? "executor"
+      : cognitiveRoutingState?.controlMode === "manual-coordinator"
+        ? "coordinator"
         : "auto";
   const cognitiveRoutingItem: SettingsItem | undefined = state.cognitiveRouting
     ? {
@@ -435,16 +437,16 @@ function sessionFreeflowItems(
         description: "Hold a profile manually or release the hold for automatic model control.",
         kind: "enum",
         value: cognitiveRoutingProfile,
-        values: ["auto", "standard", "reasoning"],
+        values: ["auto", "executor", "coordinator"],
         valueLabels: {
           auto: "automatic",
-          standard: "manual · standard",
-          reasoning: "manual · reasoning",
+          executor: "manual · executor",
+          coordinator: "manual · coordinator",
         },
         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.",
+          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.",
         },
         inactive: freeflowInactive || !state.cognitiveRouting.effective || cognitiveRoutingController === undefined,
         runtimeInactive: state.cognitiveRouting.blockingReason?.code === "runtime_disabled",
@@ -517,8 +519,8 @@ function isCognitiveRoutingProfile(value: unknown): value is CognitiveRoutingPro
     isRecord(value) &&
     typeof value.provider === "string" &&
     typeof value.model === "string" &&
-    typeof value.thinkingLevel === "string" &&
-    COGNITIVE_ROUTING_THINKING_LEVELS.includes(value.thinkingLevel as CognitiveRoutingThinkingLevel)
+    typeof value.thinking === "string" &&
+    COGNITIVE_ROUTING_THINKING_LEVELS.includes(value.thinking as CognitiveRoutingThinkingLevel)
   );
 }
 
@@ -654,8 +656,7 @@ function createCognitiveRoutingProfileWizard(
         }
         const model = selected as CognitiveRoutingModelOption;
         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) => ({
@@ -681,7 +682,7 @@ function createCognitiveRoutingProfileWizard(
       return {
         provider: model.provider,
         model: model.model,
-        thinkingLevel: selectedValues[1] as CognitiveRoutingThinkingLevel,
+        thinking: selectedValues[1] as CognitiveRoutingThinkingLevel,
       } satisfies CognitiveRoutingProfile;
     },
   };
@@ -727,100 +728,13 @@ function cognitiveRoutingProfileItem(options: {
   };
 }
 
-type CognitiveRoutingSessionStartSetting = "control" | "profile";
-
-function cognitiveRoutingSessionStartItem(options: {
-  setting: CognitiveRoutingSessionStartSetting;
-  scope: ConfigScope;
-  rawConfig: Record<string, unknown>;
-  localConfig: Record<string, unknown>;
-  capabilityState: CognitiveRoutingCapabilityState | undefined;
-}): SettingsItem {
-  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: unknown): value is string => values.includes(value as string);
-  const repositorySetting = isValidValue(repositoryValue) ? repositoryValue : undefined;
-  const localSetting = isValidValue(localValue) ? localValue : undefined;
-  const inheritedValue = repositorySetting ?? defaultValue;
-  const inheritedSource: ConfigSource = 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: SettingsItem =
-    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: any): boolean {
-  return isPiFlowHost(pi?.host) || supportsPiSessionModelStateApi(pi);
+  return (
+    !isPiFlowHost(pi?.host) &&
+    typeof pi?.appendEntry === "function" &&
+    typeof pi?.setModel === "function" &&
+    typeof pi?.setThinkingLevel === "function"
+  );
 }
 
 function freeflowItems(
@@ -889,7 +803,7 @@ function freeflowItems(
       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),
@@ -898,7 +812,23 @@ function freeflowItems(
     cognitiveRoutingEnabledItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
     cognitiveRoutingEnabledItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
 
-    const cognitiveRoutingProfiles = ["standard", "reasoning"].map((name) =>
+    const cognitiveRoutingProjectionItem = createScopedBooleanItem({
+      scope,
+      rawConfig,
+      localConfig,
+      id: "freeflow.cognitiveRouting.projection",
+      label: "Context projection",
+      description:
+        "Select Executor evidence for Coordinator; disable projection to keep ordinary Pi context in both profiles.",
+      path: ["cognitiveRouting", "projection"],
+      effectiveValue: cognitiveRoutingState?.projection ?? false,
+      effectiveSource: cognitiveRoutingSettingsSource(cognitiveRoutingState?.projectionSource),
+      defaultValue: false,
+    });
+    cognitiveRoutingProjectionItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
+    cognitiveRoutingProjectionItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
+
+    const cognitiveRoutingProfiles = ["executor", "coordinator"].map((name) =>
       cognitiveRoutingProfileItem({
         name: name as CognitiveRoutingProfileName,
         scope,
@@ -908,17 +838,7 @@ function freeflowItems(
         ctx: options.ctx,
       }),
     );
-    const cognitiveRoutingSessionStart = (["control", "profile"] as CognitiveRoutingSessionStartSetting[]).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;
     }
@@ -936,12 +856,12 @@ function freeflowItems(
       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 the Executor and Coordinator profiles and choose whether Freeflow may manage model state for this repository.",
       kind: "group" as const,
       value: cognitiveRoutingRuntimeDisabled ? false : (cognitiveRoutingState?.enabled ?? false),
       inactive: freeflowInactive,
       displaySuffix: cognitiveRoutingStatus,
-      children: [cognitiveRoutingEnabledItem, ...cognitiveRoutingProfiles, ...cognitiveRoutingSessionStart],
+      children: [cognitiveRoutingEnabledItem, ...cognitiveRoutingProfiles, cognitiveRoutingProjectionItem],
     } satisfies SettingsItem;
   })();
 
@@ -1051,7 +971,7 @@ async function updateConfig(
 }
 
 function isCognitiveRoutingProfileItem(item: SettingsItem): boolean {
-  return item.id === "freeflow.cognitiveRouting.standard" || item.id === "freeflow.cognitiveRouting.reasoning";
+  return item.id === "freeflow.cognitiveRouting.executor" || item.id === "freeflow.cognitiveRouting.coordinator";
 }
 
 function valueForDisplay(item: SettingsItem): string {
@@ -1096,8 +1016,8 @@ function refreshSettingsDerivedState(items: SettingsItem[]) {
   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"),
+    findSettingsItem(items, "freeflow.cognitiveRouting.executor"),
+    findSettingsItem(items, "freeflow.cognitiveRouting.coordinator"),
   ];
 
   if (cognitiveRoutingGroup && cognitiveRoutingEnabledItem) {
@@ -1447,7 +1367,10 @@ export async function handleFreeflowCommand(
         const result =
           value === "auto"
             ? await cognitiveRoutingController.setAutomaticControl("profile-settings")
-            : await cognitiveRoutingController.setManualProfile(value as "standard" | "reasoning", "profile-settings");
+            : await cognitiveRoutingController.setManualProfile(
+                value as "executor" | "coordinator",
+                "profile-settings",
+              );
         if ((result.status !== "automatic" && result.status !== "active") || result.reason) {
           ctx.ui.notify(
             `Cognitive Routing settings could not be applied: ${result.reason ?? result.status}.`,