praxis-agent 0.45.3 → 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
@@ -126,7 +129,8 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   support, and no-color output,
   cursor/history composer, provider-free `/cost` usage and pricing summaries,
   with a hermetic PTY smoke covering real `runInteractive` ANSI entry,
-  resize-safe lifecycle, and Ctrl-C restoration,
+  resize-safe lifecycle, Ctrl-C restoration, fullscreen `Ctrl+L` redraw, and
+  mouse-wheel/drag selection with edge autoscroll and OSC 52 copy,
   interactive `/doctor` diagnostics, per-session model/effort/permission controls,
   context/status/skill/task dashboards, prompt stash and continuation shortcuts,
   filterable `@` file and agent references, composer undo, `Ctrl+G` external

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>;