praxis-agent 0.46.1 → 0.46.4

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/platform/bounded-process-runner.d.ts

@@ -5,6 +5,7 @@ export interface ProcessResult {
     code: number;
     timedOut: boolean;
     truncated: boolean;
+    controlOutput?: string;
 }
 export interface BoundedProcessRunnerOptions {
     cwd: string;
@@ -18,6 +19,9 @@ export interface RunProcessOptions {
     signal?: AbortSignal;
     onOutput?: (output: string) => void | Promise<void>;
     env?: Readonly<Record<string, string>>;
+    controlOutputBytes?: number;
+    controlOutputFd?: number;
+    scriptInput?: string;
 }
 export declare function joinedProcessOutput(result: ProcessResult): string;
 export declare class BoundedProcessRunner {

package/dist/platform/bounded-process-runner.js

@@ -87,15 +87,35 @@ export class BoundedProcessRunner {
             const sensitiveValues = sensitiveEnvironmentValues(process.env);
             const longestSensitiveValueBytes = sensitiveValues.reduce((longest, value) => Math.max(longest, Buffer.byteLength(value)), 0);
             const rawOutputLimit = this.options.maxOutputBytes + Math.max(3, longestSensitiveValueBytes);
+            const controlOutputFd = options.controlOutputBytes === undefined
+                ? undefined
+                : (options.controlOutputFd ?? 3);
+            const scriptInputFd = options.scriptInput === undefined ? undefined : 4;
+            if (controlOutputFd !== undefined &&
+                scriptInputFd !== undefined &&
+                controlOutputFd === scriptInputFd) {
+                reject(new Error('Process control output and script input FDs conflict'));
+                return;
+            }
+            const highestFd = Math.max(2, controlOutputFd ?? 2, scriptInputFd ?? 2);
+            const stdio = Array.from({ length: highestFd + 1 }, () => 'ignore');
+            stdio[1] = 'pipe';
+            stdio[2] = 'pipe';
+            if (controlOutputFd !== undefined)
+                stdio[controlOutputFd] = 'pipe';
+            if (scriptInputFd !== undefined)
+                stdio[scriptInputFd] = 'pipe';
             const child = spawn(options.command, options.args, {
                 cwd: options.cwd ?? this.options.cwd,
                 detached: process.platform !== 'win32',
                 env: { ...sanitizeChildEnvironment(), ...options.env },
-                stdio: ['ignore', 'pipe', 'pipe'],
+                stdio,
             });
             const chunks = { stdout: [], stderr: [] };
             const combined = [];
             const retainedBytes = { stdout: 0, stderr: 0, combined: 0 };
+            const controlChunks = [];
+            let controlBytes = 0;
             let outputBytes = 0;
             let timedOut = false;
             let settled = false;
@@ -136,8 +156,41 @@ export class BoundedProcessRunner {
                 }
                 updateLiveOutput();
             };
+            if (!child.stdout || !child.stderr) {
+                reject(new Error('Process output streams were not created'));
+                return;
+            }
             child.stdout.on('data', (chunk) => retain('stdout', chunk));
             child.stderr.on('data', (chunk) => retain('stderr', chunk));
+            const controlStream = controlOutputFd === undefined ? undefined : child.stdio[controlOutputFd];
+            if (controlStream) {
+                controlStream.on('data', (chunk) => {
+                    const remaining = Math.max(0, (options.controlOutputBytes ?? 0) - controlBytes);
+                    if (remaining <= 0)
+                        return;
+                    const retained = chunk.subarray(0, remaining);
+                    controlChunks.push(retained);
+                    controlBytes += retained.length;
+                });
+                child.once('exit', () => {
+                    setImmediate(() => controlStream.destroy());
+                });
+            }
+            const scriptStream = scriptInputFd === undefined ? undefined : child.stdio[scriptInputFd];
+            if (scriptStream) {
+                scriptStream.on('error', () => {
+                    // The child process result remains authoritative if it exits before
+                    // consuming the complete script.
+                });
+                if (!('end' in scriptStream)) {
+                    reject(new Error('Process script input stream is not writable'));
+                    return;
+                }
+                scriptStream.end(options.scriptInput);
+                child.once('exit', () => {
+                    setImmediate(() => scriptStream.destroy());
+                });
+            }
             const kill = () => {
                 if (child.pid === undefined)
                     return;
@@ -200,6 +253,11 @@ export class BoundedProcessRunner {
                         code: code ?? 1,
                         timedOut,
                         truncated,
+                        ...(options.controlOutputBytes === undefined
+                            ? {}
+                            : {
+                                controlOutput: Buffer.concat(controlChunks).toString('utf8'),
+                            }),
                     });
                 }, reject);
             });

package/dist/sandbox/claude-sandbox-runtime.d.ts

@@ -21,6 +21,7 @@ export interface SandboxBackend {
 export interface SandboxCommandInput {
     command: string;
     dangerouslyDisableSandbox?: boolean;
+    executionCommand?: string;
 }
 export declare class ClaudeSandboxRuntime {
     private readonly backend;

package/dist/sandbox/claude-sandbox-runtime.js

@@ -136,7 +136,7 @@ export class ClaudeSandboxRuntime {
             throw new Error('Sandbox has not been initialized');
         if (!this.shouldUseSandbox(input))
             return input.command;
-        return this.backend.wrapWithSandbox(input.command, options.shell, undefined, options.signal, {
+        return this.backend.wrapWithSandbox(input.executionCommand ?? input.command, options.shell, undefined, options.signal, {
             ...(options.commandId ? { commandId: options.commandId } : {}),
             commandText: input.command,
         });

package/dist/tools/local-tools.d.ts

@@ -26,6 +26,7 @@ export interface BashSandboxRuntime {
     wrapCommand(input: {
         command: string;
         dangerouslyDisableSandbox?: boolean;
+        executionCommand?: string;
     }, options?: {
         shell?: string;
         signal?: AbortSignal;
@@ -43,6 +44,7 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readonly maxOutputBytes;
     private readonly maxFileBytes;
     private readonly maxShellTimeoutMs;
+    private readonly maxSearchTimeoutMs;
     private readonly processRunner;
     private readonly enableReportFindings;
     private readonly environment;
@@ -50,11 +52,14 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private readonly sandbox;
     private readonly homeDirectory;
     private readonly configRoot;
+    private readonly sessionCwds;
     private readonly protectedWriteReason;
+    private readonly mutationTargetExisted;
     constructor(options: LocalToolRegistryOptions);
     private assertProtectedWritePath;
     private assertProtectedBashCommand;
     private currentCwd;
+    private currentBashCwd;
     definitions(): readonly ModelToolDefinition[];
     schedulingPolicy(call: ModelToolCall): {
         concurrency: "concurrent";
@@ -78,7 +83,9 @@ export declare class LocalToolRegistry implements ToolRegistry {
     private workspacePath;
     private filePath;
     private resolvePath;
+    private pathExists;
     private assertStablePath;
+    private assertStableCreationParent;
     private globRoot;
     private wasSuccessfullyRead;
     private read;