@aragon-agent/cli 0.6.34 → 0.6.35

package/dist/ui/overlays/kit-picker-state.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The `ctrl+K` list, as a pure view model (agent-model-kits §4.6 / D-10).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHY THE ROWS ARE COMPUTED HERE AND NOT IN THE COMPONENT: three surfaces print
+ * the same three connections (this list, the settings manager, `/kit list`).
+ * One function produces them, so the wording of "the fast tier is off" cannot
+ * differ between the key the user pressed and the command they typed.
+ */
+import type { CliConfig, TeamConfig } from '../../config/schema.js';
+import type { ModelProfilesConfig } from '../../config/model-profiles.js';
+import { type KitConnection, type KitSlot } from '../../config/model-kits.js';
+import { type ActiveKit } from '../../config/kit-resolution.js';
+export interface KitPickerRow {
+    /** `null` = `Current setup` (the release action). */
+    id: string | null;
+    /** The one-line label, markers included. */
+    label: string;
+    /** Machine-checkable markers, so tests never grep a rendered string. */
+    markers: {
+        inUse: boolean;
+        isDefault: boolean;
+        modified: boolean;
+    };
+    /** Non-empty when a referenced profile is gone. */
+    missing: KitSlot[];
+}
+export interface KitPickerInput {
+    library?: ModelProfilesConfig | undefined;
+    active: ActiveKit;
+}
+/** `provider:model` plus the endpoint clause shared by every surface. */
+export declare function connectionText(connection: KitConnection): string;
+/**
+ * Rows in a FIXED order: `Current setup` first, then the library's own order.
+ *
+ * The first row never moves (AC-24) - it is the only row that can always be
+ * chosen, and a list whose "off" entry wanders with the data is a list a user
+ * has to read every single time.
+ */
+export declare function kitRows(input: KitPickerInput): KitPickerRow[];
+/**
+ * The three bindings `Current setup` describes.
+ *
+ * STRUCTURAL, NOT `CliConfig`: the caller hands in the PERSISTED config for this
+ * block (§4.6), because the live config no longer holds the file's bindings once
+ * a session kit is applied - it mirrors the kit (I-6). Both shapes satisfy this
+ * interface, so neither layer has to convert anything.
+ */
+export interface KitConnectionsSource {
+    provider: string;
+    model: string;
+    team?: {
+        model: TeamConfig['model'];
+        modelProfileId?: string | null;
+    } | undefined;
+    fast: {
+        enabled: boolean;
+        provider: string;
+        model: string;
+    };
+    modelProfiles?: ModelProfilesConfig | undefined;
+}
+/** The three lines under the focused row (§4.6). */
+export declare function kitDetail(input: {
+    row: KitPickerRow;
+    library?: ModelProfilesConfig | undefined;
+    config: CliConfig;
+    /** The config file's copy of the bindings; see the `Current setup` note below. */
+    diskConfig?: KitConnectionsSource | undefined;
+}): string[];
+/**
+ * The footer. `busy` is a warning, never a reason to hide the list (§4.7).
+ *
+ * THE LAST CLAUSE IS D-7, VERBATIM: this overlay is a session-only surface, so it
+ * says where the persistence actually lives. Without it the natural reading of
+ * `Enter` is "make this my default", and D-7 exists to keep that action one
+ * deliberate trip to `/settings` instead of one keystroke next to a browse key.
+ * It is LAST so that a 40-column terminal clips the pointer, never the action.
+ */
+export declare function kitPickHint(input: {
+    busy: boolean;
+    hasKits: boolean;
+}): string;
+/** The one guidance row an empty library renders (AC-26). */
+export declare const NO_KITS_HINT = "No kits yet. Create one in /settings (Settings > Kit pack).";

package/dist/ui/overlays/kit-picker-state.js

