praxis-agent 0.46.0 → 0.46.2

package/README.md

@@ -212,9 +212,13 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   installing it, rejects concurrent updates, and can roll back after an
   interruption or crash.
 
-Detailed feature status and executable evidence live in the
-[parity matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md),
-not in this entry-point README.
+Current qualification status and executable evidence live in the
+[Native Fixture Contracts](https://github.com/Forest-Isle/Praxis/blob/main/docs/NATIVE_FIXTURE_CONTRACTS.md)
+and its machine-readable
+[fixture manifest](https://github.com/Forest-Isle/Praxis/blob/main/test/fixtures/manifest.json).
+The [parity matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md)
+and [roadmap](https://github.com/Forest-Isle/Praxis/blob/main/docs/ROADMAP.md) are
+historical clean-room records.
 
 ## Native data plane
 
@@ -234,17 +238,17 @@ only; they do not change Praxis data ownership.
 
 ## Documentation
 
-| Need                                       | Document                                                                                         |
-| ------------------------------------------ | ------------------------------------------------------------------------------------------------ |
-| Install and run the first session          | [Getting Started](https://github.com/Forest-Isle/Praxis/blob/main/docs/GETTING_STARTED.md)       |
-| Common commands and environment variables  | [CLI Reference](https://github.com/Forest-Isle/Praxis/blob/main/docs/CLI_REFERENCE.md)           |
-| Find all user and maintainer documentation | [Documentation Index](https://github.com/Forest-Isle/Praxis/blob/main/docs/README.md)            |
-| Understand module and data-flow boundaries | [Architecture](https://github.com/Forest-Isle/Praxis/blob/main/docs/ARCHITECTURE.md)             |
-| Review security assumptions                | [Threat Model](https://github.com/Forest-Isle/Praxis/blob/main/docs/THREAT_MODEL.md)             |
-| Check Claude Code parity                   | [Parity Matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md)           |
-| Review interactive TUI design and evidence | [Quiet Operator Spec](https://github.com/Forest-Isle/Praxis/blob/main/docs/TUI_REDESIGN_SPEC.md) |
-| Build, test, and contribute                | [Contributing](https://github.com/Forest-Isle/Praxis/blob/main/CONTRIBUTING.md)                  |
-| Verify release and supply-chain controls   | [Release Contract](https://github.com/Forest-Isle/Praxis/blob/main/docs/RELEASE.md)              |
+| Need                                       | Document                                                                                                     |
+| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
+| Install and run the first session          | [Getting Started](https://github.com/Forest-Isle/Praxis/blob/main/docs/GETTING_STARTED.md)                   |
+| Common commands and environment variables  | [CLI Reference](https://github.com/Forest-Isle/Praxis/blob/main/docs/CLI_REFERENCE.md)                       |
+| Find all user and maintainer documentation | [Documentation Index](https://github.com/Forest-Isle/Praxis/blob/main/docs/README.md)                        |
+| Understand module and data-flow boundaries | [Architecture](https://github.com/Forest-Isle/Praxis/blob/main/docs/ARCHITECTURE.md)                         |
+| Review security assumptions                | [Threat Model](https://github.com/Forest-Isle/Praxis/blob/main/docs/THREAT_MODEL.md)                         |
+| Qualify native behavior and evidence       | [Native Fixture Contracts](https://github.com/Forest-Isle/Praxis/blob/main/docs/NATIVE_FIXTURE_CONTRACTS.md) |
+| Review interactive TUI design and evidence | [Quiet Operator Spec](https://github.com/Forest-Isle/Praxis/blob/main/docs/TUI_REDESIGN_SPEC.md)             |
+| Build, test, and contribute                | [Contributing](https://github.com/Forest-Isle/Praxis/blob/main/CONTRIBUTING.md)                              |
+| Verify release and supply-chain controls   | [Release Contract](https://github.com/Forest-Isle/Praxis/blob/main/docs/RELEASE.md)                          |
 
 ## Project boundary
 
@@ -286,10 +290,13 @@ injected regression protection, plus Quiet Operator input echo `<50 ms` and
 normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run check` also enforces the corresponding source dependency direction.
 `npm run test:coverage` measures all production code under `src/**` with V8 and
-enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines.
-`npm run test:core-completion` runs the 56-story #402 audit and reports
-implemented, qualified, blocked, deferred, and out-of-scope states separately;
-it never treats missing live prerequisites as a pass.
+enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines,
+and rejects any production runtime module with zero covered statements (while allowing
+type-only modules). `npm run test:fixtures` executes the 67-behavior native contract; 59 behaviors
+are qualified and 8 are explicitly excluded. `npm run verify:fixture-contracts`
+performs the structural check and is part of `npm run check`.
+`npm run test:core-completion` is retained as a compatibility alias for
+`npm run test:fixtures`.
 
 Contributions use Conventional Commit pull-request titles and the protected
 squash-merge workflow. Read

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

@@ -123,6 +123,11 @@ export interface SessionRunResult {
     costUsd?: number;
     modelUsage?: Readonly<Record<string, ModelUsage>>;
 }
+export interface CwdInspection {
+    readonly canonicalTarget: string;
+    readonly canonicalCurrentCwd: string;
+    readonly sameDirectory: boolean;
+}
 export interface SideQuestionResult {
     sessionId: string;
     text: string;
@@ -290,7 +295,8 @@ export declare class ClaudeSessionService {
     metadata(sessionId: string): Promise<ClaudeSessionMetadata>;
     rename(sessionId: string, name: string): Promise<void>;
     tag(sessionId: string, tag: string): Promise<void>;
-    changeCwd(sessionId: string | undefined, requestedCwd: string): Promise<string>;
+    changeCwd(sessionId: string | undefined, requestedCwd: string, expectedCanonicalTarget?: string): Promise<string>;
+    inspectCwd(requestedCwd: string): Promise<CwdInspection>;
     recordCdUsage(sessionId: string): Promise<void>;
     approveRecentlyDenied(sessionId: string, display: string): Promise<void>;
     retryRecentlyDenied(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;

package/dist/application/session-service.js

@@ -1806,17 +1806,23 @@ export class ClaudeSessionService {
         const normalized = tag.trim();
         await this.appendNativeCommand(sessionId, `/tag ${normalized}`);
     }
-    async changeCwd(sessionId, requestedCwd) {
+    async changeCwd(sessionId, requestedCwd, expectedCanonicalTarget) {
         this.assertWritable();
         const previousCwd = this.activeCwd();
-        const expandedCwd = requestedCwd === '~'
-            ? homedir()
-            : requestedCwd.startsWith('~/')
-                ? join(homedir(), requestedCwd.slice(2))
-                : requestedCwd;
-        const cwd = await realpath(isAbsolute(expandedCwd) ? expandedCwd : join(previousCwd, expandedCwd));
-        if (!(await stat(cwd)).isDirectory()) {
-            throw new Error(`Not a directory: ${requestedCwd}`);
+        let inspection;
+        try {
+            inspection = await this.inspectCwd(requestedCwd);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes(' is not a directory.'))
+                throw new Error(`Not a directory: ${requestedCwd}; ${error.message}`);
+            throw error;
+        }
+        const cwd = inspection.canonicalTarget;
+        if (expectedCanonicalTarget !== undefined &&
+            cwd !== expectedCanonicalTarget) {
+            throw new Error(`Directory changed after approval: expected ${expectedCanonicalTarget}, resolved to ${cwd}. Review the target and try again.`);
         }
         if (sessionId && this.options.sessionPersistence !== false) {
             const sourcePaths = this.pathsForCwd(sessionId, this.sessionCwds.get(sessionId) ?? previousCwd);
@@ -1896,6 +1902,33 @@ export class ClaudeSessionService {
         }
         return cwd;
     }
+    async inspectCwd(requestedCwd) {
+        const current = await realpath(this.activeCwd());
+        const expanded = requestedCwd === '~'
+            ? homedir()
+            : requestedCwd.startsWith('~/')
+                ? join(homedir(), requestedCwd.slice(2))
+                : requestedCwd;
+        const resolved = isAbsolute(expanded) ? expanded : join(current, expanded);
+        let target;
+        try {
+            target = await realpath(resolved);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                throw new Error(`Could not find a directory at ${resolved}.`);
+            throw error;
+        }
+        const info = await stat(target);
+        if (!info.isDirectory()) {
+            throw new Error(`${target} is not a directory. Did you mean ${dirname(target)}?`);
+        }
+        return {
+            canonicalTarget: target,
+            canonicalCurrentCwd: current,
+            sameDirectory: target === current,
+        };
+    }
     async recordCdUsage(sessionId) {
         this.assertWritable();
         const transcript = new NativeSessionTranscript({

package/dist/cli/interactive.d.ts

@@ -1,4 +1,4 @@
-import type { ForkResult, ManualCompactResult, ManualCompactSelection, RewindPoint, SessionForkCheckpoint, SessionRunResult, SessionSummary, SideQuestionForkResult, SideQuestionResult } from '../application/session-service.js';
+import type { CwdInspection, 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';
@@ -46,7 +46,8 @@ interface InteractiveSessionCommands {
     compact?(sessionId: string, signal?: AbortSignal, selection?: ManualCompactSelection): Promise<ManualCompactResult>;
     rewindFiles?(sessionId: string, userMessageId: string): Promise<void>;
     rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
-    changeCwd?(sessionId: string | undefined, cwd: string): Promise<string>;
+    changeCwd?(sessionId: string | undefined, cwd: string, expectedCanonicalTarget?: string): Promise<string>;
+    inspectCwd?(cwd: string): Promise<CwdInspection>;
     notify?(sessionId: string | undefined, message: string, notificationType: string, title?: string): void;
     recordCdUsage?(sessionId: string): Promise<void>;
     approveRecentlyDenied?(sessionId: string, display: string): Promise<void>;

package/dist/cli/interactive.js

@@ -44,6 +44,7 @@ import { projectTuiCommandPalette, tuiCommandPaletteCommandId, } from './tui/com
 import { runDoctor, } from '../maintenance/doctor.js';
 import { canonicalClaudeCostModelName, formatCostSummary, } from './tui/cost-summary.js';
 import { createComposerEditor, deleteComposerBackward, deleteComposerForward, insertComposerText, moveComposerCursor, } from './tui/composer-editor.js';
+import { createComposerPromptHistory, navigateComposerPromptHistory, recordComposerPrompt, resetComposerPromptHistoryNavigation, seedComposerPromptHistory, } from './tui/composer-prompt-history.js';
 import { routeComposerKey, } from './tui/composer-key-router.js';
 import { routeTuiInteraction, } from './tui/tui-interaction-router.js';
 import { currentTuiInteractionLayer, projectTuiFocusStack, } from './tui/tui-focus-stack.js';
@@ -239,6 +240,9 @@ const HIDDEN_TUI_SLASH_COMMANDS = new Set([
     'update',
     'usage',
 ]);
+function transcriptPrompts(items) {
+    return items.flatMap((item) => (item.kind === 'user' ? [item.text] : []));
+}
 /** Advances the React-owned transcript plus its exact local mutation fact. */
 export function advanceInteractiveHistoryState(current, items, changedFrom) {
     if (!Number.isInteger(changedFrom) ||
@@ -372,9 +376,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const [pendingFork, setPendingFork] = useState(resume?.forkSession === true);
     const inputRef = useRef('');
     const inputCursorRef = useRef(0);
-    const inputHistoryRef = useRef([]);
-    const inputHistoryIndexRef = useRef(null);
-    const inputHistoryDraftRef = useRef('');
+    const promptHistoryRef = useRef(seedComposerPromptHistory(transcriptPrompts(initialHistory)));
     const [pendingInputs, setPendingInputs] = useState([]);
     const pendingInputsRef = useRef(pendingInputs);
     pendingInputsRef.current = pendingInputs;
@@ -608,6 +610,35 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
     const planApprovalRef = useRef(null);
     const [planApprovalSelection, setPlanApprovalSelection] = useState(0);
     const [planApprovalFeedbackMode, setPlanApprovalFeedbackMode] = useState(false);
+    const [cdTrust, setCdTrust] = useState(null);
+    const [cdTrustSelection, setCdTrustSelection] = useState(0);
+    const cdTrustRef = useRef(null);
+    const trustedCwdsBySessionRef = useRef(new Map());
+    const trustedCwdSessionRef = useRef(sessionId);
+    useEffect(() => {
+        const previousSessionId = trustedCwdSessionRef.current;
+        if (previousSessionId === sessionId)
+            return;
+        if (previousSessionId === null && sessionId !== null) {
+            const pendingSessionTrust = trustedCwdsBySessionRef.current.get(null);
+            if (pendingSessionTrust)
+                trustedCwdsBySessionRef.current.set(sessionId, pendingSessionTrust);
+            trustedCwdsBySessionRef.current.delete(null);
+        }
+        else if (sessionId === null) {
+            trustedCwdsBySessionRef.current.delete(null);
+        }
+        trustedCwdSessionRef.current = sessionId;
+    }, [sessionId]);
+    const trustedCwds = () => {
+        const key = sessionIdRef.current;
+        const existing = trustedCwdsBySessionRef.current.get(key);
+        if (existing)
+            return existing;
+        const created = new Set();
+        trustedCwdsBySessionRef.current.set(key, created);
+        return created;
+    };
     const serviceRef = useRef(null);
     const serviceCreationRef = useRef(undefined);
     const onCleanupRef = useRef(onCleanup);
@@ -866,6 +897,13 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             answer: input,
         })
         : null, [question, input]);
+    const cdTrustSurface = useMemo(() => cdTrust
+        ? projectTuiDecisionSurface({
+            kind: 'cd-trust',
+            canonicalPath: cdTrust.canonicalPath,
+            selectedIndex: cdTrustSelection,
+        })
+        : null, [cdTrust, cdTrustSelection]);
     const elicitationSurface = useMemo(() => elicitation === null
         ? null
         : projectTuiElicitationSurface({
@@ -1127,16 +1165,18 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                 }
                 : planApproval !== null && planDecisionSurface !== null
                     ? { priority: planDecisionSurface }
-                    : question !== null && questionDecisionSurface !== null
-                        ? { priority: questionDecisionSurface }
-                        : elicitation !== null && elicitationSurface !== null
-                            ? {
-                                priority: {
-                                    kind: 'elicitation',
-                                    surface: elicitationSurface,
-                                },
-                            }
-                            : {}),
+                    : cdTrust !== null && cdTrustSurface !== null
+                        ? { priority: cdTrustSurface }
+                        : question !== null && questionDecisionSurface !== null
+                            ? { priority: questionDecisionSurface }
+                            : elicitation !== null && elicitationSurface !== null
+                                ? {
+                                    priority: {
+                                        kind: 'elicitation',
+                                        surface: elicitationSurface,
+                                    },
+                                }
+                                : {}),
         ...(secondarySurface === undefined
             ? {}
             : { secondary: secondarySurface }),
@@ -1154,6 +1194,8 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         permission,
         permissionPrioritySurface,
         planApproval,
+        cdTrust,
+        cdTrustSurface,
         question,
         planDecisionSurface,
         questionDecisionSurface,
@@ -1466,6 +1508,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         fileSelectionRef.current = 0;
     };
     const updateComposerEditor = (editor, recordUndo = true) => {
+        promptHistoryRef.current = resetComposerPromptHistoryNavigation(promptHistoryRef.current);
         if (recordUndo && editor.text !== inputRef.current) {
             undoStackRef.current = [
                 ...undoStackRef.current,
@@ -1474,7 +1517,10 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         }
         updateComposerInput(editor.text, editor.cursor);
     };
-    const clearComposerInput = () => updateComposerInput('');
+    const clearComposerInput = () => {
+        promptHistoryRef.current = resetComposerPromptHistoryNavigation(promptHistoryRef.current);
+        updateComposerInput('');
+    };
     const promptImages = (prompt) => {
         const seen = new Set();
         return composerImageIds(prompt).flatMap((id) => {
@@ -1706,36 +1752,13 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         return () => clearInterval(timer);
     }, [menu?.kind]);
     const appendPromptHistory = (prompt) => {
-        if (!prompt)
-            return;
-        const history = inputHistoryRef.current.filter((item) => item !== prompt);
-        inputHistoryRef.current = [prompt, ...history].slice(0, 100);
-        inputHistoryIndexRef.current = null;
-        inputHistoryDraftRef.current = '';
+        promptHistoryRef.current = recordComposerPrompt(promptHistoryRef.current, prompt);
     };
     const restorePromptHistory = (direction) => {
-        const history = inputHistoryRef.current;
-        if (history.length === 0)
-            return;
-        const currentIndex = inputHistoryIndexRef.current;
-        if (direction === 'previous') {
-            if (currentIndex === null)
-                inputHistoryDraftRef.current = inputRef.current;
-            const nextIndex = Math.min(history.length - 1, (currentIndex ?? -1) + 1);
-            inputHistoryIndexRef.current = nextIndex;
-            updateComposerInput(history[nextIndex] ?? '');
-            return;
-        }
-        if (currentIndex === null)
-            return;
-        const nextIndex = currentIndex - 1;
-        if (nextIndex < 0) {
-            inputHistoryIndexRef.current = null;
-            updateComposerInput(inputHistoryDraftRef.current);
-            return;
-        }
-        inputHistoryIndexRef.current = nextIndex;
-        updateComposerInput(history[nextIndex] ?? '');
+        const transition = navigateComposerPromptHistory(promptHistoryRef.current, direction, createComposerEditor(inputRef.current, inputCursorRef.current));
+        promptHistoryRef.current = transition.state;
+        if (transition.editor !== null)
+            updateComposerInput(transition.editor.text, transition.editor.cursor);
     };
     const withdrawLatestPending = () => {
         if (inputRef.current.trim().length !== 0)
@@ -2253,10 +2276,12 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         const loadId = sessionLoadRef.current + 1;
         sessionLoadRef.current = loadId;
         if (nextSessionId === null) {
+            promptHistoryRef.current = createComposerPromptHistory();
             setHistory([]);
             setSessionColor(undefined);
             return;
         }
+        promptHistoryRef.current = createComposerPromptHistory();
         const loading = (async () => {
             try {
                 const commands = await service();
@@ -2266,6 +2291,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     : await commands.agentColor(nextSessionId);
                 if (sessionLoadRef.current === loadId) {
                     setHistory(transcript ? [...transcript] : []);
+                    promptHistoryRef.current = seedComposerPromptHistory(transcriptPrompts(transcript ?? []));
                     setSessionColor(agentColor);
                 }
             }
@@ -2753,23 +2779,58 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         onTurnChange?.(loading);
         void loading.finally(() => onTurnChange?.(null));
     };
-    const changeWorkingDirectory = (requestedCwd) => {
+    const changeWorkingDirectory = (requestedCwd, authorization = {
+        kind: 'unapproved',
+    }) => {
         const changing = (async () => {
-            setBusy(true);
-            setStatus('changing directory');
             try {
                 const commands = await service();
                 if (!commands.changeCwd) {
                     throw new Error('This interactive service cannot change working directories.');
                 }
-                const cwd = await commands.changeCwd(sessionId ?? undefined, requestedCwd);
+                if (!commands.inspectCwd) {
+                    throw new Error('This interactive service cannot inspect or change working directories.');
+                }
+                const inspection = await commands.inspectCwd(requestedCwd);
+                if (authorization.kind === 'approved' &&
+                    inspection.canonicalTarget !== authorization.canonicalTarget) {
+                    throw new Error(`Directory changed after approval: expected ${authorization.canonicalTarget}, resolved to ${inspection.canonicalTarget}. Review the target and try again.`);
+                }
+                const activeSessionTrust = trustedCwds();
+                activeSessionTrust.add(inspection.canonicalCurrentCwd);
+                if (inspection.sameDirectory) {
+                    append({
+                        kind: 'local-result',
+                        text: `Already in ${inspection.canonicalTarget}.`,
+                    });
+                    return;
+                }
+                if (authorization.kind === 'unapproved' &&
+                    !activeSessionTrust.has(inspection.canonicalTarget)) {
+                    const pending = {
+                        canonicalPath: inspection.canonicalTarget,
+                    };
+                    cdTrustRef.current = pending;
+                    setCdTrust(pending);
+                    return;
+                }
+                setBusy(true);
+                setStatus('changing directory');
+                const cwd = await commands.changeCwd(sessionId ?? undefined, inspection.canonicalTarget, inspection.canonicalTarget);
+                activeSessionTrust.add(cwd);
                 runtimeCwdRef.current = cwd;
                 setRuntimeCwd(cwd);
                 await retireService();
                 append({ kind: 'local-result', text: `Moved to ${cwd}` });
             }
             catch (error) {
-                warn(error);
+                const message = error instanceof Error ? error.message : String(error);
+                if (authorization.kind === 'approved')
+                    trustedCwds().delete(authorization.canonicalTarget);
+                if (/^(Could not find a directory at .*\.|.* is not a directory\. Did you mean .+\?)$/u.test(message))
+                    append({ kind: 'local-result', text: message });
+                else
+                    warn(error);
             }
             finally {
                 setBusy(false);
@@ -3249,6 +3310,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     setSessionId(restoredConversation.sessionId || null);
                     setPendingFork(false);
                     setHistory(restoredConversation.history);
+                    promptHistoryRef.current = seedComposerPromptHistory(transcriptPrompts(restoredConversation.history));
                     updateComposerInput(point.prompt);
                 }
                 append({
@@ -3701,6 +3763,11 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                         case 'command-palette':
                             setCommandPaletteOpen(false);
                             break;
+                        case 'cd-trust':
+                            cdTrustRef.current = null;
+                            setCdTrust(null);
+                            setCdTrustSelection(0);
+                            break;
                         default: {
                             const unhandledTarget = effect.target;
                             return unhandledTarget;
@@ -3751,7 +3818,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                                 : ['Select']
             : commandPaletteVisible || filePickerVisible
                 ? ['Autocomplete', 'Chat']
-                : permission || planApproval
+                : permission || planApproval || cdTrust
                     ? ['Confirmation']
                     : selectingSession
                         ? ['Select']
@@ -3822,6 +3889,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             pendingPrefix: hasPendingPrefix,
             permission: Boolean(permission),
             planApproval: Boolean(planApproval),
+            cdTrust: Boolean(cdTrust),
             question: Boolean(question),
             elicitation: elicitation
                 ? elicitationUrlWaiting
@@ -4076,6 +4144,35 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
             }
             return;
         }
+        if (cdTrust) {
+            const resolveCdTrust = (selectedIndex) => {
+                const pending = cdTrustRef.current;
+                cdTrustRef.current = null;
+                setCdTrust(null);
+                setCdTrustSelection(0);
+                if (!pending || selectedIndex !== 1)
+                    return;
+                changeWorkingDirectory(pending.canonicalPath, {
+                    kind: 'approved',
+                    canonicalTarget: pending.canonicalPath,
+                });
+            };
+            if (key.upArrow) {
+                setCdTrustSelection((current) => Math.max(0, current - 1));
+            }
+            else if (key.downArrow) {
+                setCdTrustSelection((current) => Math.min(1, current + 1));
+            }
+            else if (lower === 'y')
+                resolveCdTrust(1);
+            else if (lower === 'n')
+                resolveCdTrust(0);
+            else if (/^[12]$/u.test(value))
+                resolveCdTrust(Number(value) - 1);
+            else if (key.return)
+                resolveCdTrust(cdTrustSelection);
+            return;
+        }
         if (planApproval) {
             const elevatedMode = runtimeSettingsRef.current
                 .useAutoModeDuringPlan
@@ -6285,9 +6382,6 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                     streamingFrameRef.current?.flush();
                     setThinkingExpanded(false);
                     setStatus('ready');
-                    inputHistoryRef.current = [];
-                    inputHistoryIndexRef.current = null;
-                    inputHistoryDraftRef.current = '';
                 })().catch(warn);
             }
             else if (prompt === '/model') {

package/dist/cli/tui/composer-prompt-history.d.ts

@@ -0,0 +1,17 @@
+import { type ComposerEditorState } from './composer-editor.js';
+export declare const COMPOSER_PROMPT_HISTORY_LIMIT = 100;
+export interface ComposerPromptHistoryState {
+    readonly entries: readonly string[];
+    readonly index: number | null;
+    readonly draft: ComposerEditorState | null;
+}
+export interface ComposerPromptHistoryTransition {
+    readonly state: ComposerPromptHistoryState;
+    readonly editor: ComposerEditorState | null;
+}
+export declare function createComposerPromptHistory(): ComposerPromptHistoryState;
+export declare function seedComposerPromptHistory(prompts: readonly string[]): ComposerPromptHistoryState;
+export declare function recordComposerPrompt(state: ComposerPromptHistoryState, prompt: string): ComposerPromptHistoryState;
+export declare function navigateComposerPromptHistory(state: ComposerPromptHistoryState, direction: 'previous' | 'next', currentEditor: ComposerEditorState): ComposerPromptHistoryTransition;
+export declare function resetComposerPromptHistoryNavigation(state: ComposerPromptHistoryState): ComposerPromptHistoryState;
+//# sourceMappingURL=composer-prompt-history.d.ts.map

package/dist/cli/tui/composer-prompt-history.js

@@ -0,0 +1,63 @@
+import { createComposerEditor, } from './composer-editor.js';
+export const COMPOSER_PROMPT_HISTORY_LIMIT = 100;
+export function createComposerPromptHistory() {
+    return { entries: [], index: null, draft: null };
+}
+function normalize(prompts) {
+    const entries = [];
+    for (const prompt of prompts) {
+        if (prompt.trim() === '')
+            continue;
+        if (entries.at(-1) === prompt)
+            continue;
+        entries.push(prompt);
+    }
+    return entries.slice(-COMPOSER_PROMPT_HISTORY_LIMIT);
+}
+export function seedComposerPromptHistory(prompts) {
+    return { entries: normalize(prompts), index: null, draft: null };
+}
+export function recordComposerPrompt(state, prompt) {
+    if (prompt.trim() === '')
+        return state;
+    return {
+        entries: normalize([...state.entries, prompt]),
+        index: null,
+        draft: null,
+    };
+}
+export function navigateComposerPromptHistory(state, direction, currentEditor) {
+    if (state.entries.length === 0)
+        return { state, editor: null };
+    if (direction === 'previous') {
+        const index = state.index === null
+            ? state.entries.length - 1
+            : Math.max(0, state.index - 1);
+        const draft = state.index === null
+            ? createComposerEditor(currentEditor.text, currentEditor.cursor)
+            : state.draft;
+        const nextState = { ...state, index, draft };
+        return {
+            state: nextState,
+            editor: createComposerEditor(state.entries[index]),
+        };
+    }
+    if (state.index === null)
+        return { state, editor: null };
+    if (state.index < state.entries.length - 1) {
+        const index = state.index + 1;
+        return {
+            state: { ...state, index },
+            editor: createComposerEditor(state.entries[index]),
+        };
+    }
+    const editor = state.draft;
+    return {
+        state: { ...state, index: null, draft: null },
+        editor,
+    };
+}
+export function resetComposerPromptHistoryNavigation(state) {
+    return { ...state, index: null, draft: null };
+}
+//# sourceMappingURL=composer-prompt-history.js.map

package/dist/cli/tui/decision-surface-model.d.ts

@@ -32,6 +32,10 @@ export type TuiDecisionSurfaceInput = {
     readonly questions: readonly ClaudeQuestion[];
     readonly questionIndex: number;
     readonly answer: string;
+} | {
+    readonly kind: 'cd-trust';
+    readonly canonicalPath: string;
+    readonly selectedIndex: number;
 };
 export interface TuiPlanApprovalSurfaceModel {
     readonly kind: 'plan-approval';
@@ -66,6 +70,19 @@ export interface TuiQuestionSurfaceModel {
     readonly cancellation: TuiDecisionSurfaceCancellation;
     readonly emptyState?: string;
 }
-export type TuiDecisionSurfaceModel = TuiPlanApprovalSurfaceModel | TuiQuestionSurfaceModel;
+export interface TuiCdTrustSurfaceModel {
+    readonly kind: 'cd-trust';
+    readonly heading: 'Moving to a new directory:';
+    readonly canonicalPath: string;
+    readonly explanation: "This session hasn't worked here before. Is this a directory you created or one you trust?";
+    readonly scope: 'Praxis can read, edit, and execute files in this directory.';
+    readonly securityGuide: 'Security guide: https://code.claude.com/docs/en/security';
+    readonly options: readonly TuiDecisionSurfaceOption[];
+    readonly selectedIndex: number;
+    readonly range: TuiDecisionSurfaceRange;
+    readonly actions: readonly TuiDecisionSurfaceAction[];
+    readonly cancellation: TuiDecisionSurfaceCancellation;
+}
+export type TuiDecisionSurfaceModel = TuiPlanApprovalSurfaceModel | TuiQuestionSurfaceModel | TuiCdTrustSurfaceModel;
 export declare function projectTuiDecisionSurface(input: TuiDecisionSurfaceInput): TuiDecisionSurfaceModel;
 //# sourceMappingURL=decision-surface-model.d.ts.map