praxis-agent 0.35.0 → 0.37.0

package/dist/cli/tui/permission-surface-model.js

@@ -0,0 +1,360 @@
+function integer(value, fallback = 0) {
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.trunc(value);
+}
+function selectedIndex(value, count, empty = -1) {
+    if (count <= 0)
+        return empty;
+    return Math.max(0, Math.min(count - 1, integer(value)));
+}
+function dashboardSelectedIndex(value, count) {
+    if (count <= 0)
+        return -1;
+    const normalized = integer(value, -1);
+    return normalized < 0 ? -1 : Math.min(count - 1, normalized);
+}
+function range(count) {
+    return { min: count > 0 ? 1 : 0, max: count };
+}
+function options(labels, selection) {
+    const selected = selectedIndex(selection, labels.length);
+    return {
+        options: labels.map((option, index) => ({
+            ...option,
+            index: index + 1,
+            selected: index === selected,
+        })),
+        selectedIndex: selected,
+        range: range(labels.length),
+    };
+}
+function permissionRuleDescription(rule) {
+    const bashPrefix = /^Bash\((.*?)(?::\*| \*)\)$/u.exec(rule)?.[1]?.trim();
+    return bashPrefix ? `Any Bash command starting with ${bashPrefix}` : undefined;
+}
+function permissionScopeLabel(scope) {
+    return scope === 'local'
+        ? 'From project local settings'
+        : scope === 'project'
+            ? 'From project settings'
+            : 'From user settings';
+}
+export function projectTuiPermissionSurface(input) {
+    switch (input.kind) {
+        case 'tool-request': {
+            const selected = selectedIndex(input.selection, input.model.options.length);
+            return {
+                kind: input.kind,
+                heading: input.model.title,
+                tool: input.model,
+                options: input.model.options,
+                selectedIndex: selected,
+                range: range(input.model.options.length),
+                feedbackMode: input.feedbackMode,
+                feedback: input.feedback,
+                ...(input.ruleEditor === undefined
+                    ? {}
+                    : { ruleEditor: input.ruleEditor }),
+                actions: [
+                    {
+                        label: input.feedbackMode ? 'Enter to submit' : 'Enter to select',
+                        key: 'Enter',
+                        usesSelectionRange: !input.feedbackMode,
+                    },
+                    { label: 'Tab to amend', key: 'Tab' },
+                ],
+                cancellation: 'Escape to cancel',
+            };
+        }
+        case 'recovery-request': {
+            const projected = options([{ label: 'Yes' }, { label: 'No' }], input.selection);
+            return {
+                kind: input.kind,
+                heading: input.heading ?? 'Retry interrupted tool?',
+                display: input.display,
+                question: 'Do you want to proceed?',
+                ...projected,
+                feedbackMode: input.feedbackMode,
+                feedback: input.feedback,
+                feedbackPlaceholder: projected.selectedIndex === 0
+                    ? 'tell Praxis what to do next'
+                    : 'tell Praxis what to do differently',
+                actions: [
+                    {
+                        label: input.feedbackMode ? 'Enter to submit' : 'Enter to confirm',
+                        key: 'Enter',
+                        usesSelectionRange: !input.feedbackMode,
+                    },
+                    {
+                        label: input.feedbackMode
+                            ? 'Tab to collapse'
+                            : 'Tab to add feedback',
+                        key: 'Tab',
+                    },
+                ],
+                cancellation: 'Escape to cancel',
+            };
+        }
+        case 'permission-dashboard': {
+            const tabs = [
+                'Recently denied',
+                'Allow',
+                'Ask',
+                'Deny',
+                'Workspace',
+            ];
+            const tabIndex = selectedIndex(input.tabIndex, tabs.length);
+            const behavior = ['allow', 'ask', 'deny'][tabIndex - 1];
+            const normalizedQuery = input.query.trim().toLowerCase();
+            const matchingRules = behavior
+                ? input.rules.filter((rule) => rule.behavior === behavior &&
+                    (!normalizedQuery ||
+                        rule.rule.toLowerCase().includes(normalizedQuery) ||
+                        rule.scope.includes(normalizedQuery)))
+                : [];
+            const originalWorkspace = input.workspaceDirectories.find((directory) => directory.original);
+            const additionalWorkspaces = input.workspaceDirectories.filter((directory) => !directory.original);
+            let rows;
+            let rowCount;
+            if (tabIndex === 0) {
+                rows = input.recentDenied.map((action, index) => ({
+                    index: index + 1,
+                    label: action.display,
+                    description: action.reason,
+                    selected: index ===
+                        dashboardSelectedIndex(input.selectedIndex, input.recentDenied.length),
+                    id: action.id,
+                    status: action.id === input.retryingDeniedId ? 'retrying' : 'denied',
+                }));
+                rowCount = rows.length;
+            }
+            else if (tabIndex === 4) {
+                rows = additionalWorkspaces.map((directory, index) => ({
+                    index: index + 1,
+                    label: directory.path,
+                    selected: index ===
+                        dashboardSelectedIndex(input.selectedIndex, additionalWorkspaces.length + 1),
+                    original: false,
+                }));
+                rowCount = additionalWorkspaces.length + 1;
+                rows.push({
+                    index: rowCount,
+                    label: 'Add directory…',
+                    selected: dashboardSelectedIndex(input.selectedIndex, rowCount) ===
+                        rowCount - 1,
+                });
+            }
+            else {
+                rows = matchingRules.map((rule, index) => ({
+                    index: index + 2,
+                    label: rule.rule,
+                    description: permissionScopeLabel(rule.scope),
+                    selected: index + 1 ===
+                        dashboardSelectedIndex(input.selectedIndex, matchingRules.length + 1),
+                }));
+                rows.unshift({
+                    index: 1,
+                    label: 'Add a new rule…',
+                    selected: dashboardSelectedIndex(input.selectedIndex, matchingRules.length + 1) === 0,
+                });
+                rowCount = rows.length;
+            }
+            const normalizedSelected = dashboardSelectedIndex(input.selectedIndex, rowCount);
+            rows = rows.map((row, index) => ({
+                ...row,
+                selected: index === normalizedSelected,
+            }));
+            const description = tabIndex === 0
+                ? input.recentDenied.length === 0
+                    ? 'Commands denied by the auto mode classifier will appear here.'
+                    : 'Commands recently denied by the auto mode classifier.'
+                : tabIndex === 1
+                    ? "Praxis Code won't ask before using allowed tools."
+                    : tabIndex === 2
+                        ? 'Praxis Code will always ask for confirmation before using these tools.'
+                        : tabIndex === 3
+                            ? 'Praxis Code will reject requests to use denied tools.'
+                            : 'Praxis Code can read files in the workspace, and make edits when auto-accept edits is on.';
+            const emptyState = tabIndex === 0 && input.recentDenied.length === 0
+                ? 'No recent denials.'
+                : tabIndex >= 1 && tabIndex <= 3 && matchingRules.length === 0
+                    ? 'No matching permission rules.'
+                    : undefined;
+            return {
+                kind: input.kind,
+                heading: 'Permissions',
+                tabs: tabs.map((label, index) => ({
+                    index,
+                    label,
+                    current: index === tabIndex,
+                })),
+                tabIndex,
+                description,
+                query: input.query,
+                rows,
+                ...(emptyState ? { emptyState } : {}),
+                ...(tabIndex === 4 && originalWorkspace
+                    ? {
+                        originalWorkspace: {
+                            index: 0,
+                            label: originalWorkspace.path,
+                            description: 'Original working directory',
+                            selected: false,
+                            original: true,
+                        },
+                    }
+                    : {}),
+                range: range(rowCount),
+                actions: tabIndex === 0
+                    ? input.recentDenied.length === 0
+                        ? [
+                            {
+                                label: '←/→ to switch',
+                                screenReaderLabel: 'Use left/right arrows to switch tabs',
+                            },
+                        ]
+                        : [
+                            {
+                                label: 'Enter to approve',
+                                key: 'Enter',
+                                usesSelectionRange: true,
+                            },
+                            { label: 'r to retry', key: 'r' },
+                            {
+                                label: '↑/↓ to navigate',
+                                screenReaderLabel: 'Use up/down arrows to navigate',
+                            },
+                        ]
+                    : normalizedSelected >= 0
+                        ? [
+                            {
+                                label: '↑/↓ navigate',
+                                screenReaderLabel: 'Use up/down arrows to navigate',
+                            },
+                            {
+                                label: 'Enter to select',
+                                key: 'Enter',
+                                usesSelectionRange: true,
+                            },
+                            {
+                                label: '←/→ to switch',
+                                screenReaderLabel: 'Use left/right arrows to switch tabs',
+                            },
+                        ]
+                        : [
+                            {
+                                label: '←/→ to switch',
+                                screenReaderLabel: 'Use left/right arrows to switch tabs',
+                            },
+                            {
+                                label: '↓ to select',
+                                screenReaderLabel: 'Use down arrow to select',
+                            },
+                        ],
+                cancellation: 'Escape to cancel',
+            };
+        }
+        case 'permission-rule-input':
+            return {
+                kind: input.kind,
+                heading: `Add ${input.behavior} permission rule`,
+                behavior: input.behavior,
+                value: input.value,
+                description: 'Permission rules are a tool name, optionally followed by a specifier in parentheses.\ne.g., WebFetch or Bash(ls *)',
+                placeholder: 'Enter permission rule…',
+                actions: [{ label: 'Enter to submit', key: 'Enter' }],
+                cancellation: 'Escape to cancel',
+            };
+        case 'permission-scope': {
+            const projected = options([
+                {
+                    label: 'Project settings (local)',
+                    description: `Saved in ${input.settingsDirectory}/settings.local.json`,
+                    value: 'local',
+                },
+                {
+                    label: 'Project settings',
+                    description: `Checked in at ${input.settingsDirectory}/settings.json`,
+                    value: 'project',
+                },
+                {
+                    label: 'User settings',
+                    description: `Saved in ~/${input.settingsDirectory}/settings.json`,
+                    value: 'user',
+                },
+            ], input.selectedIndex);
+            return {
+                kind: input.kind,
+                heading: 'Where should this rule be saved?',
+                behavior: input.behavior,
+                rule: input.rule,
+                description: permissionRuleDescription(input.rule)
+                    ? `${input.rule} · ${permissionRuleDescription(input.rule)}`
+                    : input.rule,
+                ...projected,
+                actions: [
+                    {
+                        label: 'Enter to select',
+                        key: 'Enter',
+                        usesSelectionRange: true,
+                    },
+                ],
+                cancellation: 'Escape to cancel',
+            };
+        }
+        case 'permission-delete': {
+            const projected = options([{ label: 'Yes' }, { label: 'No' }], input.selectedIndex);
+            const ruleDescription = permissionRuleDescription(input.rule.rule);
+            return {
+                kind: input.kind,
+                heading: `Delete ${input.rule.behavior === 'allow' ? 'allowed' : input.rule.behavior === 'deny' ? 'denied' : 'ask'} tool?`,
+                rule: input.rule.rule,
+                ...(ruleDescription ? { description: ruleDescription } : {}),
+                scope: permissionScopeLabel(input.rule.scope),
+                question: 'Are you sure you want to delete this permission rule?',
+                ...projected,
+                actions: [
+                    {
+                        label: 'Enter to select',
+                        key: 'Enter',
+                        usesSelectionRange: true,
+                    },
+                ],
+                cancellation: 'Escape to cancel',
+            };
+        }
+        case 'workspace-directory-input':
+            return {
+                kind: input.kind,
+                heading: 'Add directory to workspace',
+                description: 'Praxis Code will be able to read files in this directory and make edits when auto-accept edits is on.\n\nEnter the path to the directory:',
+                value: input.value,
+                placeholder: 'Directory path…',
+                actions: [
+                    { label: 'Tab to complete', key: 'Tab' },
+                    { label: 'Enter to add', key: 'Enter' },
+                ],
+                cancellation: 'Escape to cancel',
+            };
+        case 'workspace-directory-delete': {
+            const projected = options([{ label: 'Yes' }, { label: 'No' }], input.selectedIndex);
+            return {
+                kind: input.kind,
+                heading: 'Remove directory from workspace?',
+                path: input.path,
+                description: 'Praxis Code will no longer have access to files in this directory.',
+                ...projected,
+                actions: [
+                    {
+                        label: 'Enter to confirm',
+                        key: 'Enter',
+                        usesSelectionRange: true,
+                    },
+                ],
+                cancellation: 'Escape to cancel',
+            };
+        }
+    }
+}
+//# sourceMappingURL=permission-surface-model.js.map

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

