@hassangameryt/freeflow 0.8.0 → 0.9.0

package/pi-extension/dist/host/catalog.js

@@ -4,59 +4,38 @@ import { fileURLToPath } from "node:url";
  * their files live.
  */
 export const WORKFLOW_COMMANDS = [
-  { command: "discuss", skill: "discuss" },
-  { command: "action-selection", skill: "action-selection" },
+  { command: "discuss-work", skill: "discuss-work" },
   { command: "track-work", skill: "track-work" },
-  { command: "write-spec", skill: "write-spec" },
-  { command: "review-artifact", skill: "review-artifact" },
-  { command: "write-plan", skill: "write-plan" },
   { command: "write-docs", skill: "write-docs" },
   { command: "execute-work", skill: "execute-work" },
-  { command: "simplify-code", skill: "simplify-code" },
-  { command: "migration-work", skill: "migration-work" },
-  { command: "diagnose-failure", skill: "diagnose-failure" },
   { command: "verify-work", skill: "verify-work" },
   { command: "review-work", skill: "review-work" },
-  { command: "commit-work", skill: "commit-work" },
-  { command: "handoff", skill: "handoff" },
-  { command: "finish-branch", skill: "finish-branch" },
-  { command: "release-work", skill: "release-work" },
-  { command: "launch-work", skill: "launch-work" },
-  { command: "bypass", skill: "bypass" },
+  { command: "deliver-work", skill: "deliver-work" },
 ];
