praxis-agent 0.45.4 → 0.46.0

package/README.md

@@ -106,7 +106,10 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   terminal-native background, and a minimal composer/status row. Interactive
   surfaces share the same presentation across terminals, with English
   permission/configuration choices and a taught `❯` / Up/Down / Enter / Esc
-  interaction grammar, plus a
+  interaction grammar. While a regular turn is active, the composer remains
+  editable: Enter steers at the next safe continuation boundary, Tab or
+  Alt+Enter queues a sequential follow-up turn, and pending input stays visible
+  and can be withdrawn with Up. The TUI also includes a
   shared-command
   slash palette, tabbed help and shortcut surfaces, searchable resume picker,
   restored active-branch conversation history, streaming and expandable

package/dist/application/session-service.d.ts

@@ -9,6 +9,7 @@ import { type ClaudeInterruptionClassification } from '../native/interruption.js
 import { type ModelDocument, type ModelImage, type ModelToolCall, type ModelProvider, type ModelUsage, type PermissionApproval, type PermissionDecision, type PermissionResolver, type PermissionUpdate, type RuntimeEventSink, type ToolRegistry } from '../core/runtime.js';
 import { type BackgroundTaskSnapshot } from './background-task-runtime.js';
 import type { ModelPricingRegistry } from '../core/usage.js';
+import { type ActiveTurnInputCommandResult } from '../core/active-turn-input.js';
 import type { Compactor } from '../core/compaction.js';
 import { ContextBudget } from '../core/context-budget.js';
 import { type ContextAssembler } from '../core/context.js';
