@aragon-agent/cli 0.6.11 → 0.6.13

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

@@ -0,0 +1,199 @@
+import { loadConfig } from '../config/load.js';
+import { DEFAULT_CONFIG } from '../config/schema.js';
+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 { registerProfileSecrets } from '../logging/secret-registry.js';
+/** Capture both baselines when the editor opens, without migrating or writing anything. */
+export function createModelSettingsDraft(live, liveRevision) {
+    const disk = readModelSettingsDisk();
+    return {
+        diskRevision: disk.revision, liveRevision,
+        baseline: structuredClone(disk.config ?? DEFAULT_CONFIG),
+        liveBaseline: structuredClone(live),
+        profiles: disk.config?.modelProfiles
+            ? structuredClone(disk.config.modelProfiles) : undefined,
+        activateRoles: [], patch: {},
+        ...(!disk.ok ? { readError: 'Cannot read config. Repair it with aragon config edit.' } : {}),
+    };
+}
+/** Map stable failure codes to safe UI text; never include parser or SDK error messages. */
+export function modelSettingsResultMessage(result) {
+    if (result.status === 'saved_apply_failed') {
+        return result.persisted
+            ? 'Saved, but this session could not apply all settings. Restart required.'
+            : 'Could not apply the reloaded settings completely. Restart required.';
+    }
+    if (result.status === 'restart_required') {
+        return 'Saved. Fast tier requires a restart; check its model and credentials.';
+    }
+    const messages = {
+        busy: 'Wait for the run, team, review, or compaction to finish before saving.',
+        conflict: 'Settings changed elsewhere. Reload before saving.',
+        read_failed: 'Cannot read config. Repair it with aragon config edit.',
+        write_failed: 'Could not write config. Your draft is preserved.',
+        invalid: 'Invalid model settings. Check the highlighted field or aragon config edit.',
+        profile_key_required: 'This profile has a dedicated key. Edit or copy it in /settings.',
+        legacy_conversion_unsupported: 'This endpoint needs a profile. Edit it in /settings.',
+    };
+    return result.ok ? 'Settings saved.' : messages[result.code ?? 'invalid'];
+}
+function rejected(code) {
+    return { ok: false, persisted: false, status: 'rejected', code };
+}
+function connectionChanged(draft, role) {
+    if (draft.profiles === undefined)
+        return false;
+    const before = draft.baseline.modelProfiles;
+    const after = draft.profiles;
+    if ((before?.[`${role}Id`] ?? null) !== (after?.[`${role}Id`] ?? null))
+        return true;
+    const id = after?.[`${role}Id`];
+    if (!id)
+        return false;
+    const a = before?.entries.find((entry) => entry.id === id);
+    const b = after?.entries.find((entry) => entry.id === id);
+    return ['provider', 'model', 'baseUrl', 'apiKey']
+        .some((key) => a?.[key] !== b?.[key]);
+}
+function hasConnectionPatch(patch, role) {
+    const section = role === 'main' ? patch : patch.fast;
+    return !!section && ['provider', 'model', 'baseUrl'].some((key) => key in section);
+}
+function liveCandidate(live, candidate, draft) {
+    const patch = draft.patch;
+    const normalizedPatch = {};
+    for (const key of Object.keys(patch)) {
+        normalizedPatch[key] = candidate[key];
+    }
+    const next = { ...live, ...normalizedPatch };
+    for (const section of ['apiKeys', 'fast', 'compaction', 'log']) {
+        const normalized = { ...live[section] };
+        for (const key of Object.keys(patch[section] ?? {})) {
+            normalized[key] = candidate[section][key];
+        }
+        Object.assign(next, { [section]: normalized });
+    }
+    if (patch.apiKeys && Object.hasOwn(patch.apiKeys, live.provider)) {
+        next.apiKeyOverride = undefined;
+        next.apiKeyOverrideTarget = undefined;
+    }
+    // These fields have intentionally different disk and runtime representations.
+    if ('maxTokens' in patch)
+        next.maxTokens = candidate.maxTokens ?? undefined;
+    if ('baseUrl' in patch)
+        next.baseUrl = candidate.baseUrl ?? undefined;
+    const projected = projectModelProfiles(candidate).file;
+    if (draft.profiles !== undefined || candidate.modelProfiles !== undefined) {
+        next.modelProfiles = structuredClone(projected.modelProfiles);
+    }
+    next.liveToolOutput = live.liveToolOutput;
+    for (const role of ['main', 'fast']) {
+        if (!draft.activateRoles.includes(role) && !connectionChanged(draft, role)
+            && !hasConnectionPatch(patch, role))
+            continue;
+        if (role === 'main') {
+            next.provider = projected.provider;
+            next.model = projected.model;
+            next.baseUrl = projected.baseUrl ?? undefined;
+            next.apiKeyOverride = undefined;
+            next.apiKeyOverrideTarget = undefined;
+        }
+        else {
+            next.fast = { ...next.fast, provider: projected.fast.provider,
+                model: projected.fast.model, baseUrl: projected.fast.baseUrl };
+        }
+    }
+    if (next.apiKeyOverride && !next.apiKeyOverrideTarget
+        && (next.modelProfiles?.mainId || next.modelProfiles?.fastId)) {
+        next.apiKeyOverrideTarget = { provider: live.provider, baseUrl: live.baseUrl ?? null };
+    }
+    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);
+    if (issues.length)
+        return { ...rejected('invalid'), issues };
+    let snapshot;
+    let candidate;
+    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);
+        // 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);
+    }
+    catch (error) {
+        const code = error.code ?? 'invalid';
+        return rejected(code);
+    }
+    const commit = commitModelSettings({ candidate, diskRevision: draft.diskRevision });
+    if (!commit.ok)
+        return rejected(commit.code ?? 'write_failed');
+    return applyPreparedSnapshot(controller, snapshot, true);
+}
+function applyPreparedSnapshot(controller, snapshot, persisted) {
+    try {
+        controller.applyModelSettingsSnapshot(snapshot);
+    }
+    catch {
+        controller.blockModelSettingsRequests();
+        return { ok: false, persisted, status: 'saved_apply_failed', code: 'apply_failed', restartRequired: true };
+    }
+    try {
+        controller.applyModelSettingsEffects();
+    }
+    catch {
+        return { ok: false, persisted, status: 'saved_apply_failed', code: 'apply_failed', restartRequired: true };
+    }
+    const restartRequired = snapshot.config.fast.enabled && !controller.isFastRegistered();
+    return { ok: true, persisted, status: restartRequired ? 'restart_required' : 'applied',
+        restartRequired };
+}
+/** Reload the complete model snapshot; invalid disk content never replaces a live session. */
+export function reloadModelSettings(controller) {
+    if (controller.isModelSettingsBusy())
+        return rejected('busy');
+    const disk = readModelSettingsDisk();
+    if (!disk.ok)
+        return rejected('read_failed');
+    if (validateModelProfiles(disk.config?.modelProfiles).length)
+        return rejected('invalid');
+    try {
+        const resolved = loadConfig({ cwd: controller.getConfig().cwd });
+        resolved.liveToolOutput = controller.getConfig().liveToolOutput;
+        const after = readModelSettingsDisk();
+        if (!after.ok)
+            return rejected('read_failed');
+        if (after.revision !== disk.revision)
+            return rejected('conflict');
+        if (resolved.modelProfileState?.main.invalid)
+            return rejected('invalid');
+        return applyPreparedSnapshot(controller, controller.prepareModelSettingsSnapshot(resolved), false);
+    }
+    catch {
+        return rejected('invalid');
+    }
+}