@@ -0,0 +1,7 @@
+import type { TuiPermissionSurfaceModel } from './permission-surface-model.js';
+export declare function PermissionSurface({ model, width, screenReader, }: {
+    model: TuiPermissionSurfaceModel;
+    width: number;
+    screenReader: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=permission-surface.d.ts.map

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

@@ -0,0 +1,69 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { DialogFrame } from './claude-style.js';
+import { ToolPermissionDialog } from './tool-permission.js';
+import { useTuiTheme } from './theme.js';
+function selectionPrefix(selected, screenReader) {
+    if (screenReader)
+        return selected ? 'Selected: ' : '';
+    return selected ? '❯ ' : '  ';
+}
+function optionsBlock(options, screenReader, selectedRow) {
+    return options.map((option) => (_jsxs(Text, { ...(option.selected ? selectedRow : {}), children: [selectionPrefix(option.selected, screenReader), option.index, ". ", option.label, option.description ? `: ${option.description}` : ''] }, `${option.index}-${option.label}`)));
+}
+function rowsBlock(rows, screenReader, selectedRow) {
+    return rows.map((row) => (_jsxs(Text, { ...(row.selected ? selectedRow : {}), children: [selectionPrefix(row.selected, screenReader), row.index, ".", ' ', row.status === 'retrying'
+                ? screenReader
+                    ? 'Retrying: '
+                    : '✔ '
+                : row.status === 'denied'
+                    ? screenReader
+                        ? 'Denied: '
+                        : '✘ '
+                    : '', row.label, row.status === 'retrying' ? ' (retry)' : '', row.description ? `  ${row.description}` : ''] }, `${row.index}-${row.id ?? row.label}`)));
+}
+function Footer({ model, screenReader, }) {
+    const enter = 'range' in model && model.range.max > 0
+        ? `Enter selection [1-${model.range.max}]`
+        : (model.actions[0]?.label ?? 'Enter');
+    const completeActions = model.actions.map((action) => screenReader
+        ? action.usesSelectionRange === true &&
+            'range' in model &&
+            model.range.max > 0
+            ? enter
+            : (action.screenReaderLabel ?? action.label)
+        : action.label);
+    return (_jsx(Text, { dimColor: true, children: screenReader
+            ? `${completeActions.join(' · ')} · ${model.cancellation}`
+            : `${completeActions.join(' · ')} · ${model.cancellation.replace('Escape', 'Esc')}` }));
+}
+function Dashboard({ model, width, screenReader, }) {
+    const theme = useTuiTheme();
+    return (_jsxs(Box, { flexDirection: "column", width: Math.min(100, width), children: [!screenReader ? (_jsx(Text, { dimColor: true, children: '─'.repeat(Math.min(100, width)) })) : null, _jsx(Text, { ...theme.text.navigation, bold: true, children: model.heading }), _jsx(Text, { children: model.tabs.map((tab) => (_jsxs(Text, { ...(tab.current ? theme.text.selectedTab : {}), children: [screenReader && tab.current ? 'Current tab: ' : '', tab.label, ' '] }, tab.label))) }), _jsx(Text, { children: " " }), _jsx(Text, { children: model.description }), model.emptyState ? _jsx(Text, { dimColor: true, children: model.emptyState }) : null, model.tabIndex >= 1 && model.tabIndex <= 3 ? (_jsx(Box, { borderStyle: screenReader ? undefined : 'round', paddingX: 1, marginY: 1, children: _jsxs(Text, { ...(model.query ? {} : { dimColor: true }), children: [screenReader ? 'Search: ' : '⌕ ', model.query || 'Search…'] }) })) : (_jsx(Text, { children: " " })), model.originalWorkspace ? (_jsxs(Text, { children: [screenReader ? '' : '    -  ', model.originalWorkspace.label, " (", model.originalWorkspace.description, ")"] })) : null, rowsBlock(model.rows, screenReader, theme.text.selectedRow), _jsx(Text, { children: " " }), _jsx(Footer, { model: model, screenReader: screenReader })] }));
+}
+function InputSurface({ heading, description, value, placeholder, model, screenReader, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: heading }), description.split('\n').map((line, index) => (_jsx(Text, { children: line || ' ' }, `${index}-${line}`))), _jsx(Box, { borderStyle: screenReader ? undefined : 'round', paddingX: screenReader ? 0 : 1, children: _jsx(Text, { ...(value ? {} : { dimColor: true }), children: value || placeholder }) }), _jsx(Footer, { model: model, screenReader: screenReader })] }));
+}
+export function PermissionSurface({ model, width, screenReader, }) {
+    const theme = useTuiTheme();
+    switch (model.kind) {
+        case 'tool-request':
+            return (_jsx(Box, { flexDirection: "column", width: Math.min(100, width), children: _jsx(ToolPermissionDialog, { model: model.tool, selection: model.selectedIndex, feedbackMode: model.feedbackMode, feedback: model.feedback, ...(model.ruleEditor === undefined
+                        ? {}
+                        : { ruleEditor: model.ruleEditor }), screenReader: screenReader }) }));
+        case 'recovery-request':
+            return (_jsxs(DialogFrame, { title: model.heading, screenReader: screenReader, children: [_jsx(Box, { flexDirection: "column", paddingX: screenReader ? 0 : 1, paddingY: screenReader ? 0 : 1, children: _jsx(Text, { bold: true, children: model.display }) }), _jsx(Text, { children: model.question }), optionsBlock(model.options, screenReader, theme.text.selectedRow), model.feedbackMode ? (_jsxs(Text, { children: [screenReader ? 'Feedback: ' : '› ', model.feedback || model.feedbackPlaceholder] })) : null, _jsx(Footer, { model: model, screenReader: screenReader })] }));
+        case 'permission-dashboard':
+            return (_jsx(Dashboard, { model: model, width: width, screenReader: screenReader }));
+        case 'permission-rule-input':
+        case 'workspace-directory-input':
+            return (_jsx(InputSurface, { heading: model.heading, description: model.description, value: model.value, placeholder: model.placeholder, model: model, screenReader: screenReader }));
+        case 'permission-scope':
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: model.heading }), _jsx(Text, { dimColor: true, children: model.description }), optionsBlock(model.options, screenReader, theme.text.selectedRow), _jsx(Footer, { model: model, screenReader: screenReader })] }));
+        case 'permission-delete':
+            return (_jsxs(Box, { flexDirection: "column", borderStyle: screenReader ? undefined : 'round', ...theme.surface.decision, paddingX: screenReader ? 0 : 1, marginTop: 1, children: [_jsx(Text, { ...theme.text.heading, ...theme.text.warning, bold: true, children: model.heading }), _jsx(Text, { children: model.rule }), model.description ? _jsx(Text, { dimColor: true, children: model.description }) : null, _jsx(Text, { dimColor: true, children: model.scope }), _jsx(Text, { children: model.question }), optionsBlock(model.options, screenReader, theme.text.selectedRow), _jsx(Footer, { model: model, screenReader: screenReader })] }));
+        case 'workspace-directory-delete':
+            return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: model.heading }), _jsx(Text, { children: model.path }), _jsx(Text, { children: model.description }), optionsBlock(model.options, screenReader, theme.text.selectedRow), _jsx(Footer, { model: model, screenReader: screenReader })] }));
+    }
+}
+//# sourceMappingURL=permission-surface.js.map

