@mrclrchtr/supi-extras 8.0.1 → 9.0.0

package/README.md

@@ -32,16 +32,47 @@ pi install npm:@mrclrchtr/supi-extras
 `/supi-capabilities` opens a searchable selector. Use it to change extension tool and skill visibility for the current session.
 
 - The selector lists only extension tools that were active at startup. It does not list PI built-in tools or tools supplied by integrations.
-- Tool and skill overrides are stored in the session. Resume restores them. Fork and `/clone-session` copy them. `/new` starts without overrides.
+- Tool and skill overrides are stored in the session. Resume restores them. Fork and `/clone-session` copy them. New sessions use the optional default profile; without a default, they start without overrides.
 - Tree navigation keeps explicit capability tool choices and does not change other tool choices.
-- Tool changes affect later requests. They do not stop a tool call that is already running.
-- Saved tool restrictions also apply if a tool becomes available later. Use **Reset Tools** to clear them.
+- The selector waits until the agent is idle before it opens. It does not interrupt a running tool call.
+- Saved tool and skill exclusions remain stored when an item is absent. They apply if the item becomes eligible later.
 - Skill changes affect the model skill catalog only. Explicit `/skill:name` commands and `$name` shortcuts stay available.
 - Use **Reset Tools**, **Reset Skills**, or **Reset All** to remove overrides.