-export const CONTRIBUTOR_COMMANDS = ["setup-freeflow", "write-skill", "evaluate-skill"];
-const FREEFLOW_MODEL_SKILL_NAMES = [
-  "action-selection",
-  "bypass",
-  "commit-work",
-  "decision-gate",
-  "migration-work",
-  "design-for-depth",
-  "diagnose-failure",
-  "discuss",
-  "evaluate-skill",
+export const CONTRIBUTOR_COMMANDS = ["setup-freeflow", "write-skill", "evaluate-behavior"];
+/**
+ * Every portable skill Freeflow ships, by directory name. The canonical list: validation scripts and tests compare the
+ * skills directory, the package and the coverage matrix against it instead of a fixed count.
+ */
+export const FREEFLOW_MODEL_SKILL_NAMES = [
+  "deliver-work",
+  "discuss-work",
+  "evaluate-behavior",
   "execute-work",
-  "finish-branch",
-  "handoff",
-  "release-work",
-  "review-artifact",
   "review-work",
   "setup-freeflow",
-  "launch-work",
-  "simplify-code",
   "track-work",
   "verify-work",
-  "workflow",
   "write-docs",
-  "write-plan",
   "write-skill",
-  "write-spec",
 ];
 export const STABLE_FREEFLOW_SURFACE = Object.freeze({
   enabled: true,
   cognitiveRouting: { effective: true },
   toolExecution: { effective: true },
   compaction: { effective: true },
+  taskMemory: { effective: true },
+  messaging: { effective: true },
 });
 export function freeflowSkillPath(skillName) {
   return fileURLToPath(new URL(`../../../skills/${skillName}/SKILL.md`, import.meta.url));
@@ -65,10 +44,16 @@ export function freeflowCapabilitySkillPath(skillName) {
   return fileURLToPath(new URL(`../../../capabilities/${skillName}/SKILL.md`, import.meta.url));
 }
 export function freeflowModelSkillPaths(capabilityState = undefined) {
-  const paths = FREEFLOW_MODEL_SKILL_NAMES.map((skillName) => freeflowSkillPath(skillName));
+  // A skill the user turned off is not loaded (config-validation.ts SWITCHABLE_SKILLS).
+  const off = capabilityState?.skills?.off ?? [];
+  const paths = FREEFLOW_MODEL_SKILL_NAMES.filter((skillName) => !off.includes(skillName)).map((skillName) =>
+    freeflowSkillPath(skillName),
+  );
   if (capabilityState?.cognitiveRouting?.effective === true)
     paths.push(freeflowCapabilitySkillPath("cognitive-routing"));
   if (capabilityState?.compaction?.effective === true) paths.push(freeflowCapabilitySkillPath("compaction"));
+  if (capabilityState?.taskMemory?.effective === true) paths.push(freeflowCapabilitySkillPath("task-memory"));
+  if (capabilityState?.messaging?.effective === true) paths.push(freeflowCapabilitySkillPath("messaging"));
   return paths;
 }
 export function skillPrompt(skill, args) {

package/pi-extension/dist/host/config-validation.js

@@ -0,0 +1,233 @@
+import { validateCompactionConfig } from "../compaction/config.js";
+import { validateTaskMemoryConfig } from "../task-memory/config.js";
+import { validateMessagingConfig } from "../messaging/config.js";
+import { validateToolExecutionConfig } from "../tool-execution/config.js";
+import { FREEFLOW_MODEL_SKILL_NAMES } from "./catalog.js";
+/**
+ * Whether a Freeflow config file is valid: one answer for Pi and for the session-start hooks of the other hosts, which
+ * import the built file. Also how the settings every host reads, `prompts`, `review` and `skills`, layer. Keep this module and its
+ * imports free of Pi packages; the hooks run in plain Node.
+ */
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The runtime prompts Freeflow delivers on every host, each on unless a config turns it off. */
+export const RUNTIME_PROMPTS = ["core", "interactionContract", "workingMethod"];
+/** The keys `prompts` accepts: a master switch for all three, and one switch per prompt. */
+export const PROMPTS_KEYS = ["enabled", ...RUNTIME_PROMPTS];
+/** A section's master switch (`prompts.enabled`, `skills.enabled`) for two valid layers; on unless a config turns it off. */
+export function sectionEnabled(repository, local, section) {
+  const layer = (config) => (isRecord(config?.[section]) ? config[section] : {});
+  return (layer(local).enabled ?? layer(repository).enabled ?? true) === true;
+}
+function validatePromptsConfig(value) {
+  if (!isRecord(value)) return "prompts must be an object";
+  const unknown = Object.keys(value).find((key) => !PROMPTS_KEYS.includes(key));
+  if (unknown) return `prompts has unsupported key: ${unknown}`;
+  for (const key of PROMPTS_KEYS)
+    if (value[key] !== undefined && typeof value[key] !== "boolean") return `prompts.${key} must be a boolean`;
+  return null;
+}
+/**
+ * The prompts Freeflow delivers for two valid config layers: the personal layer overrides the repository's, and the
+ * master switch off turns all three off.
+ */
+export function selectedRuntimePrompts(repository, local) {
+  const layer = (config) => (isRecord(config?.prompts) ? config.prompts : {});
+  const [shared, personal] = [layer(repository), layer(local)];
+  const master = sectionEnabled(repository, local, "prompts");
+  const selection = {};
+  for (const key of RUNTIME_PROMPTS) selection[key] = master && (personal[key] ?? shared[key] ?? true) === true;
+  return selection;
+}
+/**
+ * The skills a user can turn off. Setup Freeflow always stays, so a user can repair a configuration; the capability
+ * skills follow their capability's switch. On Pi an off skill is not loaded; other hosts load plugin skills themselves,
+ * so there the Runtime State only tells the agent not to use it.
+ */
+export const SWITCHABLE_SKILLS = FREEFLOW_MODEL_SKILL_NAMES.filter((name) => name !== "setup-freeflow").sort();
+/** The keys `skills` accepts: a master switch for every switchable skill, and one switch per skill. */
+export const SKILLS_KEYS = ["enabled", ...SWITCHABLE_SKILLS];
+function validateSkillsConfig(value) {
+  if (!isRecord(value)) return "skills must be an object";
+  const unknown = Object.keys(value).find((key) => !SKILLS_KEYS.includes(key));
+  if (unknown) return `skills has unsupported key: ${unknown}; use ${SKILLS_KEYS.join(", ")}`;
+  for (const [key, on] of Object.entries(value)) if (typeof on !== "boolean") return `skills.${key} must be a boolean`;
+  return null;
+}
+/**
+ * The skills turned off for two valid config layers: the personal layer overrides the repository's, skill by skill,
+ * and the master switch off turns every switchable skill off.
+ */
+export function skillsOff(repository, local) {
+  const layer = (config) => (isRecord(config?.skills) ? config.skills : {});
+  const [shared, personal] = [layer(repository), layer(local)];
+  if (!sectionEnabled(repository, local, "skills")) return [...SWITCHABLE_SKILLS];
+  return SWITCHABLE_SKILLS.filter((name) => (personal[name] ?? shared[name] ?? true) === false);
+}
+/** The Runtime State line for skills the user turned off; none while every skill is on. */
+export function skillsStateLine(off) {
+  return off?.length ? `Skills off: ${off.map((name) => `\`${name}\``).join(", ")}; do not open or follow them.` : null;
+}
+/**
+ * How Review Work reviews finished work. Without the key it runs `auto`, its own risk gate; `off` and `always` are the
+ * user's choice for every task, and `model` names the model a reviewer runs on. `auto` is accepted so a personal file
+ * can return a shared `off` or `always` to the default.
+ */
+export const REVIEW_MODES = ["auto", "off", "always"];
+export const REVIEW_KEYS = ["mode", "model"];
+function validateReviewConfig(value) {
+  if (!isRecord(value)) return "review must be an object";
+  const unknown = Object.keys(value).find((key) => !REVIEW_KEYS.includes(key));
+  if (unknown) return `review has unsupported key: ${unknown}`;
+  if (value.mode !== undefined && !REVIEW_MODES.includes(value.mode))
+    return `review.mode must be one of ${REVIEW_MODES.join(", ")}`;
+  // The model is shown to the agent in the Runtime State, so it must fit on one line in a code span.
+  if (
+    value.model !== undefined &&
+    (typeof value.model !== "string" || !value.model.trim() || /[\p{Cc}`]/u.test(value.model))
+  )
+    return "review.model must be a non-empty model name on one line";
+  return null;
+}
+/** Review settings for two valid config layers: the personal layer overrides the repository's, field by field. */
+export function resolveReviewSettings(repository, local) {
+  const layer = (config) => (isRecord(config?.review) ? config.review : {});
+  const [shared, personal] = [layer(repository), layer(local)];
+  const mode = personal.mode ?? shared.mode ?? "auto";
+  const model = personal.model ?? shared.model;
+  return model === undefined ? { mode } : { mode, model };
+}
+/** The Runtime State line for the user's review choice; none for the default, `auto` with no model. */
+export function reviewStateLine(review) {
+  if (!review || (review.mode === "auto" && review.model === undefined)) return null;
+  return `Review: \`${review.mode}\`${review.model === undefined ? "" : `, reviewer model \`${review.model}\``}`;
+}
+function removedContextConfigError(value, filePath) {
+  const removedKeys = ["contextVirtualization", "conversationHistory"].filter((key) =>
+    Object.prototype.hasOwnProperty.call(value, key),
+  );
+  return removedKeys.length > 0
+    ? `Removed Freeflow context setting(s) in ${filePath}: ${removedKeys.join(", ")}. Delete those keys before using Freeflow.`
+    : null;
+}
+function validateCoreConfigFields(value) {
+  if (value.enabled !== undefined && typeof value.enabled !== "boolean") {
+    return "enabled must be a boolean";
+  }
+  return null;
+}
+/** The top-level keys Freeflow acts on; the settings test checks that every key under them has a settings row. */
+export const CONFIG_SECTIONS = [
+  "enabled",
+  "cognitiveRouting",
+  "toolExecution",
+  "compaction",
+  "taskMemory",
+  "messaging",
+  "prompts",
+  "review",
+  "skills",
+];
+// outputRouter, observedRouting, and scriptTransform belong to retired features; they are accepted and ignored so
+// existing configs keep loading.
+const RETIRED_SECTIONS = ["outputRouter", "observedRouting", "scriptTransform"];
+export function validateRepositoryConfig(value) {
+  if (!isRecord(value)) {
+    return "config must be a JSON object";
+  }
+  const removedContextError = removedContextConfigError(value, ".freeflow/config.json");
+  if (removedContextError) return removedContextError;
+  const allowedKeys = new Set([...CONFIG_SECTIONS, ...RETIRED_SECTIONS]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      return `unsupported top-level config key: ${key}`;
+    }
+  }
+  const coreError = validateCoreConfigFields(value);
+  if (coreError) return coreError;
+  for (const key of ["outputRouter", "observedRouting", "scriptTransform"]) {
+    if (value[key] !== undefined && !isRecord(value[key])) {
+      return `${key} must be an object`;
+    }
+  }
+  if (value.toolExecution !== undefined) {
+    const error = validateToolExecutionConfig(value.toolExecution);
+    if (error) return error;
+  }
+  if (value.prompts !== undefined) {
+    const error = validatePromptsConfig(value.prompts);
+    if (error) return error;
+  }
+  if (value.compaction !== undefined) {
+    const error = validateCompactionConfig(value.compaction);
+    if (error) return error;
+  }
+  if (value.taskMemory !== undefined) {
+    const error = validateTaskMemoryConfig(value.taskMemory);
+    if (error) return error;
+  }
+  if (value.messaging !== undefined) {
+    const error = validateMessagingConfig(value.messaging);
+    if (error) return error;
+  }
+  if (value.skills !== undefined) {
+    const error = validateSkillsConfig(value.skills);
+    if (error) return error;
+  }
+  if (value.review !== undefined) return validateReviewConfig(value.review);
+  return null;
+}
+export function validateLocalConfig(value) {
+  if (!isRecord(value)) {
+    return "local config must be a JSON object";
+  }
+  const removedContextError = removedContextConfigError(value, ".freeflow/local.json");
+  if (removedContextError) return removedContextError;
+  // processing belongs to a retired feature; it is accepted and ignored so existing local configs keep loading.
+  const allowedKeys = new Set([
+    "enabled",
+    "processing",
+    "cognitiveRouting",
+    "toolExecution",
+    "compaction",
+    "taskMemory",
+    "messaging",
+    "prompts",
+    "review",
+    "skills",
+  ]);
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      return `unsupported top-level local config key: ${key}`;
+    }
+  }
+  const coreError = validateCoreConfigFields(value);
+  if (coreError) return coreError;
+  if (value.toolExecution !== undefined) {
+    const error = validateToolExecutionConfig(value.toolExecution);
+    if (error) return error;
+  }
+  if (value.prompts !== undefined) {
+    const error = validatePromptsConfig(value.prompts);
+    if (error) return error;
+  }
+  if (value.compaction !== undefined) {
+    const error = validateCompactionConfig(value.compaction);
+    if (error) return error;
+  }
+  if (value.taskMemory !== undefined) {
+    const error = validateTaskMemoryConfig(value.taskMemory);
+    if (error) return error;
+  }
+  if (value.messaging !== undefined) {
+    const error = validateMessagingConfig(value.messaging);
+    if (error) return error;
+  }
+  if (value.skills !== undefined) {
+    const error = validateSkillsConfig(value.skills);
+    if (error) return error;
+  }
+  if (value.review !== undefined) return validateReviewConfig(value.review);
+  return null;
+}

package/pi-extension/dist/host/config.js

@@ -2,25 +2,62 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { resolveCognitiveRoutingState, supportsCognitiveRoutingModelRegistry } from "../cognitive-routing/config.js";
 import { sessionStage, stagedFor } from "./staging.js";
-import { resolveToolExecutionConfig, validateToolExecutionConfig } from "../tool-execution/config.js";
-import { resolveCompactionConfig, validateCompactionConfig } from "../compaction/config.js";
+import { resolveToolExecutionConfig } from "../tool-execution/config.js";
+import { resolveCompactionConfig } from "../compaction/config.js";
+import { AUTO_APPROVE_GROUPS, resolveTaskMemoryConfig } from "../task-memory/config.js";
+import { INBOUND_POLICIES, resolveMessagingConfig } from "../messaging/config.js";
+import {
+  REVIEW_MODES,
+  RUNTIME_PROMPTS,
+  SWITCHABLE_SKILLS,
+  resolveReviewSettings,
+  sectionEnabled,
+  selectedRuntimePrompts,
+  skillsOff,
+  validateLocalConfig,
+  validateRepositoryConfig,
+} from "./config-validation.js";
 import { cachedBranch } from "./branch.js";
 /**
  * Freeflow configuration: the repository and personal config files, their layering, per-session core overrides, and
  * the resulting capability state, with optional capabilities disabled inside subagents.
  */
 /**
- * Settings a session may override, as dotted config paths. "enabled" is Freeflow's master switch; the others switch a
- * capability and are applied as a layer above the personal config.
+ * Settings a session may override, as dotted config paths: every setting the settings screen shows, so the Session
+ * scope has what the file scopes have. "enabled" is Freeflow's master switch; the others are applied as a layer above
+ * the personal config. Most are switches; SESSION_CHOICES lists the ones that hold a value.
  */
 export const SESSION_OVERRIDE_KEYS = [
   "enabled",
   "cognitiveRouting.enabled",
   "cognitiveRouting.projection",
   "toolExecution.enabled",
+  "toolExecution.guidanceNotices",
   "compaction.enabled",
   "compaction.carry",
+  "taskMemory.enabled",
+  ...Object.keys(AUTO_APPROVE_GROUPS).map((group) => `taskMemory.autoApprove.${group}`),
+  "messaging.enabled",
+  "messaging.inbound",
+  "review.mode",
+  "review.model",
+  "prompts.enabled",
+  ...RUNTIME_PROMPTS.map((prompt) => `prompts.${prompt}`),
+  "skills.enabled",
+  ...SWITCHABLE_SKILLS.map((skill) => `skills.${skill}`),
 ];
+/** The overrides that hold a value rather than on or off, and the values each accepts (a model is any one-line name). */
+const SESSION_CHOICES = {
+  "messaging.inbound": INBOUND_POLICIES,
+  "review.mode": REVIEW_MODES,
+  "review.model": "name",
+};
+function validSessionValue(key, value) {
+  const choice = SESSION_CHOICES[key];
+  if (!choice) return typeof value === "boolean";
+  if (choice === "name") return typeof value === "string" && value.trim() !== "" && !/[\p{Cc}`]/u.test(value);
+  return choice.includes(value);
+}
 const SESSION_OVERRIDES_ENTRY = "freeflow-session-overrides";
 const SESSION_CORE_KEYS = new Set(SESSION_OVERRIDE_KEYS);
 let currentSessionOverrides = {};