@@ -0,0 +1,136 @@
+/**
+ * The `ctrl+K` list, as a pure view model (agent-model-kits §4.6 / D-10).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHY THE ROWS ARE COMPUTED HERE AND NOT IN THE COMPONENT: three surfaces print
+ * the same three connections (this list, the settings manager, `/kit list`).
+ * One function produces them, so the wording of "the fast tier is off" cannot
+ * differ between the key the user pressed and the command they typed.
+ */
+import { kitSlotConnections } from '../../config/model-kits.js';
+import { CURRENT_SETUP_NAME } from '../../config/kit-resolution.js';
+function duplicateNames(kits) {
+    const seen = new Set();
+    const repeated = new Set();
+    for (const kit of kits) {
+        if (seen.has(kit.name))
+            repeated.add(kit.name);
+        seen.add(kit.name);
+    }
+    return repeated;
+}
+/** `provider:model` plus the endpoint clause shared by every surface. */
+export function connectionText(connection) {
+    const endpoint = connection.baseUrl ? hostOf(connection.baseUrl) : 'default URL';
+    return `${connection.provider}:${connection.model}  ${endpoint}`;
+}
+function hostOf(baseUrl) {
+    try {
+        const url = new URL(baseUrl);
+        return url.username || url.password || url.search || url.hash ? 'Invalid URL' : url.host;
+    }
+    catch {
+        return 'Invalid URL';
+    }
+}
+/**
+ * Rows in a FIXED order: `Current setup` first, then the library's own order.
+ *
+ * The first row never moves (AC-24) - it is the only row that can always be
+ * chosen, and a list whose "off" entry wanders with the data is a list a user
+ * has to read every single time.
+ */
+export function kitRows(input) {
+    const kits = input.library?.kits ?? [];
+    const repeated = duplicateNames(kits);
+    const rows = [{
+            id: null,
+            label: `${input.active.source === 'none' ? '[In use] ' : ''}${CURRENT_SETUP_NAME}`,
+            markers: { inUse: input.active.source === 'none', isDefault: false, modified: false },
+            missing: [],
+        }];
+    for (const kit of kits) {
+        const inUse = input.active.source !== 'none' && input.active.id === kit.id;
+        const isDefault = (input.library?.defaultKitId ?? null) === kit.id;
+        const modified = inUse && input.active.modified;
+        const missing = inUse ? input.active.missingProfiles : [];
+        // A DUPLICATE NAME gets its id prefix, exactly as the profile picker does:
+        // two rows reading `Cheap` would make Enter a coin flip.
+        const identity = repeated.has(kit.name) ? `#${kit.id.slice(0, 8)} ` : '';
+        const markers = [inUse ? '[In use]' : '', isDefault ? '[Default]' : '']
+            .filter(Boolean).join(' ');
+        rows.push({
+            id: kit.id,
+            label: `${identity}${markers ? `${markers} ` : ''}${kit.name}${modified ? '~' : ''}`,
+            markers: { inUse, isDefault, modified },
+            missing,
+        });
+    }
+    return rows;
+}
+function subagentText(config) {
+    const mode = config.team?.model ?? 'main';
+    if (mode === 'main')
+        return 'same as main';
+    if (mode === 'fast')
+        return 'fast tier model';
+    const id = config.team?.modelProfileId ?? null;
+    const entry = id ? config.modelProfiles?.entries.find((item) => item.id === id) : undefined;
+    return entry ? `profile ${entry.name}` : 'Profile missing';
+}
+/** The three lines under the focused row (§4.6). */
+export function kitDetail(input) {
+    const { row, library, config } = input;
+    const kit = row.id ? (library?.kits ?? []).find((item) => item.id === row.id) : undefined;
+    if (!kit) {
+        // `Current setup` describes the FILE's bindings - what the next process
+        // would run - because that is exactly what choosing it restores.
+        //
+        // THE LIVE CONFIG IS THE WRONG SOURCE WHILE A SESSION KIT IS HELD: it mirrors
+        // the kit (I-6), so this block would print the current values and thereby
+        // promise that releasing the kit changes nothing. The first row is the only
+        // row whose whole meaning is "what the file says", so it is the only one that
+        // has to be read from the file.
+        const file = input.diskConfig ?? config;
+        const fast = file.fast.enabled
+            ? `${file.fast.provider || file.provider}:${file.fast.model || '(not set)'}`
+            : 'off';
+        return [`main      ${file.provider}:${file.model}`,
+            `subagent  ${subagentText(file)}`,
+            `fast      ${fast}`];
+    }
+    const connections = kitSlotConnections(library, kit);
+    const mainLine = connections.main ? connectionText(connections.main) : 'Profile missing';
+    const fastLine = kit.fastProfileId === null ? 'off (this kit turns the tier off)'
+        : connections.fast ? `${connectionText(connections.fast)}  tier on` : 'Profile missing';
+    // THE SUBAGENT LINE REUSES THE SLOT'S OWN THREE-STATE VOCABULARY (`same as main`
+    // / `fast tier` / a profile), so this block and the settings screen's subagent
+    // row cannot say different things about the same kit.
+    const subagentLine = kit.subagent.model === 'main' ? 'same as main'
+        : kit.subagent.model === 'fast'
+            ? (connections.fast ? 'fast tier' : 'fast tier (off - falls back to main)')
+            : connections.subagent.name
+                ? `profile ${connections.subagent.name}  ${connections.subagent.provider}:${connections.subagent.model}` : 'Profile missing';
+    return [`main      ${mainLine}`, `subagent  ${subagentLine}`, `fast      ${fastLine}`];
+}
+/**
+ * The footer. `busy` is a warning, never a reason to hide the list (§4.7).
+ *
+ * THE LAST CLAUSE IS D-7, VERBATIM: this overlay is a session-only surface, so it
+ * says where the persistence actually lives. Without it the natural reading of
+ * `Enter` is "make this my default", and D-7 exists to keep that action one
+ * deliberate trip to `/settings` instead of one keystroke next to a browse key.
+ * It is LAST so that a 40-column terminal clips the pointer, never the action.
+ */
+export function kitPickHint(input) {
+    if (!input.hasKits)
+        return 'Esc close | Create a kit in /settings';
+    if (input.busy) {
+        return 'Enter use for this session (blocked while running) | Esc close'
+            + ' | Set a default in /settings';
+    }
+    return 'Enter use for this session | Esc close | Set a default in /settings';
+}
+/** The one guidance row an empty library renders (AC-26). */
+export const NO_KITS_HINT = 'No kits yet. Create one in /settings (Settings > Kit pack).';

