praxis-agent 0.31.0 → 0.32.0

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

@@ -110,7 +110,20 @@ const TUI_HOOK_EVENT_DEFINITIONS = [
         detail: [],
     },
 ];
-export const TUI_HOOK_EVENTS = TUI_HOOK_EVENT_DEFINITIONS.filter((definition) => HOOK_EVENTS.includes(definition.name));
+const OBSERVED_TUI_EVENTS_2_1_208 = new Set([
+    'PreToolUse',
+    'PostToolUse',
+    'PostToolUseFailure',
+    'UserPromptSubmit',
+    'SessionStart',
+    'Stop',
+    'SubagentStart',
+    'SubagentStop',
+    'SessionEnd',
+    'PermissionRequest',
+]);
+export const TUI_HOOK_EVENTS = TUI_HOOK_EVENT_DEFINITIONS.filter((definition) => OBSERVED_TUI_EVENTS_2_1_208.has(definition.name) &&
+    HOOK_EVENTS.includes(definition.name));
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }

package/dist/cli-runtime.d.ts

@@ -39,6 +39,7 @@ interface SessionCommands {
     rewindFiles?(sessionId: string, userMessageId: string): Promise<void>;
     rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
     changeCwd?(sessionId: string | undefined, cwd: string): Promise<string>;
+    notify?(sessionId: string | undefined, message: string, notificationType: string, title?: string): void;
     recordCdUsage?(sessionId: string): Promise<void>;
     approveRecentlyDenied?(sessionId: string, display: string): Promise<void>;
     retryRecentlyDenied?(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;

package/dist/cli-runtime.js

@@ -33,6 +33,7 @@ import { createClaudeModelAutoClassifier, defaultClaudeAutoModeConfig, loadClaud
 import { ClaudeExtensionPermissionResolver, ClaudeExtensionToolRegistry, } from './extensions/claude-extension-tools.js';
 import { ClaudeExtensionCatalog } from './extensions/claude-extensions.js';
 import { ClaudeHookRunner } from './hooks/claude-hooks.js';
+import { ClaudeSessionEnvironment } from './hooks/claude-session-environment.js';
 import { ClaudeMcpToolRegistry, } from './mcp/claude-mcp-tools.js';
 import { ClaudeMcpManagement, filterDisabledMcpResources, mcpScope, } from './mcp/claude-mcp-management.js';
 import { authenticateMcpServer, ClaudeMcpOAuthStore, mcpOAuthServerIdentity, readMcpClientSecret, } from './mcp/claude-mcp-oauth.js';
@@ -1226,6 +1227,15 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : {}),
     }), extensions);
     const permissions = permissionResolverForMode(cli.dangerouslySkipPermissions ? 'bypassPermissions' : cli.permissionMode);
