@aragon-agent/cli 0.6.33 → 0.6.35

package/dist/agent/model-profile-settings.js

@@ -4,7 +4,10 @@ import { mergePersistedConfig } from '../config/store.js';
 import { adaptLegacyConnectionPatch, assertLegacyFastTarget, commitModelSettings, readModelSettingsDisk, } from '../config/model-profile-store.js';
 import { projectModelProfiles, resolveModelProfileState } from '../config/model-profile-resolution.js';
 import { validateModelProfiles } from '../config/model-profiles.js';
+import { applyHeldToLive, carrySessionKit } from '../config/kit-resolution.js';
+import { findKit } from '../config/model-kits.js';
 import { registerProfileSecrets } from '../logging/secret-registry.js';
+import { getLogger } from '../logging/logger.js';
 /** Capture both baselines when the editor opens, without migrating or writing anything. */
 export function createModelSettingsDraft(live, liveRevision) {
     const disk = readModelSettingsDisk();
@@ -15,6 +18,11 @@ export function createModelSettingsDraft(live, liveRevision) {
         profiles: disk.config?.modelProfiles
             ? structuredClone(disk.config.modelProfiles) : undefined,
         activateRoles: [], patch: {},
+        // SEEDED FROM THE LIVE CONFIG (RV-P0-2). Without this line `draft.sessionKit`
+        // is always `undefined`, the `undefined` case below means "release", and any
+        // save made from the settings screen would silently drop a session kit the
+        // user just applied - the exact opposite of "this session only".
+        sessionKit: live.sessionKit ? structuredClone(live.sessionKit) : undefined,
         ...(!disk.ok ? { readError: 'Cannot read config. Repair it with aragon config edit.' } : {}),
     };
 }
@@ -61,6 +69,47 @@ function hasConnectionPatch(patch, role) {
     const section = role === 'main' ? patch : patch.fast;
     return !!section && ['provider', 'model', 'baseUrl'].some((key) => key in section);
 }
