praxis-agent 0.45.2 → 0.45.4

package/README.md

@@ -126,7 +126,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.js

@@ -2990,11 +2990,13 @@ export class ClaudeSessionService {
                 let projectMemoryRecallMessages = [];
                 let observeModelRequestUsage = () => undefined;
                 const durableFollowUps = new DurableFollowUpTracker();
+                const claimedToolCallIds = new Set();
                 const observer = {
                     ...(nativeLease
                         ? {
                             toolExecutionStarted: async (call) => {
                                 await nativeLease.beginToolExecution(call.id);
+                                claimedToolCallIds.add(call.id);
                             },
                         }
                         : {}),
@@ -3087,6 +3089,10 @@ export class ClaudeSessionService {
                                 await refreshRuntimeContext();
                         }
                         if (nativeLease) {
+                            if (!claimedToolCallIds.has(call.id) && !signal?.aborted) {
+                                await nativeLease.beginToolExecution(call.id);
+                                claimedToolCallIds.add(call.id);
+                            }
                             await nativeLease.appendToolCompletion({
                                 callId: call.id,
                                 result: toolResult,

package/dist/cli/interactive.js

@@ -28,6 +28,7 @@ import { createTuiAppendHistoryChange } from './tui/transcript-window-model.js';
 import { createTuiHistoryChange, resolveTuiRenderer, } from './tui/tui-view-model.js';
 import { projectTuiScreen, } from './tui/tui-screen-model.js';
 import { TuiAnsiSurface } from './tui/ansi-surface.js';
+import { clampTranscriptScrollOffset, createTerminalSelectionContext, createTerminalSelectionState, parseTerminalMouseReport, projectTerminalSelection, refreshTerminalSelection, releaseTerminalSelection, startTerminalSelection, updateTerminalSelection, } from './tui/terminal-selection.js';
 import { QuietInkFrame } from './tui/quiet-frame-adapter.js';
 import { projectQuietScreenFrame, } from './tui/quiet-screen-projector.js';
 import { projectTuiHelpSurface } from './tui/help-surface-model.js';
@@ -487,6 +488,11 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         transcriptScrollOffsetRef.current = offset;
         setTranscriptScrollOffsetState(offset);
     };
+    const [terminalSelection, setTerminalSelection] = useState(createTerminalSelectionState);
+    const terminalSelectionRef = useRef(createTerminalSelectionState());
+    const terminalSelectionContextRef = useRef(null);
+    const selectionEdgeTimerRef = useRef(null);
+    const [clearRevision, setClearRevision] = useState(0);
     const sessionLoadRef = useRef(0);
     const [turnDiffs, setTurnDiffs] = useState([]);
     const turnNumberRef = useRef(0);
@@ -1191,6 +1197,56 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const conversationScreen = screen.body.kind === 'conversation' ? screen.body : undefined;
     const transcriptPageRows = conversationScreen?.transcript.pageRows ?? 2;
     const maxTranscriptScrollOffset = conversationScreen?.transcript.maxScrollOffset ?? 0;
+    const stopSelectionEdgeScroll = () => {
+        if (selectionEdgeTimerRef.current !== null) {
+            clearInterval(selectionEdgeTimerRef.current);
+            selectionEdgeTimerRef.current = null;
+        }
+    };
+    const selectionContextRef = terminalSelectionContextRef;
+    const copyTerminalSelection = (text) => {
+        if (!text)
+            return;
+        void sideQuestionClipboardWriter(text).catch((error) => {
+            append({
+                kind: 'warning',
+                text: `Clipboard unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        });
+    };
+    const beginSelectionEdgeScroll = (direction) => {
+        if (selectionEdgeTimerRef.current !== null)
+            return;
+        selectionEdgeTimerRef.current = setInterval(() => {
+            const context = selectionContextRef.current;
+            const current = terminalSelectionRef.current;
+            if (!context ||
+                current.phase !== 'dragging' ||
+                current.edge !== direction) {
+                stopSelectionEdgeScroll();
+                return;
+            }
+            const offset = transcriptScrollOffsetRef.current;
+            const next = clampTranscriptScrollOffset(offset + (direction === 'older' ? 1 : -1), context.maxTranscriptScrollOffset);
+            if (next === offset) {
+                stopSelectionEdgeScroll();
+                setTerminalSelection((state) => ({ ...state, edge: 'none' }));
+                terminalSelectionRef.current = { ...current, edge: 'none' };
+                return;
+            }
+            setTranscriptScrollOffset(next);
+        }, 80);
+    };
+    useEffect(() => {
+        if (!ansiActive) {
+            stopSelectionEdgeScroll();
+            terminalSelectionRef.current = createTerminalSelectionState();
+            setTerminalSelection(terminalSelectionRef.current);
+        }
+        return () => {
+            stopSelectionEdgeScroll();
+        };
+    }, [ansiActive]);
     const permissionOptions = useMemo(() => [
         ...PERMISSION_OPTIONS,
         ...(allowDangerouslySkipPermissions
@@ -3360,6 +3416,53 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         return () => controller.abort();
     }, [busy, initialPromptPending, permission, selectingSession, sessionId]);
     useInput((value, key) => {
+        if (ansiActive) {
+            const mouse = parseTerminalMouseReport(value);
+            if (mouse !== null) {
+                const context = terminalSelectionContextRef.current;
+                if (context === null)
+                    return;
+                if (mouse.kind === 'wheel') {
+                    const offset = transcriptScrollOffsetRef.current;
+                    setTranscriptScrollOffset(clampTranscriptScrollOffset(offset + (mouse.direction === 'older' ? 1 : -1), context.maxTranscriptScrollOffset));
+                    return;
+                }
+                if (mouse.kind === 'press') {
+                    stopSelectionEdgeScroll();
+                    const next = startTerminalSelection(context, mouse);
+                    terminalSelectionRef.current = next;
+                    setTerminalSelection(next);
+                    return;
+                }
+                if (mouse.kind === 'drag') {
+                    const current = terminalSelectionRef.current;
+                    if (current.phase !== 'dragging')
+                        return;
+                    const previousEdge = current.edge;
+                    const next = updateTerminalSelection(current, context, mouse);
+                    terminalSelectionRef.current = next;
+                    setTerminalSelection(next);
+                    if (next.edge !== 'none') {
+                        if (next.edge !== previousEdge) {
+                            const offset = transcriptScrollOffsetRef.current;
+                            const moved = clampTranscriptScrollOffset(offset + (next.edge === 'older' ? 1 : -1), context.maxTranscriptScrollOffset);
+                            if (moved !== offset)
+                                setTranscriptScrollOffset(moved);
+                        }
+                        beginSelectionEdgeScroll(next.edge);
+                    }
+                    else
+                        stopSelectionEdgeScroll();
+                    return;
+                }
+                const released = releaseTerminalSelection(terminalSelectionRef.current, context, mouse);
+                stopSelectionEdgeScroll();
+                terminalSelectionRef.current = released.state;
+                setTerminalSelection(released.state);
+                copyTerminalSelection(released.text);
+                return;
+            }
+        }
         const lower = value.toLowerCase();
         const controlKey = (letter) => (key.ctrl && lower === letter) ||
             value === String.fromCharCode(letter.charCodeAt(0) - 96);
@@ -3547,6 +3650,32 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         if (!keybindingAction) {
             keybindingAction = resolveTuiKeybinding(keybindings, keybindingContexts, inputChord);
         }
+        const clearScreenBinding = ansiActive &&
+            (keybindingAction === 'chat:clearScreen' ||
+                (inputChord === 'ctrl+l' && keybindingAction === 'chat:clearInput'));
+        if (clearScreenBinding) {
+            stopSelectionEdgeScroll();
+            const cleared = createTerminalSelectionState();
+            terminalSelectionRef.current = cleared;
+            setTerminalSelection(cleared);
+            setClearRevision((revision) => revision + 1);
+            return;
+        }
+        if (ansiActive && terminalSelectionRef.current.phase !== 'idle') {
+            const selectionAction = resolveTuiKeybinding(keybindings, ['Scroll'], inputChord);
+            if (selectionAction === 'selection:copy') {
+                const context = terminalSelectionContextRef.current;
+                if (context === null)
+                    return;
+                const copied = releaseTerminalSelection(terminalSelectionRef.current, context);
+                copyTerminalSelection(copied.text);
+                return;
+            }
+            stopSelectionEdgeScroll();
+            const cleared = createTerminalSelectionState();
+            terminalSelectionRef.current = cleared;
+            setTerminalSelection(cleared);
+        }
         const scrollIntent = key.pageUp
             ? 'page-older'
             : key.pageDown
@@ -6545,7 +6674,25 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         conciseStatus,
         runtimeDisplay,
     ]);
-    return (_jsx(TuiThemeProvider, { settings: themeSettings, screenReader: axScreenReader, children: ansiActive ? (_jsx(TuiAnsiSurface, { frame: quietFrame, onError: () => setAnsiRendererFailed(true) })) : (_jsx(QuietInkFrame, { frame: quietFrame, screenReader: axScreenReader })) }));
+    const terminalSelectionContext = useMemo(() => createTerminalSelectionContext(quietFrame, conversationScreen?.transcript.rows.length ?? 0, transcriptScrollOffset, maxTranscriptScrollOffset), [
+        quietFrame,
+        conversationScreen?.transcript.rows.length,
+        transcriptScrollOffset,
+        maxTranscriptScrollOffset,
+    ]);
+    terminalSelectionContextRef.current = terminalSelectionContext;
+    terminalSelectionRef.current = terminalSelection;
+    useEffect(() => {
+        if (!ansiActive || terminalSelection.phase !== 'dragging')
+            return;
+        const refreshed = refreshTerminalSelection(terminalSelection, terminalSelectionContext);
+        if (refreshed !== terminalSelection) {
+            terminalSelectionRef.current = refreshed;
+            setTerminalSelection(refreshed);
+        }
+    }, [ansiActive, terminalSelection, terminalSelectionContext]);
+    const selectedQuietFrame = useMemo(() => projectTerminalSelection(quietFrame, terminalSelection, terminalSelectionContext), [quietFrame, terminalSelection, terminalSelectionContext]);
+    return (_jsx(TuiThemeProvider, { settings: themeSettings, screenReader: axScreenReader, children: ansiActive ? (_jsx(TuiAnsiSurface, { frame: selectedQuietFrame, clearRevision: clearRevision, onError: () => setAnsiRendererFailed(true) })) : (_jsx(QuietInkFrame, { frame: quietFrame, screenReader: axScreenReader })) }));
 }
 /**
  * Whether the user explicitly saved a `tui` renderer value in configuration.

package/dist/cli/tui/ansi-frame-renderer.d.ts

@@ -20,6 +20,7 @@ export declare class AnsiFullscreenRenderer {
     setStyles(styles?: Partial<Record<TuiTextRole, string>>): void;
     get mounted(): boolean;
     mount(): void;
+    clear(): void;
     draw(frame: AnsiFrame): void;
     dispose(): void;
 }

package/dist/cli/tui/ansi-frame-renderer.js

@@ -4,6 +4,18 @@ const ALTERNATE_SCREEN_ENTER = '\u001b[?1049h';
 const ALTERNATE_SCREEN_LEAVE = '\u001b[?1049l';
 const HIDE_CURSOR = '\u001b[?25l';
 const SHOW_CURSOR = '\u001b[?25h';
+const MOUSE_MODE_ENABLE = [
+    '\u001b[?1000h',
+    '\u001b[?1002h',
+    '\u001b[?1003h',
+    '\u001b[?1006h',
+];
+const MOUSE_MODE_DISABLE = [
+    '\u001b[?1006l',
+    '\u001b[?1003l',
+    '\u001b[?1002l',
+    '\u001b[?1000l',
+];
 const SYNCHRONIZED_BEGIN = '\u001b[?2026h';
 const SYNCHRONIZED_END = '\u001b[?2026l';
 const RESET = '\u001b[0m';
@@ -91,11 +103,16 @@ export class AnsiFullscreenRenderer {
         let alternateScreenEntered = false;
         let cursorHidden = false;
         let synchronizedOutputBegun = false;
+        const mouseModesEnabled = [];
         try {
             alternateScreenEntered = true;
             this.#writer.write(ALTERNATE_SCREEN_ENTER);
             cursorHidden = true;
             this.#writer.write(HIDE_CURSOR);
+            for (const [index, mode] of MOUSE_MODE_ENABLE.entries()) {
+                mouseModesEnabled[index] = true;
+                this.#writer.write(mode);
+            }
             if (this.#synchronizedOutput) {
                 synchronizedOutputBegun = true;
                 this.#writer.write(SYNCHRONIZED_BEGIN);
@@ -106,6 +123,16 @@ export class AnsiFullscreenRenderer {
             this.#mounted = false;
             this.#previousLines = [];
             this.#previousCursor = undefined;
+            for (let index = MOUSE_MODE_ENABLE.length - 1; index >= 0; index -= 1) {
+                if (!mouseModesEnabled[index])
+                    continue;
+                try {
+                    this.#writer.write(MOUSE_MODE_DISABLE[MOUSE_MODE_ENABLE.length - 1 - index]);
+                }
+                catch {
+                    // Rollback must continue if one restoration write fails.
+                }
+            }
             if (synchronizedOutputBegun) {
                 try {
                     this.#writer.write(SYNCHRONIZED_END);
@@ -133,6 +160,40 @@ export class AnsiFullscreenRenderer {
             throw error;
         }
     }
+    clear() {
+        if (!this.#mounted)
+            throw new Error('ANSI fullscreen renderer is not mounted');
+        let firstError;
+        if (this.#synchronizedOutput) {
+            try {
+                this.#writer.write(SYNCHRONIZED_BEGIN);
+            }
+            catch (error) {
+                firstError = error;
+            }
+        }
+        if (firstError === undefined) {
+            try {
+                this.#writer.write('\u001b[2J\u001b[H');
+            }
+            catch (error) {
+                firstError = error;
+            }
+        }
+        if (this.#synchronizedOutput) {
+            try {
+                this.#writer.write(SYNCHRONIZED_END);
+            }
+            catch (error) {
+                if (firstError === undefined)
+                    firstError = error;
+            }
+        }
+        if (firstError !== undefined)
+            throw firstError;
+        this.#previousLines = [];
+        this.#previousCursor = undefined;
+    }
     draw(frame) {
         if (!this.#mounted)
             throw new Error('ANSI fullscreen renderer is not mounted');
@@ -192,17 +253,31 @@ export class AnsiFullscreenRenderer {
     dispose() {
         if (!this.#mounted)
             return;
+        let firstError;
+        const attempt = (write) => {
+            try {
+                this.#writer.write(write);
+            }
+            catch (error) {
+                if (firstError === undefined)
+                    firstError = error;
+            }
+        };
         try {
+            for (const mode of MOUSE_MODE_DISABLE)
+                attempt(mode);
             if (this.#synchronizedOutput)
-                this.#writer.write(SYNCHRONIZED_END);
-            this.#writer.write(SHOW_CURSOR);
-            this.#writer.write(ALTERNATE_SCREEN_LEAVE);
+                attempt(SYNCHRONIZED_END);
+            attempt(SHOW_CURSOR);
+            attempt(ALTERNATE_SCREEN_LEAVE);
         }
         finally {
             this.#mounted = false;
             this.#previousLines = [];
             this.#previousCursor = undefined;
         }
+        if (firstError !== undefined)
+            throw firstError;
     }
 }
 //# sourceMappingURL=ansi-frame-renderer.js.map

package/dist/cli/tui/ansi-surface.d.ts

@@ -3,6 +3,7 @@ import type { QuietFrame } from './quiet-frame.js';
 export interface TuiAnsiSurfaceFrameProps {
     readonly frame: QuietFrame;
     readonly onError: (error: unknown) => void;
+    readonly clearRevision?: number;
 }
 export type TuiAnsiSurfaceProps = TuiAnsiSurfaceFrameProps;
 export declare function projectAnsiQuietFrame(frame: QuietFrame): AnsiFrame;

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

@@ -17,6 +17,7 @@ export function TuiAnsiSurface(props) {
     const styles = useMemo(() => resolveAnsiTextStyles(theme), [theme]);
     const rendererRef = useRef(null);
     const failedRef = useRef(false);
+    const clearRevisionRef = useRef(undefined);
     if (rendererRef.current === null) {
         rendererRef.current = new AnsiFullscreenRenderer({
             writer: { write: (chunk) => stdout.write(chunk) },
@@ -31,6 +32,7 @@ export function TuiAnsiSurface(props) {
             return;
         try {
             renderer.mount();
+            clearRevisionRef.current = props.clearRevision;
         }
         catch (error) {
             failedRef.current = true;
@@ -55,6 +57,10 @@ export function TuiAnsiSurface(props) {
         if (renderer === null)
             return;
         try {
+            if (clearRevisionRef.current !== props.clearRevision) {
+                renderer.clear();
+                clearRevisionRef.current = props.clearRevision;
+            }
             renderer.draw(projectAnsiQuietFrame(props.frame));
         }
         catch (error) {

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/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-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/tools/claude-workflow-tools.js

@@ -9,7 +9,7 @@ function workflowDefinition() {
         name: 'Workflow',
         description: `Run an explicitly requested, sandboxed JavaScript workflow in the background. Use only when the user asks for a workflow or named saved workflow; for ordinary delegation use Agent.
 
-Every script starts with a pure-literal \`export const meta = { name, description, phases? }\`. Its async body may use \`args\`, \`agent(prompt, options?)\`, \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`workflow(nameOrScriptPath, args)\`, \`phase(title)\`, \`log(message)\`, and \`budget.{total,spent(),remaining()}\`. Agent options are \`label\`, \`phase\`, \`model\`, \`effort\`, \`agentType\`, \`schema\`, and \`isolation: 'worktree'\`. Pipeline stages receive \`(previousResult, originalItem, index)\`; failed parallel or pipeline items become null. Nested workflows are limited to one level.
+Every script starts with a pure-literal \`export const meta = { name, description, phases? }\`. \`phases\` is optional and must be an array of objects shaped \`{ title: string, detail?: string, model?: string }\`, never an array of strings. Its async body may use \`args\`, \`agent(prompt, options?)\`, \`parallel(thunks)\`, \`pipeline(items, ...stages)\`, \`workflow(nameOrScriptPath, args)\`, \`phase(title)\`, \`log(message)\`, and \`budget.{total,spent(),remaining()}\`. Agent options are \`label\`, \`phase\`, \`model\`, \`effort\`, \`agentType\`, \`schema\`, and \`isolation: 'worktree'\`. Pipeline stages receive \`(previousResult, originalItem, index)\`; failed parallel or pipeline items become null. Nested workflows are limited to one level.
 
 Provide one source: \`scriptPath\` takes precedence over \`script\`, which takes precedence over \`name\`. Saved names resolve from project \`${projectDirectory}/workflows\`, then user workflows, followed by built-ins. The call returns a task ID immediately; use TaskOutput/TaskStop for lifecycle. Resume a terminal or interrupted run with its script path and \`resumeFromRunId\`; completed matching agents replay from journal. Workflows allow at most 1000 agents, 4096 collection items, and bounded concurrency. Scripts have no Node.js, filesystem, network, ambient time, or randomness.`,
         inputSchema: {

package/package.json

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