praxis-agent 0.46.1 → 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

@@ -610,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);
@@ -868,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({
@@ -1129,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 }),
@@ -1156,6 +1194,8 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
         permission,
         permissionPrioritySurface,
         planApproval,
+        cdTrust,
+        cdTrustSurface,
         question,
         planDecisionSurface,
         questionDecisionSurface,
@@ -2739,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);
@@ -3688,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;
@@ -3738,7 +3818,7 @@ export function InteractiveApp({ dataPlane = resolveDataPlane(), configRoot: sup
                                 : ['Select']
             : commandPaletteVisible || filePickerVisible
                 ? ['Autocomplete', 'Chat']
-                : permission || planApproval
+                : permission || planApproval || cdTrust
                     ? ['Confirmation']
                     : selectingSession
                         ? ['Select']
@@ -3809,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
@@ -4063,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

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

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

@@ -100,6 +100,32 @@ export function projectTuiDecisionSurface(input) {
             cancellation,
         };
     }
+    if (input.kind === 'cd-trust') {
+        const selectedIndex = normalizeIndex(input.selectedIndex, 2);
+        const options = projectedOptions([{ label: 'No, stay put' }, { label: 'Yes, move here' }], selectedIndex);
+        return {
+            kind: 'cd-trust',
+            heading: 'Moving to a new directory:',
+            canonicalPath: input.canonicalPath,
+            explanation: "This session hasn't worked here before. Is this a directory you created or one you trust?",
+            scope: 'Praxis can read, edit, and execute files in this directory.',
+            securityGuide: 'Security guide: https://code.claude.com/docs/en/security',
+            options,
+            selectedIndex,
+            range: range(options.length),
+            actions: [
+                {
+                    visualLabel: 'Enter to confirm',
+                    screenReaderLabel: 'Enter to confirm',
+                },
+                { screenReaderLabel: 'Use up and down arrows to change selection' },
+                { screenReaderLabel: 'Press 1 or 2 to choose directly' },
+                { screenReaderLabel: 'Press y to move here' },
+                { screenReaderLabel: 'Press n to stay put' },
+            ],
+            cancellation,
+        };
+    }
     const count = input.questions.length;
     const questionIndex = normalizeIndex(input.questionIndex, count);
     if (count === 0)

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

@@ -31,8 +31,11 @@ function PlanSurface({ model, screenReader, }) {
 function QuestionSurface({ model, screenReader, }) {
     return (_jsxs(DialogFrame, { title: model.heading, screenReader: screenReader, children: [_jsx(Text, { children: model.progress }), model.emptyState ? _jsx(Text, { dimColor: true, children: model.emptyState }) : null, model.options.map((option) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [option.index, ". ", option.label, option.description ? ` — ${option.description}` : ''] }), option.preview ? _jsx(Text, { dimColor: true, children: option.preview }) : null] }, `${option.index}-${option.label}`))), _jsxs(Text, { children: [screenReader ? 'Current answer: ' : '› ', model.answer || (screenReader ? '(empty)' : '')] }), _jsx(Footer, { ...model, screenReader: screenReader })] }));
 }