-- The footer shows a count while overrides are active.
+- The footer shows an override count and the applied profile name. `Modified` means session exclusions differ from the copy captured when the profile was applied.
 
 Install [`@mrclrchtr/supi-skills`](https://github.com/mrclrchtr/supi/tree/main/packages/supi-skills) to manage skills. Tool controls work without that package.
 
+### Session Capability Profiles
+
+Use Tab to open **Profiles** in `/supi-capabilities`. Apply a saved profile, save current exclusions under a new name, replace or delete a saved profile, or choose a default. Saving requires an explicit global or project scope. Replacement and deletion require confirmation.
+
+Profiles contain **exclusions**, not a fixed list of available capabilities. New eligible tools and skills remain available unless their exact names are excluded. Package rows select current tools only; they do not create rules for future tools. Profiles do not change the model, instructions, child Agent Profiles, or security permissions.
+
+Store definitions in `~/.pi/agent/supi/config.json` or a trusted project's `.pi/supi/config.json`:
+
+```json
+{
+  "sessionCapabilities": {
+    "profiles": {
+      "research": {
+        "excludedTools": ["agent_run"],
+        "hiddenSkills": ["implement"]
+      }
+    },
+    "defaultProfile": "research"
+  }
+}
+```
+
+- Profile IDs contain lowercase words separated by optional hyphens. Omitted exclusion lists are empty. Unknown fields and invalid values produce errors.
+- Project profiles and defaults require Pi project trust. A project definition replaces the complete global definition with the same ID. An invalid project definition blocks that ID; it does not use the global definition instead.
+- An absent project `defaultProfile` inherits the global default. Set it to `null` to use no default in that project. Missing or invalid defaults produce a warning and normal startup without profile exclusions.
+- Applying a profile replaces both session selections and stores a separate session copy. Later configuration edits, deletion, and reload do not change that copy. Resume and fork do not apply a new default.
+- Saving a profile does not apply it. Apply it explicitly to use its current saved definition.
+- Deletion leaves default references unchanged. Deleting a project definition can expose a same-ID global definition; the confirmation explains this effect.
+- **Reset All** clears session exclusions and profile identity. It does not change saved profiles or defaults, and it does not reapply the default in the current session.
+- Manual profile management is TUI-only. Configured startup defaults also work in non-interactive modes.
+
 ## Shortcuts
 
 - `Alt+S` — stash the current editor text

package/node_modules/@mrclrchtr/supi-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-core",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "Shared settings, configuration, reporting, and session infrastructure",
   "license": "MIT",
   "repository": {

package/node_modules/@mrclrchtr/supi-core/src/debug-registry.ts

@@ -6,6 +6,9 @@
 
 export type DebugLevel = "debug" | "info" | "warning" | "error";
 export type DebugAgentAccess = "off" | "sanitized" | "raw";
+
+/** Custom session-entry type used to persist sanitized debug events. */
+export const DEBUG_EVENT_ENTRY_TYPE = "supi-debug-event";
 export interface DebugRegistryConfig {
   /** Whether producers should retain debug events. */
   enabled: boolean;
@@ -212,7 +215,7 @@ function toSanitizedView(event: DebugEvent): DebugEventView {
     category: event.category,
     message: event.message,
     cwd: event.cwd,
-    data: event.data,
+    data: event.data === undefined ? undefined : redactDebugData(event.data),
   };
 }
 
@@ -241,15 +244,17 @@ export function recordDebugEvent(input: DebugEventInput): DebugEvent | null {
   };
   state.events.push(event);
   trimToMaxEvents(state);
-  const view = toSanitizedView(event);
   for (const listener of state.listeners) {
     try {
-      listener(view);
+      listener(toSanitizedView(event));
     } catch {
       // Debug-event consumers must not alter producer behavior.
     }
   }
-  return { ...event };
+  return {
+    ...event,
+    data: event.data === undefined ? undefined : redactDebugData(event.data),
+  };
 }
 
 /** Query retained debug events newest-first. Results are sanitized unless raw access is requested and allowed. */

package/node_modules/@mrclrchtr/supi-core/src/session-capabilities.ts

@@ -1,3 +1,9 @@
+import {
+  decodeSessionCapabilityProfileSnapshot,
+  type SessionCapabilityProfile,
+  type SessionCapabilityProfileSnapshot,
+} from "./session-capability-profiles.ts";
+
 /** Session-only tool and skill visibility state. */
 export interface SessionCapabilityState {
   version: 1;
@@ -7,6 +13,8 @@ export interface SessionCapabilityState {
   /** Tools that the user explicitly enabled for this session. */
   toolEnabledNames?: string[];
   hiddenSkillNames: string[];
+  /** Original profile identity and exclusions. Later configuration changes do not affect this copy. */
+  profileSnapshot?: SessionCapabilityProfileSnapshot;
 }
 
 /** A model-visible skill that a provider can offer to the selector. */
@@ -94,8 +102,9 @@ export function decodeSessionCapabilities(value: unknown): SessionCapabilityStat
     (name) => !initiallyInactive.has(name),
   );
   const eligible = new Set(eligibleToolNames);
-  const toolDenylist = stringList(record.toolDenylist).filter((name) => eligible.has(name));
+  const toolDenylist = stringList(record.toolDenylist);
   const denied = new Set(toolDenylist);
+  const profileSnapshot = decodeSessionCapabilityProfileSnapshot(record.profileSnapshot);
 
   return {
     version: 1,
@@ -106,9 +115,54 @@ export function decodeSessionCapabilities(value: unknown): SessionCapabilityStat
       (name) => eligible.has(name) && !denied.has(name),
     ),
     hiddenSkillNames: stringList(record.hiddenSkillNames),
+    ...(profileSnapshot ? { profileSnapshot } : {}),
+  };
+}
+
+/** Copy current exclusion sets for saving. Do not use inventory to remove names. */
+export function captureSessionCapabilityExclusions(
+  state: SessionCapabilityState,
+): SessionCapabilityProfile {
+  return {
+    excludedTools: [...new Set(state.toolDenylist)],
+    hiddenSkills: [...new Set(state.hiddenSkillNames)],
   };
 }
 