package/dist/cli/tui/presentation-environment.d.ts

@@ -0,0 +1,32 @@
+import type { TuiRendererMode } from './tui-view-model.js';
+export type TuiPresentationKind = 'fullscreen' | 'classic' | 'screen-reader';
+export interface TuiTerminalViewport {
+    readonly columns: number;
+    readonly rows: number | undefined;
+    readonly revision: number;
+    readonly source: 'terminal' | 'override' | 'fallback';
+}
+export interface TuiPresentationEnvironment {
+    readonly kind: TuiPresentationKind;
+    readonly viewport: TuiTerminalViewport;
+    readonly fixedViewport: boolean;
+    readonly screenReader: boolean;
+}
+export interface TuiPresentationEnvironmentInput {
+    readonly renderer: TuiRendererMode;
+    readonly screenReader: boolean;
+    readonly viewportOverride?: Readonly<{
+        columns?: number;
+        rows?: number;
+    }>;
+}
+export interface TuiInkRenderOptions {
+    readonly incrementalRendering: boolean;
+    readonly alternateScreen: boolean;
+    readonly isScreenReaderEnabled: boolean;
+    readonly maxFps: number;
+    readonly concurrent: false;
+}
+export declare function useTuiPresentationEnvironment(input: TuiPresentationEnvironmentInput): TuiPresentationEnvironment;
+export declare function tuiInkRenderOptions(renderer: TuiRendererMode, screenReader: boolean): TuiInkRenderOptions;
+//# sourceMappingURL=presentation-environment.d.ts.map

