@aragon-agent/cli 0.6.23 → 0.6.24

package/dist/team/subagent.js

@@ -18,6 +18,7 @@ import { createBuiltinTools } from '../tools/index.js';
 import { pickActivityArgs, sanitizeActivity } from './activity.js';
 import { TEAM_LIMITS, TEAM_SUBAGENT_TOOL_NAMES } from './limits.js';
 import { isRetryableStreamError } from './retry.js';
+import { resolveSubagentKey, resolveSubagentModel } from './model.js';
 import { makeTeamSend, makeTeamWait, withMailboxTail } from './comm-tools.js';
 import { buildSubagentBlock } from './prompt.js';
 /** The default factory: a real `Agent` from `@aragon-agent/core`. */
@@ -162,25 +163,34 @@ export function createSubagent(spec, deps, hooks) {
     let agentRef = null;
     const getAgent = () => agentRef;
     const tools = buildSubagentTools(spec, deps, getAgent);
-    // THE CHILD'S MODEL IS THE LEAD'S MODEL, READ FROM THE DISPATCH-TIME CONFIG
-    // (main-agent parity). Same provider, same model id, same base URL, same
-    // thinking level: a delegation is never a downgrade, and the only model a
-    // child may surprise its lead with is one a settings-screen edit made live
-    // between two dispatches.
+    // WHICH MODEL A CHILD RUNS IS A USER SETTING, RESOLVED FROM THE
+    // DISPATCH-TIME CONFIG through the one authority (subagent-model §3.4).
+    // `team.model: 'main'` - the default - is the historical main-agent parity
+    // exactly: same provider, model, base URL and thinking level as the lead.
+    // `'fast'` / `'profile'` are the user's explicit, visible, reversible cost
+    // switches, and EVERY failure mode (tier off, profile deleted, profile key
+    // missing) degrades back to the main connection with a disclosed reason
+    // rather than failing the dispatch (D-4). The MODEL itself still cannot
+    // choose: `normalizeSubagentSpecs` drops a stale `model` key (D-1).
     //
     // `maxTokens` inherits `deps.config.maxTokens` below - the same ambition the
-    // lead sends, clamped by the same adapter, so an inherited large value
-    // degrades to the right number rather than to an HTTP 400.
-    const resolved = {
-        ref: {
-            providerId: deps.config.provider,
-            modelId: deps.config.model,
-            ...(deps.config.baseUrl ? { baseUrl: deps.config.baseUrl } : {}),
-        },
-        thinkingLevel: deps.config.thinkingLevel,
-        role: 'main',
-    };
-    const model = resolved.ref;
+    // lead sends, clamped by Core's `resolveOutputTokens` against the CHILD
+    // model's own ceiling, so an inherited large value degrades to the right
+    // number rather than to an HTTP 400.
+    const resolution = resolveSubagentModel(deps.config, (id, role) => Boolean(deps.getApiKey(id, role)));
+    const model = resolution.ref;
+    // THE CHILD'S OWN KEY CLOSURE, PROFILE-AWARE (§3.3 / I-4). A bound profile's
+    // dedicated key is visible ONLY inside this closure - never in env, config
+    // `apiKeys` or a log line - while every other provider resolves through the
+    // lead's resolver at `resolution.keyRole`, which is what keeps a fast child
+    // entitled to the fast-role key and a main child to the main one.
+    const childGetApiKey = (id) => resolveSubagentKey(deps.config, resolution, id, (providerId, role) => deps.getApiKey(providerId, role));
+    // The boolean twin, for the child's compaction summarizer (V-4): the child's
+    // own resolution first, the lead layer by role second. Forwarding only
+    // `deps.getApiKey` would hide a profile-dedicated key from `resolveSummarizer`
+    // and silently disable the child's compaction - the exact gap the req-level
+    // resolvers on `ChildContextManagerRequest` exist to close.
+    const childHasKey = (id, role) => Boolean(childGetApiKey(id) ?? deps.getApiKey(id, role));
     // HOISTED TO A LOCAL, AND THAT IS WHAT MAKES W3 POSSIBLE AT ALL. This was built
     // INLINE inside the `agentFactory({...})` argument, so there was nothing for the
     // child manager's `getSystemPrompt` accessor to close over - and the accessor
@@ -216,7 +226,12 @@ export function createSubagent(spec, deps, hooks) {
     const contextManager = deps.contextManagerFor?.({
         label: spec.label,
         model,
-        role: resolved.role ?? 'main',
+        // keyRole (V-4): a fast child's summarizer resolves its main choice with
+        // role='fast', so a fast-only key is visible to it; profile keys reach it
+        // through the req-level resolvers below instead.
+        role: resolution.keyRole,
+        getApiKey: childGetApiKey,
+        hasKey: childHasKey,
         getMessages: () => agentRef?.state.messages ?? [],
         getSystemPrompt: () => systemPrompt,
         onCompacted: () => {
@@ -227,12 +242,13 @@ export function createSubagent(spec, deps, hooks) {
         systemPrompt,
         model,
         tools,
-        thinkingLevel: resolved.thinkingLevel,
+        thinkingLevel: resolution.thinkingLevel,
         // The LEAD's registry instance, REUSED (P2-2). It holds adapter state, and
         // constructing five of them per dispatch is pure waste.
         providerRegistry: deps.providerRegistry,
-        // The lead's closure, so a settings-screen key edit reaches children too.
-        getApiKey: (id) => deps.getApiKey(id, resolved.role ?? 'main'),
+        // The child's own profile-aware closure, so a settings-screen key edit
+        // reaches children too and a bound profile's key reaches ONLY them.
+        getApiKey: childGetApiKey,
         ...(deps.config.maxTokens !== undefined ? { maxTokens: deps.config.maxTokens } : {}),
         timeouts: {
             toolTimeout: deps.config.toolTimeoutMs,

package/dist/team/task-tool.d.ts

@@ -20,14 +20,17 @@
  * in the schema would behave differently depending on whether `ajv`, an OPTIONAL
  * dependency of core, happened to install.
  *
- * EVERY CHILD RUNS THE LEAD'S OWN MODEL (main-agent parity): same provider,
- * model, thinking level and token ambition, resolved from the LIVE config at
- * dispatch. There is no per-child `model` property and no cheap tier to pick -
- * a delegation is never a downgrade, and the fast tier reaches children the
- * same way it reaches the lead (compaction summaries, per-child reviews).
+ * WHICH MODEL A CHILD RUNS IS THE USER'S SETTING, NOT THE MODEL'S (D-1):
+ * `team.model` defaults to the lead's own connection (main-agent parity) and
+ * can name the fast tier or a profile; there is still no per-child `model`
+ * property, so a delegation is never a self-downgrade. Resolution lives in
+ * `team/model.ts` and is re-read from the LIVE config at every dispatch; the
+ * fast tier otherwise reaches children the way it reaches the lead
+ * (compaction summaries, per-child reviews).
  */
 import { type AgentTool } from '@aragon-agent/core';
 import type { ModelCost } from '@aragon-agent/core';
+import type { SubagentModelResolution } from './model.js';
 import type { TeamRuntime } from './runtime.js';
 export interface TaskToolDeps {
     runtime: TeamRuntime;
@@ -37,8 +40,24 @@ export interface TaskToolDeps {
     /** Whether a usable key exists for the active provider right now (P2-3). */
     hasApiKey: () => boolean;
     activeProvider: () => string;
-    /** The lead's cost table, so the report header states real spend (R-5). */
+    /**
+     * The cost table of the model children ACTUALLY run (subagent-model §3.4).
+     *
+     * The controller resolves `team.model` live and prices `modelCost` at the
+     * EFFECTIVE model's table: with the default `main` mode this is exactly the
+     * lead's own table, so the report's spend line is byte-identical to the
+     * parity behavior; with `fast` / `profile` it is that model's table, and an
+     * UNPRICED one yields `undefined` so the header says `pricing unknown`
+     * rather than fabricating `$0.00` (C-11 / RV-4).
+     */
     modelCost: () => ModelCost | undefined;
+    /**
+     * The dispatch-time subagent model resolution, for the report's disclosure
+     * line (D-4): rendered ONLY when children did not run the main model, and
+     * carrying the fallback reason when they could not. OPTIONAL so existing
+     * construction sites compile; absent simply omits the line.
+     */
+    subagentModel?: () => SubagentModelResolution;
     /**
      * The FAST tier's cost table, so the report's supervisor spend line states
      * real spend (subagent-overseer-v2 D-7 / R-P1-2). OPTIONAL and returning

package/dist/team/task-tool.js

@@ -20,11 +20,13 @@
  * in the schema would behave differently depending on whether `ajv`, an OPTIONAL
  * dependency of core, happened to install.
  *
- * EVERY CHILD RUNS THE LEAD'S OWN MODEL (main-agent parity): same provider,
- * model, thinking level and token ambition, resolved from the LIVE config at
- * dispatch. There is no per-child `model` property and no cheap tier to pick -
- * a delegation is never a downgrade, and the fast tier reaches children the
- * same way it reaches the lead (compaction summaries, per-child reviews).
+ * WHICH MODEL A CHILD RUNS IS THE USER'S SETTING, NOT THE MODEL'S (D-1):
+ * `team.model` defaults to the lead's own connection (main-agent parity) and
+ * can name the fast tier or a profile; there is still no per-child `model`
+ * property, so a delegation is never a self-downgrade. Resolution lives in
+ * `team/model.ts` and is re-read from the LIVE config at every dispatch; the
+ * fast tier otherwise reaches children the way it reaches the lead
+ * (compaction summaries, per-child reviews).
  */
 import { errorResult, textResult } from '@aragon-agent/core';
 import { TEAM_LIMITS } from './limits.js';
@@ -39,8 +41,9 @@ const TEAM_OFF_REFUSAL = 'Team mode is off for this session. Do this work yourse
  */
 const TASK_DESCRIPTION = 'Run several independent subagents in parallel and get one combined report. Each ' +
     'subagent is a fresh agent with the same tools and working directory but NO memory of ' +
-    'this conversation - its prompt must be self-contained. Each runs on the same model ' +
-    'you are running on. Use this when a task splits ' +
+    'this conversation - its prompt must be self-contained. Each runs on the model the ' +
+    'user configured for subagents (the main model by default). Use this when a task ' +
+    'splits ' +
     'into 2 or more parts that do not depend on each other\'s output, especially reading or ' +
     'searching several areas at once. Do NOT use it when one part needs another part\'s ' +
     'result (do those yourself, in order), when two parts would edit the same file, or for ' +
@@ -120,13 +123,16 @@ export function createTaskTool(deps) {
             //    A cancellation or a partial result rendered as a tool FAILURE invites
             //    the model to retry the whole fan-out, which is the most expensive
             //    possible reaction (the same reasoning as `ask_user`'s cancelled
-            //    shape, and D-14 one level up). Every child ran the lead's own model,
-            //    so the lead's cost table is the one honest price for the total.
+            //    shape, and D-14 one level up). `modelCost` is priced at the model
+            //    children ACTUALLY ran - the lead's own table under the default
+            //    `main` mode - so the total stays one honest price.
             const cost = deps.modelCost();
             const fastCost = deps.fastModelCost?.();
+            const subagentModel = deps.subagentModel?.();
             return textResult(buildDispatchReport(outcome, {
                 ...(cost ? { cost } : {}),
                 ...(fastCost ? { fastCost } : {}),
+                ...(subagentModel ? { subagentModel } : {}),
             }));
         },
     };

package/dist/ui/App.js

@@ -2144,6 +2144,11 @@ export function App({ controller, version, initialOverlay, initialPrompt, confir
             // `auto`, not an empty string: an empty field reads as "unset", which
             // is indistinguishable from AUTO and is not a state this can be in.
             maxTokens: cfg.maxTokens ? String(cfg.maxTokens) : 'auto',
+            // BOTH HALVES, seeded AND read back (§6.3): the sibling comment above
+            // records what omitting either one costs. `auto` mirrors the row's
+            // empty-field reading; a bound Main profile hides the row entirely
+            // and the profile editor seeds from the entry instead.
+            contextWindow: cfg.contextWindow === null ? 'auto' : String(cfg.contextWindow),
             apiKey: '',
             logLevel: cfg.log.level,
             // The four fast rows, seeded through the pure mapper so the screen and

package/dist/ui/overlays/ModelProfileEditor.js

@@ -9,8 +9,13 @@ import { stripEnterFrames } from '../enter-frames.js';
 import { pickGlyphs } from '../glyphs.js';
 import { profileEndpointSummary, useProfileScroll } from './ModelProfilePicker.js';
 import { finishProfileEditor } from './model-profile-state.js';
-const FIELDS = ['name', 'provider', 'model', 'baseUrl', 'credentialMode', 'apiKey'];
-const LABELS = ['Name', 'Provider', 'Model', 'Base URL', 'Credential mode', 'API key'];
+// `Context window` sits right after Model: the window is an attribute of the
+// model+endpoint the two rows above name. 14 characters, inside the 18-column
+// label budget `LABELS.map(...padEnd(18))` enforces below.
+const FIELDS = ['name', 'provider', 'model', 'contextWindow', 'baseUrl', 'credentialMode',
+    'apiKey'];
+const LABELS = ['Name', 'Provider', 'Model', 'Context window', 'Base URL', 'Credential mode',
+    'API key'];
 function useEditorInput(props, navigation) {
     const { editor, dispatch } = props;
     const { index, setIndex, retain, count } = navigation;
@@ -83,8 +88,11 @@ function buildEditorRows(props, navigation) {
                 : editor.credentialMode === 'keep' ? 'Configured (unchanged)' : 'Shared / environment';
         if (field === 'credentialMode')
             return editor.credentialMode;
-        return editor[field] || (field === 'name' ? '(defaults to model)' : field === 'baseUrl'
-            ? '(provider default)' : '(required)');
+        // `(auto)` EXPLICITLY, or an empty window field would fall through to
+        // `(required)` - and AUTO is this field's natural state, never a gap.
+        return editor[field] || (field === 'name' ? '(defaults to model)'
+            : field === 'contextWindow' ? '(auto)' : field === 'baseUrl'
+                ? '(provider default)' : '(required)');
     });
     const lines = LABELS.map((label, at) => `${label.padEnd(18)}${values[at]}`);
     if (retain)
@@ -92,6 +100,12 @@ function buildEditorRows(props, navigation) {
     lines.push('Apply to settings draft', 'Cancel editing');
     const rows = lines.map((line, at) => _jsxs(Text, { wrap: "truncate", color: at === index ? props.theme.accent : props.theme.muted, children: [at === index ? `${glyphs.caret} ` : '  ', line] }, at));
     rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: ["Target: ", editor.provider, " ", profileEndpointSummary(editor.baseUrl)] }, "target"));
+    // HONESTY FOR THE FAST-ONLY ENTRY (§6.5): a window saved on a profile that
+    // only ever serves the Fast role does not take effect today, and saying so
+    // beats letting the user believe it does.
+    if (props.users === 'Fast') {
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: "Window applies when this profile is bound as Main." }, "window-scope"));
+    }
     return rows;
 }
 /** Replacement key input starts empty; retention across targets is explicit. */

package/dist/ui/overlays/ModelProfilePicker.d.ts

@@ -1,7 +1,8 @@
 import React from 'react';
-import type { ModelProfile, ModelProfilesConfig, ModelRole } from '../../config/model-profiles.js';
+import type { ModelProfile, ModelProfilesConfig } from '../../config/model-profiles.js';
 import type { Theme } from '../theme.js';
 import type { TermCapabilities } from '../capabilities.js';
+import { type ProfilePickerRole } from './model-profile-state.js';
 export interface ProfileFrameProps {
     isActive?: boolean;
     theme: Theme;
@@ -19,11 +20,22 @@ export declare function profileEndpointSummary(baseUrl: string | null): string;
 interface ModelProfilePickerProps extends ProfileFrameProps {
     profiles: ModelProfilesConfig;
     savedProfiles?: ModelProfilesConfig;
-    role: ModelRole;
+    /** Which role this page selects for; `'subagent'` swaps the built-in rows (D-5). */
+    role: ProfilePickerRole;
     manager?: boolean;
     error?: string;
     apiKeys: Record<string, string | undefined>;
     customProfile?: ModelProfile;
+    /**
+     * The selection id for a role the library has no `${role}Id` key for: the
+     * subagent projection (`Same as main` = null, fast = the sentinel, profile
+     * = its id). Takes precedence over the `${role}Id` lookup when present.
+     */
+    selectedIdOverride?: string | null;
+    /** The subagent binding, for the reference suffix on profile labels (3.7). */
+    subagentProfileId?: string | null;
+    /** Whether to annotate the built-in `Fast tier model` row with `(fast tier off)`. */
+    fastTierOff?: boolean;
     onSelect: (id: string | null) => void;
     onCreate: () => void;
     onEdit: (profile: ModelProfile) => void;

package/dist/ui/overlays/ModelProfilePicker.js

@@ -6,7 +6,7 @@ import { pickGlyphs } from '../glyphs.js';
 import { OverlayFrame, overlayBodyRows } from '../layout/OverlayFrame.js';
 import { stripPasteFrames } from '../paste-frames.js';
 import { stripEnterFrames } from '../enter-frames.js';
-import { profileUsers } from './model-profile-state.js';
+import { profileUsers, SUBAGENT_FAST_ROW_ID } from './model-profile-state.js';
 /** Move focus into view while accepting App's independent wheel/page scrolling. */
 export function useProfileScroll(props, focus) {
     const [offset, setOffset] = useState(0);
@@ -62,7 +62,9 @@ function usePickerState(props) {
     const entries = props.profiles.entries.filter((entry) => `${entry.name} ${entry.provider} ${entry.model}`.toLocaleLowerCase()
         .includes(query.toLocaleLowerCase()));
     const actions = props.manager ? ['New', 'Edit', 'Duplicate', 'Delete'] : ['Create profile'];
-    const prefix = props.manager ? 0 : 1;
+    // THE SUBAGENT PICKER swaps the `Current custom` row for TWO built-in rows:
+    // `Same as main` (selection id null) and `Fast tier model` (the sentinel).
+    const prefix = props.role === 'subagent' ? 2 : props.manager ? 0 : 1;
     const count = entries.length + prefix + actions.length;
     const cursor = Math.min(index, count - 1);
     const focused = entries[cursor - prefix];
@@ -76,7 +78,18 @@ function usePickerState(props) {
 function usePickerInput(props, state) {
     const { cursor, focused, selected, actions, prefix, entries, count, searching, searchable, setIndex, setQuery, setSearching } = state;
     function activate() {
-        if (!props.manager && cursor === 0) {
+        if (props.role === 'subagent') {
+            // Built-in rows first: `Same as main`, then `Fast tier model`.
+            if (cursor === 0) {
+                props.onSelect(null);
+                return;
+            }
+            if (cursor === 1) {
+                props.onSelect(SUBAGENT_FAST_ROW_ID);
+                return;
+            }
+        }
+        else if (!props.manager && cursor === 0) {
             props.onSelect(null);
             return;
         }
@@ -138,11 +151,26 @@ function usePickerInput(props, state) {
         else if (!key.ctrl && !key.meta && input.toLowerCase() === 'e' && focused) {
             props.onEdit(focused);
         }
+        // `d` deletes the focused entry (D-7), symmetric with `e`: same guards,
+        // same no-ops on the built-in and action rows (`focused` is undefined
+        // there), and the `searching` early-return above keeps `d` a query
+        // character while typing a search.
+        else if (!key.ctrl && !key.meta && input.toLowerCase() === 'd' && focused) {
+            props.onDelete(focused.id);
+        }
     });
 }
+/** The selection id this page marks with `[Selected]`, by role (6.2). */
+function currentSelectionId(props) {
+    if (props.selectedIdOverride !== undefined)
+        return props.selectedIdOverride;
+    if (props.role === 'subagent')
+        return undefined;
+    return props.profiles[`${props.role}Id`];
+}
 function profilePickerLabel(props, entry) {
-    const saved = profileUsers(props.savedProfiles, entry.id);
-    const checked = props.profiles[`${props.role}Id`] === entry.id ? '[Selected] ' : '';
+    const saved = profileUsers(props.savedProfiles, entry.id, props.subagentProfileId);
+    const checked = currentSelectionId(props) === entry.id ? '[Selected] ' : '';
     const duplicate = props.profiles.entries.some((other) => other.id !== entry.id
         && other.name === entry.name);
     const identity = duplicate ? `#${uniqueId(entry, props.profiles.entries)} ` : '';
@@ -154,18 +182,30 @@ function buildPickerRows(props, state) {
     const { entries, actions, cursor, searching, searchable, query, focused, selected } = state;
     const glyphs = pickGlyphs(props.caps);
     const lines = [];
-    if (!props.manager)
+    if (props.role === 'subagent') {
+        // TWO BUILT-IN ROWS (D-5), marked with the same `[Selected]` prefix the
+        // profile rows use; the fast row annotates an unusable tier honestly.
+        const current = props.selectedIdOverride ?? null;
+        lines.push(`${current === null ? '[Selected] ' : ''}Same as main`);
+        lines.push(`${current === SUBAGENT_FAST_ROW_ID ? '[Selected] ' : ''}Fast tier model`
+            + `${props.fastTierOff === true ? '  (fast tier off)' : ''}`);
+    }
+    else if (!props.manager)
         lines.push('Current custom');
     lines.push(...entries.map((entry) => profilePickerLabel(props, entry)));
     lines.push(...actions);
     const rows = lines.map((line, row) => _jsxs(Text, { wrap: "truncate", color: row === cursor ? props.theme.accent : props.theme.muted, children: [`${row === cursor && !searching ? glyphs.caret : ' '} `, clipProfileText(line, props.cols - 8)] }, row));
     if (searchable)
         rows.unshift(_jsxs(Text, { wrap: "truncate", color: props.theme.primary, children: [searching ? `${glyphs.caret} ` : '  ', "Search: ", query || '(/ to search)'] }, "search"));
-    const detail = !props.manager && cursor === 0 ? props.customProfile : focused ?? selected;
+    // The subagent picker has no `Current custom` row to describe; its
+    // built-in rows already say everything there is to say.
+    const detail = props.role === 'subagent' ? focused
+        : !props.manager && cursor === 0 ? props.customProfile : focused ?? selected;
     if (detail) {
         rows.push(_jsxs(Text, { wrap: "truncate", color: props.theme.muted, children: [detail.provider, ":", detail.model || '(not set)', " ", host(detail), detail === props.customProfile ? '' : ` #${detail.id}`] }, "detail"));
         rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: detail.apiKey ? 'Profile key: Configured'
                 : props.apiKeys[detail.provider] ? 'Shared / environment: Configured' : 'Missing API key' }, "key"));
+        rows.push(_jsx(Text, { wrap: "truncate", color: props.theme.muted, children: `Window: ${detail.contextWindow ?? 'auto'}` }, "window"));
     }
     return rows;
 }
@@ -174,7 +214,8 @@ export function ModelProfilePicker(props) {
     const state = usePickerState(props);
     usePickerInput(props, state);
     return _jsx(OverlayFrame, { ...props, title: props.error ?? (props.manager ? 'Manage profiles'
-            : `${props.role === 'main' ? 'Main' : 'Fast'} profile`), rows: buildPickerRows(props, state), scrollOffset: state.searching ? 0 : state.offset, hint: state.searching ? 'Type search | Enter done | Esc back'
-            : props.manager ? 'Enter action | e edit | Esc back'
-                : 'Enter select | e edit | Esc back' });
+            : props.role === 'subagent' ? 'Subagent model'
+                : `${props.role === 'main' ? 'Main' : 'Fast'} profile`), rows: buildPickerRows(props, state), scrollOffset: state.searching ? 0 : state.offset, hint: state.searching ? 'Type search | Enter done | Esc back'
+            : props.manager ? 'Enter action | e edit | d delete | Esc back'
+                : 'Enter select | e edit | d delete | Esc back' });
 }

package/dist/ui/overlays/QuestionOverlay.js

@@ -38,6 +38,21 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
     const [phase, setPhase] = useState('choosing');
     const [cursors, setCursors] = useState(() => initialCursors(questions));
     const [selections, setSelections] = useState(() => initialSelections(questions));
+    /**
+     * THE PER-QUESTION EXPLICIT-MARK BIT (V-1 / D-8).
+     *
+     * `initialSelections` PRE-SELECTS the recommended option on EVERY question
+     * (or the first option when there is none), so "the selection set is empty"
+     * is unreachable and can never be the test for "did the user choose?". The
+     * only reliable discriminator is the fact itself: the user pressed SPACE on
+     * this question. Without it, a user who only MOVES the cursor and presses
+     * Enter would submit the RECOMMENDED option instead of the highlighted one -
+     * a silent regression of the wizard's most common path. The bit survives
+     * Left/Right navigation exactly like `selections` and `cursors` do, and a
+     * single-choice mark is idempotent (no un-mark; Enter always has at least
+     * the marked item to submit).
+     */
+    const [markedSteps, setMarkedSteps] = useState(() => questions.map(() => false));
     const [customs, setCustoms] = useState(() => questions.map(() => ''));
     const [draft, setDraft] = useState('');
     const [offset, setOffset] = useState(0);
@@ -56,6 +71,7 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
         return next;
     }));
     const chooseAt = (index, option) => setSelections((prev) => prev.map((set, i) => (i === index ? new Set([option]) : set)));
+    const markAt = (index) => setMarkedSteps((prev) => prev.map((marked, i) => (i === index ? true : marked)));
     const buildAnswers = () => questions.map((q, i) => {
         const chosen = [...(selections[i] ?? new Set())].sort((a, b) => a - b);
         const labels = chosen.map((index) => q.options[index]?.label ?? '').filter((l) => l.length > 0);
@@ -159,8 +175,21 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
             goBack();
             return;
         }
-        if (input === ' ' && question.allowMultiple) {
-            toggleAt(step, cursor);
+        // SPACE, BY QUESTION SHAPE (D-8). The strict `input === ' '` keeps a
+        // multi-character paste frame from ever matching (R-8); the Other row is
+        // a no-op in both shapes because it needs TEXT, and Enter is its key.
+        if (input === ' ' && !question.options[cursor]?.isOther) {
+            if (question.allowMultiple) {
+                toggleAt(step, cursor);
+                return;
+            }
+            // SINGLE CHOICE: mark the highlighted item and STAY - the terminal
+            // convention of "space selects, enter confirms". The mark is recorded
+            // both in the selection set (so `[x]` renders) and in the explicit
+            // mark bit (so a later Enter submits THIS item even after the cursor
+            // has moved on).
+            chooseAt(step, cursor);
+            markAt(step);
             return;
         }
         if (key.return) {
@@ -170,8 +199,15 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
                 setPhase('typingOther');
                 return;
             }
-            if (!question.allowMultiple)
-                chooseAt(step, cursor);
+            // A single-choice Enter submits the CURSOR item unless the user has
+            // explicitly space-marked this question, in which case the marked item
+            // wins even if the cursor has since moved (V-1's regression guard:
+            // cursor + Enter alone keeps today's behavior, recommended preselect
+            // and all).
+            if (!question.allowMultiple) {
+                if (!markedSteps[step])
+                    chooseAt(step, cursor);
+            }
             else if (!(selections[step] ?? new Set()).has(cursor))
                 toggleAt(step, cursor);
             advance();
@@ -183,7 +219,9 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
         ? `type your answer ${glyphs.midDot} ${glyphs.enterKey} commit ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
         : phase === 'review'
             ? `${glyphs.enterKey} submit ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
-            : `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} ${glyphs.enterKey} next${question.allowMultiple ? ` ${glyphs.midDot} space toggle` : ''} ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`;
+            : question.options[cursor]?.isOther
+                ? `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} ${glyphs.enterKey} to type ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`
+                : `${glyphs.arrowUp}${glyphs.arrowDown} choose ${glyphs.midDot} space select ${glyphs.midDot} ${glyphs.enterKey} next ${glyphs.midDot} ${glyphs.arrowLeft} back ${glyphs.midDot} esc cancel`;
     const rowTexts = [];
     const optionStarts = [];
     const push = (text) => { rowTexts.push(...wrapToRows(text, Math.max(1, cols - 4))); };
@@ -208,8 +246,11 @@ export function QuestionOverlay({ isActive = true, questions, maxRows, cols, the
         setOffset(previous => focus < previous ? focus : focus >= previous + height
             ? focus - height + 1 : previous);
     }, [focus, maxRows, cols, step, phase]);
+    // `space select` shows for BOTH shapes (AC-10) - 42 characters on the
+    // single-choice shape without `cancel`, a deliberate 5-column growth inside
+    // the `cols <= 48` budget this hint exists for (V-12).
     const shortHint = phase === 'typingOther' ? 'Enter commit | Left back | Esc cancel'
         : phase === 'review' ? 'Enter submit | Left back | Esc cancel'
-            : question.allowMultiple ? '^v choose Space toggle Enter next Esc' : 'Up/Down choose Enter next Esc cancel';
+            : '^v choose Space select Enter next Esc';
     return _jsx(OverlayFrame, { title: `${title}${position}`, hint: cols <= 48 ? shortHint : hint, maxRows: maxRows, cols: cols, theme: theme, caps: caps, rows: rowTexts.map((line, index) => _jsx(Text, { wrap: "truncate", children: line || ' ' }, index)), scrollOffset: offset, onScrollClamp: setOffset });
 }

package/dist/ui/overlays/SettingsScreen.d.ts

@@ -36,6 +36,15 @@ export interface SettingsValues {
      */
     liveToolOutput: 'on' | 'off';
     maxTokens: string;
+    /**
+     * The top-level context-window override, as text (profile-context-window
+     * §6.3). EDITED ONLY WHILE MAIN IS UNBOUND: once a profile is bound as Main
+     * the profile owns the denominator, this row hides, and the editor becomes
+     * the only surface that writes the key - two entries on one key can only
+     * drift. Empty renders as `auto` because an empty field IS AUTO here, the
+     * reading `maxTokens` established.
+     */
+    contextWindow: string;
     apiKey: string;
     /**
      * Only the LEVEL is editable here. The rest of `LogConfig` — and above all