package/dist/ui/overlays/kit-settings-state.d.ts

@@ -0,0 +1,129 @@
+/**
+ * The settings screen's kit pages: manager rows, the editor draft, and the ONE
+ * reducer that turns intents into draft mutations (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * TWO REDUCERS, ONE PAGE AXIS. `modelProfileReducer` owns the profile pages and
+ * `kitReducer` owns kit data; both return the same `ModelProfileState`, so the
+ * screen still has exactly one state object and one Save button. The alternative
+ * - a second state machine inside `SettingsScreen.tsx`, which is already over the
+ * 1000-line cap - is what this module exists to avoid.
+ *
+ * NOTHING HERE WRITES ANYTHING: every action mutates the transaction draft and
+ * sets `dirty`. `Save` stays the only writer (F-7/F-10).
+ */
+import type { KitSlot, AgentKit } from '../../config/model-kits.js';
+import type { ModelProfilesConfig } from '../../config/model-profiles.js';
+import type { SubagentModelMode } from '../../team/model.js';
+import type { ModelProfileState } from './model-profile-state.js';
+export interface KitDraft {
+    /** `null` while creating; the delete confirmation reuses this field as its id. */
+    id: string | null;
+    name: string;
+    mainProfileId: string;
+    /** `null` = this kit turns the fast tier off (D-8). */
+    fastProfileId: string | null;
+    subagent: {
+        model: SubagentModelMode;
+        modelProfileId: string | null;
+    };
+    /** Which slot the profile picker is choosing for; `null` on the editor page. */
+    slot: KitSlot | null;
+    error?: string;
+    /** The row the cursor jumps to when `error` is set (focus-lands-on-error). */
+    field?: KitSlot | 'name';
+}
+export type KitAction = {
+    type: 'kit-open';
+    id: string | null;
+} | {
+    type: 'kit-name';
+    value: string;
+} | {
+    type: 'kit-slot';
+    slot: KitSlot;
+} | {
+    type: 'kit-main';
+    id: string | null;
+} | {
+    type: 'kit-fast';
+    id: string | null;
+} | {
+    type: 'kit-subagent';
+    model: SubagentModelMode;
+    modelProfileId: string | null;
+} | {
+    type: 'kit-save';
+} | {
+    type: 'kit-cancel';
+} | {
+    type: 'kit-duplicate';
+    id: string;
+} | {
+    type: 'kit-delete';
+    id: string;
+} | {
+    type: 'kit-confirm-delete';
+} | {
+    type: 'kit-apply';
+    id: string;
+} | {
+    type: 'kit-default';
+    id: string;
+};
+/** The library the transaction would save, with a read error falling back to empty. */
+export declare function draftLibrary(state: ModelProfileState): ModelProfilesConfig;
+export declare function findKitInState(state: ModelProfileState, id: string | null): AgentKit | undefined;
+/**
+ * Open the editor on an existing kit, or on a PREFILLED new one (§4.10).
+ *
+ * THE FIRST KIT IS NEVER A BLANK FORM (D-13): it starts from the three bindings
+ * this machine already runs, so "create a kit" is one rename and one Save. When
+ * no Main profile is bound the kit starts with an empty main slot and Save
+ * refuses - the picker's own `Create profile` action is where a profile is born,
+ * which keeps this module free of the profile-creating code path.
+ */
+export declare function openKitDraft(state: ModelProfileState, id: string | null): KitDraft;
+/** Every kit-page intent, applied to the ONE draft. */
+export declare function kitReducer(state: ModelProfileState, action: KitAction): ModelProfileState;
+/** One manager row: the label with its markers, plus the three-slot summary. */
+export interface KitManagerRow {
+    id: string;
+    label: string;
+    summary: string;
+    isDefault: boolean;
+    inUse: boolean;
+}
+/** Rows in library order, each with the markers the picker also uses (§4.5). */
+export declare function kitManagerRows(state: ModelProfileState): KitManagerRow[];
+/**
+ * The `Kit pack` root row's five states (§4.5 table, AC-27).
+ *
+ * READ FROM THE DRAFT, not from the live config: the row sits inside a
+ * transaction, and showing the saved state under a pending selection is how a
+ * settings screen lies to the user about what `Save` is going to do.
+ */
+export declare function kitPackRow(state: ModelProfileState): string;
+/** Which of the three root rows must show the KIT's value, and under which name. */
+export interface HeldSlots {
+    kitName: string | null;
+    /** The slots the session kit still owns; `mainId`/`fastId` are only meaningful
+     *  for a slot in this list (`null` means "this kit turns the tier off"). */
+    held: KitSlot[];
+    mainId: string | null;
+    fastId: string | null;
+    subagent: {
+        model: SubagentModelMode;
+        modelProfileId: string | null;
+    } | null;
+}
+/**
+ * The held slots' EFFECTIVE values (RV-P0-2).
+ *
+ * WITHOUT THIS the root page shows the file's bindings while the header shows the
+ * kit's, and the only conclusion available to the user is that one of them is
+ * broken. `Enter` on any of these rows writes an explicit choice, which releases
+ * that slot - so "what you see is what you change" stays true.
+ */
+export declare function heldSlots(state: ModelProfileState): HeldSlots;