@@ -227,6 +228,7 @@ export declare class ClaudeSessionService {
     private readonly hookLifecycle;
     private readonly leadOperations;
     private readonly fileChangeWatcher;
+    private readonly activeTurnInputs;
     private runtimeCwd;
     constructor(options: ClaudeSessionServiceOptions);
     nextScheduledPrompt(signal?: AbortSignal): Promise<ScheduledPrompt | null>;
@@ -270,6 +272,8 @@ export declare class ClaudeSessionService {
     run(prompt: string, signal?: AbortSignal, sessionId?: string, name?: string, images?: readonly ModelImage[], documents?: readonly ModelDocument[]): Promise<SessionRunResult>;
     runShell(command: string, signal?: AbortSignal, sessionId?: string, name?: string): Promise<SessionRunResult>;
     resume(sessionId: string, prompt: string, signal?: AbortSignal, name?: string, images?: readonly ModelImage[], documents?: readonly ModelDocument[], resumeSessionAt?: string): Promise<SessionRunResult>;
+    steer(sessionId: string, content: string): ActiveTurnInputCommandResult;
+    withdrawSteering(sessionId: string, id: string): ActiveTurnInputCommandResult;
     resumeShell(sessionId: string, command: string, signal?: AbortSignal, name?: string, resumeSessionAt?: string): Promise<SessionRunResult>;
     answerSideQuestion(sessionId: string | undefined, question: string, signal?: AbortSignal, onDelta?: (delta: string) => void, permissionMode?: ClaudePermissionMode): Promise<SideQuestionResult>;
     forkSideQuestion(sessionId: string, question: string, signal?: AbortSignal): Promise<SideQuestionForkResult>;

package/dist/application/session-service.js

@@ -21,6 +21,7 @@ import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
 import { usageCostUsd } from '../core/usage.js';
 import { isSessionId } from '../core/session.js';
+import { ActiveTurnInputMailbox, } from '../core/active-turn-input.js';
 import { ContextBudget, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
 import { ContextEngine } from './context-engine.js';
 import { TurnMemoryCoordinator } from './turn-memory-coordinator.js';
@@ -682,6 +683,7 @@ export class ClaudeSessionService {
     hookLifecycle;
     leadOperations;
     fileChangeWatcher;
+    activeTurnInputs = new Map();
     runtimeCwd;
     constructor(options) {
         const dataPlane = options.dataPlane ?? 'native';
@@ -887,6 +889,18 @@ export class ClaudeSessionService {
     }
     async close() {
         this.closing = true;
+        for (const { mailbox } of this.activeTurnInputs.values()) {
+            if (!mailbox)
+                continue;
+            for (const item of mailbox.close()) {
+                this.options.eventSink?.({
+                    type: 'user-input-rejected',
+                    id: item.id,
+                    content: item.content,
+                    reason: 'closed',
+                });
+            }
+        }
         await this.fileChangeWatcher?.close(5_000);
         await this.hookLifecycle.close();
         await this.drainDetachedHookRuns(5_000);
@@ -1299,6 +1313,30 @@ export class ClaudeSessionService {
             ...(signal ? { signal } : {}),
         });
     }
+    steer(sessionId, content) {
+        const active = this.activeTurnInputs.get(sessionId);
+        if (!active)
+            return { kind: 'no-active-turn' };
+        const mailbox = active.mailbox;
+        if (!mailbox)
+            return { kind: 'not-steerable' };
+        const result = mailbox.enqueue(content);
+        if (result.kind === 'accepted')
+            return result;
+        if (result.kind === 'empty')
+            return result;
+        return { kind: 'turn-completing' };
+    }
+    withdrawSteering(sessionId, id) {
+        const active = this.activeTurnInputs.get(sessionId);
+        if (!active)
+            return { kind: 'no-active-turn' };
+        const mailbox = active.mailbox;
+        if (!mailbox)
+            return { kind: 'not-steerable' };
+        const result = mailbox.withdraw(id);
+        return result.kind === 'withdrawn' ? result : { kind: 'not-pending' };
+    }
     async resumeShell(sessionId, command, signal, name, resumeSessionAt) {
         this.worktreeManager?.bindSession(sessionId);
         return this.executeTurn({
@@ -2449,6 +2487,8 @@ export class ClaudeSessionService {
         const shellCommand = submission.kind === 'shell' ? submission.command : undefined;
         const skipUserPrompt = submission.kind === 'retry';
         const controller = new TurnTerminalController(this.options.eventSink ?? (() => undefined));
+        let activeTurnInput;
+        let activeTurnRecord;
         try {
             this.assertTurnWritable();
             if (prompt.length === 0 && images.length === 0 && documents.length === 0)
@@ -2459,6 +2499,16 @@ export class ClaudeSessionService {
             if (shellCommand !== undefined && shellCommand.trim().length === 0) {
                 throw new Error('Shell command must not be empty');
             }
+            if (this.activeTurnInputs.has(sessionId)) {
+                throw new Error(`conflict: locked (session ${sessionId} already has an active turn)`);
+            }
+            activeTurnRecord =
+                shellCommand === undefined
+                    ? {
+                        mailbox: (activeTurnInput = new ActiveTurnInputMailbox(randomUUID)),
+                    }
+                    : {};
+            this.activeTurnInputs.set(sessionId, activeTurnRecord);
             await this.activateSessionCostTracker(sessionId);
             await this.ensureFileResources(sessionId, signal);
             this.worktreeManager?.bindSession(sessionId);
@@ -3213,6 +3263,24 @@ export class ClaudeSessionService {
                         }
                         await durableFollowUps.followUpUserMessagesCompleted(messages);
                     },
+                    userInputDelivered: async (item) => {
+                        if (nativeLease) {
+                            await nativeLease.appendMessages({
+                                messages: [{ role: 'user', content: item.content }],
+                            });
+                            currentTurnUserMessages?.push(item.content);
+                            return;
+                        }
+                        const [steeringEntry] = translateProviderEvents([{ type: 'user-text-block', text: item.content }], this.translationContext(sessionId, snapshot));
+                        if (!steeringEntry)
+                            throw new Error('Could not translate steering message');
+                        const steeringTail = await this.append(lease, snapshot.tail, steeringEntry);
+                        snapshot = {
+                            entries: [...snapshot.entries, steeringEntry],
+                            tail: steeringTail,
+                        };
+                        currentTurnUserMessages?.push(item.content);
+                    },
                 };
                 let turnCompleted = false;
                 try {
@@ -3974,6 +4042,7 @@ export class ClaudeSessionService {
                         cwd: this.activeCwd(),
                         toolResultDirectory,
                         observer,
+                        ...(activeTurnInput ? { steering: activeTurnInput } : {}),
                         ...(this.options.effort ? { effort: this.options.effort } : {}),
                         ...(this.options.maxModelTurns !== undefined
                             ? { maxModelTurns: this.options.maxModelTurns }
@@ -4373,6 +4442,20 @@ export class ClaudeSessionService {
             controller.fail(error, signal);
             throw error;
         }
+        finally {
+            if (activeTurnInput !== undefined) {
+                for (const item of activeTurnInput.close()) {
+                    this.options.eventSink?.({
+                        type: 'user-input-rejected',
+                        id: item.id,
+                        content: item.content,
+                        reason: signal?.aborted ? 'cancelled' : 'failed',
+                    });
+                }
+            }
+            if (this.activeTurnInputs.get(sessionId) === activeTurnRecord)
+                this.activeTurnInputs.delete(sessionId);
+        }
     }
     async ensureFileResources(sessionId, signal) {
         const resources = this.options.fileResources ?? [];

package/dist/cli/interactive.d.ts

@@ -1,6 +1,7 @@
 import type { ForkResult, ManualCompactResult, ManualCompactSelection, RewindPoint, SessionForkCheckpoint, SessionRunResult, SessionSummary, SideQuestionForkResult, SideQuestionResult } from '../application/session-service.js';
 import type { ClaudeSessionCostSnapshot } from '../application/session-cost-tracker.js';
 import type { ModelImage, ModelToolCall, PermissionApproval, PermissionDecision, RuntimeEventSink } from '../core/runtime.js';
+import type { ActiveTurnInputCommandResult } from '../core/active-turn-input.js';
 import { type DataPlane } from '../persistence/data-plane.js';
 import type { CliElicitationRequest, CliElicitationResult, CliRuntimeInfo } from './protocol.js';
 import type { ClaudeInteractiveToolCallbacks } from '../tools/claude-interactive-tools.js';
@@ -34,6 +35,8 @@ import type { BackgroundTaskSnapshot } from '../application/background-task-runt
 interface InteractiveSessionCommands {
     run(prompt: string, signal?: AbortSignal, sessionId?: string, name?: string, images?: readonly ModelImage[]): Promise<SessionRunResult>;
     resume(sessionId: string, prompt: string, signal?: AbortSignal, name?: string, images?: readonly ModelImage[]): Promise<SessionRunResult>;
+    steer?(sessionId: string, content: string): ActiveTurnInputCommandResult;
+    withdrawSteering?(sessionId: string, id: string): ActiveTurnInputCommandResult;
     runShell?(command: string, signal?: AbortSignal, sessionId?: string, name?: string): Promise<SessionRunResult>;
     resumeShell?(sessionId: string, command: string, signal?: AbortSignal): Promise<SessionRunResult>;
     fork(sessionId: string, targetSessionId?: string, resumeSessionAt?: string): Promise<ForkResult>;

package/dist/cli/interactive.js

@@ -375,6 +375,15 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const inputHistoryRef = useRef([]);
     const inputHistoryIndexRef = useRef(null);
     const inputHistoryDraftRef = useRef('');
+    const [pendingInputs, setPendingInputs] = useState([]);
+    const pendingInputsRef = useRef(pendingInputs);
+    pendingInputsRef.current = pendingInputs;
+    const followUpQueueRef = useRef([]);
+    const updatePendingInputs = (update) => {
+        const next = typeof update === 'function' ? update(pendingInputsRef.current) : update;
+        pendingInputsRef.current = next;
+        setPendingInputs(next);
+    };
     const undoStackRef = useRef([]);
     const composerImagesRef = useRef(new Map());
     const nextImageIdRef = useRef(1);
@@ -1728,6 +1737,30 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         inputHistoryIndexRef.current = nextIndex;
         updateComposerInput(history[nextIndex] ?? '');
     };
+    const withdrawLatestPending = () => {
+        if (inputRef.current.trim().length !== 0)
+            return false;
+        const pending = pendingInputsRef.current.at(-1);
+        if (!pending)
+            return false;
+        if (pending.kind === 'follow-up') {
+            followUpQueueRef.current = followUpQueueRef.current.filter((item) => item.id !== pending.id);
+            updatePendingInputs((current) => current.filter((item) => item.id !== pending.id));
+            updateComposerInput(pending.text);
+            return true;
+        }
+        const activeSessionId = sessionIdRef.current;
+        const result = activeSessionId
+            ? serviceRef.current?.withdrawSteering?.(activeSessionId, pending.id)
+            : undefined;
+        if (result?.kind === 'withdrawn') {
+            updatePendingInputs((current) => current.filter((item) => item.id !== pending.id));
+            updateComposerInput(result.item.content);
+            return true;
+        }
+        append({ kind: 'warning', text: 'Input is already delivered.' });
+        return true;
+    };
     const dismissExitConfirmation = () => {
         if (!exitConfirmation)
             return;
@@ -1781,6 +1814,33 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             case 'user-message':
                 append({ kind: 'assistant', text: event.message });
                 break;
+            case 'user-input-delivered':
+                // Steering is delivered after the preceding assistant batch has been
+                // persisted. Commit that batch to the visible transcript before the
+                // user row, then start the next provider continuation with a fresh
+                // active buffer. Otherwise the active row would appear after the
+                // steering message and be discarded when the turn finally completes.
+                if ((streamingFrameRef.current?.text.trim().length ?? 0) > 0) {
+                    append({
+                        kind: 'assistant',
+                        text: streamingFrameRef.current?.text ?? '',
+                    });
+                }
+                streamingFrameRef.current?.resetText();
+                streamingFrameRef.current?.resetThinking();
+                streamingFrameRef.current?.flush();
+                updatePendingInputs((current) => current.filter((item) => item.id !== event.id));
+                append({ kind: 'user', text: event.content });
+                break;
+            case 'user-input-rejected':
+                updatePendingInputs((current) => current.filter((item) => item.id !== event.id));
+                if (inputRef.current.trim().length === 0)
+                    updateComposerInput(event.content);
+                append({
+                    kind: 'warning',
+                    text: `Input not delivered · ${redactSensitiveText(event.content, sensitiveValues)}`,
+                });
+                break;
             case 'state':
                 if (event.state === 'awaiting-model') {
                     activeAttemptThinkingItemsRef.current = [];
@@ -3212,7 +3272,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         onTurnChange?.(restoring);
         void restoring.finally(() => onTurnChange?.(null));
     };
-    const submit = async (prompt, shellCommand, images = []) => {
+    const submitTurn = async (prompt, shellCommand, images = [], followUpId, internal = false) => {
         setTranscriptScrollOffset(0);
         const turnNumber = turnNumberRef.current + 1;
         const turnStartedAt = Date.now();
@@ -3227,6 +3287,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             ? AbortSignal.any([signal, turnController.signal])
             : turnController.signal;
         setBusy(true);
+        if (followUpId !== undefined) {
+            updatePendingInputs((current) => current.filter((item) => item.id !== followUpId));
+        }
         setTurnDuration(undefined);
         setCommandPaletteOpen(false);
         const submittedCommandName = /^\/([^\s]+)/u.exec(prompt)?.[1]?.toLowerCase();
@@ -3245,9 +3308,10 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         else
             turnMutatedFilesRef.current = true;
         let commands;
+        let turnSucceeded = false;
         try {
             commands = await service();
-            let activeSessionId = sessionId;
+            let activeSessionId = sessionIdRef.current;
             const startedNewSession = activeSessionId === null;
             if (activeSessionId === null) {
                 activeSessionId = randomUUID();
@@ -3316,7 +3380,9 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             streamingFrameRef.current?.flush();
             setStatus('ready');
             setTurnDuration(Date.now() - turnStartedAt);
-            if (runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
+            if (!internal &&
+                followUpQueueRef.current.length === 0 &&
+                runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
                 notifyTerminal({
                     channel: runtimeSettingsRef.current.notifChannel,
                     title: 'Praxis',
@@ -3326,6 +3392,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                         : { write: notificationWriter }),
                 });
             }
+            turnSucceeded = true;
         }
         catch (error) {
             if (turnController.signal.aborted && !signal?.aborted) {
@@ -3343,7 +3410,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
         }
         finally {
-            if (!factory.scheduledPrompts && commands) {
+            if (!internal && !factory.scheduledPrompts && commands) {
                 try {
                     await commands.close?.();
                 }
@@ -3360,6 +3427,62 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             if (turnControllerRef.current === turnController)
                 turnControllerRef.current = null;
+            if (!internal) {
+                setBusy(false);
+            }
+        }
+        return turnSucceeded;
+    };
+    const submit = async (prompt, shellCommand, images = [], followUpId) => {
+        let currentPrompt = prompt;
+        let currentShellCommand = shellCommand;
+        let currentImages = images;
+        let currentFollowUpId = followUpId;
+        let completed = false;
+        try {
+            while (true) {
+                completed = await submitTurn(currentPrompt, currentShellCommand, currentImages, currentFollowUpId, true);
+                if (!completed)
+                    break;
+                const next = followUpQueueRef.current.shift();
+                if (!next)
+                    break;
+                currentPrompt = next.text;
+                currentShellCommand = undefined;
+                currentImages = [];
+                currentFollowUpId = next.id;
+            }
+            if (completed &&
+                runtimeSettingsRef.current.notifChannel !== 'notifications_disabled') {
+                notifyTerminal({
+                    channel: runtimeSettingsRef.current.notifChannel,
+                    title: 'Praxis',
+                    message: 'Turn complete',
+                    ...(notificationWriter === undefined
+                        ? {}
+                        : { write: notificationWriter }),
+                });
+            }
+        }
+        finally {
+            if (!factory.scheduledPrompts) {
+                const commands = serviceRef.current;
+                if (commands) {
+                    try {
+                        await commands.close?.();
+                    }
+                    catch (error) {
+                        append({
+                            kind: 'warning',
+                            text: redactSensitiveText(error instanceof Error ? error.message : String(error), sensitiveValues),
+                        });
+                    }
+                    finally {
+                        if (serviceRef.current === commands)
+                            serviceRef.current = null;
+                    }
+                }
+            }
             setBusy(false);
         }
     };
@@ -5890,6 +6013,94 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 void backgrounding;
                 return;
             }
+            const pendingText = inputRef.current.trim();
+            const addPending = (item) => updatePendingInputs((current) => [...current, item]);
+            if (key.upArrow && pendingText.length === 0) {
+                withdrawLatestPending();
+                return;
+            }
+            if (key.return && key.shift) {
+                updateComposerEditor(insertComposerText(editor(), '\n'));
+                return;
+            }
+            if (isKeybinding('chat:submit') && !key.shift && !key.meta && !key.ctrl) {
+                if (!pendingText)
+                    return;
+                const controller = turnControllerRef.current;
+                if (!controller) {
+                    append({
+                        kind: 'warning',
+                        text: 'Turn is completing; input was retained.',
+                    });
+                    return;
+                }
+                const restoreSteeringText = () => {
+                    const current = inputRef.current;
+                    updateComposerInput(current.trim().length === 0
+                        ? pendingText
+                        : `${pendingText}\n${current}`);
+                };
+                // Service construction may still be in flight while the busy composer
+                // is already visible. Clear now so newly typed text becomes a distinct
+                // draft; restore both drafts if the active-turn command loses a race.
+                clearComposerInput();
+                const steer = async () => {
+                    const commands = serviceRef.current ?? (await service());
+                    if (turnControllerRef.current !== controller ||
+                        controller.signal.aborted) {
+                        restoreSteeringText();
+                        append({
+                            kind: 'warning',
+                            text: 'Active turn changed; input was retained.',
+                        });
+                        return;
+                    }
+                    const activeSessionId = sessionIdRef.current;
+                    const result = activeSessionId
+                        ? commands.steer?.(activeSessionId, pendingText)
+                        : undefined;
+                    if (result?.kind === 'accepted') {
+                        addPending({
+                            id: result.item.id,
+                            kind: 'steering',
+                            text: result.item.content,
+                        });
+                    }
+                    else {
+                        restoreSteeringText();
+                        append({
+                            kind: 'warning',
+                            text: result?.kind === 'turn-completing'
+                                ? 'Turn is completing; input was retained.'
+                                : result?.kind === 'not-steerable'
+                                    ? 'This turn cannot be steered; input was retained.'
+                                    : 'Steering is unavailable; input was retained.',
+                        });
+                    }
+                };
+                void steer().catch((error) => {
+                    restoreSteeringText();
+                    warn(error);
+                });
+                return;
+            }
+            if (key.tab || (key.return && key.meta)) {
+                if (!pendingText)
+                    return;
+                if (!turnControllerRef.current) {
+                    append({
+                        kind: 'warning',
+                        text: 'Turn is completing; follow-up input was retained.',
+                    });
+                    return;
+                }
+                const item = { id: randomUUID(), text: pendingText };
+                followUpQueueRef.current.push(item);
+                addPending({ id: item.id, kind: 'follow-up', text: item.text });
+                clearComposerInput();
+                return;
+            }
+            editComposer();
             return;
         }
         if (isKeybinding('chat:imagePaste')) {
@@ -6571,6 +6782,11 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             return;
         }
+        if (isKeybinding('history:previous') &&
+            inputRef.current.length === 0 &&
+            withdrawLatestPending()) {
+            return;
+        }
         if (isKeybinding('history:previous')) {
             restorePromptHistory('previous');
             return;
@@ -6664,6 +6880,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         shellMode,
         busy,
         status: conciseStatus,
+        pendingItems: pendingInputs,
         display: runtimeDisplay,
     }), [
         screen,
@@ -6672,6 +6889,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         inputCursor,
         busy,
         conciseStatus,
+        pendingInputs,
         runtimeDisplay,
     ]);
     const terminalSelectionContext = useMemo(() => createTerminalSelectionContext(quietFrame, conversationScreen?.transcript.rows.length ?? 0, transcriptScrollOffset, maxTranscriptScrollOffset), [

package/dist/cli/tui/quiet-frame.d.ts

@@ -1,7 +1,7 @@
 import type { TuiScreenModel } from './tui-screen-model.js';
 import type { TuiRow, TuiTextRole } from './tui-row-ir.js';
 export type QuietFrameDensity = 'full' | 'standard' | 'compact' | 'narrow' | 'minimal';
-export type QuietFrameRegion = 'identity' | 'transcript' | 'active' | 'focus' | 'composer' | 'status';
+export type QuietFrameRegion = 'identity' | 'transcript' | 'active' | 'pending' | 'focus' | 'composer' | 'status';
 export interface QuietFrameRow extends TuiRow {
     readonly region: QuietFrameRegion;
     readonly accessibleText?: string;
@@ -26,6 +26,11 @@ export interface QuietFrameInput {
     readonly shellMode: boolean;
     readonly busy: boolean;
     readonly status: string;
+    readonly pendingItems?: readonly {
+        readonly id: string;
+        readonly kind: 'steering' | 'follow-up';
+        readonly text: string;
+    }[];
     readonly display?: {
         readonly cwd?: string;
         readonly model?: string;

package/dist/cli/tui/quiet-frame.js

@@ -280,6 +280,10 @@ export function projectQuietFrame(input) {
                 thinking.lines.forEach(({ text: part, start }, index) => lines.push(createQuietFrameRow(`quiet:active:thinking:${start}`, `${index === 0 ? '✻ ' : '  '}${part}`, 'active', 'muted', `${index === 0 ? 'Thinking: ' : ''}${part}`)));
         }
     }
+    for (const item of input.pendingItems ?? []) {
+        const label = item.kind === 'steering' ? 'steer' : 'follow-up';
+        lines.push(createQuietFrameRow(`quiet:pending:${item.id}`, `${label} · ${clean(item.text)}`, 'pending', 'muted', `${label} pending input: ${clean(item.text)}`));
+    }
     const focus = input.focusRows.length > 0
         ? input.focusRows.map((item) => withRegion(item, 'focus'))
         : [

package/dist/cli/tui/quiet-screen-projector.d.ts

@@ -19,6 +19,7 @@ export interface QuietScreenProjectionInput {
     readonly shellMode: boolean;
     readonly busy: boolean;
     readonly status: string;
+    readonly pendingItems?: QuietFrameInput['pendingItems'];
     readonly display?: QuietFrameInput['display'];
 }
 export declare function projectQuietScreenFrame(input: QuietScreenProjectionInput): QuietFrame;

package/dist/cli/tui/quiet-screen-projector.js

@@ -103,6 +103,9 @@ export function projectQuietScreenFrame(input) {
         shellMode: input.shellMode,
         busy: input.busy,
         status: input.status,
+        ...(input.pendingItems === undefined
+            ? {}
+            : { pendingItems: input.pendingItems }),
         ...(input.display === undefined ? {} : { display: input.display }),
         focusRows,
     });

package/dist/cli/tui/tui-interaction-router.js

@@ -71,7 +71,7 @@ export function routeTuiInteraction(snapshot, input) {
         }
         if (input.action === 'chat:cancel')
             return handled([...confirmationEffects, { kind: 'interrupt-turn' }]);
-        return handled(confirmationEffects);
+        return delegated(confirmationEffects);
     }
     if (input.callerIntent !== 'none')
         return delegated(confirmationEffects);

package/dist/core/active-turn-input.d.ts

@@ -0,0 +1,63 @@
+/** A user input item accepted by an active, steerable turn. */
+export interface SteeringItem {
+    readonly id: string;
+    readonly content: string;
+}
+export type SteeringEnqueueResult = {
+    readonly kind: 'accepted';
+    readonly item: SteeringItem;
+} | {
+    readonly kind: 'empty';
+} | {
+    readonly kind: 'sealed';
+};
+export type SteeringWithdrawResult = {
+    readonly kind: 'withdrawn';
+    readonly item: SteeringItem;
+} | {
+    readonly kind: 'not-pending';
+};
+/** Results returned by the session-level steering commands. */
+export type ActiveTurnInputCommandResult = {
+    readonly kind: 'accepted';
+    readonly item: SteeringItem;
+} | {
+    readonly kind: 'withdrawn';
+    readonly item: SteeringItem;
+} | {
+    readonly kind: 'empty';
+} | {
+    readonly kind: 'no-active-turn';
+} | {
+    readonly kind: 'not-steerable';
+} | {
+    readonly kind: 'turn-completing';
+} | {
+    readonly kind: 'not-pending';
+};
+/** The synchronous port exposed to the runtime at safe continuation points. */
+export interface ActiveTurnInputPort {
+    take(): SteeringItem | undefined;
+    takeOrSeal(): SteeringItem | undefined;
+    /** Drain and seal the port, returning every item that was not delivered. */
+    close(): readonly SteeringItem[];
+}
+/**
+ * A small synchronous FIFO. Keeping all state transitions synchronous makes
+ * enqueue/take-or-seal atomic with respect to the runtime's await boundaries.
+ */
+export declare class ActiveTurnInputMailbox implements ActiveTurnInputPort {
+    private readonly createId;
+    private readonly items;
+    private sealed;
+    constructor(createId: () => string);
+    enqueue(content: string): SteeringEnqueueResult;
+    take(): SteeringItem | undefined;
+    /** Take one item, or seal an empty mailbox before returning. */
+    takeOrSeal(): SteeringItem | undefined;
+    withdraw(id: string): SteeringWithdrawResult;
+    close(): readonly SteeringItem[];
+    isSealed(): boolean;
+    get pendingCount(): number;
+}
+//# sourceMappingURL=active-turn-input.d.ts.map

package/dist/core/active-turn-input.js

@@ -0,0 +1,53 @@
+/**
+ * A small synchronous FIFO. Keeping all state transitions synchronous makes
+ * enqueue/take-or-seal atomic with respect to the runtime's await boundaries.
+ */
+export class ActiveTurnInputMailbox {
+    createId;
+    items = [];
+    sealed = false;
+    constructor(createId) {
+        this.createId = createId;
+    }
+    enqueue(content) {
+        const trimmed = content.trim();
+        if (trimmed.length === 0)
+            return { kind: 'empty' };
+        if (this.sealed)
+            return { kind: 'sealed' };
+        const item = { id: this.createId(), content: trimmed };
+        this.items.push(item);
+        return { kind: 'accepted', item };
+    }
+    take() {
+        return this.items.shift();
+    }
+    /** Take one item, or seal an empty mailbox before returning. */
+    takeOrSeal() {
+        const item = this.items.shift();
+        if (item !== undefined)
+            return item;
+        this.sealed = true;
+        return undefined;
+    }
+    withdraw(id) {
+        const index = this.items.findIndex((item) => item.id === id);
+        if (index < 0)
+            return { kind: 'not-pending' };
+        const [item] = this.items.splice(index, 1);
+        return item === undefined
+            ? { kind: 'not-pending' }
+            : { kind: 'withdrawn', item };
+    }
+    close() {
+        this.sealed = true;
+        return this.items.splice(0);
+    }
+    isSealed() {
+        return this.sealed;
+    }
+    get pendingCount() {
+        return this.items.length;
+    }
+}
+//# sourceMappingURL=active-turn-input.js.map

package/dist/core/runtime.d.ts

@@ -1,3 +1,4 @@
+import type { ActiveTurnInputPort, SteeringItem } from './active-turn-input.js';
 export type RuntimeState = 'idle' | 'assembling-context' | 'compacting' | 'awaiting-model' | 'streaming' | 'awaiting-permission' | 'executing-tools' | 'persisting-results' | 'completed' | 'cancelled' | 'failed';
 export type ModelMessage = {
     role: 'system';
@@ -175,6 +176,15 @@ export type RuntimeEvent = {
     message: string;
     attachments?: readonly string[];
     status: 'normal' | 'proactive';
+} | {
+    type: 'user-input-delivered';
+    id: string;
+    content: string;
+} | {
+    type: 'user-input-rejected';
+    id: string;
+    content: string;
+    reason: 'cancelled' | 'failed' | 'closed';
 } | {
     type: 'usage';
     usage: ModelUsage;
@@ -434,6 +444,7 @@ export interface AgentRunObserver {
     }): Promise<void>;
     toolCompleted(call: ModelToolCall, result: ToolExecutionResult): Promise<void>;
     followUpUserMessagesCompleted?(messages: readonly string[]): Promise<void>;
+    userInputDelivered?(item: SteeringItem): Promise<void>;
 }
 export interface ToolUseSummaryOutcome {
     summary: string | null;
@@ -471,6 +482,7 @@ export interface AgentRunRequest {
     cwd?: string;
     toolResultDirectory?: string;
     observer?: AgentRunObserver;
+    steering?: ActiveTurnInputPort;
     reloadMessages?: () => Promise<readonly ModelMessage[]>;
     approveTool?: (call: ModelToolCall, originalCall?: ModelToolCall, decision?: PermissionDecision) => PermissionApproval | Promise<PermissionApproval>;
     permissionUpdates?: readonly PermissionUpdate[];

package/dist/core/runtime.js

@@ -255,13 +255,58 @@ export class AgentRuntime {
         this.options = options;
     }
     async run(request) {
+        const steering = request.steering;
+        const rejectSteering = (reason) => {
+            for (const item of steering?.close() ?? []) {
+                this.emit({
+                    type: 'user-input-rejected',
+                    id: item.id,
+                    content: item.content,
+                    reason,
+                });
+            }
+        };
+        const cancelWithSteering = () => {
+            rejectSteering('cancelled');
+            return this.cancel();
+        };
+        const deliverSteering = async (item) => {
+            try {
+                if (!request.observer?.userInputDelivered) {
+                    throw new Error('Active-turn steering requires a durable delivery observer');
+                }
+                await request.observer.userInputDelivered(item);
+            }
+            catch (error) {
+                this.emit({
+                    type: 'user-input-rejected',
+                    id: item.id,
+                    content: item.content,
+                    reason: 'failed',
+                });
+                throw error;
+            }
+            messages.push({ role: 'user', content: item.content });
+            this.emit({
+                type: 'user-input-delivered',
+                id: item.id,
+                content: item.content,
+            });
+        };
+        const deliverNextSteering = async () => {
+            const item = steering?.take();
+            if (!item)
+                return false;
+            await deliverSteering(item);
+            return true;
+        };
         const failurePresentationDeferred = (kind) => request.deferFailureKinds === true ||
             request.deferFailureKinds?.includes(kind) === true;
         if (this.options.emitInitialContextState !== false) {
             this.emit({ type: 'state', state: 'assembling-context' });
         }
         if (request.signal?.aborted)
-            return this.cancel();
+            return cancelWithSteering();
         const messages = [...request.messages];
         let usage = emptyUsage();
         let modelUsage = emptyUsage();
@@ -295,7 +340,7 @@ export class AgentRuntime {
                 activeAttemptHasPresentation = false;
                 activeAttemptDiscarded = false;
                 if (request.signal?.aborted)
-                    return this.cancel();
+                    return cancelWithSteering();
                 if (maxModelTurns !== undefined && modelTurns >= maxModelTurns) {
                     throw new Error(`Maximum model turns of ${maxModelTurns} exceeded`);
                 }
@@ -399,7 +444,7 @@ export class AgentRuntime {
                 try {
                     for await (const event of this.provider.complete(providerRequest)) {
                         if (request.signal?.aborted)
-                            return this.cancel();
+                            return cancelWithSteering();
                         if (terminalReason !== undefined) {
                             throw new ModelProviderError(`Provider emitted ${event.type} after terminal reason ${terminalReason}`, { retryable: false });
                         }
@@ -499,7 +544,7 @@ export class AgentRuntime {
                     }
                     await toolScheduler.settle().catch(() => undefined);
                     if (request.signal?.aborted)
-                        return this.cancel();
+                        return cancelWithSteering();
                     throw error;
                 }
                 finally {
@@ -582,6 +627,11 @@ export class AgentRuntime {
                 messages.push(assistantMessage);
                 toolScheduler.releaseExclusiveTools();
                 if (toolCalls.length === 0) {
+                    const preStopSteering = steering?.take();
+                    if (preStopSteering !== undefined) {
+                        await deliverSteering(preStopSteering);
+                        continue;
+                    }
                     const stopResult = (await request.onStop?.(text)) ?? [];
                     const stopBatch = Array.isArray(stopResult)
                         ? null
@@ -617,11 +667,16 @@ export class AgentRuntime {
                         if (request.reloadMessages) {
                             const reloadedMessages = await request.reloadMessages();
                             if (request.signal?.aborted)
-                                return this.cancel();
+                                return cancelWithSteering();
                             messages.splice(0, messages.length, ...reloadedMessages);
                         }
                         continue;
                     }
+                    const completionInput = steering?.takeOrSeal();
+                    if (completionInput !== undefined) {
+                        await deliverSteering(completionInput);
+                        continue;
+                    }
                     this.emit({ type: 'state', state: 'completed' });
                     const modelUsage = modelUsageByModel.size === 0
                         ? undefined
@@ -709,14 +764,18 @@ export class AgentRuntime {
                 if (request.reloadMessages) {
                     const reloadedMessages = await request.reloadMessages();
                     if (request.signal?.aborted)
-                        return this.cancel();
+                        return cancelWithSteering();
                     messages.splice(0, messages.length, ...reloadedMessages);
                 }
+                await deliverNextSteering();
             }
         }
         catch (error) {
-            if (request.signal?.aborted)
+            if (request.signal?.aborted) {
+                rejectSteering('cancelled');
                 return this.cancel();
+            }
+            rejectSteering('failed');
             const message = error instanceof Error ? error.message : String(error);
             const retryable = error instanceof ModelProviderError ? error.retryable : false;
             const kind = error instanceof ModelProviderError

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.45.4",
+  "version": "0.46.0",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",