+/**
+ * Replace exclusions and capture a profile copy. Return undefined for an invalid profile.
+ * Do not mutate the input state or activate tools. The caller owns runtime restoration.
+ */
+export function applySessionCapabilityProfile(
+  state: SessionCapabilityState,
+  profile: unknown,
+): SessionCapabilityState | undefined {
+  const profileSnapshot = decodeSessionCapabilityProfileSnapshot(profile);
+  if (!profileSnapshot) return undefined;
+  return decodeSessionCapabilities({
+    ...state,
+    toolDenylist: profileSnapshot.excludedTools,
+    hiddenSkillNames: profileSnapshot.hiddenSkills,
+    profileSnapshot,
+  });
+}
+
+function equalNameSets(left: readonly string[], right: readonly string[]): boolean {
+  const leftSet = new Set(left);
+  const rightSet = new Set(right);
+  return leftSet.size === rightSet.size && [...leftSet].every((name) => rightSet.has(name));
+}
+
+/** Compare current exclusions with the applied copy. No profile means no Modified marker. */
+export function isSessionCapabilityProfileModified(state: SessionCapabilityState): boolean {
+  const snapshot = state.profileSnapshot;
+  return (
+    snapshot !== undefined &&
+    (!equalNameSets(state.toolDenylist, snapshot.excludedTools) ||
+      !equalNameSets(state.hiddenSkillNames, snapshot.hiddenSkills))
+  );
+}
+
 /** Return a safe copy of the latest valid snapshot in all session entries. */
 export function findSessionCapabilities(
   entries: readonly unknown[],

package/node_modules/@mrclrchtr/supi-core/src/session-capability-profiles.ts

@@ -0,0 +1,240 @@
+/** Exact names to exclude. Omitted configuration lists mean empty sets. */
+export interface SessionCapabilityProfileDefinition {
+  excludedTools?: string[];
+  hiddenSkills?: string[];
+}
+
+/** Validated exclusion sets. Names need not match the current inventory. */
+export interface SessionCapabilityProfile {
+  excludedTools: string[];
+  hiddenSkills: string[];
+}
+
+/** A profile is available only when validation has no errors. */
+export interface SessionCapabilityProfileValidation {
+  profile?: SessionCapabilityProfile;
+  errors: string[];
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function readNames(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const names: unknown[] = [...new Set(value)];
+  return names.every((name): name is string => typeof name === "string") ? names : undefined;
+}
+
+/** Validate and copy a complete definition. Do not check inventory or expand patterns. */
+export function validateSessionCapabilityProfile(
+  value: unknown,
+): SessionCapabilityProfileValidation {
+  if (!isRecord(value)) return { errors: ["Profile must be an object."] };
+  const excludedTools = Object.hasOwn(value, "excludedTools") ? readNames(value.excludedTools) : [];
+  const hiddenSkills = Object.hasOwn(value, "hiddenSkills") ? readNames(value.hiddenSkills) : [];
+  const errors = Object.keys(value)
+    .filter((key) => key !== "excludedTools" && key !== "hiddenSkills")
+    .map((key) => `Unknown profile field: ${key}.`);
+  if (!excludedTools) errors.push("excludedTools must be an array of strings.");
+  if (!hiddenSkills) errors.push("hiddenSkills must be an array of strings.");
+  if (errors.length || !excludedTools || !hiddenSkills) return { errors };
+  return { profile: { excludedTools, hiddenSkills }, errors };
+}
+
+/** Configuration scope that supplied a profile or default. */
+export type SessionCapabilityProfileScope = "global" | "project";
+
+/** Configuration values for the sessionCapabilities section. */
+export interface SessionCapabilityProfilesSection {
+  profiles?: Record<string, SessionCapabilityProfileDefinition>;
+  defaultProfile?: string | null;
+}
+
+/** Session-owned identity and original exclusion sets, independent of configuration. */
+export interface SessionCapabilityProfileSnapshot extends SessionCapabilityProfile {
+  id: string;
+  source: SessionCapabilityProfileScope;
+}
+
+/** A configuration error with a scope and field path for display. */
+export interface SessionCapabilityProfileDiagnostic {
+  scope: SessionCapabilityProfileScope;
+  path: string;
+  message: string;
+}
+
+/** A scoped definition, including invalid definitions and hidden global definitions. */
+export interface SessionCapabilityProfileEntry {
+  id: string;
+  source: SessionCapabilityProfileScope;
+  shadowed: boolean;
+  profile?: SessionCapabilityProfile;
+  errors: SessionCapabilityProfileDiagnostic[];
+}
+
+/** Default selection source can differ from the effective profile source. */
+export type SessionCapabilityProfileDefault =
+  | { status: "none"; source?: SessionCapabilityProfileScope }
+  | {
+      status: "resolved";
+      source: SessionCapabilityProfileScope;
+      id: string;
+      profile: SessionCapabilityProfileSnapshot;
+    }
+  | { status: "invalid"; source: SessionCapabilityProfileScope; id?: string };
+
+/** Raw sections, not merged configuration. Callers must check trust before project reads. */
+export interface ResolveSessionCapabilityProfilesOptions {
+  global?: unknown;
+  project?: unknown;
+  projectTrusted: boolean;
+}
+
+/** Data for profile rows, scoped actions, and default warnings. No I/O is performed. */
+export interface SessionCapabilityProfilesResolution {
+  entries: SessionCapabilityProfileEntry[];
+  effectiveProfiles: SessionCapabilityProfileSnapshot[];
+  default: SessionCapabilityProfileDefault;
+  errors: SessionCapabilityProfileDiagnostic[];
+}
+
+/** IDs contain lowercase ASCII words separated by single hyphens. */
+export function isSessionCapabilityProfileId(value: unknown): value is string {
+  return typeof value === "string" && /^[a-z]+(?:-[a-z]+)*$/.test(value);
+}
+
+/** Validate and copy stored identity and original lists. Invalid metadata has no identity. */
+export function decodeSessionCapabilityProfileSnapshot(
+  value: unknown,
+): SessionCapabilityProfileSnapshot | undefined {
+  if (!isRecord(value) || !isSessionCapabilityProfileId(value.id)) return undefined;
+  if (value.source !== "global" && value.source !== "project") return undefined;
+  const { id, source, ...definition } = value;
+  if (!Object.hasOwn(definition, "excludedTools") || !Object.hasOwn(definition, "hiddenSkills"))
+    return undefined;
+  const result = validateSessionCapabilityProfile(definition);
+  return result.profile ? { id, source, ...result.profile } : undefined;
+}
+
+function readEntries(
+  value: unknown,
+  source: SessionCapabilityProfileScope,
+): SessionCapabilityProfileEntry[] {
+  if (!isRecord(value) || !isRecord(value.profiles)) return [];
+  return Object.entries(value.profiles).map(([id, definition]) => {
+    const result = validateSessionCapabilityProfile(definition);
+    if (!isSessionCapabilityProfileId(id))
+      result.errors.push("Invalid profile ID: use lowercase words with single hyphens.");
+    return {
+      id,
+      source,
+      shadowed: false,
+      profile: result.errors.length ? undefined : result.profile,
+      errors: result.errors.map((message) => ({ scope: source, path: `profiles.${id}`, message })),
+    };
+  });
+}
+
+type DefaultReference =
+  | SessionCapabilityProfileDefault
+  | { status: "pending"; source: SessionCapabilityProfileScope; id: string };
+
+function readDefault(
+  value: unknown,
+  source: SessionCapabilityProfileScope,
+  errors: SessionCapabilityProfileDiagnostic[],
+): DefaultReference | undefined {
+  if (!isRecord(value) || !Object.hasOwn(value, "defaultProfile")) return undefined;
+  if (value.defaultProfile === null) return { status: "none", source };
+  if (isSessionCapabilityProfileId(value.defaultProfile)) {
+    return { status: "pending", source, id: value.defaultProfile };
+  }
+  errors.push({
+    scope: source,
+    path: "defaultProfile",
+    message: "defaultProfile must be null or a valid profile ID.",
+  });
+  return { status: "invalid", source };
+}
+
+function resolveDefault(
+  selected: DefaultReference | undefined,
+  profiles: SessionCapabilityProfileSnapshot[],
+  errors: SessionCapabilityProfileDiagnostic[],
+): SessionCapabilityProfileDefault {
+  if (!selected) return { status: "none" };
+  if (selected.status !== "pending") return selected;
+  const { source, id } = selected;
+  const profile = profiles.find((entry) => entry.id === id);
+  if (profile) return { status: "resolved", source, id, profile };
+  errors.push({
+    scope: source,
+    path: "defaultProfile",
+    message: `Default profile ${id} is missing or invalid. No profile will be applied.`,
+  });
+  return { status: "invalid", source, id };
+}
+
+interface ScopedProfiles {
+  entries: SessionCapabilityProfileEntry[];
+  errors: SessionCapabilityProfileDiagnostic[];
+  default?: DefaultReference;
+}
+
+/** Reject malformed sections, but retain known IDs to prevent global fallback. */
+function readSection(value: unknown, scope: SessionCapabilityProfileScope): ScopedProfiles {
+  if (value === undefined) return { entries: [], errors: [] };
+  if (!isRecord(value)) {
+    return {
+      entries: [],
+      default: { status: "invalid", source: scope },
+      errors: [
+        { scope, path: "sessionCapabilities", message: "sessionCapabilities must be an object." },
+      ],
+    };
+  }
+  const sectionErrors = Object.keys(value)
+    .filter((key) => key !== "profiles" && key !== "defaultProfile")
+    .map((key) => ({ scope, path: key, message: `Unknown section field: ${key}.` }));
+  if (Object.hasOwn(value, "profiles") && !isRecord(value.profiles)) {
+    sectionErrors.push({ scope, path: "profiles", message: "profiles must be an object." });
+  }
+  const entries = readEntries(value, scope);
+  const errors = [...sectionErrors, ...entries.flatMap((entry) => entry.errors)];
+  const selection = readDefault(value, scope, errors);
+  if (sectionErrors.length) {
+    for (const entry of entries) {
+      entry.profile = undefined;
+      entry.errors.push(...sectionErrors);
+    }
+    return { entries, errors, default: { status: "invalid", source: scope } };
+  }
+  return { entries, errors, default: selection };
+}
+
+/**
+ * Resolve whole profiles by ID. Ignore project data unless projectTrusted is true.
+ * An absent section is undefined. Malformed sections cannot supply profiles or a default.
+ */
+export function resolveSessionCapabilityProfiles(
+  options: ResolveSessionCapabilityProfilesOptions,
+): SessionCapabilityProfilesResolution {
+  const global = readSection(options.global, "global");
+  const project = readSection(options.projectTrusted ? options.project : undefined, "project");
+  const entries = [...global.entries, ...project.entries];
+  const errors = [...global.errors, ...project.errors];
+  const selected = new Map(entries.map((entry) => [entry.id, entry]));
+  for (const entry of entries) entry.shadowed = selected.get(entry.id) !== entry;
+  const effectiveProfiles = [...selected.values()].flatMap((entry) =>
+    entry.profile ? [{ id: entry.id, source: entry.source, ...entry.profile }] : [],
+  );
+  return {
+    entries,
+    effectiveProfiles,
+    default: resolveDefault(project.default ?? global.default, effectiveProfiles, errors),
+    errors,
+  };
+}

package/node_modules/@mrclrchtr/supi-core/src/session.ts

@@ -7,17 +7,39 @@ export type {
   SessionCapabilityState,
 } from "./session-capabilities.ts";
 export {
+  applySessionCapabilityProfile,
+  captureSessionCapabilityExclusions,
   clearPendingSessionCapabilityForks,
   createEmptySessionCapabilityState,
   decodeSessionCapabilities,
   findSessionCapabilities,
   getSessionCapabilitySkillProvider,
+  isSessionCapabilityProfileModified,
   readPendingSessionCapabilityFork,
   registerSessionCapabilitySkillProvider,
   SESSION_CAPABILITIES_ENTRY,
   sessionCapabilityState,
   setPendingSessionCapabilityFork,
 } from "./session-capabilities.ts";
+export type {
+  ResolveSessionCapabilityProfilesOptions,
+  SessionCapabilityProfile,
+  SessionCapabilityProfileDefault,
+  SessionCapabilityProfileDefinition,
+  SessionCapabilityProfileDiagnostic,
+  SessionCapabilityProfileEntry,
+  SessionCapabilityProfileScope,
+  SessionCapabilityProfileSnapshot,
+  SessionCapabilityProfilesResolution,
+  SessionCapabilityProfilesSection,
+  SessionCapabilityProfileValidation,
+} from "./session-capability-profiles.ts";
+export {
+  decodeSessionCapabilityProfileSnapshot,
+  isSessionCapabilityProfileId,
+  resolveSessionCapabilityProfiles,
+  validateSessionCapabilityProfile,
+} from "./session-capability-profiles.ts";
 export type { SessionNameTrackerHost } from "./session-utils.ts";
 export {
   createSessionNameTracker,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mrclrchtr/supi-extras",
-  "version": "8.0.1",
+  "version": "9.0.0",
   "description": "Session capability controls, prompt stash, shortcuts, and activity indicators",
   "license": "MIT",
   "repository": {
@@ -33,7 +33,7 @@
   ],
   "dependencies": {
     "clipboardy": "^5.3.1",
-    "@mrclrchtr/supi-core": "8.0.1"
+    "@mrclrchtr/supi-core": "9.0.0"
   },
   "bundledDependencies": [
     "@mrclrchtr/supi-core"

package/src/session-capabilities-selector.ts

@@ -0,0 +1,67 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type {
+  SessionCapabilityProfileSnapshot,
+  SessionCapabilitySkill,
+  SessionCapabilityState,
+} from "@mrclrchtr/supi-core/session";
+import {
+  type CapabilityProfileAction,
+  type CapabilityToolItem,
+  createCapabilitySelector,
+} from "./session-capabilities-ui.ts";
+import type { CapabilitySection } from "./session-capabilities-ui-rows.ts";
+import { createCapabilityProfileStore } from "./session-capability-profile-store.ts";
+import {
+  buildCapabilityProfileRows,
+  runCapabilityProfileAction,
+} from "./session-capability-profile-ui.ts";
+
+interface SelectorOptions {
+  ctx: ExtensionCommandContext;
+  homeDir?: string;
+  state: SessionCapabilityState;
+  tools: CapabilityToolItem[];
+  skills: SessionCapabilitySkill[] | undefined;
+  onChange(id: string, value: string): void;
+  onApply(profile: SessionCapabilityProfileSnapshot): void;
+}
+
+/** Close custom UI before built-in dialogs, then reopen Profiles with current configuration. */
+export async function openCapabilitySelector(options: SelectorOptions): Promise<void> {
+  const { ctx, state, tools, skills } = options;
+  const store = createCapabilityProfileStore({
+    cwd: ctx.cwd,
+    homeDir: options.homeDir,
+    isProjectTrusted: () => ctx.isProjectTrusted(),
+  });
+  let initialSection: CapabilitySection = "tools";
+  while (true) {
+    const profileRows = buildCapabilityProfileRows({
+      catalog: store.read(),
+      tools,
+      skills,
+      projectTrusted: ctx.isProjectTrusted(),
+    });
+    const action = await ctx.ui.custom<CapabilityProfileAction | undefined>(
+      (tui, theme, _keys, done) =>
+        createCapabilitySelector({
+          state,
+          tools,
+          skills,
+          profileRows,
+          initialSection,
+          theme,
+          tui,
+          done,
+          onChange: options.onChange,
+        }),
+    );
+    if (!action) return;
+    try {
+      await runCapabilityProfileAction(action, { ctx, store, state, apply: options.onApply });
+    } catch (error) {
+      ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+    }
+    initialSection = "profiles";
+  }
+}

package/src/session-capabilities-tools.ts

@@ -83,7 +83,6 @@ export function reconcileToolInventory(
 
   state.initiallyInactiveToolNames = Array.from(initiallyInactive);
   state.eligibleToolNames = Array.from(eligible);
-  state.toolDenylist = state.toolDenylist.filter((name) => eligible.has(name));
   state.toolEnabledNames = (state.toolEnabledNames ?? []).filter(
     (name) => eligible.has(name) && !state.toolDenylist.includes(name),
   );

package/src/session-capabilities-ui-rows.ts

@@ -2,7 +2,13 @@ import type { SelectItem } from "@earendil-works/pi-tui";
 import type { SessionCapabilitySkill, SessionCapabilityState } from "@mrclrchtr/supi-core/session";
 
 /** A section shown by the session capability selector. */
-export type CapabilitySection = "tools" | "skills";
+export type CapabilitySection = "tools" | "skills" | "profiles";
+
+/** A profile action returned after the selector closes, before any dialog opens. */
+export interface CapabilityProfileAction {
+  id: string;
+  value: string;
+}
 
 /** A tool row that the session selector can display. */
 export interface CapabilityToolItem {
@@ -182,11 +188,14 @@ function skillRows(
 }
 
 /** Build the rows for one session capability section. */
-export function buildCapabilityRows(
-  section: CapabilitySection,
-  tools: CapabilityToolItem[],
-  skills: SessionCapabilitySkill[] | undefined,
-  state: SessionCapabilityState,
-): CapabilityRow[] {
+export function buildCapabilityRows(options: {
+  section: CapabilitySection;
+  tools: CapabilityToolItem[];
+  skills: SessionCapabilitySkill[] | undefined;
+  state: SessionCapabilityState;
+  profileRows?: CapabilityRow[];
+}): CapabilityRow[] {
+  const { section, tools, skills, state, profileRows = [] } = options;
+  if (section === "profiles") return profileRows;
   return section === "tools" ? toolRows(tools, state) : skillRows(skills, state);
 }