+function CdTrustSurface({ model, screenReader, }) {
+    return (_jsxs(DialogFrame, { title: model.heading, screenReader: screenReader, children: [_jsx(Text, { children: model.canonicalPath }), _jsx(Text, { dimColor: true, children: model.explanation }), _jsx(Text, { dimColor: true, children: model.scope }), _jsx(Text, { dimColor: true, children: model.securityGuide }), model.options.map((option) => (_jsx(Option, { option: option, screenReader: screenReader }, option.index))), _jsx(Footer, { ...model, screenReader: screenReader })] }));
+}
 export function DecisionSurface({ model, width, screenReader, }) {
-    const content = model.kind === 'plan-approval' ? (_jsx(PlanSurface, { model: model, screenReader: screenReader })) : (_jsx(QuestionSurface, { model: model, screenReader: screenReader }));
+    const content = model.kind === 'plan-approval' ? (_jsx(PlanSurface, { model: model, screenReader: screenReader })) : model.kind === 'question' ? (_jsx(QuestionSurface, { model: model, screenReader: screenReader })) : (_jsx(CdTrustSurface, { model: model, screenReader: screenReader }));
     const normalizedWidth = Number.isFinite(width)
         ? Math.min(100, Math.max(1, Math.trunc(width)))
         : 100;

package/dist/cli/tui/open-url.d.ts

@@ -1,2 +1,12 @@
-export declare function openTuiUrl(url: string): Promise<void>;
+type OpenUrlOptions = {
+    timeout: number;
+    shell: false;
+};
+type OpenUrlExecutor = (command: string, args: string[], options: OpenUrlOptions, callback: (error?: Error | null) => void) => unknown;
+type OpenUrlDependencies = {
+    platform?: NodeJS.Platform;
+    execFile?: OpenUrlExecutor;
+};
+export declare function openTuiUrl(url: string, dependencies?: OpenUrlDependencies): Promise<void>;
+export {};
 //# sourceMappingURL=open-url.d.ts.map

package/dist/cli/tui/open-url.js

@@ -1,13 +1,33 @@
 import { execFile } from 'node:child_process';
-export async function openTuiUrl(url) {
-    const command = process.platform === 'darwin'
+const defaultExecFile = (command, args, options, callback) => execFile(command, args, options, callback);
+export async function openTuiUrl(url, dependencies = {}) {
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch {
+        throw new Error('TUI URL must be an absolute HTTP(S) URL');
+    }
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')
+        throw new Error('TUI URL must be an absolute HTTP(S) URL');
+    const canonicalUrl = parsedUrl.href;
+    const platform = dependencies.platform ?? process.platform;
+    const command = platform === 'darwin'
         ? 'open'
-        : process.platform === 'win32'
-            ? 'cmd'
+        : platform === 'win32'
+            ? 'rundll32.exe'
             : 'xdg-open';
-    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
-    await new Promise((resolvePromise) => {
-        execFile(command, args, { timeout: 10_000 }, () => resolvePromise());
+    const args = platform === 'win32'
+        ? ['url.dll,FileProtocolHandler', canonicalUrl]
+        : [canonicalUrl];
+    const executor = dependencies.execFile ?? defaultExecFile;
+    await new Promise((resolvePromise, rejectPromise) => {
+        try {
+            executor(command, args, { timeout: 10_000, shell: false }, (error) => error == null ? resolvePromise() : rejectPromise(error));
+        }
+        catch (error) {
+            rejectPromise(error);
+        }
     });
 }
 //# sourceMappingURL=open-url.js.map

package/dist/cli/tui/quiet-choice-rows.js

@@ -176,6 +176,17 @@ function decision(surface, density, sr) {
             explicitFooter('quiet:plan:footer', '↑/↓ select  Enter confirm  Esc cancel', 'Use up and down arrows to select. Press Enter to confirm. Press Escape to cancel.'),
         ];
     }
+    if (surface.kind === 'cd-trust') {
+        out.push(row('quiet:cd-trust:path', surface.canonicalPath, 'body'));
+        out.push(row('quiet:cd-trust:explanation', surface.explanation, 'muted'));
+        out.push(row('quiet:cd-trust:scope', surface.scope, 'muted'));
+        out.push(row('quiet:cd-trust:security-guide', surface.securityGuide, 'muted'));
+        out.push(...optionsRows(surface.options, 'quiet:cd-trust:option', density, sr));
+        return [
+            ...out,
+            explicitFooter('quiet:cd-trust:footer', '↑/↓ select  Enter confirm  Esc cancel', 'Use up and down arrows to select. Press Enter to confirm. Press Escape to cancel.'),
+        ];
+    }
     if (surface.progress)
         out.push(row('quiet:question:progress', surface.progress, 'muted'));
     if (surface.question)
@@ -291,7 +302,9 @@ export function projectQuietChoiceRows(surface, options) {
             row('quiet:exit:heading', 'Exit Praxis?', 'heading'),
             explicitFooter('quiet:exit:footer', 'Enter confirm  Esc cancel', 'Press Enter to confirm. Press Escape to cancel.'),
         ];
-    if (surface.kind === 'plan-approval' || surface.kind === 'question')
+    if (surface.kind === 'plan-approval' ||
+        surface.kind === 'question' ||
+        surface.kind === 'cd-trust')
         return decision(surface, options.density, sr);
     if (surface.kind === 'session-picker' ||
         surface.kind === 'command-palette' ||

package/dist/cli/tui/sandbox-settings.d.ts

@@ -1,8 +1,16 @@
 import type { SandboxDependencyCheck } from '@anthropic-ai/sandbox-runtime';
 import type { JsonResource } from '../../core/resources.js';
+import { type ClaudeSandboxPlatform } from '../../sandbox/claude-sandbox-runtime.js';
 import { type ClaudeSandboxSettings } from '../../sandbox/claude-sandbox-settings.js';
 export type TuiSandboxMode = 'auto-allow' | 'regular' | 'disabled';
 export type TuiSandboxTab = 'mode' | 'dependencies' | 'overrides' | 'config';
+export interface TuiSandboxRuntime {
+    initialize(settings: ClaudeSandboxSettings): Promise<void>;
+    unavailableReason(settings: ClaudeSandboxSettings): string | undefined;
+    platformName(): ClaudeSandboxPlatform;
+    dependencyCheck(settings: ClaudeSandboxSettings): SandboxDependencyCheck;
+    isSupportedPlatform(): boolean;
+}
 export interface TuiSandboxSnapshot {
     settings: ClaudeSandboxSettings;
     dependencies: SandboxDependencyCheck;
@@ -22,11 +30,12 @@ export interface TuiSandboxStore {
     }>;
 }
 export declare function linuxGlobPatternWarnings(resources: readonly JsonResource[], platform: 'macos' | 'linux' | 'windows' | 'wsl'): string[];
-export declare function createTuiSandboxStore({ configRoot, cwd, homeDirectory, additionalDirectories, environment, }: {
+export declare function createTuiSandboxStore({ configRoot, cwd, homeDirectory, additionalDirectories, environment, runtime, }: {
     configRoot: string;
     cwd: string;
     homeDirectory: string;
     additionalDirectories?: readonly string[];
     environment?: NodeJS.ProcessEnv;
+    runtime?: TuiSandboxRuntime;
 }): TuiSandboxStore;
 //# sourceMappingURL=sandbox-settings.d.ts.map

package/dist/cli/tui/sandbox-settings.js

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 import { writeFileAtomically } from '../../platform/atomic-write.js';
 import { loadNativeSharedResources } from '../../persistence/native-resources.js';
-import { claudeSandboxRuntime } from '../../sandbox/claude-sandbox-runtime.js';
+import { claudeSandboxRuntime, } from '../../sandbox/claude-sandbox-runtime.js';
 import { nativeSandboxTempDirectory, loadClaudeSandboxSettings, } from '../../sandbox/claude-sandbox-settings.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -75,7 +75,7 @@ export function linuxGlobPatternWarnings(resources, platform) {
     }
     return [...new Set(warnings)];
 }
-export function createTuiSandboxStore({ configRoot, cwd, homeDirectory, additionalDirectories = [], environment = process.env, }) {
+export function createTuiSandboxStore({ configRoot, cwd, homeDirectory, additionalDirectories = [], environment = process.env, runtime = claudeSandboxRuntime, }) {
     const localSettingsPath = join(cwd, '.praxis', 'settings.local.json');
     const load = async () => {
         const resources = (await loadNativeSharedResources({ root: configRoot, cwd })).settings;
@@ -87,13 +87,13 @@ export function createTuiSandboxStore({ configRoot, cwd, homeDirectory, addition
             additionalDirectories,
             tempDirectory: nativeSandboxTempDirectory(environment),
         });
-        await claudeSandboxRuntime.initialize(settings);
-        const unavailableReason = claudeSandboxRuntime.unavailableReason(settings);
-        const platform = claudeSandboxRuntime.platformName();
+        await runtime.initialize(settings);
+        const unavailableReason = runtime.unavailableReason(settings);
+        const platform = runtime.platformName();
         return {
             settings,
-            dependencies: claudeSandboxRuntime.dependencyCheck(settings),
-            supported: claudeSandboxRuntime.isSupportedPlatform(),
+            dependencies: runtime.dependencyCheck(settings),
+            supported: runtime.isSupportedPlatform(),
             platform,
             globPatternWarnings: linuxGlobPatternWarnings(resources, platform),
             ...(unavailableReason ? { unavailableReason } : {}),

package/dist/cli/tui/tui-focus-stack.d.ts

@@ -7,6 +7,7 @@ export interface TuiFocusProjectionInput {
     readonly pendingPrefix: boolean;
     readonly permission: boolean;
     readonly planApproval: boolean;
+    readonly cdTrust?: boolean;
     readonly question: boolean;
     readonly elicitation: 'plain' | 'url-waiting' | 'expanded-options' | false;
     readonly selectingSession: boolean;

package/dist/cli/tui/tui-focus-stack.js

@@ -19,6 +19,12 @@ export function projectTuiFocusStack(input) {
             layer: { kind: 'cancelable', target: 'plan-approval' },
         };
     }
+    else if (input.cdTrust) {
+        higher = {
+            id: 'cd-trust',
+            layer: { kind: 'cancelable', target: 'cd-trust' },
+        };
+    }
     else if (input.question) {
         higher = {
             id: 'question',

package/dist/cli/tui/tui-interaction-router.d.ts

@@ -1,7 +1,7 @@
 import { type ComposerKeyProjection } from './composer-key-router.js';
 import type { ComposerEditorState } from './composer-editor.js';
 export type TuiScrollIntent = 'page-older' | 'page-newer' | 'half-page-older' | 'half-page-newer' | 'line-older' | 'line-newer' | 'none';
-export type TuiCancellationTarget = 'permission' | 'plan-approval' | 'question' | 'elicitation' | 'elicitation-url-waiting' | 'elicitation-options' | 'file-picker' | 'command-palette';
+export type TuiCancellationTarget = 'permission' | 'plan-approval' | 'cd-trust' | 'question' | 'elicitation' | 'elicitation-url-waiting' | 'elicitation-options' | 'file-picker' | 'command-palette';
 export type TuiInteractionLayer = {
     readonly kind: 'none';
 } | {

package/dist/cli-runtime.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { type ForkResult, type ManualCompactResult, type ManualCompactSelection, type RewindPoint, type SessionForkCheckpoint, type SessionInspection, type SessionRunResult, type SessionSummary, type SideQuestionForkResult, type SideQuestionResult } from './application/session-service.js';
+import { type CwdInspection, type ForkResult, type ManualCompactResult, type ManualCompactSelection, type RewindPoint, type SessionForkCheckpoint, type SessionInspection, type SessionRunResult, type SessionSummary, type SideQuestionForkResult, type SideQuestionResult } from './application/session-service.js';
 import type { TeamLeadOperations } from './application/team-lead-operations.js';
 import type { ClaudeSessionCostSnapshot } from './application/session-cost-tracker.js';
 import { type AgentColorName, type AgentColorSelection } from './core/agent-color.js';
@@ -43,7 +43,8 @@ interface SessionCommands {
     setPermissionMode?(sessionId: string, mode: ClaudePermissionMode): Promise<void>;
     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-runtime.js

@@ -2049,7 +2049,8 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             setPermissionMode: (sessionId, permissionMode) => service.setPermissionMode(sessionId, permissionMode),
             rewindFiles: (sessionId, userMessageId) => service.rewindFiles(sessionId, userMessageId),
             rewindPoints: (sessionId) => service.rewindPoints(sessionId),
-            changeCwd: (sessionId, cwd) => service.changeCwd(sessionId, cwd),
+            changeCwd: (sessionId, cwd, expectedCanonicalTarget) => service.changeCwd(sessionId, cwd, expectedCanonicalTarget),
+            inspectCwd: (cwd) => service.inspectCwd(cwd),
             notify: (sessionId, message, notificationType, title) => service.notifyDetached(sessionId, message, notificationType, title),
             recordCdUsage: (sessionId) => service.recordCdUsage(sessionId),
             approveRecentlyDenied: (sessionId, display) => service.approveRecentlyDenied(sessionId, display),

package/dist/native/schema.d.ts

@@ -7,8 +7,4 @@
 export type NativeTranscriptEntry = Record<string, unknown> & {
     type: string;
 };
-export declare function isNativeForkableEntryType(type: string): boolean;
-/** Copy only projection metadata; persisted native events are copied by
- * NativeSessionTranscript.forkTo and retain their event identity semantics. */
-export declare function copyNativeEntryWithSessionId(entry: NativeTranscriptEntry, sessionId: string): NativeTranscriptEntry;
 //# sourceMappingURL=schema.d.ts.map

package/dist/native/schema.js

@@ -1,24 +1,2 @@
-const FORKABLE_ENTRY_TYPES = new Set([
-    'agent-color',
-    'agent-name',
-    'agent-setting',
-    'ai-title',
-    'assistant',
-    'attachment',
-    'custom-title',
-    'last-prompt',
-    'mode',
-    'permission-mode',
-    'pr-link',
-    'system',
-    'user',
-]);
-export function isNativeForkableEntryType(type) {
-    return FORKABLE_ENTRY_TYPES.has(type);
-}
-/** Copy only projection metadata; persisted native events are copied by
- * NativeSessionTranscript.forkTo and retain their event identity semantics. */
-export function copyNativeEntryWithSessionId(entry, sessionId) {
-    return { ...entry, sessionId };
-}
+export {};
 //# sourceMappingURL=schema.js.map

package/dist/tools/team-lead-tools.js

@@ -304,11 +304,12 @@ function validate(input, name) {
         for (const member of input.roster) {
             if (!member || typeof member !== 'object' || Array.isArray(member))
                 throw new Error('Invalid Team member');
-            objectInput(member, [
-                'name',
-                'agentType',
-                'access',
-            ]);
+            const value = member;
+            objectInput(value, ['name', 'agentType', 'access']);
+            stringValue(value, 'name');
+            stringValue(value, 'agentType');
+            if (value.access !== 'read-only' && value.access !== 'write')
+                throw new Error('Invalid Team member access');
         }
         for (const task of input.tasks) {
             if (!task || typeof task !== 'object' || Array.isArray(task))
@@ -321,6 +322,12 @@ function validate(input, name) {
                 'blockedBy',
                 'claims',
             ]);
+            stringValue(value, 'id');
+            stringValue(value, 'description');
+            stringValue(value, 'assignee');
+            if (!Array.isArray(value.blockedBy) ||
+                value.blockedBy.some((entry) => typeof entry !== 'string' || entry.trim() === ''))
+                throw new Error('Invalid Team blockedBy');
             if (!value.claims ||
                 typeof value.claims !== 'object' ||
                 Array.isArray(value.claims))
@@ -332,6 +339,18 @@ function validate(input, name) {
                 'migrations',
                 'mergeTargets',
             ]);
+            for (const key of [
+                'files',
+                'publicContracts',
+                'generatedArtifacts',
+                'migrations',
+                'mergeTargets',
+            ]) {
+                const entries = value.claims[key];
+                if (!Array.isArray(entries) ||
+                    entries.some((entry) => typeof entry !== 'string' || entry.trim() === ''))
+                    throw new Error(`Invalid Team claim list: ${key}`);
+            }
         }
         return input;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "praxis-agent",
-  "version": "0.46.1",
+  "version": "0.46.2",
   "description": "Local-first, single-user general agent for the command line.",
   "license": "MIT",
   "author": "wuqisen",
@@ -29,7 +29,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "check": "npm run format:check && npm run lint && npm run test:docs && npm run verify:release-automation && npm run verify:ci-coverage && npm run check:boundaries && npm run typecheck && npm run build:native && npm run build && npm test",
+    "check": "npm run format:check && npm run lint && npm run test:docs && npm run verify:release-automation && npm run verify:ci-coverage && npm run verify:fixture-contracts && npm run check:boundaries && npm run typecheck && npm run build:native && npm run build && npm test",
     "check:boundaries": "node scripts/check-boundaries.mjs",
     "dev": "tsx src/cli.ts",
     "format": "prettier --write .",
@@ -44,11 +44,11 @@
     "release:artifacts": "node scripts/build-release-artifacts.mjs",
     "release:verify": "node scripts/verify-release-ref.mjs",
     "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage && node scripts/verify-nonzero-runtime-coverage.mjs",
     "test:docs": "node scripts/verify-docs.mjs",
     "test:tui:pty": "npm run build && node scripts/verify-fullscreen-rendering.mjs && node scripts/verify-interactive-ansi.mjs",
     "test:self-update": "npm run build && node scripts/verify-self-update-contract.mjs",
-    "test:core-completion": "npm run build && node scripts/verify-core-completion-audit.mjs",
+    "test:core-completion": "npm run test:fixtures",
     "test:performance": "npm run build && node scripts/verify-projection-scaling.mjs && node scripts/verify-projection-regression.mjs && node scripts/verify-quiet-frame-performance.mjs",
     "test:performance:projection": "npm run build && node scripts/verify-projection-scaling.mjs",
     "test:performance:projection-regression": "npm run build && node scripts/verify-projection-regression.mjs",
@@ -56,9 +56,12 @@
     "test:prompt-suggestions": "npm run build && node scripts/verify-prompt-suggestions.mjs",
     "test:mcp-oauth-serve": "npm run build && node scripts/verify-mcp-oauth-serve.mjs",
     "test:package": "npm run build && node scripts/verify-native-release-package.mjs",
+    "test:security": "npm audit --omit=dev",
     "typecheck": "tsc --noEmit",
     "verify:release-automation": "node scripts/verify-release-automation.mjs",
-    "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs"
+    "verify:ci-coverage": "node scripts/verify-ci-coverage.mjs",
+    "verify:fixture-contracts": "node scripts/verify-fixture-contracts.mjs",
+    "test:fixtures": "node scripts/run-fixture-contracts.mjs"
   },
   "engines": {
     "node": ">=24"

package/dist/native/fork.d.ts

@@ -1,9 +0,0 @@
-import { type NativeTranscriptEntry } from './schema.js';
-export interface ClaudeNativeForkOptions {
-    source: readonly NativeTranscriptEntry[];
-    sourceSessionId: string;
-    sessionId: string;
-    resumeSessionAt?: string;
-}
-export declare function createClaudeNativeFork({ source, sourceSessionId, sessionId, resumeSessionAt, }: ClaudeNativeForkOptions): NativeTranscriptEntry[];
-//# sourceMappingURL=fork.d.ts.map

package/dist/native/fork.js

@@ -1,260 +0,0 @@
-import { getClaudeContentBlocks } from './tool-links.js';
-import { getClaudePreservedMessageUuids } from './compaction.js';
-import { selectClaudeActiveTranscript, selectClaudeTranscriptAtMessage, } from './history.js';
-import { copyNativeEntryWithSessionId, isNativeForkableEntryType, } from './schema.js';
-const TRANSIENT_ENTRY_TYPES = new Set([
-    'atis-latch',
-    'file-history-delta',
-    'file-history-snapshot',
-    'queue-operation',
-    'relocated',
-]);
-function advancesLogicalTail(entry) {
-    if (entry.type === 'system' && entry.subtype === 'compact_boundary') {
-        return false;
-    }
-    if (entry.type !== 'attachment')
-        return true;
-    const attachment = entry.attachment;
-    if (typeof attachment !== 'object' || attachment === null)
-        return true;
-    const attachmentType = attachment.type;
-    return (attachmentType !== 'hook_success' &&
-        attachmentType !== 'hook_error' &&
-        attachmentType !== 'hook_additional_context');
-}
-function validateNativeHistory(entries) {
-    const entriesByUuid = new Map();
-    const toolCalls = new Map();
-    for (const entry of entries) {
-        if (typeof entry.uuid !== 'string')
-            continue;
-        if (entriesByUuid.has(entry.uuid)) {
-            throw new Error(`Claude fork source has duplicate UUID ${entry.uuid}`);
-        }
-        entriesByUuid.set(entry.uuid, entry);
-        if (entry.type !== 'assistant')
-            continue;
-        for (const block of getClaudeContentBlocks(entry)) {
-            if (block.type !== 'tool_use')
-                continue;
-            const id = block.id;
-            if (typeof id !== 'string')
-                continue;
-            if (toolCalls.has(id)) {
-                throw new Error(`Claude fork source has duplicate tool_use ${id}`);
-            }
-            toolCalls.set(id, entry.uuid);
-        }
-    }
-    const childParentUuids = new Set();
-    const externalParentUuids = new Set();
-    let externalParentReferenceCount = 0;
-    const completedToolCalls = new Set();
-    let ordinaryRootCount = 0;
-    let compactBoundary;
-    let logicalTailUuid;
-    for (const entry of entries) {
-        const isCompactSummary = entry.isCompactSummary === true;
-        if (compactBoundary && !isCompactSummary) {
-            throw new Error('Claude compact boundary has no adjacent summary');
-        }
-        if (isCompactSummary) {
-            if (!compactBoundary || entry.parentUuid !== compactBoundary.uuid) {
-                throw new Error('Claude compact summary has no matching boundary');
-            }
-            compactBoundary = undefined;
-        }
-        else if (entry.type === 'system' &&
-            entry.subtype === 'compact_boundary') {
-            const metadata = entry.compactMetadata;
-            const preservedSegment = typeof metadata === 'object' && metadata !== null
-                ? metadata.preservedSegment
-                : undefined;
-            const preservedUuids = getClaudePreservedMessageUuids(entry);
-            const segment = typeof preservedSegment === 'object' && preservedSegment !== null
-                ? preservedSegment
-                : {};
-            const segmentMatchesLogicalTail = segment.headUuid === logicalTailUuid &&
-                segment.tailUuid === logicalTailUuid;
-            const segmentMatchesPreserved = segment.headUuid === preservedUuids[0] &&
-                segment.tailUuid === preservedUuids[preservedUuids.length - 1];
-            if (typeof preservedSegment !== 'object' ||
-                preservedSegment === null ||
-                entry.logicalParentUuid !== logicalTailUuid ||
-                (!segmentMatchesLogicalTail && !segmentMatchesPreserved)) {
-                throw new Error('Claude compact boundary has invalid logical parent');
-            }
-            compactBoundary = entry;
-        }
-        if (typeof entry.uuid === 'string') {
-            if (entry.parentUuid === null &&
-                !(entry.type === 'system' && entry.subtype === 'compact_boundary')) {
-                ordinaryRootCount += 1;
-            }
-            else if (typeof entry.parentUuid === 'string') {
-                if (entriesByUuid.has(entry.parentUuid)) {
-                    childParentUuids.add(entry.parentUuid);
-                }
-                else {
-                    externalParentUuids.add(entry.parentUuid);
-                    externalParentReferenceCount += 1;
-                }
-            }
-        }
-        if (typeof entry.uuid === 'string' && advancesLogicalTail(entry)) {
-            logicalTailUuid = entry.uuid;
-        }
-        for (const block of getClaudeContentBlocks(entry)) {
-            if (entry.type !== 'user' || block.type !== 'tool_result')
-                continue;
-            const id = block.tool_use_id;
-            if (typeof id !== 'string' ||
-                typeof entry.sourceToolAssistantUUID !== 'string' ||
-                toolCalls.get(id) !== entry.sourceToolAssistantUUID) {
-                throw new Error('Claude fork source has an unmatched tool_result');
-            }
-            if (completedToolCalls.has(id)) {
-                throw new Error(`Claude fork source has duplicate tool_result ${id}`);
-            }
-            completedToolCalls.add(id);
-        }
-    }
-    if (compactBoundary) {
-        throw new Error('Claude compact boundary has no adjacent summary');
-    }
-    const omittedSeedUserParent = externalParentUuids.size === 1 ? [...externalParentUuids][0] : undefined;
-    const firstEntry = entries[0];
-    const isOmittedSeedUserChain = externalParentUuids.size === 1 &&
-        ordinaryRootCount === 0 &&
-        externalParentReferenceCount === 1 &&
-        firstEntry?.type === 'assistant' &&
-        firstEntry?.parentUuid === omittedSeedUserParent;
-    if ((externalParentUuids.size > 0 && !isOmittedSeedUserChain) ||
-        ordinaryRootCount > 1) {
-        throw new Error('Claude fork source has a dangling parentUuid');
-    }
-    const states = new Map();
-    for (const startUuid of entriesByUuid.keys()) {
-        if (states.get(startUuid) === 'visited')
-            continue;
-        const path = [];
-        let uuid = startUuid;
-        while (uuid !== undefined && entriesByUuid.has(uuid)) {
-            const state = states.get(uuid);
-            if (state === 'visiting') {
-                throw new Error('Claude fork source parentUuid graph has a cycle');
-            }
-            if (state === 'visited')
-                break;
-            states.set(uuid, 'visiting');
-            path.push(uuid);
-            const parentUuid = entriesByUuid.get(uuid)?.parentUuid;
-            uuid = typeof parentUuid === 'string' ? parentUuid : undefined;
-        }
-        for (const pathUuid of path)
-            states.set(pathUuid, 'visited');
-    }
-    for (let index = entries.length - 1; index >= 0; index -= 1) {
-        const uuid = entries[index]?.uuid;
-        if (typeof uuid === 'string' && !childParentUuids.has(uuid))
-            return uuid;
-    }
-    return undefined;
-}
-export function createClaudeNativeFork({ source, sourceSessionId, sessionId, resumeSessionAt, }) {
-    const agentColors = [];
-    const titles = [];
-    const modes = [];
-    const permissionModes = [];
-    const prLinks = [];
-    const history = [];
-    const nativeHistory = [];
-    let lastPrompt;
-    let nativeLastPrompt;
-    const hasSelectiveSummary = source.some((entry) => {
-        if (entry.isCompactSummary !== true)
-            return false;
-        const metadata = entry.summarizeMetadata;
-        return (typeof metadata === 'object' &&
-            metadata !== null &&
-            (metadata.direction === 'from' ||
-                metadata.direction === 'up_to'));
-    });
-    const hasCompactHistory = source.some((entry) => entry.isCompactSummary === true ||
-        (entry.type === 'system' && entry.subtype === 'compact_boundary'));
-    const activeSource = resumeSessionAt === undefined
-        ? hasCompactHistory || hasSelectiveSummary
-            ? selectClaudeActiveTranscript(source)
-            : source
-        : selectClaudeTranscriptAtMessage(source, resumeSessionAt);
-    for (const entry of activeSource) {
-        if (TRANSIENT_ENTRY_TYPES.has(entry.type)) {
-            if ((entry.type === 'queue-operation' &&
-                entry.sessionId !== sourceSessionId) ||
-                (entry.type !== 'queue-operation' &&
-                    entry.sessionId !== undefined &&
-                    entry.sessionId !== sourceSessionId)) {
-                throw new Error('Claude fork source entry has the wrong sessionId');
-            }
-            continue;
-        }
-        if (entry.isSidechain === true) {
-            if (!isNativeForkableEntryType(entry.type)) {
-                throw new Error(`Claude transcript entry type ${entry.type} is not forkable by Praxis`);
-            }
-            if (typeof entry.sessionId !== 'string' || entry.sessionId.length === 0) {
-                throw new Error('Claude fork entry has no sessionId');
-            }
-            continue;
-        }
-        if (!isNativeForkableEntryType(entry.type)) {
-            throw new Error(`Claude transcript entry type ${entry.type} is not forkable by Praxis`);
-        }
-        if (typeof entry.sessionId !== 'string' || entry.sessionId.length === 0) {
-            throw new Error('Claude fork entry has no sessionId');
-        }
-        if (entry.sessionId !== sourceSessionId) {
-            throw new Error('Claude fork source entry has the wrong sessionId');
-        }
-        const copied = copyNativeEntryWithSessionId(entry, sessionId);
-        if (entry.type === 'agent-color')
-            agentColors.push(copied);
-        else if (entry.type === 'ai-title')
-            titles.push(copied);
-        else if (entry.type === 'mode')
-            modes.push(copied);
-        else if (entry.type === 'permission-mode')
-            permissionModes.push(copied);
-        else if (entry.type === 'pr-link')
-            prLinks.push(copied);
-        else if (entry.type === 'last-prompt') {
-            lastPrompt = copied;
-            nativeLastPrompt = entry;
-        }
-        else {
-            history.push(copied);
-            nativeHistory.push(entry);
-        }
-    }
-    if (!nativeHistory.some((entry) => typeof entry.uuid === 'string')) {
-        throw new Error('Claude session has no native history to fork');
-    }
-    const logicalTailUuid = validateNativeHistory(nativeHistory);
-    if (nativeLastPrompt &&
-        (typeof nativeLastPrompt.leafUuid !== 'string' ||
-            nativeLastPrompt.leafUuid !== logicalTailUuid)) {
-        nativeLastPrompt = undefined;
-        lastPrompt = undefined;
-    }
-    return [
-        ...agentColors.slice(-1),
-        ...titles.slice(-1),
-        ...modes.slice(-1),
-        ...permissionModes.slice(-1),
-        ...prLinks.slice(-1),
-        ...history,
-        ...(lastPrompt ? [lastPrompt] : []),
-    ];
-}
-//# sourceMappingURL=fork.js.map