@@ -51,81 +88,6 @@ function disableSubagentCapability(capability) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function removedContextConfigError(value, filePath) {
-  const removedKeys = ["contextVirtualization", "conversationHistory"].filter((key) =>
-    Object.prototype.hasOwnProperty.call(value, key),
-  );
-  return removedKeys.length > 0
-    ? `Removed Freeflow context setting(s) in ${filePath}: ${removedKeys.join(", ")}. Delete those keys before using Freeflow.`
-    : null;
-}
-function validateCoreConfigFields(value) {
-  if (value.enabled !== undefined && typeof value.enabled !== "boolean") {
-    return "enabled must be a boolean";
-  }
-  return null;
-}
-function validateFreeflowConfigShape(value) {
-  if (!isRecord(value)) {
-    return "config must be a JSON object";
-  }
-  const removedContextError = removedContextConfigError(value, ".freeflow/config.json");
-  if (removedContextError) return removedContextError;
-  // outputRouter, observedRouting, and scriptTransform belong to retired features; they are accepted and ignored so
-  // existing configs keep loading.
-  const allowedKeys = new Set([
-    "enabled",
-    "outputRouter",
-    "observedRouting",
-    "scriptTransform",
-    "cognitiveRouting",
-    "toolExecution",
-    "compaction",
-  ]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      return `unsupported top-level config key: ${key}`;
-    }
-  }
-  const coreError = validateCoreConfigFields(value);
-  if (coreError) return coreError;
-  for (const key of ["outputRouter", "observedRouting", "scriptTransform"]) {
-    if (value[key] !== undefined && !isRecord(value[key])) {
-      return `${key} must be an object`;
-    }
-  }
-  if (value.toolExecution !== undefined) {
-    const error = validateToolExecutionConfig(value.toolExecution);
-    if (error) return error;
-  }
-  if (value.compaction !== undefined) {
-    const error = validateCompactionConfig(value.compaction);
-    if (error) return error;
-  }
-  return null;
-}
-function validateFreeflowLocalConfigShape(value) {
-  if (!isRecord(value)) {
-    return "local config must be a JSON object";
-  }
-  const removedContextError = removedContextConfigError(value, ".freeflow/local.json");
-  if (removedContextError) return removedContextError;
-  // processing belongs to a retired feature; it is accepted and ignored so existing local configs keep loading.
-  const allowedKeys = new Set(["enabled", "processing", "cognitiveRouting", "toolExecution", "compaction"]);
-  for (const key of Object.keys(value)) {
-    if (!allowedKeys.has(key)) {
-      return `unsupported top-level local config key: ${key}`;
-    }
-  }
-  const coreError = validateCoreConfigFields(value);
-  if (coreError) return coreError;
-  if (value.toolExecution !== undefined) {
-    const error = validateToolExecutionConfig(value.toolExecution);
-    if (error) return error;
-  }
-  if (value.compaction !== undefined) return validateCompactionConfig(value.compaction);
-  return null;
-}
 async function readConfigFileState(path, validate) {
   try {
     const raw = await readFile(path, "utf8");
@@ -142,7 +104,7 @@ async function readConfigFileState(path, validate) {
     }
     return { path, exists: true, valid: true, parsed, parseError: null };
   } catch (error) {
-    const code = error && typeof error === "object" ? error.code : undefined;
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
     if (code === "ENOENT") {
       return {
         path,
@@ -163,10 +125,10 @@ async function readConfigFileState(path, validate) {
   }
 }
 function readFreeflowConfigState(cwd) {
-  return readConfigFileState(join(cwd, ".freeflow/config.json"), validateFreeflowConfigShape);
+  return readConfigFileState(join(cwd, ".freeflow/config.json"), validateRepositoryConfig);
 }
 function readFreeflowLocalConfigState(cwd) {
-  return readConfigFileState(join(cwd, ".freeflow/local.json"), validateFreeflowLocalConfigShape);
+  return readConfigFileState(join(cwd, ".freeflow/local.json"), validateLocalConfig);
 }
 export async function readFreeflowConfig(cwd) {
   const state = await readFreeflowConfigState(cwd);
@@ -196,26 +158,29 @@ function normalizeSessionOverrides(value) {
   if (!isRecord(value)) return {};
   const overrides = {};
   for (const key of SESSION_CORE_KEYS) {
-    if (typeof value[key] === "boolean") {
+    if (validSessionValue(key, value[key])) {
       overrides[key] = value[key];
     }
   }
   return overrides;
 }
-/** The capability overrides of this session as a config layer, e.g. { compaction: { carry: false } }. */
+/** The setting overrides of this session as a config layer, e.g. { compaction: { carry: false } }. */
 function sessionConfigLayer(overrides) {
   const layer = {};
   for (const [key, value] of Object.entries(overrides)) {
-    const [section, field] = key.split(".");
-    if (!field || typeof value !== "boolean") continue;
-    layer[section] = { ...(layer[section] ?? {}), [field]: value };
+    const path = key.split(".");
+    if (path.length < 2 || value === undefined) continue;
+    let at = layer;
+    for (const part of path.slice(0, -1)) at = at[part] = isRecord(at[part]) ? at[part] : {};
+    at[path.at(-1)] = value;
   }
   return layer;
 }
+/** The personal config with the session layer over it, merged object by object. */
 function withSessionLayer(local, session) {
   const merged = { ...local };
-  for (const [section, fields] of Object.entries(session))
-    merged[section] = { ...(isRecord(local[section]) ? local[section] : {}), ...fields };
+  for (const [key, value] of Object.entries(session))
+    merged[key] = isRecord(value) && isRecord(local[key]) ? withSessionLayer(local[key], value) : value;
   return merged;
 }
 function resolveSessionCoreConfig(layers) {
@@ -251,6 +216,7 @@ export async function readFreeflowConfigLayers(cwd) {
     parseError: blockingState?.parseError ?? null,
   };
 }
+// host is Pi's extension context (or none); Pi's runtime objects are wider than its exported types.
 export async function readCapabilityState(cwd, host = undefined) {
   const layers = await readFreeflowConfigLayers(cwd);
   const effectiveCore = resolveSessionCoreConfig(layers);
@@ -278,6 +244,16 @@ export async function readCapabilityState(cwd, host = undefined) {
   const sessionLocalConfig = withSessionLayer(localConfig, sessionLayer);
   const toolExecution = resolveToolExecutionConfig(repositoryConfig, sessionLocalConfig, enabled);
   const compaction = resolveCompactionConfig(repositoryConfig, sessionLocalConfig, enabled);
+  const taskMemory = resolveTaskMemoryConfig(repositoryConfig, sessionLocalConfig, enabled);
+  const messaging = resolveMessagingConfig(repositoryConfig, sessionLocalConfig, enabled);
+  // Not capabilities: the user's choices for Review Work, the runtime prompts and the skills, on every host.
+  const review = resolveReviewSettings(repositoryConfig, sessionLocalConfig);
+  const prompts = selectedRuntimePrompts(repositoryConfig, sessionLocalConfig);
+  const skills = {
+    enabled: sectionEnabled(repositoryConfig, sessionLocalConfig, "skills"),
+    off: skillsOff(repositoryConfig, sessionLocalConfig),
+  };
+  const promptsEnabled = sectionEnabled(repositoryConfig, sessionLocalConfig, "prompts");
   const capabilityState = {
     configured: layers.configured,
     repositoryConfigured: layers.repositoryConfigured,
@@ -298,6 +274,14 @@ export async function readCapabilityState(cwd, host = undefined) {
     cognitiveRouting,
     toolExecution,
     compaction,
+    taskMemory,
+    messaging,
+    review,
+    prompts,
+    promptsEnabled,
+    skills,
+    // ask_user: core, on whenever Freeflow is enabled (Task 002 D-001); off in subagents, which have no user.
+    askUser: { enabled, effective: enabled },
   };
   if (!subagentContext) return capabilityState;
   return {
@@ -305,6 +289,9 @@ export async function readCapabilityState(cwd, host = undefined) {
     cognitiveRouting: disableSubagentCapability(capabilityState.cognitiveRouting),
     toolExecution: disableSubagentCapability(capabilityState.toolExecution),
     compaction: disableSubagentCapability(capabilityState.compaction),
+    taskMemory: disableSubagentCapability(capabilityState.taskMemory),
+    messaging: disableSubagentCapability(capabilityState.messaging),
+    askUser: disableSubagentCapability(capabilityState.askUser),
   };
 }
 function recordedSessionOverrides(sessionManager) {
@@ -335,7 +322,7 @@ export async function setSessionCoreOverride(key, value, ctx, pi) {
   if (!SESSION_CORE_KEYS.has(key)) {
     throw new Error(`Invalid Freeflow session override: ${String(key)}`);
   }
-  if (value !== null && typeof value !== "boolean") {
+  if (value !== null && !validSessionValue(key, value)) {
     throw new Error(`Invalid Freeflow session override value for ${key}: ${String(value)}`);
   }
   const hasOverride = Object.hasOwn(currentSessionOverrides, key);
@@ -352,7 +339,7 @@ export async function setSessionCoreOverride(key, value, ctx, pi) {
   recordSessionOverrides(ctx, pi);
   return {
     changed: true,
-    // Every session override switches Freeflow or a capability, which changes tools and guidance: reload.
+    // A session override can switch Freeflow, a capability, a skill or a prompt, which changes tools and guidance: reload.
     reloadRequired: true,
     sessionOverrides: { ...currentSessionOverrides },
     capabilityState: await readCapabilityState(ctx.cwd, ctx),