+    const hookSessionEnvironment = new ClaudeSessionEnvironment({
+        stateRoot: resolveDataPlanePaths({
+            dataPlane,
+            root: configRoot,
+            cwd,
+            sessionId: '00000000-0000-4000-8000-000000000000',
+        }).stateRoot,
+        warn: (message) => runtimeEventSink({ type: 'warning', message }),
+    });
     const localTools = new LocalToolRegistry({
         cwd,
         cwdProvider: () => workspace.cwd(),
@@ -1237,6 +1247,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         homeDirectory: sandboxEnvironment.HOME ?? sandboxEnvironment.USERPROFILE ?? homedir(),
         configRoot,
         dataPlane,
+        sessionEnvironment: (sessionId) => hookSessionEnvironment.environment(sessionId),
         ...(environment ? { environment } : {}),
     });
     const runtimeMcpResources = async (candidates) => {
@@ -1437,6 +1448,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 settings,
                 cwd,
                 onEvent: (event) => runtimeEventSink({ type: 'hook', event }),
+                sessionEnvironment: hookSessionEnvironment,
             });
         const interactiveTools = selectedInteractiveTools.length > 0 && askUser && approvePlan
             ? new ClaudeInteractiveToolManager({
@@ -1454,6 +1466,11 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : undefined;
         contextAssembler = new ClaudeContextAssembler({
             loadResources: loadContextResources,
+            onInstructionsLoaded: async (instructions, context) => {
+                if (!context.lifecycleId)
+                    return;
+                await service.instructionsLoaded(context.lifecycleId, instructions, context.reason);
+            },
             loadDynamicContext: (runtimeCwd = workspace.cwd()) => loadClaudeDynamicContext({
                 cwd: runtimeCwd,
                 ...(memoryDirectory ? { memoryDirectory } : {}),
@@ -1624,6 +1641,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             rewindFiles: (sessionId, userMessageId) => service.rewindFiles(sessionId, userMessageId),
             rewindPoints: (sessionId) => service.rewindPoints(sessionId),
             changeCwd: (sessionId, cwd) => service.changeCwd(sessionId, cwd),
+            notify: (sessionId, message, notificationType, title) => service.notifyDetached(sessionId, message, notificationType, title),
             recordCdUsage: (sessionId) => service.recordCdUsage(sessionId),
             approveRecentlyDenied: (sessionId, display) => service.approveRecentlyDenied(sessionId, display),
             retryRecentlyDenied: (sessionId, display, retrySignal) => service.retryRecentlyDenied(sessionId, display, retrySignal),

package/dist/compatibility/claude/context.d.ts

@@ -1,8 +1,13 @@
 import type { AssembledContext, ContextAssembler, ContextAssemblyOptions, ContextInvalidationOptions } from '../../core/context.js';
 import { type ClaudeDynamicContextSections } from './dynamic-context.js';
-import type { ClaudeContextResources, ClaudeConditionalRule } from './shared-resources.js';
+import type { ClaudeContextResources, ClaudeConditionalRule, ClaudeTextResource } from './shared-resources.js';
 export interface ClaudeContextAssemblerOptions {
     loadResources(cwd?: string): Promise<ClaudeContextResources>;
+    onInstructionsLoaded?(resources: readonly ClaudeTextResource[], context: {
+        lifecycleId?: string;
+        cwd?: string;
+        reason: 'session_start' | 'compact' | 'resource_reload';
+    }): Promise<void>;
     loadDynamicContext?(cwd?: string): Promise<ClaudeDynamicContextSections>;
     loadMcpInstructions?(): Promise<readonly ClaudeMcpInstruction[]>;
     loadSessionGuidance?(): Promise<string | undefined>;

package/dist/compatibility/claude/context.js

@@ -171,6 +171,8 @@ ${sections.join('\n\n')}`,
             if (options.reason === 'resource-reload' ||
                 options.reason === 'compact') {
                 delete snapshot.resources;
+                snapshot.resourceLoadReason =
+                    options.reason === 'compact' ? 'compact' : 'resource_reload';
                 continue;
             }
             if (options.reason === 'tool-pool') {
@@ -199,7 +201,18 @@ ${sections.join('\n\n')}`,
         if (!snapshot)
             return this.options.loadResources(cwd);
         if (!snapshot.resources) {
-            const pending = this.options.loadResources(cwd);
+            const reason = snapshot.resourceLoadReason ?? 'session_start';
+            delete snapshot.resourceLoadReason;
+            const pending = this.options
+                .loadResources(cwd)
+                .then(async (resources) => {
+                await this.options.onInstructionsLoaded?.(resources.instructions, {
+                    lifecycleId: snapshot.lifecycleId,
+                    ...(cwd === undefined ? {} : { cwd }),
+                    reason,
+                });
+                return resources;
+            });
             snapshot.resources = pending;
             void pending.catch(() => {
                 if (snapshot.resources === pending)

package/dist/core/runtime.d.ts

@@ -319,6 +319,7 @@ export interface ToolExecutionResult {
 }
 export interface ToolExecutionContext {
     cwd: string;
+    sessionId?: string;
     messages?: readonly ModelMessage[];
     signal?: AbortSignal;
     toolResultDirectory?: string;
@@ -407,6 +408,7 @@ export type PermissionDecision = {
 } | {
     behavior: 'deny';
     reason: string;
+    followUpUserMessages?: readonly string[];
     source?: PermissionDecisionSource;
 };
 export interface PermissionResolver {
@@ -455,6 +457,7 @@ export interface AgentRuntimeOptions {
 }
 export interface AgentRunRequest {
     messages: readonly ModelMessage[];
+    sessionId?: string;
     /** Number of leading system messages that form the stable prompt prefix. */
     stableSystemMessageCount?: number;
     cwd?: string;
@@ -481,7 +484,7 @@ export interface AgentRunRequest {
     maxModelTurns?: number;
     betas?: readonly string[];
 }
-export interface AgentToolRecoveryRequest extends Pick<AgentRunRequest, 'approveTool' | 'cwd' | 'observer' | 'onPermissionUpdates' | 'permissionUpdates' | 'signal' | 'toolResultDirectory'> {
+export interface AgentToolRecoveryRequest extends Pick<AgentRunRequest, 'approveTool' | 'cwd' | 'observer' | 'onPermissionUpdates' | 'permissionUpdates' | 'signal' | 'sessionId' | 'toolResultDirectory'> {
     approveRecovery?: (call: ModelToolCall) => boolean | Promise<boolean>;
     messages?: readonly ModelMessage[];
 }

package/dist/core/runtime.js

@@ -845,6 +845,8 @@ export class AgentRuntime {
             permissionPhase: 'request',
             permissionUpdates: request.permissionUpdates ?? [],
         };
+        if (request.sessionId)
+            context.sessionId = request.sessionId;
         if (request.signal)
             context.signal = request.signal;
         if (request.toolResultDirectory) {
@@ -926,7 +928,13 @@ export class AgentRuntime {
                     : decision.behavior === 'ask'
                         ? (decision.reason ?? 'Permission approval was not provided')
                         : 'Permission approval was not provided');
-            return { content: reason, isError: true };
+            return {
+                content: reason,
+                isError: true,
+                ...(decision.behavior === 'deny' && decision.followUpUserMessages
+                    ? { followUpUserMessages: decision.followUpUserMessages }
+                    : {}),
+            };
         }
         if (request.signal?.aborted) {
             throw request.signal.reason ?? new AgentRunCancelledError();

package/dist/hooks/claude-file-change-watcher.d.ts

@@ -0,0 +1,43 @@
+export type ClaudeFileChangeEvent = 'add' | 'change' | 'unlink';
+interface DirectoryWatcher {
+    close(): void;
+    on(event: 'error', listener: (error: Error) => void): DirectoryWatcher;
+    unref?(): void;
+}
+type WatchDirectory = (directory: string, listener: (filename: string | null) => void) => DirectoryWatcher;
+export interface ClaudeFileChangeWatcherOptions {
+    cwd: string;
+    staticPaths: readonly string[];
+    onFileChanged(filePath: string, event: ClaudeFileChangeEvent, signal: AbortSignal): Promise<readonly string[] | undefined>;
+    warn(message: string): void;
+    debounceMs?: number;
+    pathExists?(path: string): boolean;
+    watchDirectory?: WatchDirectory;
+}
+export declare class ClaudeFileChangeWatcher {
+    private readonly options;
+    private cwd;
+    private staticPaths;
+    private dynamicPaths;
+    private readonly watchers;
+    private readonly knownExistence;
+    private readonly pending;
+    private readonly inFlight;
+    private readonly debounceMs;
+    private readonly pathExists;
+    private readonly watchDirectory;
+    private generation;
+    private closed;
+    constructor(options: ClaudeFileChangeWatcherOptions);
+    updateForCwd(cwd: string, staticPaths: readonly string[], dynamicPaths: readonly string[]): void;
+    updateDynamicPaths(paths: readonly string[]): void;
+    close(timeoutMs?: number): Promise<void>;
+    private validDynamicPaths;
+    private targetPaths;
+    private rebuild;
+    private schedule;
+    private dispatch;
+    private clearResources;
+}
+export {};
+//# sourceMappingURL=claude-file-change-watcher.d.ts.map

package/dist/hooks/claude-file-change-watcher.js

@@ -0,0 +1,185 @@
+import { existsSync, watch } from 'node:fs';
+import { basename, dirname, isAbsolute, resolve } from 'node:path';
+function defaultWatchDirectory(directory, listener) {
+    return watch(directory, (_event, filename) => {
+        listener(filename);
+    });
+}
+export class ClaudeFileChangeWatcher {
+    options;
+    cwd;
+    staticPaths;
+    dynamicPaths = [];
+    watchers = new Map();
+    knownExistence = new Map();
+    pending = new Map();
+    inFlight = new Map();
+    debounceMs;
+    pathExists;
+    watchDirectory;
+    generation = 0;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.cwd = options.cwd;
+        this.staticPaths = options.staticPaths;
+        this.debounceMs = options.debounceMs ?? 500;
+        this.pathExists = options.pathExists ?? existsSync;
+        this.watchDirectory = options.watchDirectory ?? defaultWatchDirectory;
+        this.rebuild();
+    }
+    updateForCwd(cwd, staticPaths, dynamicPaths) {
+        if (this.closed)
+            return;
+        this.cwd = cwd;
+        this.staticPaths = staticPaths;
+        this.dynamicPaths = this.validDynamicPaths(dynamicPaths);
+        this.rebuild();
+    }
+    updateDynamicPaths(paths) {
+        if (this.closed)
+            return;
+        const next = this.validDynamicPaths(paths);
+        if (next.length === this.dynamicPaths.length &&
+            next.every((path, index) => path === this.dynamicPaths[index])) {
+            return;
+        }
+        this.dynamicPaths = next;
+        this.rebuild();
+    }
+    async close(timeoutMs = 5_000) {
+        if (this.closed)
+            return;
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+            throw new Error('FileChanged watcher close timeout must be non-negative');
+        }
+        this.closed = true;
+        this.generation += 1;
+        this.clearResources();
+        const pending = [...this.inFlight.keys()];
+        if (pending.length === 0)
+            return;
+        let timer;
+        try {
+            if ((await Promise.race([
+                Promise.allSettled(pending).then(() => 'settled'),
+                new Promise((resolveTimeout) => {
+                    timer = setTimeout(() => resolveTimeout('timeout'), timeoutMs);
+                }),
+            ])) === 'timeout') {
+                for (const controller of this.inFlight.values())
+                    controller.abort();
+                this.inFlight.clear();
+                await Promise.resolve();
+            }
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    validDynamicPaths(paths) {
+        const valid = [];
+        for (const path of paths) {
+            if (!isAbsolute(path)) {
+                this.options.warn(`FileChanged hook ignored non-absolute watch path: ${path}`);
+                continue;
+            }
+            valid.push(resolve(path));
+        }
+        return [...new Set(valid)];
+    }
+    targetPaths() {
+        return [
+            ...new Set([
+                ...this.staticPaths.map((path) => isAbsolute(path) ? resolve(path) : resolve(this.cwd, path)),
+                ...this.dynamicPaths,
+            ]),
+        ];
+    }
+    rebuild() {
+        this.generation += 1;
+        this.clearResources();
+        const targets = this.targetPaths();
+        const byDirectory = new Map();
+        for (const target of targets) {
+            this.knownExistence.set(target, this.pathExists(target));
+            const directory = dirname(target);
+            const names = byDirectory.get(directory) ?? new Set();
+            names.add(basename(target));
+            byDirectory.set(directory, names);
+        }
+        for (const [directory, names] of byDirectory) {
+            try {
+                const watcher = this.watchDirectory(directory, (filename) => {
+                    if (filename === null) {
+                        for (const name of names)
+                            this.schedule(resolve(directory, name));
+                        return;
+                    }
+                    if (names.has(filename))
+                        this.schedule(resolve(directory, filename));
+                });
+                watcher.on('error', (error) => {
+                    this.options.warn(`FileChanged watcher failed for ${directory}: ${error.message}`);
+                });
+                watcher.unref?.();
+                this.watchers.set(directory, watcher);
+            }
+            catch (error) {
+                this.options.warn(`FileChanged watcher could not watch ${directory}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+    schedule(path) {
+        const previous = this.pending.get(path);
+        if (previous)
+            clearTimeout(previous);
+        const generation = this.generation;
+        const timer = setTimeout(() => {
+            this.pending.delete(path);
+            if (this.closed || generation !== this.generation)
+                return;
+            const controller = new AbortController();
+            const dispatch = this.dispatch(path, generation, controller.signal);
+            this.inFlight.set(dispatch, controller);
+            void dispatch.finally(() => this.inFlight.delete(dispatch));
+        }, this.debounceMs);
+        timer.unref?.();
+        this.pending.set(path, timer);
+    }
+    async dispatch(path, generation, signal) {
+        const existed = this.knownExistence.get(path) ?? false;
+        const exists = this.pathExists(path);
+        this.knownExistence.set(path, exists);
+        if (!existed && !exists)
+            return;
+        const event = !existed
+            ? 'add'
+            : !exists
+                ? 'unlink'
+                : 'change';
+        try {
+            const watchPaths = await this.options.onFileChanged(path, event, signal);
+            if (!this.closed &&
+                generation === this.generation &&
+                watchPaths &&
+                watchPaths.length > 0) {
+                this.updateDynamicPaths(watchPaths);
+            }
+        }
+        catch (error) {
+            this.options.warn(`FileChanged hook failed for ${path}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    clearResources() {
+        for (const timer of this.pending.values())
+            clearTimeout(timer);
+        this.pending.clear();
+        for (const watcher of this.watchers.values())
+            watcher.close();
+        this.watchers.clear();
+        this.knownExistence.clear();
+    }
+}
+//# sourceMappingURL=claude-file-change-watcher.js.map

package/dist/hooks/claude-hook-tools.d.ts

@@ -12,6 +12,7 @@ export interface ClaudeHookToolCoordinatorOptions {
     hooks: ClaudeHookRunner;
     session: ClaudeHookSessionInput;
     recordOutcome(outcome: ClaudeHookOutcome, deferUntilApproval?: boolean): Promise<void>;
+    warn?(message: string): void;
     deferPreToolUseOutcome?(call: ModelToolCall): boolean;
 }
 export declare class ClaudeHookToolCoordinator implements ToolRegistry, PermissionResolver {
@@ -25,6 +26,7 @@ export declare class ClaudeHookToolCoordinator implements ToolRegistry, Permissi
     };
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     resolve(call: ModelToolCall, context?: PermissionResolutionContext): Promise<PermissionDecision>;
+    private withPermissionDeniedHook;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }
 //# sourceMappingURL=claude-hook-tools.d.ts.map

package/dist/hooks/claude-hook-tools.js

@@ -1,3 +1,4 @@
+import { permissionDecisionSource } from '../core/runtime.js';
 export class ClaudeHookToolCoordinator {
     options;
     prepared = new Map();
@@ -57,11 +58,13 @@ export class ClaudeHookToolCoordinator {
     }
     async resolve(call, context) {
         const prepared = this.prepared.get(call.id);
-        if (prepared?.permissionDecision)
-            return prepared.permissionDecision;
+        if (prepared?.permissionDecision) {
+            return this.withPermissionDeniedHook(call, prepared.permissionDecision, prepared.signal);
+        }
         const decision = await this.options.permissions.resolve(call, context);
-        if (decision.behavior !== 'ask')
-            return decision;
+        if (decision.behavior !== 'ask') {
+            return this.withPermissionDeniedHook(call, decision, prepared?.signal);
+        }
         const outcome = await this.options.hooks.run({
             ...this.options.session,
             hook_event_name: 'PermissionRequest',
@@ -72,17 +75,53 @@ export class ClaudeHookToolCoordinator {
         }, call.name, prepared?.signal);
         await this.options.recordOutcome(outcome);
         if (outcome.blockedReason || outcome.permissionDecision === 'deny') {
-            return {
+            return this.withPermissionDeniedHook(call, {
                 behavior: 'deny',
                 reason: outcome.blockedReason ??
                     outcome.permissionDecisionReason ??
                     `PermissionRequest:${call.name} hook denied tool`,
-            };
+            }, prepared?.signal);
         }
         if (outcome.permissionDecision === 'allow')
             return { behavior: 'allow' };
         return decision;
     }
+    async withPermissionDeniedHook(call, decision, signal) {
+        const decisionSource = permissionDecisionSource(decision);
+        if (decision.behavior !== 'deny' || decisionSource !== 'auto-classifier') {
+            return decision;
+        }
+        const prepared = this.prepared.get(call.id);
+        try {
+            const outcome = await this.options.hooks.run({
+                ...this.options.session,
+                hook_event_name: 'PermissionDenied',
+                tool_name: call.name,
+                tool_input: prepared?.hookInput ?? call.input,
+                tool_use_id: call.id,
+                reason: decision.reason,
+            }, call.name, signal);
+            await this.options.recordOutcome(outcome);
+            if (outcome.retry) {
+                return {
+                    ...decision,
+                    followUpUserMessages: [
+                        ...(decision.followUpUserMessages ?? []),
+                        'The PermissionDenied hook indicated this command is now approved. You may retry it if you would like.',
+                    ],
+                    source: decisionSource,
+                };
+            }
+        }
+        catch (error) {
+            if (signal?.aborted ||
+                (error instanceof Error && error.name === 'AbortError')) {
+                throw error;
+            }
+            this.options.warn?.(`PermissionDenied:${call.name} hook failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return decision;
+    }
     async execute(call, context) {
         const prepared = this.prepared.get(call.id);
         try {

package/dist/hooks/claude-hooks.d.ts

@@ -1,6 +1,7 @@
 import type { ClaudeJsonResource } from '../compatibility/claude/shared-resources.js';
 import type { PermissionBehavior } from '../core/runtime.js';
-export type ClaudeHookEventName = 'Setup' | 'SessionStart' | 'SubagentStart' | 'UserPromptSubmit' | 'PreToolUse' | 'PermissionRequest' | 'PostToolUse' | 'PostToolUseFailure' | 'Stop' | 'SubagentStop' | 'SessionEnd';
+import type { ClaudeSessionEnvironment } from './claude-session-environment.js';
+export type ClaudeHookEventName = 'Setup' | 'SessionStart' | 'SubagentStart' | 'UserPromptSubmit' | 'PreToolUse' | 'PermissionRequest' | 'PermissionDenied' | 'PostToolUse' | 'PostToolUseFailure' | 'Notification' | 'Stop' | 'StopFailure' | 'SubagentStop' | 'PreCompact' | 'PostCompact' | 'TaskCreated' | 'TaskCompleted' | 'ConfigChange' | 'InstructionsLoaded' | 'WorktreeCreate' | 'WorktreeRemove' | 'CwdChanged' | 'FileChanged' | 'SessionEnd';
 export interface ClaudeHookInput extends Record<string, unknown> {
     session_id: string;
     transcript_path: string;
@@ -53,6 +54,9 @@ export interface ClaudeHookOutcome {
     updatedInput?: Record<string, unknown>;
     permissionDecision?: PermissionBehavior;
     permissionDecisionReason?: string;
+    retry?: boolean;
+    watchPaths?: readonly string[];
+    systemMessages?: readonly string[];
     blockedReason?: string;
 }
 interface ProcessResult {
@@ -71,6 +75,7 @@ export interface ClaudeHookRunnerOptions {
     maxTimeoutMs?: number;
     executeCommand?: ClaudeHookCommandExecutor;
     onEvent?: (event: ClaudeHookStreamEvent) => void;
+    sessionEnvironment?: ClaudeSessionEnvironment;
 }
 export declare const HOOK_EVENTS: readonly ClaudeHookEventName[];
 export declare function validateClaudeHooks(settings: readonly ClaudeJsonResource[], maxTimeoutMs?: number): void;
@@ -81,9 +86,16 @@ export declare class ClaudeHookRunner {
     private readonly executeCommand;
     private readonly onEvent;
     private readonly cwd;
-    constructor(options: ClaudeHookRunnerOptions);
+    private readonly sessionEnvironment;
+    private readonly asynchronousHooks;
+    constructor(options: ClaudeHookRunnerOptions, asynchronousHooks?: Map<Promise<void>, AbortController>);
     withAdditionalSettings(settings: readonly ClaudeJsonResource[]): ClaudeHookRunner;
+    fileChangedWatchPaths(cwd?: string): readonly string[];
     run(input: ClaudeHookInput, matcherValue?: string, signal?: AbortSignal): Promise<ClaudeHookOutcome>;
+    drainAsync(timeoutMs: number): Promise<void>;
+    clearCwdEnvironment(sessionId: string): Promise<void>;
+    private executionEnvironment;
+    private invalidateSessionEnvironment;
     private runCommand;
 }
 export {};