praxis-agent 0.30.0 → 0.32.0

package/dist/application/session-service.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { appendFile, copyFile, link, lstat, mkdir, readdir, realpath, stat, unlink, } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, extname, isAbsolute, join, relative, resolve, } from 'node:path';
+import { isPathWithin } from '../platform/path-containment.js';
 import { AGENT_COLOR_DEFAULT, agentColorMessage, getClaudeEffectiveAgentColor, } from '../compatibility/claude/agent-color.js';
 import { createClaudeCompactEntries, formatClaudeCompactSummary, getCumulativeDroppedTokens, } from '../compatibility/claude/compaction.js';
 import { discoverClaudeProjectRoot, isClaudeSessionId, resolveClaudePaths, resolveClaudeScheduledTaskFile, } from '../compatibility/claude/paths.js';
@@ -15,13 +16,14 @@ import { getClaudeAgentSetting, getClaudeLastPrompt, projectClaudeDisplayTranscr
 import { selectClaudeSchemaAdapter, } from '../compatibility/claude/schema.js';
 import { findUnresolvedClaudeToolCalls, getClaudeContentBlocks, } from '../compatibility/claude/tool-links.js';
 import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../compatibility/claude/translation.js';
-import { AgentRunCancelledError, AgentRuntime, } from '../core/runtime.js';
+import { AgentRunCancelledError, AgentRuntime, ModelProviderError, } from '../core/runtime.js';
 import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { usageCostUsd } from '../core/usage.js';
-import { ContextBudget, ContextRecoveryPlanner, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
+import { ContextBudget, ContextRecoveryPlanner, contextRecoveryMadeProgress, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
 import { injectFirstUserMessageContext, } from '../core/context.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
+import { ClaudeFileChangeWatcher } from '../hooks/claude-file-change-watcher.js';
 import { ClaudeTranscriptStore, } from '../persistence/claude-transcript-store.js';
 import { InMemoryTranscriptStore } from '../persistence/in-memory-transcript-store.js';
 import { ModelCompactor } from './model-compactor.js';
@@ -464,6 +466,50 @@ function validSessionName(value) {
         ? name.toLocaleLowerCase()
         : null;
 }
+function projectMemoryMessages(entries) {
+    return selectClaudeActiveTranscript(entries).flatMap((entry) => {
+        if (typeof entry.uuid !== 'string')
+            return [];
+        return projectClaudeModelMessages([entry]).flatMap((message) => (message.role === 'user' || message.role === 'assistant') &&
+            message.content.trim().length > 0
+            ? [
+                {
+                    id: entry.uuid,
+                    role: message.role,
+                    content: message.content,
+                },
+            ]
+            : []);
+    });
+}
+function successfulHookOutput(outcome) {
+    return (outcome?.executions ?? []).flatMap((execution) => {
+        const output = execution.stdout.trim();
+        return execution.exitCode === 0 && output.length > 0 ? [output] : [];
+    });
+}
+function claudeStopFailureError(kind) {
+    switch (kind) {
+        case 'authentication_failed':
+        case 'billing_error':
+        case 'rate_limit':
+        case 'invalid_request':
+        case 'server_error':
+        case 'max_output_tokens':
+            return kind;
+        case 'prompt_too_long':
+            return 'invalid_request';
+        case 'timeout':
+        case 'overloaded':
+        case 'api_error':
+        case 'transport_error':
+            return 'server_error';
+        case 'cancelled':
+        case 'unknown':
+        case undefined:
+            return 'unknown';
+    }
+}
 const SESSION_END_HOOK_TIMEOUT_MS = 15_000;
 class HookLifecycle {
     hooks;
@@ -589,6 +635,7 @@ export class ClaudeSessionService {
     hostedSubagentsByRegistry = new WeakMap();
     backgroundNotificationWrites = new Map();
     downloadedFileResourceSessions = new Set();
+    detachedHookRuns = new Map();
     activeProvider;
     mcpClosePromise;
     sessionCostTrackers = new Map();
@@ -597,11 +644,26 @@ export class ClaudeSessionService {
     sessionMemoryControllers = new Map();
     resolvedSessionMemoryProvider;
     hookLifecycle;
+    fileChangeWatcher;
     runtimeCwd;
     constructor(options) {
         this.options = options;
         this.hookLifecycle = new HookLifecycle(options.hooks, options.eventSink);
         this.runtimeCwd = options.workspace?.cwd() ?? options.cwd;
+        this.fileChangeWatcher = options.hooks
+            ? new ClaudeFileChangeWatcher({
+                cwd: this.runtimeCwd,
+                staticPaths: options.hooks.fileChangedWatchPaths(this.runtimeCwd),
+                onFileChanged: async (filePath, event, signal) => {
+                    const sessionId = this.activeCostSessionId;
+                    if (!sessionId)
+                        return undefined;
+                    const outcome = await this.runAdvisoryHook(sessionId, 'FileChanged', { file_path: filePath, event }, undefined, signal);
+                    return outcome?.watchPaths;
+                },
+                warn: (message) => options.eventSink?.({ type: 'warning', message }),
+            })
+            : null;
         this.schema = selectClaudeSchemaAdapter(options.claudeVersion);
         this.scheduledPrompts =
             options.tools && (options.scheduledToolNames?.length ?? 0) > 0
@@ -739,8 +801,12 @@ export class ClaudeSessionService {
         }
     }
     async close() {
+        await this.fileChangeWatcher?.close(5_000);
         await this.hookLifecycle.close();
+        await this.drainDetachedHookRuns(5_000);
+        await this.options.hooks?.drainAsync(5_000);
         this.scheduledPrompts?.close();
+        await this.options.projectMemoryExtraction?.close(5_000);
         await Promise.all([...this.hostedSubagents].map((executor) => executor.close()));
         await Promise.resolve();
         await Promise.all([...this.backgroundNotificationWrites.values()]);
@@ -756,6 +822,9 @@ export class ClaudeSessionService {
     }
     async transitionHookSession(sessionId, reason) {
         await this.hookLifecycle.transition(sessionId, reason);
+        if (reason === 'clear') {
+            this.options.projectMemoryRecall?.clearSession?.(sessionId);
+        }
         this.options.contextAssembler?.invalidate?.({
             lifecycleId: sessionId,
             reason: reason === 'resume' ? 'restore' : 'clear',
@@ -767,6 +836,119 @@ export class ClaudeSessionService {
             reason: 'resource-reload',
         });
     }
+    async notify(sessionId, message, notificationType, title, signal) {
+        const targetSessionId = sessionId ?? this.activeCostSessionId;
+        if (!targetSessionId)
+            return;
+        await this.runAdvisoryHook(targetSessionId, 'Notification', {
+            message,
+            notification_type: notificationType,
+            ...(title === undefined ? {} : { title }),
+        }, notificationType, signal);
+    }
+    notifyDetached(sessionId, message, notificationType, title) {
+        const controller = new AbortController();
+        const pending = this.notify(sessionId, message, notificationType, title, controller.signal);
+        this.detachedHookRuns.set(pending, controller);
+        void pending.finally(() => this.detachedHookRuns.delete(pending));
+    }
+    async drainDetachedHookRuns(timeoutMs) {
+        const pending = [...this.detachedHookRuns.keys()];
+        if (pending.length === 0)
+            return;
+        let timer;
+        try {
+            if ((await Promise.race([
+                Promise.allSettled(pending).then(() => 'settled'),
+                new Promise((resolve) => {
+                    timer = setTimeout(() => resolve('timeout'), timeoutMs);
+                }),
+            ])) === 'timeout') {
+                for (const controller of this.detachedHookRuns.values()) {
+                    controller.abort();
+                }
+                this.detachedHookRuns.clear();
+                await Promise.resolve();
+            }
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async instructionsLoaded(sessionId, resources, reason) {
+        if (reason === 'resource_reload')
+            return;
+        for (const resource of resources) {
+            const loadReason = resource.importedFrom
+                ? 'include'
+                : reason === 'compact'
+                    ? 'compact'
+                    : 'session_start';
+            await this.instructionLoaded(sessionId, {
+                path: resource.path,
+                memoryType: resource.scope === 'user'
+                    ? 'User'
+                    : resource.scope === 'local'
+                        ? 'Local'
+                        : 'Project',
+                ...(resource.importedFrom === undefined
+                    ? {}
+                    : { parentFilePath: resource.importedFrom }),
+            }, loadReason);
+        }
+    }
+    async instructionLoaded(sessionId, resource, loadReason) {
+        await this.runAdvisoryHook(sessionId, 'InstructionsLoaded', {
+            file_path: resource.path,
+            memory_type: resource.memoryType,
+            load_reason: loadReason,
+            ...(resource.globs === undefined ? {} : { globs: resource.globs }),
+            ...(resource.triggerFilePath === undefined
+                ? {}
+                : { trigger_file_path: resource.triggerFilePath }),
+            ...(resource.parentFilePath === undefined
+                ? {}
+                : { parent_file_path: resource.parentFilePath }),
+        }, loadReason);
+    }
+    async runAdvisoryHook(sessionId, event, fields, matcher, signal) {
+        if (!this.options.hooks)
+            return undefined;
+        try {
+            const outcome = await this.options.hooks.run({
+                session_id: sessionId,
+                transcript_path: this.paths(sessionId).sessionFile,
+                cwd: this.activeCwd(),
+                permission_mode: 'default',
+                hook_event_name: event,
+                ...fields,
+            }, matcher, signal);
+            for (const message of outcome.systemMessages ?? []) {
+                this.options.eventSink?.({
+                    type: 'user-message',
+                    message,
+                    status: 'proactive',
+                });
+            }
+            return outcome;
+        }
+        catch (error) {
+            this.options.eventSink?.({
+                type: 'warning',
+                message: `${event} hook failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+            return undefined;
+        }
+    }
+    async cwdChanged(sessionId, previousCwd, cwd) {
+        await this.options.hooks?.clearCwdEnvironment(sessionId);
+        const outcome = await this.runAdvisoryHook(sessionId, 'CwdChanged', {
+            old_cwd: previousCwd,
+            new_cwd: cwd,
+        });
+        this.fileChangeWatcher?.updateForCwd(cwd, this.options.hooks?.fileChangedWatchPaths(cwd) ?? [], outcome?.watchPaths ?? []);
+    }
     createHostedToolRegistry(sessionId) {
         const baseTools = this.options.tools;
         if (!baseTools)
@@ -1430,6 +1612,7 @@ export class ClaudeSessionService {
                 lifecycleId: sessionId,
                 reason: 'cwd',
             });
+            await this.cwdChanged(sessionId, previousCwd, cwd);
             return cwd;
         }
         this.runtimeCwd = cwd;
@@ -1441,6 +1624,7 @@ export class ClaudeSessionService {
                 lifecycleId: sessionId,
                 reason: 'cwd',
             });
+            await this.cwdChanged(sessionId, previousCwd, cwd);
         }
         return cwd;
     }
@@ -1689,6 +1873,14 @@ export class ClaudeSessionService {
             if (findUnresolvedClaudeToolCalls(snapshot.entries).length > 0) {
                 throw new Error('Cannot compact a Claude session with unresolved tool calls');
             }
+            const preCompact = await this.runAdvisoryHook(sessionId, 'PreCompact', {
+                trigger: 'manual',
+                custom_instructions: selection?.context ?? null,
+            }, 'manual', signal);
+            messages.push(...successfulHookOutput(preCompact).map((content) => ({
+                role: 'user',
+                content: `Additional summarization context: ${content}`,
+            })));
             this.options.eventSink?.({ type: 'state', state: 'compacting' });
             const contextWindowTokens = this.contextBudget(provider)?.contextWindowTokens ??
                 provider.capabilities.contextWindowTokens ??
@@ -1784,12 +1976,14 @@ export class ClaudeSessionService {
             if (appendResult.status === 'conflict') {
                 throw new Error(`Claude transcript append conflict: ${appendResult.reason}`);
             }
+            this.options.projectMemoryRecall?.recordCompact(sessionId);
             this.options.eventSink?.({
                 type: 'compact-boundary',
                 trigger: 'manual',
                 preTokens,
                 uuid: boundaryUuid,
             });
+            await this.runAdvisoryHook(sessionId, 'PostCompact', { trigger: 'manual', compact_summary: summary }, 'manual', signal);
             if (meteringTurnInput !== undefined) {
                 const tracker = this.sessionCostTrackers.get(sessionId);
                 if (!tracker) {
@@ -2147,6 +2341,14 @@ export class ClaudeSessionService {
                 agent?.initialPrompt
                 ? `${agent.initialPrompt}\n\n${prompt}`
                 : prompt;
+            const projectMemoryRecallTurn = !skipUserPrompt && shellCommand === undefined
+                ? this.options.projectMemoryRecall?.prefetch({
+                    sessionId,
+                    turnId: randomUUID(),
+                    prompt: effectivePrompt,
+                    ...(signal ? { signal } : {}),
+                })
+                : undefined;
             const initialPricing = this.options.pricing?.resolve(provider.model ?? 'praxis/provider');
             if (this.options.maxBudgetUsd !== undefined && !initialPricing) {
                 throw new Error(`Cannot enforce --max-budget-usd: no pricing is configured for model ${provider.model ?? 'praxis/provider'}`);
@@ -2228,6 +2430,42 @@ export class ClaudeSessionService {
                         ? { eventSink: this.options.eventSink }
                         : {}),
                     enabledTools: taskToolNames,
+                    ...(this.options.hooks
+                        ? {
+                            taskHooks: {
+                                created: async (task, taskSignal) => {
+                                    const outcome = await this.options.hooks?.run({
+                                        ...hookSession,
+                                        hook_event_name: 'TaskCreated',
+                                        task_id: task.id,
+                                        task_subject: task.subject,
+                                        task_description: task.description,
+                                    }, undefined, taskSignal);
+                                    if (!outcome)
+                                        return;
+                                    await recordHookOutcome(outcome);
+                                    if (outcome.blockedReason) {
+                                        throw new Error(`TaskCreated hook error: ${outcome.blockedReason}`);
+                                    }
+                                },
+                                completed: async (task, taskSignal) => {
+                                    const outcome = await this.options.hooks?.run({
+                                        ...hookSession,
+                                        hook_event_name: 'TaskCompleted',
+                                        task_id: task.id,
+                                        task_subject: task.subject,
+                                        task_description: task.description,
+                                    }, undefined, taskSignal);
+                                    if (!outcome)
+                                        return;
+                                    await recordHookOutcome(outcome);
+                                    if (outcome.blockedReason) {
+                                        throw new Error(`TaskCompleted hook error: ${outcome.blockedReason}`);
+                                    }
+                                },
+                            },
+                        }
+                        : {}),
                 })
                 : null;
             const scheduledTools = this.scheduledPrompts &&
@@ -2426,6 +2664,11 @@ export class ClaudeSessionService {
                     hooks: this.options.hooks,
                     session: hookSession,
                     recordOutcome: recordHookOutcome,
+                    ...(this.options.eventSink
+                        ? {
+                            warn: (message) => this.options.eventSink?.({ type: 'warning', message }),
+                        }
+                        : {}),
                     deferPreToolUseOutcome: (call) => pendingRecoveryToolCallIds.has(call.id),
                 })
                 : null;
@@ -2456,6 +2699,8 @@ export class ClaudeSessionService {
             });
             let currentTurnUserMessages = null;
             let currentTurnToolCalls = 0;
+            let projectMemoryMaintained = false;
+            let projectMemoryRecallMessages = [];
             const observer = {
                 assistantCompleted: async (message) => {
                     const [entry] = translateProviderEvents([
@@ -2534,6 +2779,29 @@ export class ClaudeSessionService {
                         throw new Error('Could not translate tool result');
                     const tail = await this.append(lease, snapshot.tail, entry);
                     snapshot = { entries: [...snapshot.entries, entry], tail };
+                    if (!toolResult.isError && this.options.projectMemoryDirectory) {
+                        const pathValue = call.input.file_path;
+                        const path = typeof pathValue === 'string'
+                            ? resolve(this.activeCwd(), pathValue)
+                            : null;
+                        if (path &&
+                            isPathWithin(this.options.projectMemoryDirectory, path)) {
+                            if (call.name === 'Read') {
+                                this.options.projectMemoryRecall?.recordRead(sessionId, path);
+                            }
+                            else if (call.name === 'Write' || call.name === 'Edit') {
+                                projectMemoryMaintained = true;
+                            }
+                        }
+                        if (call.name === 'Read') {
+                            for (const accessedPath of toolResult.accessedPaths ?? []) {
+                                const resolvedAccessedPath = resolve(this.activeCwd(), accessedPath);
+                                if (isPathWithin(this.options.projectMemoryDirectory, resolvedAccessedPath)) {
+                                    this.options.projectMemoryRecall?.recordRead(sessionId, resolvedAccessedPath);
+                                }
+                            }
+                        }
+                    }
                     if (toolResult.isError ||
                         call.name !== 'Read' ||
                         !this.options.conditionalRuleResolver ||
@@ -2551,6 +2819,19 @@ export class ClaudeSessionService {
                                 tail: attachmentTail,
                             };
                             attachedRulePaths.add(rule.path);
+                            await this.instructionLoaded(sessionId, {
+                                path: rule.path,
+                                memoryType: rule.scope === 'user'
+                                    ? 'User'
+                                    : rule.scope === 'local'
+                                        ? 'Local'
+                                        : 'Project',
+                                globs: rule.globs,
+                                triggerFilePath: filePath,
+                                ...(rule.importedFrom === undefined
+                                    ? {}
+                                    : { parentFilePath: rule.importedFrom }),
+                            }, 'path_glob_match');
                         }
                     }
                 },
@@ -2807,7 +3088,10 @@ export class ClaudeSessionService {
                 const compactIfNeeded = async (pendingMessages = [], preservedUserMessages = [], options = {}) => {
                     if (!budget || this.options.autoCompact === false)
                         return;
-                    const historyMessages = projectClaudeModelMessages(snapshot.entries);
+                    const historyMessages = [
+                        ...projectClaudeModelMessages(snapshot.entries),
+                        ...projectMemoryRecallMessages,
+                    ];
                     const predicted = budget.evaluate([
                         ...contextMessages,
                         ...injectTurnContext([...historyMessages, ...pendingMessages]),
@@ -2834,6 +3118,7 @@ export class ClaudeSessionService {
                     if (findUnresolvedClaudeToolCalls(snapshot.entries).length > 0) {
                         throw new Error('Cannot compact a Claude session with unresolved tool calls');
                     }
+                    const preCompact = await this.runAdvisoryHook(sessionId, 'PreCompact', { trigger: 'auto', custom_instructions: null }, 'auto', signal);
                     const memorySelection = sessionMemory
                         ? await this.selectMemoryPreservedCompact(sessionId, selectClaudeActiveTranscript(snapshot.entries))
                         : null;
@@ -2843,6 +3128,10 @@ export class ClaudeSessionService {
                             ...projectClaudeModelMessages(memorySelection.compactedEntries),
                         ]
                         : historyMessages;
+                    compactorMessages.push(...successfulHookOutput(preCompact).map((content) => ({
+                        role: 'user',
+                        content: `Additional summarization context: ${content}`,
+                    })));
                     if (memorySelection) {
                         logicalParentUuid = memorySelection.logicalParentUuid;
                     }
@@ -2925,17 +3214,27 @@ export class ClaudeSessionService {
                         createUuid: () => replayUuids.shift() ?? randomUUID(),
                         now: () => timestamp,
                     });
-                    const compactedHistory = projectClaudeModelMessages([
-                        ...snapshot.entries,
-                        ...provisionalEntries,
-                        ...replayEntries,
-                    ]);
+                    const compactedHistory = [
+                        ...projectClaudeModelMessages([
+                            ...snapshot.entries,
+                            ...provisionalEntries,
+                            ...replayEntries,
+                        ]),
+                        ...projectMemoryRecallMessages,
+                    ];
                     const afterHistory = budget.evaluate([...contextMessages, ...injectTurnContext(compactedHistory)], definitions);
                     const afterPending = budget.evaluate([
                         ...contextMessages,
                         ...injectTurnContext([...compactedHistory, ...pendingMessages]),
                     ], definitions);
                     budget.assertFits(afterPending);
+                    if (options.promptTooLong === true &&
+                        !contextRecoveryMadeProgress({
+                            beforeOccupancyTokens: predicted.occupancyTokens,
+                            afterOccupancyTokens: afterPending.occupancyTokens,
+                        })) {
+                        throw new Error('Reactive context compaction made no occupancy progress');
+                    }
                     const entries = [
                         ...compactEntries(afterHistory.estimatedTokens),
                         ...replayEntries,
@@ -3003,6 +3302,7 @@ export class ClaudeSessionService {
                         entries: [...snapshot.entries, ...entries],
                         tail: appendResult.tail,
                     };
+                    await this.runAdvisoryHook(sessionId, 'PostCompact', { trigger: 'auto', compact_summary: compacted.summary }, 'auto', signal);
                     // The boundary is durable: mirror Claude's full-compact behavior by
                     // rerunning SessionStart with source compact and refreshing the
                     // runtime-only context so the next request retains current
@@ -3016,6 +3316,7 @@ export class ClaudeSessionService {
                         lifecycleId: sessionId,
                         reason: 'compact',
                     });
+                    this.options.projectMemoryRecall?.recordCompact(sessionId);
                     await refreshRuntimeContext();
                     this.options.eventSink?.({
                         type: 'compact-boundary',
@@ -3112,6 +3413,7 @@ export class ClaudeSessionService {
                     try {
                         shellResult = await runtime.executeDirectToolCall(call, {
                             cwd: this.activeCwd(),
+                            sessionId,
                             toolResultDirectory,
                             messages: projectClaudeModelMessages(snapshot.entries),
                             observer: {
@@ -3183,6 +3485,7 @@ export class ClaudeSessionService {
                 }
                 let stopHookActive = false;
                 const runtimeRequest = {
+                    sessionId,
                     messages: [
                         ...contextMessages,
                         ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
@@ -3201,7 +3504,16 @@ export class ClaudeSessionService {
                     ...(this.options.collectMetrics || this.options.costStateStore
                         ? { collectMetrics: true }
                         : {}),
+                    ...(budget
+                        ? { deferFailureKinds: ['prompt_too_long'] }
+                        : {}),
                     reloadMessages: async () => {
+                        const recalled = projectMemoryRecallTurn?.consumeIfSettled();
+                        if (recalled) {
+                            projectMemoryRecallMessages = [
+                                { role: 'user', content: recalled.content },
+                            ];
+                        }
                         await compactIfNeeded([], currentTurnUserMessages ?? []);
                         if (stableSystemMessageCount === undefined) {
                             delete runtimeRequest.stableSystemMessageCount;
@@ -3211,7 +3523,10 @@ export class ClaudeSessionService {
                         }
                         return [
                             ...contextMessages,
-                            ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
+                            ...injectTurnContext([
+                                ...projectClaudeModelMessages(snapshot.entries),
+                                ...projectMemoryRecallMessages,
+                            ]),
                         ];
                     },
                     ...(this.options.hooks ||
@@ -3297,47 +3612,95 @@ export class ClaudeSessionService {
                 const attemptMainTurn = () => signal
                     ? runtime.run({ ...runtimeRequest, signal })
                     : runtime.run(runtimeRequest);
+                const surfaceExhaustedRecovery = (error) => {
+                    this.options.eventSink?.({
+                        type: 'failed',
+                        message: error.message,
+                        retryable: false,
+                    });
+                };
                 let result;
                 try {
-                    result = await attemptMainTurn();
-                }
-                catch (error) {
-                    if (!budget || !isPromptTooLongError(error))
-                        throw error;
-                    if (recoveryPlanner.consumeReactiveRetry() !== 'reactive-retry')
-                        throw error;
-                    try {
-                        await compactIfNeeded([], currentTurnUserMessages ?? [], {
-                            promptTooLong: true,
-                        });
-                    }
-                    catch {
-                        // Compaction could not free the provider-bounded context; surface
-                        // the original prompt-too-long error rather than the compaction
-                        // failure.
-                        throw error;
-                    }
-                    // The single reactive retry must use the compacted transcript, not
-                    // the stale request copy captured before the compact boundary.
-                    runtimeRequest.messages = [
-                        ...contextMessages,
-                        ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
-                    ];
-                    if (stableSystemMessageCount === undefined) {
-                        delete runtimeRequest.stableSystemMessageCount;
-                    }
-                    else {
-                        runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
-                    }
                     try {
                         result = await attemptMainTurn();
                     }
-                    catch {
-                        // Exactly one reactive retry is consumed; fail deterministically
-                        // and surface the original prompt-too-long error.
-                        recoveryPlanner.recordFailure();
-                        throw error;
+                    catch (error) {
+                        if (!budget || !isPromptTooLongError(error))
+                            throw error;
+                        if (recoveryPlanner.reactiveRetriesRemaining === 0) {
+                            surfaceExhaustedRecovery(error);
+                            throw error;
+                        }
+                        const beforeRecovery = budget.evaluate(runtimeRequest.messages, definitions);
+                        try {
+                            await compactIfNeeded([], currentTurnUserMessages ?? [], {
+                                promptTooLong: true,
+                            });
+                        }
+                        catch (compactionError) {
+                            if (signal?.aborted ||
+                                compactionError instanceof AgentRunCancelledError) {
+                                throw new AgentRunCancelledError();
+                            }
+                            // Compaction could not free the provider-bounded context; surface
+                            // the original prompt-too-long error rather than the compaction
+                            // failure.
+                            surfaceExhaustedRecovery(error);
+                            throw error;
+                        }
+                        // The single reactive retry must use the compacted transcript, not
+                        // the stale request copy captured before the compact boundary.
+                        runtimeRequest.messages = [
+                            ...contextMessages,
+                            ...injectTurnContext([
+                                ...projectClaudeModelMessages(snapshot.entries),
+                                ...projectMemoryRecallMessages,
+                            ]),
+                        ];
+                        if (stableSystemMessageCount === undefined) {
+                            delete runtimeRequest.stableSystemMessageCount;
+                        }
+                        else {
+                            runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
+                        }
+                        const afterRecovery = budget.evaluate(runtimeRequest.messages, definitions);
+                        if (recoveryPlanner.consumeReactiveRetry({
+                            beforeOccupancyTokens: beforeRecovery.occupancyTokens,
+                            afterOccupancyTokens: afterRecovery.occupancyTokens,
+                        }) !== 'reactive-retry') {
+                            surfaceExhaustedRecovery(error);
+                            throw error;
+                        }
+                        runtimeRequest.deferFailureKinds = true;
+                        try {
+                            result = await attemptMainTurn();
+                        }
+                        catch (retryError) {
+                            // Exactly one reactive retry is consumed; fail deterministically
+                            // and surface the original prompt-too-long error.
+                            recoveryPlanner.recordFailure();
+                            if (signal?.aborted ||
+                                retryError instanceof AgentRunCancelledError) {
+                                throw new AgentRunCancelledError();
+                            }
+                            surfaceExhaustedRecovery(error);
+                            throw error;
+                        }
+                    }
+                }
+                catch (error) {
+                    if (!signal?.aborted &&
+                        !(error instanceof AgentRunCancelledError) &&
+                        !(error instanceof ModelProviderError && error.kind === 'cancelled')) {
+                        const failureKind = error instanceof ModelProviderError
+                            ? claudeStopFailureError(error.kind)
+                            : 'unknown';
+                        await this.runAdvisoryHook(sessionId, 'StopFailure', {
+                            error: failureKind,
+                            error_details: error instanceof Error ? error.message : String(error),
+                        }, failureKind, signal);
                     }
+                    throw error;
                 }
                 recoveryPlanner.recordSuccess();
                 const mainModel = provider.model !== undefined && provider.model.trim() !== ''
@@ -3465,6 +3828,11 @@ export class ClaudeSessionService {
                         });
                     }
                 }
+                this.options.projectMemoryExtraction?.observe({
+                    sessionId,
+                    directMaintenance: projectMemoryMaintained,
+                    messages: projectMemoryMessages(snapshot.entries),
+                });
                 turnCompleted = true;
                 return {
                     sessionId,