package/dist/agent/queued-messages.d.ts

@@ -0,0 +1,20 @@
+import type { Entry } from './reducer.js';
+/** Full user text retained until Core acknowledges its opaque ID. */
+export interface PendingSteering {
+    readonly queueId: string;
+    readonly text: string;
+}
+/** Hide only active pending entries, using the same projection for measurement and paint. */
+export declare function selectTranscriptEntries(entries: Entry[], pending: readonly PendingSteering[]): Entry[];
+/** Restore trimmed messages in FIFO order before atomically accepting known receipts. */
+export declare function reconcileSteeringReceipt(options: {
+    entries: Entry[];
+    pending: readonly PendingSteering[];
+    ids: readonly string[];
+}): {
+    entries: Entry[];
+    pending: PendingSteering[];
+    changed: boolean;
+};
+/** Supplement trimmed/cleared history for save and exit without deduplicating text. */
+export declare function mergePendingEntries(entries: Entry[], pending: readonly PendingSteering[]): Entry[];

package/dist/agent/queued-messages.js

@@ -0,0 +1,46 @@
+/** Hide only active pending entries, using the same projection for measurement and paint. */
+export function selectTranscriptEntries(entries, pending) {
+    if (pending.length === 0)
+        return entries;
+    const ids = new Set(pending.map((item) => item.queueId));
+    return entries.filter((entry) => entry.kind !== 'queued' || !ids.has(entry.queueId ?? ''));
+}
+/** Restore trimmed messages in FIFO order before atomically accepting known receipts. */
+export function reconcileSteeringReceipt(options) {
+    const receipts = new Set(options.ids);
+    const ids = new Set(options.pending.filter((item) => receipts.has(item.queueId))
+        .map((item) => item.queueId));
+    if (!ids.size)
+        return { entries: options.entries, pending: [...options.pending], changed: false };
+    const entries = mergePendingEntries(options.entries, options.pending).map((entry) => entry.kind === 'queued' && ids.has(entry.queueId ?? '')
+        ? { id: entry.id, kind: 'user', text: entry.text } : entry);
+    return { entries, pending: options.pending.filter((item) => !ids.has(item.queueId)), changed: true };
+}
+/** Supplement trimmed/cleared history for save and exit without deduplicating text. */
+export function mergePendingEntries(entries, pending) {
+    if (pending.length === 0)
+        return entries;
+    const positions = new Map(pending.map((item, index) => [item.queueId, index]));
+    const visible = new Map(entries.flatMap((entry) => entry.kind === 'queued' && entry.queueId !== undefined
+        ? [[entry.queueId, entry]] : []));
+    const merged = [];
+    let cursor = 0;
+    const appendThrough = (last) => {
+        while (cursor <= last) {
+            const item = pending[cursor++];
+            const existing = visible.get(item.queueId);
+            merged.push(existing ? { ...existing, text: item.text } :
+                { id: `pending:${item.queueId}`, kind: 'queued', ...item });
+        }
+    };
+    for (const entry of entries) {
+        const position = entry.kind === 'queued' && entry.queueId !== undefined
+            ? positions.get(entry.queueId) : undefined;
+        if (position === undefined)
+            merged.push(entry);
+        else
+            appendThrough(position);
+    }
+    appendThrough(pending.length - 1);
+    return merged;
+}