package/dist/cli/tui/presentation-environment.js

@@ -0,0 +1,149 @@
+import { useEffect, useRef, useState } from 'react';
+import { useStdout } from 'ink';
+function normalizeDimension(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return undefined;
+    const normalized = Math.floor(value);
+    return normalized > 0 ? normalized : undefined;
+}
+function initialViewport(stdout, override) {
+    const overrideColumns = normalizeDimension(override?.columns);
+    const overrideRows = normalizeDimension(override?.rows);
+    if (override !== undefined) {
+        return {
+            columns: overrideColumns ?? 80,
+            rows: overrideRows,
+            revision: 0,
+            source: 'override',
+        };
+    }
+    const columns = normalizeDimension(stdout.columns);
+    return {
+        columns: columns ?? 80,
+        rows: normalizeDimension(stdout.rows),
+        revision: 0,
+        source: columns === undefined ? 'fallback' : 'terminal',
+    };
+}
+function sameViewport(left, right) {
+    return (left.columns === right.columns &&
+        left.rows === right.rows &&
+        left.source === right.source);
+}
+function publishViewport(current, next) {
+    if (sameViewport(current, next))
+        return current;
+    return { ...next, revision: current.revision + 1 };
+}
+function resolveTuiPresentationKind(renderer, screenReader) {
+    if (screenReader)
+        return 'screen-reader';
+    return renderer === 'fullscreen' ? 'fullscreen' : 'classic';
+}
+export function useTuiPresentationEnvironment(input) {
+    const { stdout } = useStdout();
+    const overrideColumns = input.viewportOverride?.columns;
+    const overrideRows = input.viewportOverride?.rows;
+    const hasOverride = input.viewportOverride !== undefined;
+    const [viewport, setViewport] = useState(() => initialViewport(stdout, input.viewportOverride));
+    const publishedViewport = useRef(viewport);
+    const resizeTimer = useRef(undefined);
+    const pendingViewport = useRef(undefined);
+    const mounted = useRef(true);
+    useEffect(() => {
+        mounted.current = true;
+        const normalizedOverrideColumns = normalizeDimension(overrideColumns);
+        const normalizedOverrideRows = normalizeDimension(overrideRows);
+        if (hasOverride) {
+            pendingViewport.current = undefined;
+            setViewport((current) => {
+                const next = publishViewport(current, {
+                    columns: normalizedOverrideColumns ?? 80,
+                    rows: normalizedOverrideRows,
+                    source: 'override',
+                });
+                publishedViewport.current = next;
+                return next;
+            });
+            return () => {
+                mounted.current = false;
+                if (resizeTimer.current !== undefined) {
+                    clearTimeout(resizeTimer.current);
+                    resizeTimer.current = undefined;
+                }
+                pendingViewport.current = undefined;
+            };
+        }
+        const resize = () => {
+            const columns = normalizeDimension(stdout.columns);
+            const rows = normalizeDimension(stdout.rows);
+            const lastPublished = publishedViewport.current;
+            pendingViewport.current = {
+                columns: columns ?? lastPublished.columns,
+                rows: rows ?? lastPublished.rows,
+                source: 'terminal',
+            };
+            if (resizeTimer.current !== undefined)
+                return;
+            resizeTimer.current = setTimeout(() => {
+                resizeTimer.current = undefined;
+                const pending = pendingViewport.current;
+                pendingViewport.current = undefined;
+                if (!mounted.current || pending === undefined)
+                    return;
+                setViewport((current) => {
+                    const next = publishViewport(current, pending);
+                    publishedViewport.current = next;
+                    return next;
+                });
+            }, 33);
+        };
+        stdout.on('resize', resize);
+        return () => {
+            mounted.current = false;
+            stdout.off('resize', resize);
+            if (resizeTimer.current !== undefined) {
+                clearTimeout(resizeTimer.current);
+                resizeTimer.current = undefined;
+            }
+            pendingViewport.current = undefined;
+        };
+    }, [hasOverride, overrideColumns, overrideRows, stdout]);
+    const screenReader = input.screenReader;
+    const kind = resolveTuiPresentationKind(input.renderer, screenReader);
+    return {
+        kind,
+        viewport,
+        fixedViewport: kind === 'fullscreen' && viewport.rows !== undefined,
+        screenReader,
+    };
+}
+export function tuiInkRenderOptions(renderer, screenReader) {
+    const kind = resolveTuiPresentationKind(renderer, screenReader);
+    if (kind === 'screen-reader') {
+        return {
+            incrementalRendering: false,
+            alternateScreen: false,
+            isScreenReaderEnabled: true,
+            maxFps: 30,
+            concurrent: false,
+        };
+    }
+    if (kind === 'fullscreen') {
+        return {
+            incrementalRendering: false,
+            alternateScreen: true,
+            isScreenReaderEnabled: false,
+            maxFps: 30,
+            concurrent: false,
+        };
+    }
+    return {
+        incrementalRendering: true,
+        alternateScreen: false,
+        isScreenReaderEnabled: false,
+        maxFps: 30,
+        concurrent: false,
+    };
+}
+//# sourceMappingURL=presentation-environment.js.map

package/dist/cli/tui/task-panel.js

@@ -47,10 +47,19 @@ export function projectBackgroundBashTask(snapshot) {
     };
 }
 export function projectBackgroundAgentTask(snapshot) {
+    const status = snapshot.status === 'cancelled'
+        ? 'stopped'
+        : snapshot.status === 'orphaned'
+            ? 'interrupted'
+            : snapshot.status === 'queued' ||
+                snapshot.status === 'waiting' ||
+                snapshot.status === 'cancelling'
+                ? 'running'
+                : snapshot.status;
     return {
         id: snapshot.agentId,
         kind: 'agent',
-        status: snapshot.status,
+        status,
         label: snapshot.name ?? snapshot.description,
         output: snapshot.result?.text ?? snapshot.error ?? '',
         startedAtMs: snapshot.startedAt,