praxis-agent 0.20.21 → 0.21.0

package/dist/application/session-service.js

@@ -17,7 +17,7 @@ import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, creat
 import { AgentRunCancelledError, AgentRuntime, } from '../core/runtime.js';
 import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { usageCostUsd } from '../core/usage.js';
-import { ContextBudget, estimateModelRequestTokens, } from '../core/context-budget.js';
+import { ContextBudget, ContextRecoveryPlanner, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
 import { injectFirstUserMessageContext, } from '../core/context.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
 import { ClaudeTranscriptStore, } from '../persistence/claude-transcript-store.js';
@@ -33,7 +33,9 @@ import { SessionWorktreeManager } from './session-worktree.js';
 import { ClaudeSessionCostTracker, } from './session-cost-tracker.js';
 import { ClaudeWorktreeToolRegistry } from '../tools/claude-worktree-tools.js';
 import { completeMeteredModelRequest } from './metered-model-completion.js';
+import { SessionMemoryController, SessionMemoryStateError, SessionMemoryStore, } from './session-memory.js';
 import { FilteredToolRegistry } from '../tools/filtered-tool-registry.js';
+import { ClaudeCapabilityToolRegistry, resolveClaudeToolCapabilities, } from '../tools/claude-capabilities.js';
 import { generateToolUseSummary } from './tool-use-summary.js';
 import { ClaudeUserMessageToolRegistry, CLAUDE_USER_MESSAGE_PROMPT, } from '../tools/claude-user-message.js';
 function agentPermissionMode(mode) {
@@ -286,6 +288,19 @@ Reply with ONLY the suggestion, no quotes or explanation.
 Use 2-12 words. Do not ask a question, evaluate the prior response, introduce a new idea, or use a Claude voice. If the topic is unsafe or sensitive, reply with an empty string.`;
 const SESSION_NAME_INSTRUCTION = `Generate a concise name for this coding session based on the conversation.
 Use 2-5 short words in kebab-case. Reply with ONLY the name, without quotes, punctuation, or explanation.`;
+const SESSION_MEMORY_MAX_LINES = 200;
+const SESSION_MEMORY_MAX_CHARS = 32_000;
+const SESSION_MEMORY_EXTRACTION_PROMPT = `You maintain durable session memory for one coding session.
+
+Update the durable session memory from the conversation so far. Preserve:
+- The user's intent and current goals
+- Decisions made and the reasoning behind them
+- Active constraints, requirements, and preferences
+- Pending work, blockers, and next steps
+
+Omit transient chatter, credentials, secrets, or personal data.
+
+Return ONLY an updated Markdown document that becomes the session's durable memory. Do not call tools. Do not include any prose outside the Markdown document.`;
 function validPromptSuggestion(value) {
     const suggestion = value.trim();
     if (!suggestion)
@@ -323,6 +338,7 @@ export class ClaudeSessionService {
     sessionCostTrackers = new Map();
     activeCostSessionId;
     closeCostSavePromise;
+    sessionMemoryControllers = new Map();
     runtimeCwd;
     constructor(options) {
         this.options = options;
@@ -456,6 +472,7 @@ export class ClaudeSessionService {
         await Promise.all([...this.backgroundNotificationWrites.values()]);
         this.hostedSubagents.clear();
         this.backgroundTasks.clear();
+        this.sessionMemoryControllers.clear();
         await this.workflowManager?.close();
         this.closeCostSavePromise ??= this.persistActiveSessionCost();
         await this.closeCostSavePromise;
@@ -467,7 +484,10 @@ export class ClaudeSessionService {
         if (!baseTools)
             throw new Error('Hosted tool registry requires base tools');
         const paths = this.paths(sessionId);
-        const taskTools = (this.options.taskToolNames?.length ?? 0) > 0
+        const capabilities = this.toolCapabilities();
+        const taskToolNames = this.capabilityToolNames(this.options.taskToolNames, capabilities);
+        const scheduledToolNames = this.capabilityToolNames(this.options.scheduledToolNames, capabilities);
+        const taskTools = taskToolNames.length > 0
             ? new ClaudeTaskToolRegistry({
                 base: baseTools,
                 cwd: this.activeCwd(),
@@ -478,22 +498,17 @@ export class ClaudeSessionService {
                 ...(this.options.eventSink
                     ? { eventSink: this.options.eventSink }
                     : {}),
-                ...(this.options.taskToolNames
-                    ? { enabledTools: this.options.taskToolNames }
-                    : {}),
+                enabledTools: taskToolNames,
             })
             : null;
         if (taskTools)
             this.backgroundTasks.registerBash(sessionId, taskTools);
-        const scheduledTools = this.scheduledPrompts &&
-            (this.options.scheduledToolNames?.length ?? 0) > 0
+        const scheduledTools = this.scheduledPrompts && scheduledToolNames.length > 0
             ? new ClaudeScheduledToolRegistry({
                 base: taskTools ?? baseTools,
                 manager: this.scheduledPrompts,
                 sessionId,
-                ...(this.options.scheduledToolNames
-                    ? { enabledTools: this.options.scheduledToolNames }
-                    : {}),
+                enabledTools: scheduledToolNames,
             })
             : null;
         const wrappedBase = scheduledTools ?? taskTools ?? baseTools;
@@ -522,7 +537,9 @@ export class ClaudeSessionService {
                 parentPermissionMode: () => agentPermissionMode(this.options.interactiveTools?.mode(sessionId) ??
                     this.options.permissionMode),
                 ...(this.options.subagentToolNames
-                    ? { toolNames: this.options.subagentToolNames }
+                    ? {
+                        toolNames: this.capabilityToolNames(this.options.subagentToolNames, capabilities),
+                    }
                     : {}),
                 ...(this.options.extensions
                     ? { extensions: this.options.extensions }
@@ -574,7 +591,7 @@ export class ClaudeSessionService {
                 promptIdForCall: (callId) => callId,
                 defaultModel: this.options.provider?.model ?? 'praxis/provider',
                 tokenBudget: null,
-                enabled: true,
+                enabled: capabilities.has('Workflow'),
             })
             : agentTools;
         if (this.worktreeManager)
@@ -602,6 +619,7 @@ export class ClaudeSessionService {
         const interactiveRegistry = this.options.interactiveTools
             ? this.options.interactiveTools.registry(messageRegistry, sessionId)
             : messageRegistry;
+        const capabilityRegistry = new ClaudeCapabilityToolRegistry(interactiveRegistry, capabilities);
         const preferredOrder = [
             'Agent',
             'AskUserQuestion',
@@ -637,7 +655,7 @@ export class ClaudeSessionService {
         ];
         const hostedRegistry = {
             definitions: () => {
-                const definitions = interactiveRegistry.definitions();
+                const definitions = capabilityRegistry.definitions();
                 return [...definitions].sort((left, right) => {
                     const leftIndex = preferredOrder.indexOf(left.name);
                     const rightIndex = preferredOrder.indexOf(right.name);
@@ -645,8 +663,8 @@ export class ClaudeSessionService {
                         (rightIndex < 0 ? preferredOrder.length : rightIndex));
                 });
             },
-            prepare: (call, context) => interactiveRegistry.prepare(call, context),
-            execute: (call, context) => interactiveRegistry.execute(call, context),
+            prepare: (call, context) => capabilityRegistry.prepare(call, context),
+            execute: (call, context) => capabilityRegistry.execute(call, context),
         };
         if (subagentExecutor) {
             this.hostedSubagentsByRegistry.set(hostedRegistry, subagentExecutor);
@@ -718,6 +736,7 @@ export class ClaudeSessionService {
             ...(onDelta ? { onTextDelta: onDelta } : {}),
             onMetrics: (recorded) => this.recordAuxiliaryMetrics(activeSessionId, recorded),
         });
+        budget?.observeUsage(metrics.usage);
         if (metrics.toolCalls.length > 0) {
             throw new Error('Side questions cannot call tools; press f to fork');
         }
@@ -1865,7 +1884,10 @@ export class ClaudeSessionService {
                 snapshot = { entries: history, tail: appendResult.tail };
                 pendingRecoveryHookOutcomes.length = 0;
             };
-            const taskTools = this.options.tools && (this.options.taskToolNames?.length ?? 0) > 0
+            const capabilities = this.toolCapabilities();
+            const taskToolNames = this.capabilityToolNames(this.options.taskToolNames, capabilities);
+            const scheduledToolNames = this.capabilityToolNames(this.options.scheduledToolNames, capabilities);
+            const taskTools = this.options.tools && taskToolNames.length > 0
                 ? new ClaudeTaskToolRegistry({
                     base: this.options.tools,
                     cwd: this.activeCwd(),
@@ -1876,21 +1898,17 @@ export class ClaudeSessionService {
                     ...(this.options.eventSink
                         ? { eventSink: this.options.eventSink }
                         : {}),
-                    ...(this.options.taskToolNames
-                        ? { enabledTools: this.options.taskToolNames }
-                        : {}),
+                    enabledTools: taskToolNames,
                 })
                 : null;
             const scheduledTools = this.scheduledPrompts &&
                 this.options.tools &&
-                (this.options.scheduledToolNames?.length ?? 0) > 0
+                scheduledToolNames.length > 0
                 ? new ClaudeScheduledToolRegistry({
                     base: taskTools ?? this.options.tools,
                     manager: this.scheduledPrompts,
                     sessionId,
-                    ...(this.options.scheduledToolNames
-                        ? { enabledTools: this.options.scheduledToolNames }
-                        : {}),
+                    enabledTools: scheduledToolNames,
                 })
                 : null;
             const baseTools = scheduledTools ?? taskTools ?? this.options.tools;
@@ -1919,7 +1937,9 @@ export class ClaudeSessionService {
                     parentPermissionMode: () => agentPermissionMode(this.options.interactiveTools?.mode(sessionId) ??
                         this.options.permissionMode),
                     ...(this.options.subagentToolNames
-                        ? { toolNames: this.options.subagentToolNames }
+                        ? {
+                            toolNames: this.capabilityToolNames(this.options.subagentToolNames, capabilities),
+                        }
                         : {}),
                     ...(this.options.extensions
                         ? { extensions: this.options.extensions }
@@ -1975,7 +1995,7 @@ export class ClaudeSessionService {
                         this.promptIdForToolCall(snapshot.entries, callId),
                     defaultModel: provider.model ?? 'praxis/provider',
                     tokenBudget: workflowTokenTarget(effectivePrompt),
-                    enabled: true,
+                    enabled: capabilities.has('Workflow'),
                 })
                 : agentTools;
             const workspaceTools = this.worktreeManager &&
@@ -2048,14 +2068,17 @@ export class ClaudeSessionService {
                     },
                 }
                 : interactiveMessageTools;
+            const capabilityTools = fileHistoryTools
+                ? new ClaudeCapabilityToolRegistry(fileHistoryTools, capabilities)
+                : undefined;
             const structuredCapture = this.options.structuredOutputSchema
                 ? { calls: 0, value: undefined }
                 : undefined;
-            const agentScopedTools = agent && fileHistoryTools
-                ? new FilteredToolRegistry(fileHistoryTools, {
-                    tools: mainAgentToolNames(fileHistoryTools, agent),
+            const agentScopedTools = agent && capabilityTools
+                ? new FilteredToolRegistry(capabilityTools, {
+                    tools: mainAgentToolNames(capabilityTools, agent),
                 })
-                : fileHistoryTools;
+                : capabilityTools;
             const structuredTools = this.options.structuredOutputSchema && structuredCapture
                 ? new StructuredOutputRegistry(agentScopedTools ?? this.options.tools ?? emptyToolRegistry, this.options.structuredOutputSchema, structuredCapture)
                 : agentScopedTools;
@@ -2095,6 +2118,7 @@ export class ClaudeSessionService {
                     }),
             });
             let currentTurnUserMessages = null;
+            let currentTurnToolCalls = 0;
             const observer = {
                 assistantCompleted: async (message) => {
                     const [entry] = translateProviderEvents([
@@ -2117,6 +2141,7 @@ export class ClaudeSessionService {
                         typeof entry.uuid === 'string' ? entry.uuid : lastAssistantUuid;
                 },
                 toolCompleted: async (call, toolResult) => {
+                    currentTurnToolCalls += 1;
                     const transition = this.worktreeManager?.consumeTransition(call.id);
                     if (transition) {
                         const stateEntry = {
@@ -2261,37 +2286,53 @@ export class ClaudeSessionService {
                         tail: settingTail,
                     };
                 }
-                const assembledContext = await this.options.contextAssembler?.assemble({
-                    cwd: this.activeCwd(),
-                });
-                const agentSystem = await this.mainAgentSystemPrompt(agent);
-                const assembledSystemMessages = this.assembledSystemMessages(agent, assembledContext?.systemMessages ?? []);
-                const planModeMessage = this.options.interactiveTools?.contextMessage(sessionId);
-                const contextMessages = [
-                    ...(agentSystem
-                        ? [{ role: 'system', content: agentSystem }]
-                        : []),
-                    ...assembledSystemMessages,
-                    ...(planModeMessage
-                        ? [{ role: 'system', content: planModeMessage }]
-                        : []),
-                    ...(this.options.brief
-                        ? [
-                            {
-                                role: 'system',
-                                content: CLAUDE_USER_MESSAGE_PROMPT,
-                            },
-                        ]
-                        : []),
-                    ...(this.options.structuredOutputSchema
-                        ? [
-                            {
-                                role: 'system',
-                                content: 'You MUST call StructuredOutput exactly once at the end with a value matching the requested JSON Schema.',
-                            },
-                        ]
-                        : []),
-                ];
+                const sessionMemory = this.sessionMemoryController(sessionId);
+                let assembledContext;
+                let agentSystem = null;
+                let planModeMessage;
+                let sessionMemoryMessage = null;
+                let contextMessages = [];
+                const refreshRuntimeContext = async () => {
+                    assembledContext = await this.options.contextAssembler?.assemble({
+                        cwd: this.activeCwd(),
+                    });
+                    agentSystem = await this.mainAgentSystemPrompt(agent);
+                    const assembledSystemMessages = this.assembledSystemMessages(agent, assembledContext?.systemMessages ?? []);
+                    planModeMessage =
+                        this.options.interactiveTools?.contextMessage(sessionId);
+                    sessionMemoryMessage = sessionMemory
+                        ? this.sessionMemoryMessage(await sessionMemory.summary())
+                        : null;
+                    contextMessages = [
+                        ...(agentSystem
+                            ? [{ role: 'system', content: agentSystem }]
+                            : []),
+                        ...assembledSystemMessages,
+                        ...(planModeMessage
+                            ? [{ role: 'system', content: planModeMessage }]
+                            : []),
+                        ...(sessionMemoryMessage
+                            ? [{ role: 'system', content: sessionMemoryMessage }]
+                            : []),
+                        ...(this.options.brief
+                            ? [
+                                {
+                                    role: 'system',
+                                    content: CLAUDE_USER_MESSAGE_PROMPT,
+                                },
+                            ]
+                            : []),
+                        ...(this.options.structuredOutputSchema
+                            ? [
+                                {
+                                    role: 'system',
+                                    content: 'You MUST call StructuredOutput exactly once at the end with a value matching the requested JSON Schema.',
+                                },
+                            ]
+                            : []),
+                    ];
+                };
+                await refreshRuntimeContext();
                 const expansion = skipUserPrompt
                     ? { userMessages: [] }
                     : shellCommand === undefined
@@ -2321,6 +2362,7 @@ export class ClaudeSessionService {
                     ? (structuredTools?.definitions() ?? [])
                     : [];
                 const budget = this.contextBudget(provider);
+                const recoveryPlanner = new ContextRecoveryPlanner();
                 const pendingUserMessages = expandedMessages.map((message, index) => ({
                     role: 'user',
                     content: message.text,
@@ -2373,14 +2415,14 @@ export class ClaudeSessionService {
                 const injectDynamicContext = (messages) => injectFirstUserMessageContext(messages, assembledContext?.firstUserMessageContext);
                 const injectTurnContext = (messages) => injectAgentMentionContext(injectDynamicContext(messages));
                 let compactionAnchorUuid = this.lastMessageUuid(snapshot.entries);
-                const compactIfNeeded = async (pendingMessages = [], preservedUserMessages = []) => {
+                const compactIfNeeded = async (pendingMessages = [], preservedUserMessages = [], options = {}) => {
                     if (!budget || this.options.autoCompact === false)
                         return;
                     const historyMessages = projectClaudeModelMessages(snapshot.entries);
                     const predicted = budget.evaluate([
                         ...contextMessages,
                         ...injectTurnContext([...historyMessages, ...pendingMessages]),
-                    ], definitions);
+                    ], definitions, options);
                     if (!predicted.shouldCompact)
                         return;
                     const irreducibleMessages = [
@@ -2403,6 +2445,9 @@ export class ClaudeSessionService {
                     if (findUnresolvedClaudeToolCalls(snapshot.entries).length > 0) {
                         throw new Error('Cannot compact a Claude session with unresolved tool calls');
                     }
+                    if (sessionMemory) {
+                        await sessionMemory.waitForIdle();
+                    }
                     this.options.eventSink?.({ type: 'state', state: 'compacting' });
                     const compactEnvelope = budget.evaluate([
                         ...irreducibleMessages,
@@ -2555,6 +2600,22 @@ export class ClaudeSessionService {
                         entries: [...snapshot.entries, ...entries],
                         tail: appendResult.tail,
                     };
+                    // 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
+                    // instructions, plan state, session memory, and hook context.
+                    if (this.options.hooks) {
+                        const outcome = await this.options.hooks.run({
+                            ...hookSession,
+                            hook_event_name: 'SessionStart',
+                            source: 'compact',
+                        }, 'compact', signal);
+                        await recordHookOutcome(outcome);
+                        if (outcome.blockedReason) {
+                            throw new Error(`SessionStart hook error: ${outcome.blockedReason}`);
+                        }
+                    }
+                    await refreshRuntimeContext();
                     this.options.eventSink?.({
                         type: 'compact-boundary',
                         trigger: 'auto',
@@ -2823,9 +2884,55 @@ export class ClaudeSessionService {
                     permissionUpdates: this.sessionPermissionUpdates.get(sessionId) ?? [],
                     onPermissionUpdates: (updates) => this.applyPermissionUpdates(sessionId, updates),
                 };
-                const result = signal
-                    ? await runtime.run({ ...runtimeRequest, signal })
-                    : await runtime.run(runtimeRequest);
+                const attemptMainTurn = () => signal
+                    ? runtime.run({ ...runtimeRequest, signal })
+                    : runtime.run(runtimeRequest);
+                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)),
+                    ];
+                    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;
+                    }
+                }
+                recoveryPlanner.recordSuccess();
+                const mainModel = provider.model !== undefined && provider.model.trim() !== ''
+                    ? provider.model
+                    : undefined;
+                const observedUsage = (mainModel !== undefined
+                    ? result.modelUsage?.[mainModel]
+                    : undefined) ??
+                    Object.values(result.modelUsage ?? {})[0] ??
+                    result.usage;
+                budget?.observeUsage(observedUsage);
                 if (structuredCapture && structuredCapture.calls !== 1) {
                     throw new Error(`StructuredOutput must be called exactly once (received ${structuredCapture.calls})`);
                 }
@@ -2920,6 +3027,21 @@ export class ClaudeSessionService {
                             : { linesRemoved: foregroundLineChanges.linesRemoved }),
                     });
                 }
+                if (sessionMemory && finalLeafUuid) {
+                    const turnInputTokens = result.usage?.inputTokens ?? 0;
+                    try {
+                        await sessionMemory.observeDelta(turnInputTokens, currentTurnToolCalls, finalLeafUuid, projectClaudeModelMessages(snapshot.entries));
+                        await sessionMemory.waitForIdle();
+                    }
+                    catch (error) {
+                        // A failed extraction must not fail the user turn; the sidecar
+                        // retains a retryable error for the next observation.
+                        this.options.eventSink?.({
+                            type: 'warning',
+                            message: `Session memory extraction failed: ${error instanceof Error ? error.message : String(error)}`,
+                        });
+                    }
+                }
                 return {
                     sessionId,
                     text: structuredCapture && structuredCapture.calls === 1
@@ -3621,11 +3743,149 @@ export class ClaudeSessionService {
             return null;
         return new ContextBudget({
             contextWindowTokens,
+            windowSource: 'capability',
             ...(this.options.contextReserveTokens === undefined
                 ? {}
                 : { reserveTokens: this.options.contextReserveTokens }),
         });
     }
+    sessionMemoryEnabled() {
+        if (this.options.enableSessionMemory === false)
+            return false;
+        if (this.options.sessionPersistence === false)
+            return false;
+        return true;
+    }
+    sessionMemoryController(sessionId) {
+        if (!this.sessionMemoryEnabled() || !isClaudeSessionId(sessionId)) {
+            return null;
+        }
+        let controller = this.sessionMemoryControllers.get(sessionId);
+        if (!controller) {
+            controller = new SessionMemoryController({
+                store: new SessionMemoryStore({
+                    configRoot: this.options.configRoot,
+                    sessionId,
+                }),
+                extractor: (input) => this.extractSessionMemory(sessionId, input),
+            });
+            this.sessionMemoryControllers.set(sessionId, controller);
+        }
+        return controller;
+    }
+    sessionMemoryMessage(summary) {
+        const bounded = this.boundSessionMemorySummary(summary.trim());
+        if (bounded.length === 0)
+            return null;
+        return `# Session Memory\n\n${bounded}`;
+    }
+    boundSessionMemorySummary(summary) {
+        const lines = summary.split('\n');
+        const content = lines.length > SESSION_MEMORY_MAX_LINES
+            ? lines.slice(0, SESSION_MEMORY_MAX_LINES).join('\n')
+            : summary;
+        return content.length > SESSION_MEMORY_MAX_CHARS
+            ? content.slice(0, SESSION_MEMORY_MAX_CHARS)
+            : content;
+    }
+    formatSessionMemoryConversation(messages) {
+        const parts = [];
+        for (const message of messages) {
+            if (message.role === 'system') {
+                parts.push(`System: ${message.content}`);
+            }
+            else if (message.role === 'user') {
+                const body = message.contentBlocks === undefined
+                    ? message.content
+                    : message.contentBlocks
+                        .map((block) => block.type === 'text'
+                        ? block.text
+                        : block.type === 'image'
+                            ? '[image]'
+                            : '[document]')
+                        .join('\n');
+                parts.push(`User: ${body}`);
+            }
+            else if (message.role === 'assistant') {
+                const toolCalls = message.toolCalls === undefined || message.toolCalls.length === 0
+                    ? ''
+                    : `\n${message.toolCalls
+                        .map((call) => `${call.name}(${JSON.stringify(call.input)})`)
+                        .join('\n')}`;
+                parts.push(`Assistant: ${message.content}${toolCalls}`);
+            }
+            else {
+                parts.push(`Tool result: ${message.content}`);
+            }
+        }
+        return this.boundSessionMemorySummary(parts.join('\n\n'));
+    }
+    async extractSessionMemory(sessionId, input) {
+        const provider = this.provider();
+        const messages = [
+            { role: 'system', content: SESSION_MEMORY_EXTRACTION_PROMPT },
+            ...(input.summary.trim().length === 0
+                ? []
+                : [
+                    {
+                        role: 'system',
+                        content: `Previous session memory summary:\n\n${this.boundSessionMemorySummary(input.summary)}`,
+                    },
+                ]),
+            ...(input.messages === undefined || input.messages.length === 0
+                ? []
+                : [
+                    {
+                        role: 'user',
+                        content: `Conversation so far:\n\n${this.formatSessionMemoryConversation(input.messages)}`,
+                    },
+                ]),
+        ];
+        const metrics = await completeMeteredModelRequest(provider, { messages }, {
+            onMetrics: (recorded) => this.recordAuxiliaryMetrics(sessionId, recorded),
+        });
+        if (metrics.toolCalls.length > 0) {
+            throw new SessionMemoryStateError('Session memory extraction must not call tools');
+        }
+        const summary = metrics.text.trim();
+        if (summary.length === 0) {
+            throw new SessionMemoryStateError('Session memory extractor returned an empty summary');
+        }
+        return summary;
+    }
+    toolCapabilities() {
+        const taskNames = this.options.taskToolNames ?? [];
+        const input = {
+            role: this.options.toolRole ?? 'main',
+            interactive: this.options.interactiveTools !== undefined,
+            simpleMode: this.options.simpleMode ?? false,
+            tasks: taskNames.some((name) => ['TaskCreate', 'TaskGet', 'TaskList', 'TaskUpdate'].includes(name)),
+            agentTriggers: (this.options.scheduledToolNames?.length ?? 0) > 0,
+            backgroundAgents: taskNames.some((name) => ['TaskOutput', 'TaskStop'].includes(name)),
+            ...(this.options.enableWorkflows === undefined
+                ? {}
+                : { workflowScripts: this.options.enableWorkflows }),
+            ...(this.options.enableSubagents === undefined
+                ? {}
+                : { subagents: this.options.enableSubagents }),
+            ...(this.options.toolCapabilityEnvironment
+                ? { env: this.options.toolCapabilityEnvironment }
+                : {}),
+        };
+        return resolveClaudeToolCapabilities(input);
+    }
+    capabilityToolNames(names, capabilities) {
+        return (names ?? [])
+            .filter((name) => !name.startsWith('Task') || capabilities.has(name))
+            .filter((name) => ![
+            'Workflow',
+            'Agent',
+            'CronCreate',
+            'CronDelete',
+            'CronList',
+            'ScheduleWakeup',
+        ].includes(name) || capabilities.has(name));
+    }
     async append(lease, tail, entry) {
         const result = await lease.append(tail, entry);
         if (result.status === 'conflict') {

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

@@ -112,7 +112,8 @@ export declare class ClaudeSubagentExecutor {
         durationApiWithoutRetriesMs?: number;
     }>;
     private hydrateCompletedTask;
-    private resolvePersistedAgentId;
+    private resolvePersistedSidechain;
+    private discoverSidechainCandidates;
     private asyncLaunchResult;
     private runSidechain;
 }