praxis-agent 0.45.3 → 0.46.0

package/dist/cli/tui/ansi-theme.js

@@ -70,8 +70,10 @@ function styleSequence(style) {
     return codes.length === 0 ? undefined : `\u001b[${codes.join(';')}m`;
 }
 export function resolveAnsiTextStyles(theme) {
-    if (theme.noColor || theme.screenReader)
+    if (theme.screenReader)
         return {};
+    if (theme.noColor)
+        return { textSelection: '\u001b[7m' };
     const styles = {};
     const roleMap = {
         body: 'body',
@@ -83,6 +85,7 @@ export function resolveAnsiTextStyles(theme) {
         error: 'error',
         tool: 'info',
         selection: 'focusMarker',
+        textSelection: 'inputCursor',
         input: 'inputMarker',
         diffAdded: 'diffAdded',
         diffRemoved: 'diffRemoved',

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

@@ -12,6 +12,7 @@ const ROLE_MAP = {
     error: 'error',
     tool: 'info',
     selection: 'focusMarker',
+    textSelection: 'inputCursor',
     input: 'inputMarker',
     diffAdded: 'diffAdded',
     diffRemoved: 'diffRemoved',

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/terminal-selection.d.ts

@@ -0,0 +1,51 @@
+import type { QuietFrame, QuietFrameRow } from './quiet-frame.js';
+export type TerminalMouseEvent = {
+    readonly kind: 'press' | 'drag' | 'release';
+    readonly column: number;
+    readonly row: number;
+} | {
+    readonly kind: 'wheel';
+    readonly direction: 'older' | 'newer';
+    readonly column: number;
+    readonly row: number;
+};
+export interface TerminalSelectionPoint {
+    readonly row: number;
+    readonly column: number;
+}
+export type TerminalSelectionEdge = 'none' | 'older' | 'newer';
+export interface TerminalSelectionVisibleRow {
+    readonly physicalRow: number;
+    readonly logicalRow: number;
+    readonly row: QuietFrameRow;
+    readonly text: string;
+}
+export interface TerminalSelectionContext {
+    readonly frame: QuietFrame;
+    readonly transcriptRowCount: number;
+    readonly transcriptScrollOffset: number;
+    readonly maxTranscriptScrollOffset: number;
+    readonly visibleTranscriptRows: readonly TerminalSelectionVisibleRow[];
+}
+export interface TerminalSelectionState {
+    readonly phase: 'idle' | 'dragging' | 'selected';
+    readonly anchor: TerminalSelectionPoint | null;
+    readonly focus: TerminalSelectionPoint | null;
+    readonly rows: ReadonlyMap<number, string>;
+    readonly edge: TerminalSelectionEdge;
+}
+export interface TerminalSelectionRelease {
+    readonly state: TerminalSelectionState;
+    readonly text: string | null;
+}
+/** Parse one complete SGR mouse report. Coordinates returned here are zero based. */
+export declare function parseTerminalMouseReport(value: string): TerminalMouseEvent | null;
+export declare function clampTranscriptScrollOffset(offset: number, maxOffset: number): number;
+export declare function createTerminalSelectionContext(frame: QuietFrame, transcriptRowCount: number, transcriptScrollOffset: number, maxTranscriptScrollOffset: number): TerminalSelectionContext;
+export declare function createTerminalSelectionState(): TerminalSelectionState;
+export declare function startTerminalSelection(context: TerminalSelectionContext, point: TerminalSelectionPoint): TerminalSelectionState;
+export declare function updateTerminalSelection(state: TerminalSelectionState, context: TerminalSelectionContext, point: TerminalSelectionPoint): TerminalSelectionState;
+export declare function refreshTerminalSelection(state: TerminalSelectionState, context: TerminalSelectionContext, edge?: TerminalSelectionEdge): TerminalSelectionState;
+export declare function releaseTerminalSelection(state: TerminalSelectionState, context: TerminalSelectionContext, point?: TerminalSelectionPoint): TerminalSelectionRelease;
+export declare function projectTerminalSelection(frame: QuietFrame, state: TerminalSelectionState, context: TerminalSelectionContext): QuietFrame;
+//# sourceMappingURL=terminal-selection.d.ts.map

package/dist/cli/tui/terminal-selection.js

@@ -0,0 +1,263 @@
+import { stripVTControlCharacters } from 'node:util';
+import { terminalGraphemeWidth, terminalGraphemes, terminalTextWidth, } from './transcript-viewport.js';
+function safeCoordinate(value) {
+    if (!/^[0-9]+$/u.test(value))
+        return null;
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number - 1 : null;
+}
+/** Parse one complete SGR mouse report. Coordinates returned here are zero based. */
+export function parseTerminalMouseReport(value) {
+    if (typeof value !== 'string')
+        return null;
+    const report = value.codePointAt(0) === 0x1b ? value.slice(1) : value;
+    const match = /^\[<([0-9]+);([0-9]+);([0-9]+)([Mm])$/u.exec(report);
+    if (!match)
+        return null;
+    const code = Number(match[1]);
+    const column = safeCoordinate(match[2] ?? '');
+    const row = safeCoordinate(match[3] ?? '');
+    if (!Number.isSafeInteger(code) || column === null || row === null)
+        return null;
+    const final = match[4];
+    if (code === 0 && final === 'M')
+        return { kind: 'press', column, row };
+    if (code === 0 && final === 'm')
+        return { kind: 'release', column, row };
+    if (final === 'M' && code === 32)
+        return { kind: 'drag', column, row };
+    if (final === 'M' && code === 64)
+        return { kind: 'wheel', direction: 'older', column, row };
+    if (final === 'M' && code === 65)
+        return { kind: 'wheel', direction: 'newer', column, row };
+    return null;
+}
+function cleanRowText(row) {
+    return stripVTControlCharacters(row.segments.map((segment) => segment.text).join(''));
+}
+function finiteOffset(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+export function clampTranscriptScrollOffset(offset, maxOffset) {
+    const maximum = finiteOffset(maxOffset);
+    return Math.min(maximum, finiteOffset(offset));
+}
+export function createTerminalSelectionContext(frame, transcriptRowCount, transcriptScrollOffset, maxTranscriptScrollOffset) {
+    const rows = frame.lines
+        .map((row, physicalRow) => ({ row, physicalRow }))
+        .filter(({ row }) => row.region === 'transcript' && cleanRowText(row) !== '…');
+    const count = finiteOffset(transcriptRowCount);
+    const offset = clampTranscriptScrollOffset(transcriptScrollOffset, maxTranscriptScrollOffset);
+    const first = finiteOffset(maxTranscriptScrollOffset) - offset;
+    const droppedLeading = Math.max(0, count - rows.length);
+    return {
+        frame,
+        transcriptRowCount: count,
+        transcriptScrollOffset: offset,
+        maxTranscriptScrollOffset: finiteOffset(maxTranscriptScrollOffset),
+        visibleTranscriptRows: rows.map(({ row, physicalRow }, index) => ({
+            physicalRow,
+            logicalRow: first + droppedLeading + index,
+            row,
+            text: cleanRowText(row),
+        })),
+    };
+}
+export function createTerminalSelectionState() {
+    return {
+        phase: 'idle',
+        anchor: null,
+        focus: null,
+        rows: new Map(),
+        edge: 'none',
+    };
+}
+function rowAtPhysical(context, point) {
+    return context.visibleTranscriptRows.find((row) => row.physicalRow === point.row);
+}
+function clampColumn(column, text) {
+    const width = terminalTextWidth(text);
+    if (!Number.isFinite(column))
+        return 0;
+    return Math.max(0, Math.min(Math.trunc(column), Math.max(0, width - 1)));
+}
+function snapshotRows(state, context) {
+    const rows = new Map(state.rows);
+    let changed = false;
+    for (const visible of context.visibleTranscriptRows) {
+        if (state.rows.get(visible.logicalRow) === visible.text)
+            continue;
+        rows.set(visible.logicalRow, visible.text);
+        changed = true;
+    }
+    return changed ? rows : state.rows;
+}
+function pointFor(context, point) {
+    const row = rowAtPhysical(context, point);
+    if (!row)
+        return null;
+    return { row: row.logicalRow, column: clampColumn(point.column, row.text) };
+}
+function edgeFor(context, physicalRow) {
+    const first = context.visibleTranscriptRows[0]?.physicalRow;
+    const last = context.visibleTranscriptRows.at(-1)?.physicalRow;
+    if (first === undefined || last === undefined)
+        return 'none';
+    if (physicalRow <= first)
+        return context.transcriptScrollOffset < context.maxTranscriptScrollOffset
+            ? 'older'
+            : 'none';
+    if (physicalRow >= last)
+        return context.transcriptScrollOffset > 0 ? 'newer' : 'none';
+    return 'none';
+}
+export function startTerminalSelection(context, point) {
+    const logical = pointFor(context, point);
+    if (!logical)
+        return createTerminalSelectionState();
+    return {
+        phase: 'dragging',
+        anchor: logical,
+        focus: logical,
+        rows: snapshotRows(createTerminalSelectionState(), context),
+        edge: 'none',
+    };
+}
+export function updateTerminalSelection(state, context, point) {
+    if (state.phase !== 'dragging')
+        return state;
+    const logical = pointFor(context, point) ??
+        (context.visibleTranscriptRows.length > 0
+            ? (() => {
+                const first = context.visibleTranscriptRows[0];
+                const last = context.visibleTranscriptRows.at(-1);
+                if (!first || !last)
+                    return null;
+                const target = point.row <= first.physicalRow ? first : last;
+                return {
+                    row: target.logicalRow,
+                    column: clampColumn(point.column, target.text),
+                };
+            })()
+            : null);
+    if (!logical)
+        return state;
+    const rows = snapshotRows(state, context);
+    const edge = edgeFor(context, point.row);
+    if (state.focus?.row === logical.row &&
+        state.focus.column === logical.column &&
+        state.edge === edge &&
+        rows === state.rows)
+        return state;
+    return { ...state, focus: logical, rows, edge };
+}
+export function refreshTerminalSelection(state, context, edge = state.edge) {
+    if (state.phase !== 'dragging')
+        return state;
+    const visible = context.visibleTranscriptRows;
+    if (visible.length === 0)
+        return state;
+    const target = edge === 'older'
+        ? visible[0]
+        : edge === 'newer'
+            ? visible.at(-1)
+            : undefined;
+    const rows = snapshotRows(state, context);
+    if (!target)
+        return rows === state.rows ? state : { ...state, rows };
+    const focus = {
+        row: target.logicalRow,
+        column: clampColumn(state.focus?.column ?? 0, target.text),
+    };
+    const nextEdge = edgeFor(context, target.physicalRow);
+    if (state.focus?.row === focus.row &&
+        state.focus.column === focus.column &&
+        state.edge === nextEdge &&
+        rows === state.rows)
+        return state;
+    return { ...state, focus, rows, edge: nextEdge };
+}
+function normalizedPoints(state) {
+    if (!state.anchor || !state.focus)
+        return null;
+    return state.anchor.row < state.focus.row ||
+        (state.anchor.row === state.focus.row &&
+            state.anchor.column <= state.focus.column)
+        ? [state.anchor, state.focus]
+        : [state.focus, state.anchor];
+}
+function selectedText(text, start, end) {
+    const output = [];
+    let cell = 0;
+    for (const grapheme of terminalGraphemes(text)) {
+        const width = terminalGraphemeWidth(grapheme);
+        const clusterEnd = cell + Math.max(1, width) - 1;
+        if (clusterEnd >= start && cell <= end)
+            output.push(grapheme);
+        cell += width;
+    }
+    return output.join('');
+}
+export function releaseTerminalSelection(state, context, point) {
+    const updated = point && state.phase === 'dragging'
+        ? updateTerminalSelection(state, context, point)
+        : state;
+    const selected = {
+        ...updated,
+        phase: updated.anchor && updated.focus
+            ? 'selected'
+            : 'idle',
+        edge: 'none',
+    };
+    const points = normalizedPoints(selected);
+    if (!points)
+        return { state: selected, text: null };
+    const [start, end] = points;
+    const text = [];
+    for (let row = start.row; row <= end.row; row += 1) {
+        const value = selected.rows.get(row);
+        if (value === undefined)
+            return { state: selected, text: null };
+        text.push(selectedText(value, row === start.row ? start.column : 0, row === end.row ? end.column : Number.MAX_SAFE_INTEGER));
+    }
+    return { state: selected, text: text.join('\n') };
+}
+export function projectTerminalSelection(frame, state, context) {
+    const points = normalizedPoints(state);
+    if (!points || state.phase === 'idle')
+        return frame;
+    const [start, end] = points;
+    const lines = frame.lines.map((row) => {
+        const visible = context.visibleTranscriptRows.find((item) => item.row.key === row.key);
+        if (!visible ||
+            visible.logicalRow < start.row ||
+            visible.logicalRow > end.row)
+            return row;
+        const lower = visible.logicalRow === start.row ? start.column : 0;
+        const upper = visible.logicalRow === end.row ? end.column : Number.MAX_SAFE_INTEGER;
+        const segments = [];
+        let position = 0;
+        for (const segment of row.segments) {
+            const plain = stripVTControlCharacters(segment.text);
+            for (const grapheme of terminalGraphemes(plain)) {
+                const width = terminalGraphemeWidth(grapheme);
+                const clusterEnd = position + Math.max(1, width) - 1;
+                const role = clusterEnd >= lower && position <= upper
+                    ? 'textSelection'
+                    : segment.role;
+                const previous = segments.at(-1);
+                if (previous?.role === role)
+                    segments[segments.length - 1] = {
+                        ...previous,
+                        text: previous.text + grapheme,
+                    };
+                else
+                    segments.push({ text: grapheme, role });
+                position += width;
+            }
+        }
+        return { ...row, segments };
+    });
+    return { ...frame, lines };
+}
+//# sourceMappingURL=terminal-selection.js.map

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/cli/tui/tui-row-ir.d.ts

@@ -1,5 +1,5 @@
 import type { TranscriptPresentationEntry, TranscriptPresentationMode } from './transcript-presentation.js';
-export type TuiTextRole = 'body' | 'heading' | 'muted' | 'accent' | 'success' | 'warning' | 'error' | 'tool' | 'selection' | 'input' | 'diffAdded' | 'diffRemoved';
+export type TuiTextRole = 'body' | 'heading' | 'muted' | 'accent' | 'success' | 'warning' | 'error' | 'tool' | 'selection' | 'textSelection' | 'input' | 'diffAdded' | 'diffRemoved';
 export interface TuiRowSegment {
     readonly text: string;
     readonly role: TuiTextRole;

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