package/dist/ui/overlays/kit-settings-state.js

@@ -0,0 +1,267 @@
+/**
+ * The settings screen's kit pages: manager rows, the editor draft, and the ONE
+ * reducer that turns intents into draft mutations (agent-model-kits §4.5).
+ *
+ * ASCII ONLY - `src/ui/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * TWO REDUCERS, ONE PAGE AXIS. `modelProfileReducer` owns the profile pages and
+ * `kitReducer` owns kit data; both return the same `ModelProfileState`, so the
+ * screen still has exactly one state object and one Save button. The alternative
+ * - a second state machine inside `SettingsScreen.tsx`, which is already over the
+ * 1000-line cap - is what this module exists to avoid.
+ *
+ * NOTHING HERE WRITES ANYTHING: every action mutates the transaction draft and
+ * sets `dirty`. `Save` stays the only writer (F-7/F-10).
+ */
+import { KIT_LIMITS, createAgentKit, duplicateAgentKit, findKit, kitCandidate, kitSlotConnections } from '../../config/model-kits.js';
+import { resolveActiveKit } from '../../config/kit-resolution.js';
+import { emptyModelProfiles } from '../../config/model-profiles.js';
+/** The library the transaction would save, with a read error falling back to empty. */
+export function draftLibrary(state) {
+    return state.draft.profiles ?? emptyModelProfiles();
+}
+function kitsOf(state) { return draftLibrary(state).kits ?? []; }
+export function findKitInState(state, id) {
+    return id ? findKit(draftLibrary(state), id) : undefined;
+}
+/**
+ * Open the editor on an existing kit, or on a PREFILLED new one (§4.10).
+ *
+ * THE FIRST KIT IS NEVER A BLANK FORM (D-13): it starts from the three bindings
+ * this machine already runs, so "create a kit" is one rename and one Save. When
+ * no Main profile is bound the kit starts with an empty main slot and Save
+ * refuses - the picker's own `Create profile` action is where a profile is born,
+ * which keeps this module free of the profile-creating code path.
+ */
+export function openKitDraft(state, id) {
+    const existing = findKitInState(state, id);
+    if (existing) {
+        return { id: existing.id, name: existing.name, mainProfileId: existing.mainProfileId,
+            fastProfileId: existing.fastProfileId,
+            subagent: { ...existing.subagent }, slot: null };
+    }
+    const library = draftLibrary(state);
+    const team = state.draft.baseline.team;
+    return {
+        id: null,
+        name: `Kit ${kitsOf(state).length + 1}`,
+        mainProfileId: library.mainId ?? '',
+        // `fastId` alone is not enough: a tier that is switched OFF is off, and
+        // prefilling its endpoint would silently turn it back on at the first Save.
+        fastProfileId: state.draft.baseline.fast.enabled ? library.fastId ?? null : null,
+        subagent: { model: team.model, modelProfileId: team.modelProfileId ?? null },
+        slot: null,
+    };
+}
+function withDraft(state, kitDraft) {
+    return { ...state, kitDraft, error: undefined };
+}
+function saveKitDraft(state) {
+    const kitDraft = state.kitDraft;
+    if (!kitDraft)
+        return state;
+    const name = [...kitDraft.name.trim()];
+    if (!name.length) {
+        return withDraft(state, { ...kitDraft, error: 'Name: enter a name for this kit.',
+            field: 'name' });
+    }
+    if (!kitDraft.mainProfileId) {
+        return withDraft(state, { ...kitDraft, error: 'Main profile: choose a profile.',
+            field: 'main' });
+    }
+    if (kitDraft.subagent.model === 'profile' && !kitDraft.subagent.modelProfileId) {
+        return withDraft(state, { ...kitDraft, error: 'Subagent: choose a profile.',
+            field: 'subagent' });
+    }
+    const library = draftLibrary(state);
+    const kits = library.kits ?? [];
+    const fields = { name: name.slice(0, KIT_LIMITS.nameMaxChars).join(''),
+        mainProfileId: kitDraft.mainProfileId, fastProfileId: kitDraft.fastProfileId,
+        subagent: { ...kitDraft.subagent } };
+    let merged;
+    if (kitDraft.id) {
+        const existing = kits.find((kit) => kit.id === kitDraft.id);
+        if (!existing)
+            return { ...state, page: 'kits', kitDraft: undefined };
+        merged = kits.map((kit) => (kit.id === kitDraft.id ? { ...existing, ...fields } : kit));
+    }
+    else {
+        if (kits.length >= KIT_LIMITS.maxKits) {
+            return withDraft(state, { ...kitDraft,
+                error: `Maximum ${KIT_LIMITS.maxKits} kits. Delete an unused kit first.` });
+        }
+        merged = [...kits, createAgentKit(fields)];
+    }
+    return { ...state, page: 'kits', kitDraft: undefined, dirty: true,
+        draft: { ...state.draft, profiles: { ...library, kits: merged } } };
+}
+/** Exit A: the kit's three slots become the draft's bindings (§4.2). */
+function applyKitToDraft(state, id, asDefault) {
+    const library = draftLibrary(state);
+    const kit = findKit(library, id);
+    if (!kit)
+        return state;
+    const patch = kitCandidate({ library, kit, ...(asDefault ? { defaultKitId: kit.id } : {}) });
+    return { ...state, dirty: true, page: 'kits', kitDraft: undefined,
+        draft: { ...state.draft,
+            profiles: patch.modelProfiles,
+            patch: { ...state.draft.patch, team: patch.team,
+                fast: { ...state.draft.patch.fast, ...patch.fast } },
+            // I-13: a kit that turns the tier off must NOT project the fast role.
+            activateRoles: [...new Set([...state.draft.activateRoles,
+                    'main', ...(kit.fastProfileId === null ? [] : ['fast'])])],
+            // The transaction now decides all three slots, so the session kit is done
+            // (§4.3 row 4). Leaving it held would make the save ambiguous.
+            sessionKit: null } };
+}
+function removeKit(state, id) {
+    const library = draftLibrary(state);
+    const remaining = (library.kits ?? []).filter((kit) => kit.id !== id);
+    const released = state.draft.sessionKit?.id === id ? null : state.draft.sessionKit;
+    return { ...state, page: 'kits', kitDraft: undefined, dirty: true,
+        draft: { ...state.draft, sessionKit: released,
+            profiles: { ...library, kits: remaining,
+                defaultKitId: (library.defaultKitId ?? null) === id ? null : library.defaultKitId } } };
+}
+/** Every kit-page intent, applied to the ONE draft. */
+export function kitReducer(state, action) {
+    const kitDraft = state.kitDraft;
+    switch (action.type) {
+        case 'kit-open':
+            return { ...state, page: 'kit-edit', error: undefined,
+                kitDraft: openKitDraft(state, action.id) };
+        case 'kit-name':
+            if (!kitDraft)
+                return state;
+            // Control characters are stripped at the boundary rather than refused: a
+            // pasted name with a stray newline should become a name, not an error.
+            return withDraft(state, { ...kitDraft,
+                name: [...action.value.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')]
+                    .slice(0, KIT_LIMITS.nameMaxChars).join(''), error: undefined });
+        case 'kit-slot':
+            return kitDraft ? { ...state, page: 'kit-slot',
+                kitDraft: { ...kitDraft, slot: action.slot } } : state;
+        case 'kit-main':
+            return kitDraft ? { ...state, page: 'kit-edit',
+                kitDraft: { ...kitDraft, mainProfileId: action.id ?? '', slot: null, error: undefined } }
+                : state;
+        case 'kit-fast':
+            return kitDraft ? { ...state, page: 'kit-edit',
+                kitDraft: { ...kitDraft, fastProfileId: action.id, slot: null, error: undefined } } : state;
+        case 'kit-subagent':
+            return kitDraft ? { ...state, page: 'kit-edit', kitDraft: { ...kitDraft,
+                    subagent: { model: action.model, modelProfileId: action.modelProfileId },
+                    slot: null, error: undefined } } : state;
+        case 'kit-save': return saveKitDraft(state);
+        case 'kit-cancel': return { ...state, page: 'kits', kitDraft: undefined, error: undefined };
+        case 'kit-duplicate': {
+            const library = draftLibrary(state);
+            const original = findKit(library, action.id);
+            if (!original || (library.kits ?? []).length >= KIT_LIMITS.maxKits)
+                return state;
+            return { ...state, page: 'kits', dirty: true, draft: { ...state.draft,
+                    profiles: { ...library,
+                        kits: [...(library.kits ?? []), duplicateAgentKit(original, library.kits ?? [])] } } };
+        }
+        case 'kit-delete': return { ...state, page: 'kit-delete',
+            kitDraft: { ...(kitDraft ?? openKitDraft(state, action.id)), id: action.id } };
+        case 'kit-confirm-delete': return kitDraft?.id ? removeKit(state, kitDraft.id) : state;
+        case 'kit-apply': return applyKitToDraft(state, action.id, false);
+        case 'kit-default': return applyKitToDraft(state, action.id, true);
+        default: return state;
+    }
+}
+function shortConnection(connection) {
+    return connection ? `${connection.provider}:${connection.model}` : 'Profile missing';
+}
+function subagentSummary(connections, kit) {
+    if (kit.subagent.model === 'main')
+        return 'same as main';
+    if (kit.subagent.model === 'fast')
+        return 'fast tier';
+    return connections.subagent.name ? `profile ${connections.subagent.name}` : 'Profile missing';
+}
+/** Rows in library order, each with the markers the picker also uses (§4.5). */
+export function kitManagerRows(state) {
+    const library = draftLibrary(state);
+    return (library.kits ?? []).map((kit) => {
+        const connections = kitSlotConnections(library, kit);
+        const isDefault = (library.defaultKitId ?? null) === kit.id;
+        const inUse = state.draft.sessionKit?.id === kit.id;
+        const markers = [isDefault ? '[Default]' : '', inUse ? '[In use]' : '']
+            .filter(Boolean).join(' ');
+        const fast = kit.fastProfileId === null ? 'off' : shortConnection(connections.fast);
+        return {
+            id: kit.id,
+            label: `${markers ? `${markers} ` : ''}${kit.name}`,
+            summary: [shortConnection(connections.main), fast, subagentSummary(connections, kit)]
+                .join(' | '),
+            isDefault,
+            inUse,
+        };
+    });
+}
+/**
+ * Whether the kit this transaction opened on had already drifted (§4.8).
+ *
+ * READ FROM `liveBaseline`, i.e. the config the screen was opened over, because
+ * drift is a fact about the SESSION - the draft cannot change a connection
+ * without releasing the slot, so there is nothing newer to look at.
+ */
+function liveDrift(state, session) {
+    // THE DRAFT'S `held`, NOT `liveBaseline.sessionKit`: the transaction may already
+    // have given slots back, and the row has to describe THIS transaction.
+    const live = resolveActiveKit({ ...state.draft.liveBaseline, sessionKit: session });
+    return live.source === 'session' && live.modified;
+}
+/**
+ * The `Kit pack` root row's five states (§4.5 table, AC-27).
+ *
+ * READ FROM THE DRAFT, not from the live config: the row sits inside a
+ * transaction, and showing the saved state under a pending selection is how a
+ * settings screen lies to the user about what `Save` is going to do.
+ */
+export function kitPackRow(state) {
+    const library = draftLibrary(state);
+    const kits = library.kits ?? [];
+    const session = state.draft.sessionKit;
+    const sessionKit = session ? findKit(library, session.id) : undefined;
+    const defaultKit = findKit(library, library.defaultKitId ?? null);
+    const defaultClause = defaultKit ? `  (default: ${defaultKit.name})` : '';
+    if (sessionKit && session) {
+        const partial = session.held.length < 3;
+        const held = partial ? `: ${session.held.join('+')}` : '';
+        // THE SAME `~` THE CHIP SHOWS (D-12): dropping a slot is only ONE way to
+        // drift. The other is a connection that `/model`, `/fast` or `/team model`
+        // rewrote after the kit was applied, and a row that stayed silent about that
+        // would disagree with the status bar about the same session.
+        const drift = liveDrift(state, session) ? '~' : '';
+        return `${sessionKit.name}  [session${held}]${drift}${defaultClause}`;
+    }
+    if (defaultKit)
+        return `${defaultKit.name}  [default]`;
+    return kits.length ? 'Current setup' : 'Current setup  (no kit yet)';
+}
+/**
+ * The held slots' EFFECTIVE values (RV-P0-2).
+ *
+ * WITHOUT THIS the root page shows the file's bindings while the header shows the
+ * kit's, and the only conclusion available to the user is that one of them is
+ * broken. `Enter` on any of these rows writes an explicit choice, which releases
+ * that slot - so "what you see is what you change" stays true.
+ */
+export function heldSlots(state) {
+    const session = state.draft.sessionKit;
+    const kit = session ? findKitInState(state, session.id) : undefined;
+    if (!session || !kit) {
+        return { kitName: null, held: [], mainId: null, fastId: null, subagent: null };
+    }
+    const held = session.held;
+    return {
+        kitName: kit.name,
+        held,
+        mainId: held.includes('main') ? kit.mainProfileId : null,
+        fastId: held.includes('fast') ? kit.fastProfileId : null,
+        subagent: held.includes('subagent') ? { ...kit.subagent } : null,
+    };
+}