package/dist/agent/reducer.d.ts

@@ -10,6 +10,7 @@
  *   - `agent_end` after a turn that produced no `turn_end` and no error notice
  *     synthesizes a generic error notice (a swallowed throw is never a no-op).
  */
+import type { PendingSteering } from './queued-messages.js';
 import type { AgentEvent, ModelCost, ToolResult, TokenUsage } from '@aragon-agent/core';
 import type { AgentMode } from './agent-mode.js';
 import type { DispatchOutcome, SubagentRun, SubagentSpec, TeamSnapshot } from '../team/types.js';
@@ -21,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' | 'confirm' | 'question' | 'plan';
+export type Overlay = null | 'settings' | 'model' | 'help' | 'queue' | 'confirm' | 'question' | 'plan';
 export type ToolStatus = 'pending' | 'running' | 'done' | 'error';
 /** Ephemeral, auto-dismissed acknowledgement (spec §3.9). */
 export interface Toast {
@@ -40,7 +41,7 @@ export type Entry = {
 /**
  * A message submitted while a run was in flight (tui-shift-enter-copy-queue
  * 5.2). It renders as `Queue: <first line>` and is rewritten IN PLACE, same
- * id, into the `user` entry above by the `turnStart` that proves Core
+ * id, into the `user` entry above by the matching receipt that proves Core
  * accepted it -- so the id-based height cache re-measures rather than
  * freezes, and the settled boundary (positional, monotonic) never moves.
  *
@@ -51,6 +52,7 @@ export type Entry = {
     id: string;
     kind: 'queued';
     text: string;
+    queueId?: string;
 } | {
     id: string;
     kind: 'assistant';
@@ -275,6 +277,14 @@ export interface RetrySnapshot {
 }
 export interface ViewState {
     entries: Entry[];
+    pendingSteering: PendingSteering[];
+    seenSteeringIds: ReadonlySet<string>;
+    runPhase: 'idle' | 'starting' | 'waiting' | 'thinking' | 'generating' | 'preparing-tool' | 'tool';
+    activeTool?: {
+        toolCallId: string;
+        name: string;
+    };
+    runOutcome: 'none' | 'ended' | 'interrupted' | 'failed';
     status: 'idle' | 'running';
     usageTotal: UsageTotal;
     /**
@@ -402,9 +412,17 @@ export type ViewAction = {
  */
  | {
     type: 'steerQueued';
+    queueId: string;
     text: string;
+} | {
+    type: 'steeringAccepted';
+    ids: readonly string[];
 } | {
     type: 'runStart';
+} | {
+    type: 'runStarting';
+} | {
+    type: 'runError';
 } | {
     type: 'turnStart';
 } | {
@@ -431,6 +449,7 @@ export type ViewAction = {
 } | {
     type: 'toolExecStart';
     toolCallId: string;
+    toolName?: string;
 } | {
     type: 'toolExecEnd';
     toolCallId: string;

package/dist/agent/reducer.js

@@ -11,6 +11,7 @@
  *     synthesizes a generic error notice (a swallowed throw is never a no-op).
  */
 import process from 'node:process';
+import { reconcileSteeringReceipt } from './queued-messages.js';
 import { emptyContextUsage } from '../compaction/meter.js';
 import { addUsage, computeCost } from './usage.js';
 import { ENTRY_LIMITS, appendBounded, entryRetain, trimEntries } from './entry-limits.js';
@@ -46,6 +47,10 @@ const EMPTY_USAGE_TOTAL = {
 export function initialViewState(seed = {}) {
     return {
         entries: [],
+        pendingSteering: [],
+        seenSteeringIds: new Set(),
+        runPhase: 'idle',
+        runOutcome: 'none',
         status: 'idle',
         usageTotal: EMPTY_USAGE_TOTAL,
         context: emptyContextUsage(),
@@ -127,6 +132,8 @@ function firstLine(text) {
  */
 export function reduceEvent(event, cost, patches) {
     switch (event.type) {
+        case 'steering_accepted':
+            return [{ type: 'steeringAccepted', ids: event.ids }];
         case 'agent_start':
             return [{ type: 'runStart' }];
         case 'turn_start':
@@ -142,7 +149,7 @@ export function reduceEvent(event, cost, patches) {
         case 'agent_end':
             return [{ type: 'runEnd' }];
         case 'tool_execution_start':
-            return [{ type: 'toolExecStart', toolCallId: event.toolCallId }];
+            return [{ type: 'toolExecStart', toolCallId: event.toolCallId, toolName: event.toolName }];
         case 'tool_execution_end': {
             const patch = patches?.take(event.toolCallId);
             const preview = buildToolPreview(event.result);
@@ -197,8 +204,6 @@ function reduceStreamEvent(se) {
         case 'text_delta':
             return [{ type: 'textDelta', delta: se.delta }];
         case 'tool_call_start':
-            if (SELF_RENDERING_TOOLS.has(se.toolName))
-                return [];
             return [
                 { type: 'toolCallStart', toolCallId: se.toolCallId, toolName: se.toolName },
             ];
@@ -210,6 +215,7 @@ function reduceStreamEvent(se) {
             return [{ type: 'toolCallEnd', toolCallId: se.toolCallId, args: se.args }];
         case 'error':
             return [
+                { type: 'runError' },
                 {
                     type: 'notice',
                     level: 'error',
@@ -289,29 +295,6 @@ function nextId(state) {
 function mapEntry(entries, id, fn) {
     return entries.map((e) => (e.id === id ? fn(e) : e));
 }
-/**
- * Rewrite every `queued` entry in place as the user message it became
- * (tui-shift-enter-copy-queue 5.2.3).
- *
- * SAME ID, NEW OBJECT -- the `mapEntry` discipline for a non-append change:
- * the position (and therefore the settled boundary, which advances by
- * POSITION and never by identity) is untouched, while the new object
- * reference is what lets `React.memo` and the height cache see that this
- * one row changed. ALL of them at once, because `drainSteering` is a full
- * drain: converting only some would show a partial acceptance that never
- * happened. Identity-preserving when nothing is queued -- `turnStart` fires
- * every turn, and this must stay free for the common case.
- */
-function convertQueuedEntries(entries) {
-    let touched = false;
-    const next = entries.map((e) => {
-        if (e.kind !== 'queued')
-            return e;
-        touched = true;
-        return { id: e.id, kind: 'user', text: e.text };
-    });
-    return touched ? next : entries;
-}
 /**
  * Seal `thinkingMs`, once, as a spreadable patch (§3.1.2).
  *
@@ -425,7 +408,40 @@ function findToolEntryId(state, toolCallId) {
     }
     return undefined;
 }
+/** Runtime facts outlive transcript cards and are independent of command/clipboard notices. */
+function reduceRunFacts(state, action) {
+    switch (action.type) {
+        case 'runStarting': return { ...state, runPhase: 'starting', runOutcome: 'none' };
+        case 'runStart': return { ...state, runPhase: 'waiting', runOutcome: 'none', activeTool: undefined };
+        case 'turnStart': return { ...state, runPhase: 'waiting' };
+        case 'thinkingStart':
+        case 'thinkingDelta': return { ...state, runPhase: 'thinking' };
+        case 'textDelta': return { ...state, runPhase: 'generating' };
+        case 'toolCallStart':
+        case 'toolCallDelta':
+        case 'toolCallEnd': return { ...state, runPhase: 'preparing-tool' };
+        case 'toolExecStart': {
+            const card = state.entries.find((entry) => entry.kind === 'tool' && entry.toolCallId === action.toolCallId);
+            return { ...state, runPhase: 'tool', activeTool: {
+                    toolCallId: action.toolCallId,
+                    name: action.toolName ?? (card?.kind === 'tool' ? card.name : 'tool'),
+                } };
+        }
+        case 'toolExecEnd': return state.activeTool?.toolCallId === action.toolCallId
+            ? { ...state, runPhase: 'waiting', activeTool: undefined } : state;
+        case 'runError': return { ...state, runOutcome: 'failed' };
+        case 'abortMark': return { ...state, runOutcome: 'interrupted' };
+        case 'runEnd': return { ...state, runPhase: 'idle', activeTool: undefined,
+            runOutcome: state.runOutcome !== 'none' ? state.runOutcome
+                : !state.turnProduced && !state.errorNoticed && !state.aborted ? 'failed' : 'ended' };
+        case 'resetConversation':
+        case 'restoreEntries': return { ...state, runPhase: 'idle', activeTool: undefined,
+            runOutcome: 'none', seenSteeringIds: new Set() };
+        default: return state;
+    }
+}
 export function viewReducer(state, action) {
+    state = reduceRunFacts(state, action);
     switch (action.type) {
         case 'submit': {
             const { id, seq } = nextId(state);
@@ -449,13 +465,29 @@ export function viewReducer(state, action) {
             };
         }
         case 'steerQueued': {
+            if (state.seenSteeringIds.has(action.queueId))
+                return state;
             const { id, seq } = nextId(state);
-            const entry = { id, kind: 'queued', text: action.text };
+            const entry = { id, kind: 'queued', queueId: action.queueId, text: action.text };
             // NOTHING ELSE RESETS. This is not a new turn -- `turnProduced`,
             // `errorNoticed` and `aborted` describe the run that is still in
             // flight, and clearing them here would let the next `runEnd` failure
             // guard misfire on a turn that produced plenty.
-            return { ...state, seq, ...appendEntry(state, state.entries, entry) };
+            return {
+                ...state, seq, ...appendEntry(state, state.entries, entry),
+                seenSteeringIds: new Set([...state.seenSteeringIds, action.queueId]),
+                pendingSteering: [...state.pendingSteering, { queueId: action.queueId, text: action.text }],
+            };
+        }
+        case 'steeringAccepted': {
+            const receipt = reconcileSteeringReceipt({
+                entries: state.entries, pending: state.pendingSteering, ids: action.ids,
+            });
+            if (!receipt.changed)
+                return state;
+            const trimmed = trimEntries(receipt.entries, entryRetain());
+            return { ...state, pendingSteering: receipt.pending, entries: trimmed.entries,
+                droppedEntries: state.droppedEntries + trimmed.dropped };
         }
         case 'runStart':
             return {
@@ -467,14 +499,6 @@ export function viewReducer(state, action) {
             };
         case 'turnStart': {
             const { id, seq } = nextId(state);
-            // CONVERT, THEN APPEND, IN THAT ORDER AND IN THIS ONE ACTION
-            // (5.2.3): `turn_start` is the authoritative "the steering queue was
-            // drained into the conversation" signal (the loop drains at its top,
-            // immediately before emitting it), so the user message and the answer
-            // that follows it must land in the same commit, in render order, or a
-            // frame can exist where the message has vanished and the answer has
-            // not appeared.
-            const entries = convertQueuedEntries(state.entries);
             const entry = {
                 id,
                 kind: 'assistant',
@@ -483,7 +507,7 @@ export function viewReducer(state, action) {
                 thinkingOpen: false,
                 streaming: true,
             };
-            return { ...state, seq, ...appendEntry(state, entries, entry), streamingId: id };
+            return { ...state, seq, ...appendEntry(state, state.entries, entry), streamingId: id };
         }
         case 'thinkingStart': {
             if (!state.streamingId)
@@ -530,6 +554,8 @@ export function viewReducer(state, action) {
             };
         }
         case 'toolCallStart': {
+            if (SELF_RENDERING_TOOLS.has(action.toolName))
+                return state;
             const { id, seq } = nextId(state);
             const entry = {
                 id,
@@ -777,6 +803,7 @@ export function viewReducer(state, action) {
         case 'resetConversation':
             return {
                 ...state,
+                pendingSteering: [],
                 entries: [],
                 droppedEntries: 0,
                 streamingId: undefined,
@@ -1295,6 +1322,7 @@ export function viewReducer(state, action) {
             return {
                 ...state,
                 entries: restored.entries,
+                pendingSteering: [],
                 droppedEntries: restored.dropped,
                 seq: maxSeq,
                 teamEntryId: undefined,

package/dist/cli.js

@@ -18,6 +18,7 @@ import '../runtime/insecure-tls-warning.cjs';
 // Must precede every other dependency that imports Ink: CI detection is cached.
 import { render } from './ui/ink-runtime.js';
 import { Command } from 'commander';
+import { ModelProfileConfigError } from './config/model-profile-store.js';
 import { loadConfig } from './config/load.js';
 import { getConfigPath, readConfigFile, updatePersistedConfig } from './config/store.js';
 import { formatMigrationNotice, migrateLegacyState } from './config/migrate-legacy-state.js';
@@ -458,7 +459,7 @@ function runInteractive(flags, extras = {}) {
     // advising the user about a mode they just disabled.
     const wantPaste = config.paste && !!process.stdin.isTTY;
     const pasteBridge = { notify: null };
-    const filter = wantMouse || wantPaste
+    const filter = process.stdin.isTTY
         ? tryCreateStdinFilter(process.stdin, { mouse: wantMouse, paste: wantPaste }, (reason) => logger.warn('cli', 'stdin_filter_failed', { reason }), pasteBridge)
         : null;
     /**
@@ -648,6 +649,7 @@ function runInteractive(flags, extras = {}) {
     };
     const terminalBridge = {
         mouseSelect: wantSelect,
+        deleteDisambiguated: filter !== null,
         scrollbar,
         ...(mouseOn
             ? {
@@ -1009,6 +1011,18 @@ function runConfigSetContextWindow(value) {
     process.stdout.write(`Set contextWindow = ${merged.contextWindow ?? 'auto'}\n`);
 }
 function runConfigSet(key, value) {
+    try {
+        runConfigSetValue(key, value);
+    }
+    catch (error) {
+        const invalid = error instanceof ModelProfileConfigError
+            && !['read_failed', 'write_failed'].includes(error.code);
+        process.stderr.write(error instanceof ModelProfileConfigError
+            ? `${error.message}\n` : 'Could not write config. Check file permissions.\n');
+        process.exitCode = invalid ? 2 : 1;
+    }
+}
+function runConfigSetValue(key, value) {
     if (!CONFIG_SET_KEYS.has(key)) {
         process.stderr.write(`Unknown config key "${key}". Known keys: ${[...CONFIG_SET_KEYS].join(', ')}.\n`);
         process.exitCode = 2;