@hassangameryt/freeflow 0.6.0 → 0.7.0

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

@@ -3,35 +3,19 @@ import { appendFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import {
-  handleModeCommand,
   readCapabilityState,
   readFreeflowConfig,
   readFreeflowConfigLayers,
   readFreeflowLocalConfig,
-  readModeState,
   resetSessionOverrides,
   setSessionCoreOverride,
-  VALID_MODES,
 } 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";
 const DEFAULT_FREEFLOW_ENABLED = true;
-const DEFAULT_INTERACTION_CONTRACT_ENABLED = true;
-const DEFAULT_SKILLS_ENABLED = true;
 const DEFAULT_CONTEXT_VIRTUALIZATION_ENABLED = false;
 const DEFAULT_CONVERSATION_HISTORY_ENABLED = false;
-const MODE_VALUES = ["conversation", "workflow", "strict-workflow"];
-const MODE_LABELS = {
-  default: "Use configured default",
-  conversation: "conversation",
-  workflow: "workflow",
-  "strict-workflow": "strict-workflow",
-};
-const MODE_DESCRIPTIONS = {
-  conversation: "Discussion and read-only inspection",
-  workflow: "Adaptive workflow for consequential work",
-  "strict-workflow": "Stronger decision and evidence pressure for high-risk work",
-};
 const LOCAL_INHERIT = "inherit";
 const execFileAsync = promisify(execFile);
 function isRecord(value) {
@@ -208,83 +192,18 @@ function createScopedBooleanItem(options) {
   item.displaySuffix = coreDisplaySuffix(item);
   return item;
 }
-function createScopedDefaultModeItem(options) {
-  let item;
-  if (options.scope === "local") {
-    item = {
-      id: "freeflow.defaultMode",
-      label: "Default mode",
-      description:
-        "Personal default mode for this checkout. Choose inherit to use the repository default; use /freeflow settings repo to edit shared defaults.",
-      path: ["defaultMode"],
-      kind: "enum",
-      value: options.localDefaultMode ?? LOCAL_INHERIT,
-      values: [LOCAL_INHERIT, ...MODE_VALUES],
-      valueLabels: {
-        inherit: "Inherit repository",
-        ...MODE_LABELS,
-      },
-      valueDescriptions: {
-        inherit: `Use ${options.repositoryDefaultMode} from ${options.repositoryDefaultSource}.`,
-        ...MODE_DESCRIPTIONS,
-      },
-      format: (value) => String(value),
-      configScope: "local",
-      configValues: { inherit: undefined },
-      effectiveValue: options.effectiveValue,
-      effectiveSource: options.effectiveSource,
-      inheritedValue: options.repositoryDefaultMode,
-      inheritedSource: options.repositoryDefaultSource,
-    };
-  } else {
-    item = {
-      id: "freeflow.defaultMode",
-      label: "Default mode",
-      description:
-        "Shared repository default Freeflow mode used when Skills are enabled. This edits .freeflow/config.json.",
-      path: ["defaultMode"],
-      kind: "enum",
-      value: options.repositoryDefaultMode,
-      values: MODE_VALUES,
-      valueLabels: MODE_LABELS,
-      valueDescriptions: MODE_DESCRIPTIONS,
-      configScope: "repository",
-      effectiveValue: options.effectiveValue,
-      effectiveSource: options.effectiveSource,
-      localOverrideValue: options.localDefaultMode,
-    };
-  }
-  item.displaySuffix = coreDisplaySuffix(item);
-  return item;
-}
-function sessionModeDisplaySuffix(sessionMode, defaultMode, defaultSource, inactive) {
-  if (sessionMode !== "default") return undefined;
-  const inactiveSuffix = inactive ? " · inactive" : "";
-  return `(${defaultMode} · ${defaultSource}${inactiveSuffix})`;
-}
-function validModeOrUndefined(value) {
-  return typeof value === "string" && VALID_MODES.has(value) ? value : undefined;
-}
 function resolveSettingsCoreView(rawConfig, layers) {
   const localConfig = layers?.local.valid && isRecord(layers.local.parsed) ? layers.local.parsed : {};
-  const repositorySkillsValue = getPath(rawConfig, ["skills"]);
-  const repositorySkills = isRecord(repositorySkillsValue) ? repositorySkillsValue : {};
   const fallbackCore = {
     enabled: getPath(rawConfig, ["enabled"]) !== false,
-    interactionContract: getPath(rawConfig, ["interactionContract"]) !== false,
     contextVirtualization: getPath(rawConfig, ["contextVirtualization"]) === true,
     conversationHistory: getPath(rawConfig, ["conversationHistory"]) === true,
-    skills: { enabled: getPath(repositorySkills, ["enabled"]) !== false },
-    defaultMode: validModeOrUndefined(rawConfig.defaultMode) ?? "workflow",
   };
   const fallbackSources = {
     enabled: typeof getPath(rawConfig, ["enabled"]) === "boolean" ? "repository" : "builtin",
-    interactionContract: typeof getPath(rawConfig, ["interactionContract"]) === "boolean" ? "repository" : "builtin",
     contextVirtualization:
       typeof getPath(rawConfig, ["contextVirtualization"]) === "boolean" ? "repository" : "builtin",
     conversationHistory: typeof getPath(rawConfig, ["conversationHistory"]) === "boolean" ? "repository" : "builtin",
-    skillsEnabled: typeof getPath(repositorySkills, ["enabled"]) === "boolean" ? "repository" : "builtin",
-    defaultMode: validModeOrUndefined(rawConfig.defaultMode) === undefined ? "builtin" : "repository",
   };
   return {
     localConfig,
@@ -329,7 +248,7 @@ function createSessionBooleanItem(options) {
   item.displaySuffix = coreDisplaySuffix(item);
   return item;
 }
-function sessionFreeflowItems(state, modeState, cognitiveRoutingController) {
+function sessionFreeflowItems(state, cognitiveRoutingController) {
   const sessionOverrides = state.sessionOverrides;
   const configured = state.configuredCoreConfig;
   const configuredSources = state.configuredSources;
@@ -345,28 +264,6 @@ function sessionFreeflowItems(state, modeState, cognitiveRoutingController) {
     effectiveSource: effectiveSources.enabled,
     sessionOverrides,
   });
-  const interactionItem = createSessionBooleanItem({
-    id: "freeflow.interactionContract",
-    label: "Interaction Contract",
-    description: "Temporary Interaction Contract override for this Pi session.",
-    key: "interactionContract",
-    inheritedValue: configured.interactionContract,
-    inheritedSource: configuredSources.interactionContract,
-    effectiveValue: state.interactionContract.enabled,
-    effectiveSource: effectiveSources.interactionContract,
-    sessionOverrides,
-  });
-  const skillsItem = createSessionBooleanItem({
-    id: "freeflow.skills.enabled",
-    label: "Skills",
-    description: "Temporary Freeflow Skills override for this Pi session.",
-    key: "skillsEnabled",
-    inheritedValue: configured.skills.enabled,
-    inheritedSource: configuredSources.skillsEnabled,
-    effectiveValue: state.skills.enabled,
-    effectiveSource: effectiveSources.skillsEnabled,
-    sessionOverrides,
-  });
   const contextVirtualizationItem = createSessionBooleanItem({
     id: "freeflow.contextVirtualization",
     label: "Context Virtualization",
@@ -390,37 +287,8 @@ function sessionFreeflowItems(state, modeState, cognitiveRoutingController) {
     sessionOverrides,
   });
   const freeflowInactive = !state.enabled;
-  const skillsEnabled = state.skills.enabled;
-  interactionItem.inactive = freeflowInactive;
-  skillsItem.inactive = freeflowInactive;
-  contextVirtualizationItem.inactive = freeflowInactive || !skillsEnabled;
-  conversationHistoryItem.inactive = freeflowInactive || !skillsEnabled;
-  const sessionMode = modeState.currentMode ?? "default";
-  const sessionModeItem = {
-    id: "freeflow.sessionMode",
-    label: "Mode",
-    description: "Temporary mode override for this Pi session.",
-    kind: "enum",
-    value: sessionMode,
-    values: ["default", ...MODE_VALUES],
-    valueLabels: {
-      ...MODE_LABELS,
-      default: "Use configured default",
-    },
-    valueDescriptions: {
-      default: `${modeState.defaultMode} from ${modeState.defaultModeSource}`,
-      ...MODE_DESCRIPTIONS,
-    },
-    inactive: freeflowInactive || !skillsEnabled,
-    displaySuffix: sessionModeDisplaySuffix(
-      sessionMode,
-      modeState.defaultMode,
-      modeState.defaultModeSource,
-      freeflowInactive || !skillsEnabled,
-    ),
-    inheritedValue: modeState.defaultMode,
-    inheritedSource: modeState.defaultModeSource,
-  };
+  contextVirtualizationItem.inactive = freeflowInactive;
+  conversationHistoryItem.inactive = freeflowInactive;
   const cognitiveRoutingState = cognitiveRoutingController?.state();
   const cognitiveRoutingProfile =
     cognitiveRoutingState?.controlMode === "manual-standard"
@@ -446,22 +314,18 @@ function sessionFreeflowItems(state, modeState, cognitiveRoutingController) {
           standard: "Hold the standard profile until /freeflow profile auto.",
           reasoning: "Hold the reasoning profile until /freeflow profile auto.",
         },
-        inactive: !state.cognitiveRouting.effective || cognitiveRoutingController === undefined,
+        inactive: freeflowInactive || !state.cognitiveRouting.effective || cognitiveRoutingController === undefined,
         runtimeInactive: state.cognitiveRouting.blockingReason?.code === "runtime_disabled",
         displaySuffix: cognitiveRoutingState?.effective ? cognitiveRoutingProfile : "unavailable",
       }
     : undefined;
   return [
     freeflowItem,
-    interactionItem,
-    skillsItem,
-    sessionModeItem,
     ...(cognitiveRoutingItem ? [cognitiveRoutingItem] : []),
     {
       id: "freeflow.session.reset",
       label: "Reset session overrides",
-      description:
-        "Clear Freeflow, Interaction Contract, Skills, Context Virtualization, Conversation History, and mode overrides for this Pi session.",
+      description: "Clear Freeflow, Context Virtualization, and Conversation History overrides for this Pi session.",
       kind: "enum",
       value: "available",
       values: ["reset"],
@@ -688,18 +552,18 @@ function cognitiveRoutingProfileItem(options) {
 }
 function cognitiveRoutingSessionStartItem(options) {
   const path = ["cognitiveRouting", "sessionStart", options.setting];
-  const defaultValue = options.setting === "control" ? "automatic" : "standard";
+  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: "Let Cognitive Routing manage profile transitions for the new session.",
+          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 session with the configured Standard preset.",
-          reasoning: "Start a new session with the configured Reasoning preset.",
+          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);
@@ -710,13 +574,21 @@ function cognitiveRoutingSessionStartItem(options) {
   const inheritedSource = repositorySetting ? "repository" : "builtin";
   const configuredSource =
     options.capabilityState?.sessionStartSources?.[options.setting] ?? (repositorySetting ? "repository" : undefined);
-  const effectiveValue = options.capabilityState?.sessionStart?.[options.setting] ?? inheritedValue;
+  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" : "Session start profile";
+  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 initial profile 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"
       ? {
@@ -760,7 +632,10 @@ function cognitiveRoutingSessionStartItem(options) {
   item.displaySuffix = coreDisplaySuffix(item);
   return item;
 }
-function freeflowItems(rawConfig, modeState, options = {}) {
+function isCognitiveRoutingRuntimeAvailable(pi) {
+  return isPiFlowHost(pi?.host) || supportsPiSessionModelStateApi(pi);
+}
+function freeflowItems(rawConfig, options = {}) {
   const scope = options.scope ?? "repository";
   const layers = options.layers;
   const { localConfig, core, sources } = resolveSettingsCoreView(rawConfig, layers);
@@ -770,36 +645,12 @@ function freeflowItems(rawConfig, modeState, options = {}) {
     localConfig,
     id: "freeflow.enabled",
     label: "Freeflow",
-    description: "Master switch for the Interaction Contract and Freeflow skills in this checkout.",
+    description: "Master switch for Freeflow's core guidance, skills, and optional capabilities in this checkout.",
     path: ["enabled"],
     effectiveValue: core.enabled,
     effectiveSource: sources.enabled,
     defaultValue: DEFAULT_FREEFLOW_ENABLED,
   });
-  const interactionItem = createScopedBooleanItem({
-    scope,
-    rawConfig,
-    localConfig,
-    id: "freeflow.interactionContract",
-    label: "Interaction Contract",
-    description: "Apply Freeflow's compact turn-interpretation and collaboration guidance.",
-    path: ["interactionContract"],
-    effectiveValue: core.interactionContract,
-    effectiveSource: sources.interactionContract,
-    defaultValue: DEFAULT_INTERACTION_CONTRACT_ENABLED,
-  });
-  const skillsItem = createScopedBooleanItem({
-    scope,
-    rawConfig,
-    localConfig,
-    id: "freeflow.skills.enabled",
-    label: "Skills",
-    description: "Expose Freeflow skills and discover Workflow before consequential or mutating work.",
-    path: ["skills", "enabled"],
-    effectiveValue: core.skills.enabled,
-    effectiveSource: sources.skillsEnabled,
-    defaultValue: DEFAULT_SKILLS_ENABLED,
-  });
   const contextVirtualizationItem = createScopedBooleanItem({
     scope,
     rawConfig,
@@ -824,53 +675,11 @@ function freeflowItems(rawConfig, modeState, options = {}) {
     effectiveSource: sources.conversationHistory,
     defaultValue: DEFAULT_CONVERSATION_HISTORY_ENABLED,
   });
-  const repositoryModeValue = validModeOrUndefined(rawConfig.defaultMode);
-  const repositoryDefaultMode = repositoryModeValue ?? "workflow";
-  const repositoryDefaultSource = repositoryModeValue ? "repository" : "builtin";
-  const localDefaultMode = validModeOrUndefined(localConfig.defaultMode);
-  const defaultModeItem = createScopedDefaultModeItem({
-    scope,
-    repositoryDefaultMode,
-    repositoryDefaultSource,
-    localDefaultMode,
-    effectiveValue: core.defaultMode,
-    effectiveSource: sources.defaultMode,
-  });
   const freeflowInactive = !core.enabled;
-  const skillsEnabled = core.skills.enabled;
-  interactionItem.inactive = freeflowInactive;
-  skillsItem.inactive = freeflowInactive;
-  contextVirtualizationItem.inactive = freeflowInactive || !skillsEnabled;
-  conversationHistoryItem.inactive = freeflowInactive || !skillsEnabled;
-  defaultModeItem.inactive = freeflowInactive;
-  defaultModeItem.displaySuffix = coreDisplaySuffix(defaultModeItem, freeflowInactive || !skillsEnabled);
-  const sessionMode = modeState?.currentMode ?? "default";
-  const sessionModeItem = {
-    id: "freeflow.sessionMode",
-    label: "Session mode",
-    description:
-      "Temporary mode override for this Pi session. Use configured default clears the override without changing either config file.",
-    kind: "enum",
-    value: sessionMode,
-    values: ["default", ...MODE_VALUES],
-    valueLabels: {
-      ...MODE_LABELS,
-      default: "Use configured default",
-    },
-    valueDescriptions: {
-      default: `${core.defaultMode} from ${sources.defaultMode}`,
-      ...MODE_DESCRIPTIONS,
-    },
-    inactive: freeflowInactive || !skillsEnabled,
-    displaySuffix: sessionModeDisplaySuffix(
-      sessionMode,
-      core.defaultMode,
-      sources.defaultMode,
-      freeflowInactive || !skillsEnabled,
-    ),
-  };
+  contextVirtualizationItem.inactive = freeflowInactive;
+  conversationHistoryItem.inactive = freeflowInactive;
   const cognitiveRoutingState = options.cognitiveRouting;
-  const cognitiveRoutingRuntimeDisabled = !isPiFlowHost(options.hostInfo);
+  const cognitiveRoutingRuntimeDisabled = options.runtimeAvailable !== true;
   const cognitiveRoutingGroup = (() => {
     const cognitiveRoutingEnabledItem = createScopedBooleanItem({
       scope,
@@ -879,14 +688,14 @@ function freeflowItems(rawConfig, modeState, options = {}) {
       id: "freeflow.cognitiveRouting.enabled",
       label: "Enabled",
       description: cognitiveRoutingRuntimeDisabled
-        ? "Configured for PiFlow, but disabled in normal Pi."
+        ? "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.",
       path: ["cognitiveRouting", "enabled"],
       effectiveValue: cognitiveRoutingState?.enabled ?? false,
       effectiveSource: cognitiveRoutingSettingsSource(cognitiveRoutingState?.enabledSource),
       defaultValue: false,
     });
-    cognitiveRoutingEnabledItem.inactive = freeflowInactive || !skillsEnabled || cognitiveRoutingRuntimeDisabled;
+    cognitiveRoutingEnabledItem.inactive = freeflowInactive || cognitiveRoutingRuntimeDisabled;
     cognitiveRoutingEnabledItem.runtimeInactive = cognitiveRoutingRuntimeDisabled;
     const cognitiveRoutingProfiles = ["standard", "reasoning"].map((name) =>
       cognitiveRoutingProfileItem({
@@ -908,11 +717,11 @@ function freeflowItems(rawConfig, modeState, options = {}) {
       }),
     );
     for (const item of [...cognitiveRoutingProfiles, ...cognitiveRoutingSessionStart]) {
-      item.inactive ||= freeflowInactive || !skillsEnabled || cognitiveRoutingRuntimeDisabled;
+      item.inactive ||= freeflowInactive || cognitiveRoutingRuntimeDisabled;
       item.runtimeInactive = cognitiveRoutingRuntimeDisabled;
     }
     const cognitiveRoutingStatus = cognitiveRoutingRuntimeDisabled
-      ? "disabled · PiFlow only"
+      ? "unavailable · host unsupported"
       : cognitiveRoutingState
         ? cognitiveRoutingState.effective
           ? "active"
@@ -924,21 +733,17 @@ function freeflowItems(rawConfig, modeState, options = {}) {
       id: "freeflow.cognitiveRouting",
       label: "Cognitive Routing",
       description: cognitiveRoutingRuntimeDisabled
-        ? "Cognitive Routing configuration is visible for inspection but can only run in PiFlow."
-        : "Configure the automatic standard/reasoning profiles and choose whether Freeflow may manage model state for this repository.",
+        ? "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.",
       kind: "group",
       value: cognitiveRoutingRuntimeDisabled ? false : (cognitiveRoutingState?.enabled ?? false),
-      inactive: freeflowInactive || !skillsEnabled,
+      inactive: freeflowInactive,
       displaySuffix: cognitiveRoutingStatus,
       children: [cognitiveRoutingEnabledItem, ...cognitiveRoutingProfiles, ...cognitiveRoutingSessionStart],
     };
   })();
   return [
     freeflowItem,
-    interactionItem,
-    skillsItem,
-    sessionModeItem,
-    defaultModeItem,
     ...(cognitiveRoutingGroup ? [cognitiveRoutingGroup] : []),
     {
       id: "freeflow.context",
@@ -954,8 +759,7 @@ function freeflowItems(rawConfig, modeState, options = {}) {
 function pruneKnownDefaults(config) {
   const defaultPaths = [
     { path: ["enabled"], value: DEFAULT_FREEFLOW_ENABLED },
-    { path: ["interactionContract"], value: DEFAULT_INTERACTION_CONTRACT_ENABLED },
-    { path: ["skills", "enabled"], value: DEFAULT_SKILLS_ENABLED },
+    { path: ["contextVirtualization"], value: DEFAULT_CONTEXT_VIRTUALIZATION_ENABLED },
     { path: ["conversationHistory"], value: DEFAULT_CONVERSATION_HISTORY_ENABLED },
   ];
   for (const item of defaultPaths) {
@@ -1068,33 +872,12 @@ function findSettingsItem(items, id) {
 function refreshSettingsDerivedState(items) {
   const freeflowItem = findSettingsItem(items, "freeflow.enabled");
   const freeflowInactive = freeflowItem ? effectiveItemValue(freeflowItem) !== true : false;
-  const skillsItem = findSettingsItem(items, "freeflow.skills.enabled");
-  const skillsEnabled = skillsItem ? effectiveItemValue(skillsItem) === true : true;
-  const sessionModeItem = findSettingsItem(items, "freeflow.sessionMode");
-  const defaultModeItem = findSettingsItem(items, "freeflow.defaultMode");
   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"),
   ];
-  if (sessionModeItem) {
-    const defaultMode = String(
-      defaultModeItem ? effectiveItemValue(defaultModeItem) : (sessionModeItem.inheritedValue ?? "workflow"),
-    );
-    const defaultSource = defaultModeItem?.effectiveSource ?? sessionModeItem.inheritedSource ?? "builtin";
-    sessionModeItem.inactive = freeflowInactive || !skillsEnabled;
-    sessionModeItem.displaySuffix = sessionModeDisplaySuffix(
-      String(sessionModeItem.value),
-      defaultMode,
-      defaultSource,
-      freeflowInactive || !skillsEnabled,
-    );
-    sessionModeItem.valueDescriptions = {
-      default: `${defaultMode} from ${defaultSource}`,
-      ...MODE_DESCRIPTIONS,
-    };
-  }
   if (cognitiveRoutingGroup && cognitiveRoutingEnabledItem) {
     const enabled = effectiveItemValue(cognitiveRoutingEnabledItem) === true;
     const profilesConfigured = cognitiveRoutingProfiles.every((item) =>
@@ -1108,7 +891,7 @@ function refreshSettingsDerivedState(items) {
           : "configured"
         : "not configured"
       : "disabled";
-    cognitiveRoutingGroup.inactive = freeflowInactive || !skillsEnabled;
+    cognitiveRoutingGroup.inactive = freeflowInactive;
   }
   const contextGroup = findSettingsItem(items, "freeflow.context");
   if (contextGroup?.children?.length) {
@@ -1121,31 +904,11 @@ function refreshSettingsDerivedState(items) {
       candidate.inactive = false;
     } else if (candidate.configScope) {
       const inactive =
-        candidate.id === "freeflow.enabled"
-          ? false
-          : candidate.runtimeInactive === true ||
-            freeflowInactive ||
-            (!skillsEnabled &&
-              [
-                "freeflow.cognitiveRouting",
-                "freeflow.cognitiveRouting.enabled",
-                "freeflow.cognitiveRouting.standard",
-                "freeflow.cognitiveRouting.reasoning",
-                "freeflow.cognitiveRouting.sessionStart.control",
-                "freeflow.cognitiveRouting.sessionStart.profile",
-                "freeflow.contextVirtualization",
-                "freeflow.conversationHistory",
-              ].includes(candidate.id));
-      const displayInactive = candidate.id === "freeflow.defaultMode" ? freeflowInactive || !skillsEnabled : inactive;
+        candidate.id === "freeflow.enabled" ? false : candidate.runtimeInactive === true || freeflowInactive;
       candidate.inactive = inactive;
-      candidate.displaySuffix = coreDisplaySuffix(candidate, displayInactive);
-    } else if (candidate.id === "freeflow.sessionMode") {
-      candidate.inactive = candidate.runtimeInactive === true || freeflowInactive || !skillsEnabled;
+      candidate.displaySuffix = coreDisplaySuffix(candidate, inactive);
     } else {
-      candidate.inactive =
-        candidate.runtimeInactive === true ||
-        freeflowInactive ||
-        (!skillsEnabled && candidate.id === "freeflow.cognitiveRouting");
+      candidate.inactive = candidate.runtimeInactive === true || freeflowInactive;
     }
   });
 }
@@ -1251,7 +1014,7 @@ function freeflowStatusText(state, cognitiveRoutingController) {
   const cognitiveRouting = state.cognitiveRouting;
   const cognitiveRoutingStatus = cognitiveRouting
     ? cognitiveRouting.blockingReason?.code === "runtime_disabled"
-      ? "disabled (PiFlow only)"
+      ? "unavailable (host unsupported)"
       : cognitiveRouting.effective
         ? routingState?.effective
           ? `active (${routingState.activeProfile ?? "unknown"}, ${routingState.controlMode})`
@@ -1263,16 +1026,12 @@ function freeflowStatusText(state, cognitiveRoutingController) {
   const contextEnabled = state.contextVirtualization?.effective || state.conversationHistory?.effective;
   return [
     `Freeflow: ${state.enabled ? "enabled" : "disabled"}${sessionSuffix(state.configSources.enabled)}`,
-    `interaction contract: ${state.interactionContract.effective ? "enabled" : "disabled"}${sessionSuffix(state.configSources.interactionContract)}`,
-    `skills: ${state.skills.effective ? "enabled" : "disabled (workflow modes inactive)"}${sessionSuffix(state.configSources.skillsEnabled)}`,
     `context: ${contextEnabled ? "enabled" : "disabled"} (virtualization ${state.contextVirtualization?.effective ? "enabled" : "disabled"}, history ${state.conversationHistory?.effective ? "enabled" : "disabled"})`,
     ...(cognitiveRoutingStatus ? [`cognitive routing: ${cognitiveRoutingStatus}`] : []),
   ].join("; ");
 }
 const NON_TUI_SETTINGS_GUIDANCE =
-  "Freeflow settings require Pi TUI mode. Use /freeflow status to inspect current state; supported non-TUI changes are /freeflow enable, /freeflow disable, and /freeflow mode <conversation|workflow|strict-workflow|reset>.";
-const NON_TUI_MODE_GUIDANCE =
-  "Freeflow mode selector requires Pi TUI mode. Use /freeflow mode conversation, /freeflow mode workflow, /freeflow mode strict-workflow, or /freeflow mode reset.";
+  "Freeflow settings require Pi TUI mode. Use /freeflow status to inspect current state; supported non-TUI changes are /freeflow enable and /freeflow disable.";
 function ensureSettingsIdle(ctx) {
   if (typeof ctx?.isIdle !== "function" || ctx.isIdle()) return true;
   ctx.ui?.notify?.("Freeflow settings and profile changes are available only while Pi is idle.", "warning");
@@ -1323,19 +1082,15 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
   const [action, ...rest] = input.split(/\s+/);
   const actionValue = rest.join(" ");
   const nonTui = ctx?.mode && ctx.mode !== "tui";
-  if (nonTui && action === "mode" && !actionValue) {
-    return nonTuiGuidance(ctx, NON_TUI_MODE_GUIDANCE);
-  }
   const settingsSelector =
     action === "settings" &&
     (!actionValue || ["session", "local", "personal", "repo", "repository", "shared"].includes(actionValue));
   if (nonTui && settingsSelector) {
     return nonTuiGuidance(ctx, NON_TUI_SETTINGS_GUIDANCE);
   }
-  const [layers, state, modeState] = await Promise.all([
+  const [layers, state] = await Promise.all([
     readFreeflowConfigLayers(ctx.cwd),
     readCapabilityState(ctx.cwd, ctx, pi?.host),
-    readModeState(ctx.cwd),
   ]);
   const configState = layers.repository;
   const raw = configState.valid ? configState.parsed : {};
@@ -1354,48 +1109,15 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
     );
     return { changed: false, reloaded: false, error: "invalid_local_config" };
   }
-  if (action === "mode") {
-    if (!ensureSettingsIdle(ctx)) return { changed: false, reloaded: false, error: "busy" };
-    if (actionValue) {
-      const result = await handleModeCommand(actionValue, ctx, pi);
-      return { changed: result.changed, reloaded: false, error: result.error };
-    }
-    if (!state.enabled || !state.skills.effective) {
-      const result = await handleModeCommand(undefined, ctx, pi);
-      return { changed: false, reloaded: false, error: result.error };
-    }
-    if (typeof ctx?.ui?.custom !== "function") {
-      const result = await handleModeCommand(undefined, ctx, pi);
-      return { changed: false, reloaded: false, error: result.error };
-    }
-    const item = freeflowItems(raw, modeState, {
-      scope: "local",
-      layers,
-      cognitiveRouting: state.cognitiveRouting,
-      ctx,
-      hostInfo: pi?.host,
-    }).find((candidate) => candidate.id === "freeflow.sessionMode");
-    const session = await openSettings({
-      title: "Freeflow Mode",
-      items: [item],
-      initialChoice: item,
-      ctx,
-      onChange: async (_item, value) => {
-        const result = await handleModeCommand(String(value), ctx, pi);
-        return { changed: result.changed, reloadRequired: false };
-      },
-    });
-    return { changed: session.changed, reloaded: false, error: session.failed ? "write_failed" : undefined };
-  }
   if (["enable", "on", "true", "disable", "off", "false"].includes(action)) {
     if (!ensureSettingsIdle(ctx)) return { changed: false, reloaded: false, error: "busy" };
     const enabled = ["enable", "on", "true"].includes(action);
-    const item = freeflowItems(raw, modeState, {
+    const item = freeflowItems(raw, {
       scope: "repository",
       layers,
       cognitiveRouting: state.cognitiveRouting,
       ctx,
-      hostInfo: pi?.host,
+      runtimeAvailable: isCognitiveRoutingRuntimeAvailable(pi),
     }).find((candidate) => candidate.id === "freeflow.enabled");
     await updateConfig(ctx.cwd, item, enabled, "repository");
     await afterChange(true);
@@ -1409,7 +1131,7 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
   }
   if (action && action !== "settings") {
     ctx.ui.notify(
-      "Usage: /freeflow, /freeflow settings [local|repo], /freeflow status, /freeflow mode [conversation|workflow|strict-workflow|reset], /freeflow enable, or /freeflow disable",
+      "Usage: /freeflow, /freeflow settings [local|repo], /freeflow status, /freeflow enable, or /freeflow disable",
       "warning",
     );
     return { changed: false, reloaded: false, error: "invalid_action" };
@@ -1430,13 +1152,13 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
   let reconcileCognitiveRouting = settingsScope === "session";
   const items =
     settingsScope === "session"
-      ? sessionFreeflowItems(state, modeState, cognitiveRoutingController)
-      : freeflowItems(raw, modeState, {
+      ? sessionFreeflowItems(state, cognitiveRoutingController)
+      : freeflowItems(raw, {
           scope: settingsScope,
           layers,
           cognitiveRouting: state.cognitiveRouting,
           ctx,
-          hostInfo: pi?.host,
+          runtimeAvailable: isCognitiveRoutingRuntimeAvailable(pi),
         });
   const session = await openSettings({
     title:
@@ -1449,14 +1171,10 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
     ctx,
     onChange: async (item, value) => {
       if (!ensureSettingsIdle(ctx)) return { changed: false, reloadRequired: false };
-      if (!isPiFlowHost(pi?.host) && item.id.startsWith("freeflow.cognitiveRouting.")) {
-        ctx.ui.notify("Cognitive Routing is available only in PiFlow.", "warning");
+      if (!isCognitiveRoutingRuntimeAvailable(pi) && item.id.startsWith("freeflow.cognitiveRouting.")) {
+        ctx.ui.notify("Cognitive Routing is unavailable because this host lacks model-state controls.", "warning");
         return { changed: false, reloadRequired: false };
       }
-      if (item.id === "freeflow.sessionMode") {
-        const result = await handleModeCommand(String(value), ctx, pi);
-        return { changed: result.changed, reloadRequired: false };
-      }
       if (item.id === "freeflow.cognitiveRouting.profile") {
         if (!cognitiveRoutingController) {
           ctx.ui.notify("Cognitive Routing is unavailable for this session.", "warning");
@@ -1483,8 +1201,6 @@ export async function handleFreeflowCommand(args, ctx, afterChange, pi, cognitiv
       if (item.configScope === "session") {
         const keyById = {
           "freeflow.enabled": "enabled",
-          "freeflow.interactionContract": "interactionContract",
-          "freeflow.skills.enabled": "skillsEnabled",
           "freeflow.contextVirtualization": "contextVirtualization",
           "freeflow.conversationHistory": "conversationHistory",
         };