+/**
+ * The slots THIS transaction explicitly decided, and that therefore leave the
+ * session kit (§4.3 / D-6).
+ *
+ * Released BY SLOT, never wholesale: a user who only retargeted the subagent
+ * must not lose the main and fast choices the kit made for this session, and a
+ * user who retargeted main must not have it silently ignored. Per-slot is the
+ * only rule shaped like the data (three independent slots).
+ */
+export function releasedSlots(draft) {
+    const held = draft.sessionKit?.held ?? [];
+    if (!held.length)
+        return [];
+    // THE APPLY ITSELF RELEASES NOTHING (`kit-apply.ts` sets this marker). Without
+    // it the apply's own writes - `activateRoles`, `patch.team`, the re-bound
+    // library - read as "the user decided every slot", and the save would drop the
+    // three slots it was just handed.
+    if (draft.sessionKitFresh)
+        return [];
+    const kit = findKit(draft.profiles ?? draft.baseline.modelProfiles, draft.sessionKit?.id);
+    if (!kit)
+        return [...held];
+    const released = new Set();
+    for (const role of ['main', 'fast']) {
+        if (draft.activateRoles.includes(role) || connectionChanged(draft, role)
+            || hasConnectionPatch(draft.patch, role))
+            released.add(role);
+    }
+    if (draft.patch.team !== undefined)
+        released.add('subagent');
+    return [...released].filter((slot) => held.includes(slot));
+}
+/** The session kit as it stands AFTER this transaction's explicit decisions. */
+function narrowedSessionKit(draft) {
+    const current = draft.sessionKit;
+    if (!current)
+        return null;
+    const released = releasedSlots(draft);
+    const held = current.held.filter((slot) => !released.includes(slot));
+    return held.length ? { id: current.id, held } : null;
+}
 function liveCandidate(live, candidate, draft) {
     const patch = draft.patch;
     const normalizedPatch = {};
@@ -128,8 +177,16 @@ function liveCandidate(live, candidate, draft) {
             next.apiKeyOverrideTarget = undefined;
         }
         else {
-            next.fast = { ...next.fast, provider: projected.fast.provider,
-                model: projected.fast.model, baseUrl: projected.fast.baseUrl };
+            // I-13 (RV-P1-7): `projectModelProfiles` projects fast ONLY when the
+            // library binds one. With `fastId: null` the projection's `fast` is just the
+            // file's untouched section (`projected` starts as `{...file}`), so copying it
+            // here would resurrect the disk's fast endpoint underneath a kit that
+            // deliberately turned the tier off - the live config would then say "off"
+            // while naming a model nobody chose.
+            if (projected.modelProfiles?.fastId) {
+                next.fast = { ...next.fast, provider: projected.fast.provider,
+                    model: projected.fast.model, baseUrl: projected.fast.baseUrl };
+            }
         }
     }
     if (next.apiKeyOverride && !next.apiKeyOverrideTarget
@@ -139,49 +196,100 @@ function liveCandidate(live, candidate, draft) {
     next.modelProfileState = resolveModelProfileState(next);
     return next;
 }
-/** Validate and prepare everything before the one synchronous, atomic disk commit. */
-export function saveModelSettings(input) {
-    const { draft, controller } = input;
-    if (controller.isModelSettingsBusy())
-        return rejected('busy');
-    if (draft.liveRevision !== controller.getSettingsRevision())
-        return rejected('conflict');
-    const disk = readModelSettingsDisk();
-    if (!disk.ok || draft.readError)
-        return rejected('read_failed');
-    if (disk.revision !== draft.diskRevision)
-        return rejected('conflict');
-    const issues = validateModelProfiles(draft.profiles ?? disk.config?.modelProfiles);
+/**
+ * Build both candidates and the snapshot.
+ *
+ * TWO CANDIDATES, NAMED DIFFERENTLY ON PURPOSE (RV-P0-1 / I-14). `diskCandidate`
+ * is the commit side and never learns about a held slot; `liveCandidateInput`
+ * is what the session sees and is never committed. Collapsing them into one
+ * variable is the defect this split exists to prevent: one unrelated save would
+ * then write the session's kit into the user's permanent defaults, and nothing
+ * visible would change.
+ */
+function prepareModelSettings(input) {
+    const { draft, controller, current } = input;
+    const issues = validateModelProfiles(draft.profiles ?? current.modelProfiles);
     if (issues.length)
-        return { ...rejected('invalid'), issues };
-    let snapshot;
-    let candidate;
+        return { failure: { ...rejected('invalid'), issues } };
     try {
-        const current = disk.config ?? structuredClone(DEFAULT_CONFIG);
         const profilesChanged = draft.activateRoles.length > 0
             || JSON.stringify(draft.profiles) !== JSON.stringify(draft.baseline.modelProfiles);
         const implicitLegacy = draft.profiles === undefined || !profilesChanged;
         const patch = adaptLegacyConnectionPatch({ current, patch: implicitLegacy
                 ? draft.patch : { ...draft.patch, modelProfiles: draft.profiles } });
-        candidate = mergePersistedConfig(current, patch);
-        registerProfileSecrets(candidate);
-        const next = liveCandidate(controller.getConfig(), candidate, draft);
+        const diskCandidate = mergePersistedConfig(current, patch);
+        registerProfileSecrets(diskCandidate);
+        const sessionKit = narrowedSessionKit(draft);
+        const applied = applyHeldToLive(diskCandidate, sessionKit);
+        if (applied.dropped.length) {
+            getLogger().warn('agent', 'session_kit_slots_dropped', { slots: applied.dropped });
+        }
+        const next = liveCandidate(controller.getConfig(), applied.candidate, draft);
+        next.sessionKit = sessionKit ?? undefined;
         // Disk preferences cannot reveal startup/session gateways retained by the live main role.
         if (implicitLegacy && current.modelProfiles?.fastId && hasConnectionPatch(draft.patch, 'fast')) {
             assertLegacyFastTarget(next.fast, next);
         }
-        snapshot = controller.prepareModelSettingsSnapshot(next);
+        const snapshot = controller.prepareModelSettingsSnapshot(next);
+        return { prepared: { diskCandidate, liveCandidateInput: applied.candidate, snapshot } };
     }
     catch (error) {
         const code = error.code ?? 'invalid';
-        return rejected(code);
+        return { failure: rejected(code) };
     }
-    const commit = commitModelSettings({ candidate, diskRevision: draft.diskRevision });
+}
+/** Validate and prepare everything before the one synchronous, atomic disk commit. */
+export function saveModelSettings(input) {
+    const { draft, controller } = input;
+    if (controller.isModelSettingsBusy())
+        return rejected('busy');
+    if (draft.liveRevision !== controller.getSettingsRevision())
+        return rejected('conflict');
+    const disk = readModelSettingsDisk();
+    if (!disk.ok || draft.readError)
+        return rejected('read_failed');
+    if (disk.revision !== draft.diskRevision)
+        return rejected('conflict');
+    const prepared = prepareModelSettings({ draft, controller,
+        current: disk.config ?? structuredClone(DEFAULT_CONFIG) });
+    if (!prepared.prepared)
+        return prepared.failure;
+    const commit = commitModelSettings({ candidate: prepared.prepared.diskCandidate,
+        diskRevision: draft.diskRevision });
     if (!commit.ok)
         return rejected(commit.code ?? 'write_failed');
-    return applyPreparedSnapshot(controller, snapshot, true);
+    return applyPreparedSnapshot(controller, prepared.prepared.snapshot, true);
+}
+/**
+ * The SAME prepare chain, without the commit: a session kit (§4.2 exit B).
+ *
+ * NO `diskRevision` GATE: nothing is written, so a save that landed elsewhere is
+ * not this operation's business. It still refuses while work is in flight
+ * (`busy`) and still refuses a draft whose disk could not be read, so "nothing
+ * changed" is guaranteed for every other failure too (I-10).
+ */
+export function previewModelSettings(draft, controller) {
+    if (controller.isModelSettingsBusy())
+        return rejected('busy');
+    if (draft.readError)
+        return rejected('read_failed');
+    const disk = readModelSettingsDisk();
+    if (!disk.ok)
+        return rejected('read_failed');
+    const prepared = prepareModelSettings({ draft, controller,
+        current: disk.config ?? structuredClone(DEFAULT_CONFIG) });
+    if (!prepared.prepared)
+        return prepared.failure;
+    return applyPreparedSnapshot(controller, prepared.prepared.snapshot, false);
 }
-function applyPreparedSnapshot(controller, snapshot, persisted) {
+/**
+ * Apply a prepared snapshot.
+ *
+ * `persisted` HAS NO DEFAULT (RV-P1-4): the one attribute that distinguishes
+ * "the file now says this" from "only this process says this" is not something
+ * a call site should be able to forget.
+ */
+export function applyPreparedSnapshot(controller, snapshot, persisted) {
     try {
         controller.applyModelSettingsSnapshot(snapshot);
     }
@@ -220,14 +328,19 @@ export function reloadModelSettings(controller) {
         if (live.unicode !== undefined)
             resolved.unicode = live.unicode;
         resolved.reducedMotion ||= !live.color;
+        // THE SESSION KIT SURVIVES A RELOAD (D-6): the three connections it holds
+        // must come from the kit, not from the file we just re-read, and the
+        // projection has to be recomputed so the live config stays equivalent to
+        // what its own bindings say (I-3).
+        const carried = carrySessionKit({ resolved, previous: live });
         const after = readModelSettingsDisk();
         if (!after.ok)
             return rejected('read_failed');
         if (after.revision !== disk.revision)
             return rejected('conflict');
-        if (resolved.modelProfileState?.main.invalid)
+        if (carried.modelProfileState?.main.invalid)
             return rejected('invalid');
-        return applyPreparedSnapshot(controller, controller.prepareModelSettingsSnapshot(resolved), false);
+        return applyPreparedSnapshot(controller, controller.prepareModelSettingsSnapshot(carried), false);
     }
     catch {
         return rejected('invalid');

package/dist/agent/reducer.d.ts

@@ -22,7 +22,7 @@ import type { RetryPhase } from './retry-view.js';
 import type { FilePatch } from '../tools/patch.js';
 export type NoticeLevel = 'info' | 'warn' | 'error';
 export type ToastLevel = NoticeLevel | 'success';
-export type Overlay = null | 'settings' | 'model' | 'help' | 'queue' | 'confirm' | 'question' | 'plan';
+export type Overlay = null | 'settings' | 'model' | 'help' | 'queue' | 'confirm' | 'question' | 'plan' | 'kit';
 export type ToolStatus = 'pending' | 'running' | 'done' | 'error';
 /** Ephemeral, auto-dismissed acknowledgement (spec §3.9). */
 export interface Toast {

package/dist/commands/builtins.js

@@ -23,6 +23,7 @@ import { getLogger } from '../logging/logger.js';
 import { resolveFastTier } from '../fast/resolve.js';
 import { subagentModelSummary } from '../ui/overlays/model-profile-state.js';
 import { registerQueueCommand } from './queue-command.js';
+import { registerKitCommand } from './kit-command.js';
 import { perfCommand } from './perf.js';
 import { runCompactCommand } from '../compaction/command.js';
 import { runClearCommand } from './clear-command.js';
@@ -1371,6 +1372,9 @@ export function registerBuiltinCommands(registry) {
     for (const command of COMMANDS)
         registry.register(command);
     registerQueueCommand(registry);
+    // The command BODY lives in its own module (builtins.ts is already 1.5k lines);
+    // this line is the whole registration (agent-model-kits §4.9).
+    registerKitCommand(registry);
 }
 /**
  * Every built-in command name INCLUDING aliases (`quit`), for documentation and

package/dist/commands/kit-command.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `/kit` - the slash surface for agent model kits (agent-model-kits §4.9).
+ *
+ * ASCII ONLY - `src/commands/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHY A COMMAND AT ALL, WHEN `ctrl+K` EXISTS: a key that a terminal, tmux, an
+ * input method or a IME can swallow needs an equivalent that cannot be swallowed
+ * (`R-4`), and the same reading is what a user pastes into an issue. The two
+ * surfaces call the SAME controller methods, so they can never diverge in
+ * behaviour - only in how the answer is rendered.
+ *
+ * THERE IS NO `/kit default` (D-7): the session path is forbidden from writing
+ * the file, so a "make this the default" verb here would be the one hole in that
+ * promise. Setting a default is a settings action, with a Save the user sees.
+ */
+import type { CommandRegistry, CommandContext } from './registry.js';
+/** The command body; `registerKitCommand` is the only registration site. */
+export declare function runKitCommand(ctx: CommandContext): void;
+/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+export declare function registerKitCommand(registry: CommandRegistry): void;

package/dist/commands/kit-command.js

@@ -0,0 +1,131 @@
+/**
+ * `/kit` - the slash surface for agent model kits (agent-model-kits §4.9).
+ *
+ * ASCII ONLY - `src/commands/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * WHY A COMMAND AT ALL, WHEN `ctrl+K` EXISTS: a key that a terminal, tmux, an
+ * input method or a IME can swallow needs an equivalent that cannot be swallowed
+ * (`R-4`), and the same reading is what a user pastes into an issue. The two
+ * surfaces call the SAME controller methods, so they can never diverge in
+ * behaviour - only in how the answer is rendered.
+ *
+ * THERE IS NO `/kit default` (D-7): the session path is forbidden from writing
+ * the file, so a "make this the default" verb here would be the one hole in that
+ * promise. Setting a default is a settings action, with a Save the user sees.
+ */
+import { kitMatches, findKit, kitSlotConnections } from '../config/model-kits.js';
+import { kitApplyMessage, kitNoteMessages } from '../agent/kit-apply.js';
+/** `main a:b / sub same as main / fast off`, shared by every branch below. */
+function describeKit(config, kit) {
+    const connections = kitSlotConnections(config.modelProfiles, kit);
+    const main = connections.main
+        ? `${connections.main.provider}:${connections.main.model}` : 'Profile missing';
+    const fast = kit.fastProfileId === null ? 'off'
+        : connections.fast ? `${connections.fast.provider}:${connections.fast.model}`
+            : 'Profile missing';
+    const subagent = kit.subagent.model === 'main' ? 'same as main'
+        : kit.subagent.model === 'fast' ? 'fast tier'
+            : connections.subagent.name ? `profile ${connections.subagent.name}` : 'Profile missing';
+    return `main ${main} / sub ${subagent} / fast ${fast}`;
+}
+function kitNames(config) {
+    return (config.modelProfiles?.kits ?? []).map((kit) => kit.name);
+}
+/** `/kit` with no argument: what is in effect, and what it resolves to. */
+function reportActive(ctx) {
+    const config = ctx.controller.getConfig();
+    const active = ctx.controller.getActiveKit();
+    const kits = config.modelProfiles?.kits ?? [];
+    if (!kits.length) {
+        ctx.notify('info', 'No kits yet. Create one in /settings (Settings > Kit pack).');
+        return;
+    }
+    const session = active.source === 'session'
+        ? `session: ${active.name}${active.held.length < 3
+            ? `, holds ${active.held.join('+')}` : ''}`
+        : active.source === 'default' ? 'default' : 'current setup';
+    const kit = findKit(config.modelProfiles, active.id);
+    const detail = kit ? ` ${describeKit(config, kit)}.` : '';
+    const drift = active.modified && active.driftReasons.length
+        ? ` Drifted: ${active.driftReasons.join('; ')}.` : '';
+    ctx.notify('info', `Kit pack: ${active.name} (${session}).${detail}${drift}`);
+}
+/** `/kit list`: every kit, its markers and its three connections. */
+function listKits(ctx) {
+    const config = ctx.controller.getConfig();
+    const kits = config.modelProfiles?.kits ?? [];
+    const active = ctx.controller.getActiveKit();
+    const fallback = config.modelProfiles?.defaultKitId ?? null;
+    if (!kits.length) {
+        ctx.notify('info', 'No kits yet. Create one in /settings.');
+        return;
+    }
+    const lines = kits.map((kit) => {
+        const markers = [kit.id === fallback ? '[Default]' : '',
+            active.source !== 'none' && active.id === kit.id ? '[In use]' : '',
+            active.source !== 'none' && active.id === kit.id && active.modified ? '~' : '']
+            .filter(Boolean).join(' ');
+        return `${markers ? `${markers} ` : ''}${kit.name}: ${describeKit(config, kit)}`;
+    });
+    ctx.notify('info', `Kits (${kits.length}):\n${lines.join('\n')}`);
+}
+/** `/kit use current` and `/kit use <name|#prefix>`. */
+function useKit(ctx, ref) {
+    const config = ctx.controller.getConfig();
+    if (ref.toLowerCase() === 'current') {
+        const released = ctx.controller.clearSessionKit();
+        ctx.toast(released.ok ? 'success' : 'warn', kitApplyMessage(released));
+        return;
+    }
+    const matches = kitMatches(config.modelProfiles, ref);
+    if (!matches.length) {
+        const names = kitNames(config);
+        ctx.notify('warn', `No kit named "${ref}".`
+            + (names.length ? ` Available: ${names.join(', ')}.` : ' Create one in /settings first.'));
+        return;
+    }
+    if (matches.length > 1) {
+        const ids = matches.map((kit) => `#${kit.id.slice(0, 8)}`).join(', ');
+        ctx.notify('warn', `Two or more kits are named "${ref}": ${ids}. Use one of those ids.`);
+        return;
+    }
+    const kit = matches[0];
+    const result = ctx.controller.applySessionKit(kit.id);
+    if (!result.ok) {
+        // `kit_references_missing_profile` names the SLOT in its issues; without them
+        // the user would have to open three screens to find out which one is dead.
+        const detail = (result.issues ?? []).map((issue) => issue.message).join(' ');
+        ctx.notify('warn', [kitApplyMessage(result), detail].filter(Boolean).join(' '));
+        return;
+    }
+    const notes = kitNoteMessages(result.notes);
+    ctx.toast(notes.length ? 'warn' : 'success', [`Kit ${kit.name} applied for this session.`, ...notes].join(' '));
+}
+/** The command body; `registerKitCommand` is the only registration site. */
+export function runKitCommand(ctx) {
+    const args = ctx.args.trim();
+    if (!args) {
+        reportActive(ctx);
+        return;
+    }
+    const [verb = '', ...rest] = args.split(/\s+/);
+    if (verb.toLowerCase() === 'list') {
+        listKits(ctx);
+        return;
+    }
+    if (verb.toLowerCase() === 'use') {
+        const ref = rest.join(' ').trim();
+        if (!ref) {
+            ctx.notify('warn', 'Which kit? Use /kit use <name|#id prefix>, or /kit use current.');
+            return;
+        }
+        useKit(ctx, ref);
+        return;
+    }
+    ctx.notify('warn', 'Unknown /kit subcommand. Try /kit, /kit list, /kit use <name>.');
+}
+/** Registered from `builtins.ts` with one line, next to every other subsystem. */
+export function registerKitCommand(registry) {
+    registry.register({ name: 'kit', description: 'Agent kits: status, list, use for this session',
+        run: (ctx) => { runKitCommand(ctx); } });
+}

package/dist/commands/perf.d.ts

@@ -84,6 +84,16 @@ export interface BandPerf {
      */
     windowStart: number;
     windowEntries: number;
+    /**
+     * Rows the TOP GIVE-WAY has printed for entries that are still inside the window.
+     *
+     * `window=` says what the region holds; `head=` says how much of it the region could
+     * not show and therefore gave back to the terminal scrollback
+     * (tui-final-reply-truncated-unscrollable). Zero is the healthy answer for a
+     * conversation that always fits; a growing number means the box is smaller than the
+     * reply, which is exactly the state that used to be unrecoverable.
+     */
+    headRows: number;
 }
 /**
  * Why the right-edge scrollbar is or is not usable, in one record

package/dist/commands/perf.js

@@ -139,7 +139,7 @@ function formatBandLine(band) {
         `tail=${band.previewRows} pool=${band.bandRows} ` +
         `cols=${band.contentCols}/${band.previewCols} ` +
         `reason=${band.reason} held=${band.heldRailRows}/${band.heldTeamRows} ` +
-        `window=${band.windowStart}/${band.windowEntries}`;
+        `window=${band.windowStart}/${band.windowEntries} head=${band.headRows}`;
 }
 /**
  * Format a snapshot as the seven-line block documented in §5.4 (plus the scrollbar

package/dist/config/kit-resolution.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Where the ACTIVE kit comes from, and the two places a session kit has to be
+ * re-applied (agent-model-kits §4.3 / D-5 / D-6).
+ *
+ * ASCII ONLY - `src/config/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * ONE TRUTH, PURELY DERIVED. `CliConfig` carries only `sessionKit: {id, held}`;
+ * everything a surface prints about "which kit is running" comes out of
+ * `resolveActiveKit(config)`. There is no `config.activeKit` field, because a
+ * second copy of that answer is a copy that can disagree with the first.
+ */
+import type { CliConfig, FastConfig, TeamConfig } from './schema.js';
+import type { ModelProfilesConfig } from './model-profiles.js';
+import { type KitSlot, type SessionKitState } from './model-kits.js';
+/** The three slots, in the order every surface prints them. */
+export declare const ALL_SLOTS: readonly KitSlot[];
+/** The name the UI gives "no kit is in effect" (D-13). */
+export declare const CURRENT_SETUP_NAME = "Current setup";
+/**
+ * The answer when there is no kit, or when the host has no kit support at all.
+ *
+ * A CONSTANT SO CALLERS CANNOT INVENT A SECOND SHAPE: `App` needs one value that
+ * renders "no chip, `Current setup` row" for a controller that predates this
+ * port (a test double, an embedded host), and re-deriving it there would be a
+ * second definition of "nothing".
+ */
+export declare const INACTIVE_KIT: ActiveKit;
+export interface ActiveKit {
+    source: 'session' | 'default' | 'none';
+    id: string | null;
+    /** `Current setup` when `source === 'none'`. */
+    name: string;
+    /** `[]` when `source === 'none'`; all three for a default kit. */
+    held: KitSlot[];
+    /** The kit's definition and the live connections no longer agree (§4.8). */
+    modified: boolean;
+    /** Human-readable ASCII reasons, for `/kit` and the root row. */
+    driftReasons: string[];
+    /** Slots whose referenced profile is gone (RV-P1-1 / I-8). */
+    missingProfiles: KitSlot[];
+}
+/** The session-kit runtime shape, owned by `model-kits.ts` and re-exported here. */
+export type { SessionKitState } from './model-kits.js';
+/**
+ * Which kit is in effect, and whether it has drifted (§4.8).
+ *
+ * Precedence is D-6's: session kit, then the persisted default, then the disk
+ * bindings (which the UI calls `Current setup`).
+ */
+export declare function resolveActiveKit(config: CliConfig): ActiveKit;
+/**
+ * The minimum a candidate has to offer for the held slots to be re-applied.
+ *
+ * STRUCTURAL, NOT `PersistedConfig`: the same routine serves a disk candidate on
+ * its way to `liveCandidate` and a freshly reloaded `CliConfig`, and forcing
+ * either through a cast at the call site would hide the fact that only these
+ * three sections are ever written.
+ */
+export interface HeldTarget {
+    modelProfiles?: ModelProfilesConfig;
+    fast?: Partial<FastConfig>;
+    team?: Partial<TeamConfig>;
+}
+/**
+ * Re-apply the still-`held` slots of a session kit onto a candidate.
+ *
+ * THE RETURN VALUE MAY ONLY EVER FEED `liveCandidate`. It must NEVER be handed
+ * to `commitModelSettings` (I-14 / RV-P0-1): "this session only" is a claim
+ * about the FILE, and a held slot that reaches the commit turns one unrelated
+ * save into a permanent, invisible change of the user's defaults. The one
+ * caller is `prepareModelSettings` in `agent/model-profile-settings.ts`, which
+ * keeps the two candidates in separate variables for exactly this reason.
+ *
+ * Slots whose kit, or whose referenced profile, disappeared are DROPPED and
+ * reported, so the caller can log the release instead of silently forgetting it.
+ */
+export declare function applyHeldToLive<T extends HeldTarget>(candidate: T, sessionKit: SessionKitState | null | undefined): {
+    candidate: T;
+    dropped: KitSlot[];
+};
+/**
+ * Keep a session kit alive across `Reload settings` (D-6).
+ *
+ * THE PROJECTION HAS TO BE RECOMPUTED, not just the bindings: `I-3` says a
+ * library's projections never depend on whether a kit exists, so a live config
+ * whose `mainId` says "kit" while `provider`/`model` still name the reloaded
+ * file would break the equivalence every other surface relies on. Hence the
+ * round trip through `projectModelProfiles` + `resolveModelProfileState`.
+ */
+export declare function carrySessionKit(input: {
+    resolved: CliConfig;
+    previous: CliConfig;
+}): CliConfig;