praxis-agent 0.26.0 → 0.28.0

package/dist/application/session-service.js

@@ -16,6 +16,7 @@ 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 { 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';
@@ -61,6 +62,7 @@ function mainAgentToolNames(tools, agent) {
 }
 const emptyToolRegistry = {
     definitions: () => [],
+    schedulingPolicy: () => ({ concurrency: 'exclusive' }),
     prepare: async (call) => call,
     execute: async () => ({ content: '', isError: false }),
 };
@@ -307,10 +309,10 @@ Return ONLY an updated Markdown document that becomes the session's durable memo
  *  branch can provide them. Larger suffixes stay conservative. */
 const MEMORY_COMPACT_MIN_SUFFIX_MESSAGES = 5;
 const MEMORY_COMPACT_MIN_SUFFIX_TOKENS = 10_000;
-/** Above this estimated compactor projection the selective path falls back to
- *  the existing full-compaction behavior instead of building an oversized
- *  projection. */
+/** Above this estimated post-compact envelope the selective path falls back to
+ *  full compaction instead of retaining an oversized active projection. */
 const MEMORY_COMPACT_MAX_PROJECTION_TOKENS = 40_000;
+const MEMORY_COMPACT_MAX_SUMMARY_TOKENS = 8_192;
 function isTextBearingClaudeEntry(entry) {
     if (typeof entry.message !== 'object' ||
         entry.message === null ||
@@ -360,12 +362,38 @@ function claudeAssistantHasToolUse(entry, ids) {
         typeof block.id === 'string' &&
         ids.has(block.id));
 }
+function claudeAssistantResponseId(entry) {
+    if (entry?.type !== 'assistant' ||
+        typeof entry.message !== 'object' ||
+        entry.message === null ||
+        Array.isArray(entry.message)) {
+        return null;
+    }
+    const id = entry.message.id;
+    return typeof id === 'string' && id.length > 0 ? id : null;
+}
+/** Claude transcripts may normalize one provider response into consecutive
+ *  assistant records with the same message.id. Keep the whole response on one
+ *  side of the compact boundary so thinking and tool siblings stay together. */
+function completeClaudeAssistantResponseBoundary(activeEntries, startIndex, lowerBound) {
+    const responseId = claudeAssistantResponseId(activeEntries[startIndex]);
+    if (responseId === null)
+        return startIndex;
+    let boundary = startIndex;
+    for (let index = startIndex - 1; index >= lowerBound; index -= 1) {
+        const candidate = activeEntries[index];
+        if (claudeAssistantResponseId(candidate) !== responseId)
+            break;
+        boundary = index;
+    }
+    return boundary;
+}
 /** Pulls the preserved-suffix boundary backward so a tool_use assistant entry
  *  and its tool_result user entry stay siblings: the suffix never opens with an
  *  orphaned tool_result and the compacted input never ends with a dangling
  *  tool_use. Same-response thinking/tool blocks live in one assistant entry,
  *  so entry-level cutting never splits them. */
-function completeClaudeToolPairBoundary(activeEntries, startIndex) {
+function completeClaudeToolPairBoundary(activeEntries, startIndex, lowerBound) {
     let boundary = startIndex;
     while (boundary < activeEntries.length) {
         const entry = activeEntries[boundary];
@@ -375,7 +403,7 @@ function completeClaudeToolPairBoundary(activeEntries, startIndex) {
         if (ids.size === 0)
             break;
         let extended = false;
-        for (let index = boundary - 1; index >= 0; index -= 1) {
+        for (let index = boundary - 1; index >= lowerBound; index -= 1) {
             const candidate = activeEntries[index];
             if (candidate && claudeAssistantHasToolUse(candidate, ids)) {
                 boundary = index;
@@ -390,11 +418,18 @@ function completeClaudeToolPairBoundary(activeEntries, startIndex) {
 }
 /** Walks back from the active tail to the inclusive start of the recent suffix
  *  retained verbatim, then completes sibling adjacency at the boundary. */
-function memoryPreservedSuffixStart(activeEntries) {
+export function memoryPreservedSuffixStart(activeEntries) {
+    let latestCompactBoundary = 0;
+    for (let index = activeEntries.length - 1; index >= 0; index -= 1) {
+        if (activeEntries[index]?.isCompactSummary === true) {
+            latestCompactBoundary = index;
+            break;
+        }
+    }
     let start = activeEntries.length;
     let textBearing = 0;
     let estimatedTokens = 0;
-    for (let index = activeEntries.length - 1; index >= 0; index -= 1) {
+    for (let index = activeEntries.length - 1; index >= latestCompactBoundary; index -= 1) {
         const entry = activeEntries[index];
         if (!entry)
             continue;
@@ -404,11 +439,13 @@ function memoryPreservedSuffixStart(activeEntries) {
         textBearing += 1;
         estimatedTokens += estimateModelRequestTokens(projectClaudeModelMessages([entry]));
         if (textBearing >= MEMORY_COMPACT_MIN_SUFFIX_MESSAGES &&
-            (estimatedTokens >= MEMORY_COMPACT_MIN_SUFFIX_TOKENS || index === 0)) {
+            (estimatedTokens >= MEMORY_COMPACT_MIN_SUFFIX_TOKENS ||
+                index === latestCompactBoundary)) {
             break;
         }
     }
-    return completeClaudeToolPairBoundary(activeEntries, start);
+    const toolSafeStart = completeClaudeToolPairBoundary(activeEntries, start, latestCompactBoundary);
+    return completeClaudeAssistantResponseBoundary(activeEntries, toolSafeStart, latestCompactBoundary);
 }
 function validPromptSuggestion(value) {
     const suggestion = value.trim();
@@ -558,6 +595,7 @@ export class ClaudeSessionService {
     activeCostSessionId;
     closeCostSavePromise;
     sessionMemoryControllers = new Map();
+    resolvedSessionMemoryProvider;
     hookLifecycle;
     runtimeCwd;
     constructor(options) {
@@ -708,6 +746,7 @@ export class ClaudeSessionService {
         await Promise.all([...this.backgroundNotificationWrites.values()]);
         this.hostedSubagents.clear();
         this.backgroundTasks.clear();
+        await Promise.all([...this.sessionMemoryControllers.values()].map((controller) => controller.close()));
         this.sessionMemoryControllers.clear();
         await this.workflowManager?.close();
         this.closeCostSavePromise ??= this.persistActiveSessionCost();
@@ -906,6 +945,7 @@ export class ClaudeSessionService {
                         (rightIndex < 0 ? preferredOrder.length : rightIndex));
                 });
             },
+            schedulingPolicy: (call) => resolveToolSchedulingPolicy(capabilityRegistry, call),
             prepare: (call, context) => capabilityRegistry.prepare(call, context),
             execute: (call, context) => capabilityRegistry.execute(call, context),
         };
@@ -2279,6 +2319,10 @@ export class ClaudeSessionService {
             const fileHistoryTools = fileHistory && interactiveMessageTools
                 ? {
                     definitions: () => interactiveMessageTools.definitions(),
+                    schedulingPolicy: (call) => ({
+                        ...resolveToolSchedulingPolicy(interactiveMessageTools, call),
+                        startAfterAssistant: true,
+                    }),
                     prepare: (call, context) => interactiveMessageTools.prepare(call, context),
                     execute: async (call, context) => {
                         const path = call.name === 'Write' || call.name === 'Edit'
@@ -2685,7 +2729,7 @@ export class ClaudeSessionService {
                     ];
                     const irreducible = budget.evaluate(irreducibleMessages, definitions);
                     budget.assertFits(irreducible);
-                    const logicalParentUuid = compactionAnchorUuid;
+                    let logicalParentUuid = compactionAnchorUuid;
                     if (!logicalParentUuid || historyMessages.length === 0) {
                         budget.assertFits(predicted);
                         throw new Error('Cannot compact an empty Claude transcript');
@@ -2693,8 +2737,17 @@ 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();
+                    const memorySelection = sessionMemory
+                        ? await this.selectMemoryPreservedCompact(sessionId, selectClaudeActiveTranscript(snapshot.entries))
+                        : null;
+                    const compactorMessages = memorySelection
+                        ? [
+                            memorySelection.memoryMessage,
+                            ...projectClaudeModelMessages(memorySelection.compactedEntries),
+                        ]
+                        : historyMessages;
+                    if (memorySelection) {
+                        logicalParentUuid = memorySelection.logicalParentUuid;
                     }
                     this.options.eventSink?.({ type: 'state', state: 'compacting' });
                     const compactEnvelope = budget.evaluate([
@@ -2716,7 +2769,7 @@ export class ClaudeSessionService {
                         targetTokens = 1;
                     }
                     const compacted = await (this.options.compactor ?? new ModelCompactor(provider)).compact({
-                        messages: historyMessages,
+                        messages: compactorMessages,
                         targetTokens,
                         contextWindowTokens: budget.contextWindowTokens,
                         ...(signal ? { signal } : {}),
@@ -2748,6 +2801,11 @@ export class ClaudeSessionService {
                             cwd: this.activeCwd(),
                             claudeVersion: this.options.claudeVersion,
                             gitBranch: null,
+                            ...(memorySelection
+                                ? {
+                                    preservedUuids: memorySelection.preservedEntries.flatMap((entry) => typeof entry.uuid === 'string' ? [entry.uuid] : []),
+                                }
+                                : {}),
                             createUuid: () => uuids.shift() ?? randomUUID(),
                             now: () => timestamp,
                         });
@@ -3032,7 +3090,7 @@ export class ClaudeSessionService {
                     toolResultDirectory,
                     observer,
                     ...(this.options.effort ? { effort: this.options.effort } : {}),
-                    ...(this.options.maxModelTurns
+                    ...(this.options.maxModelTurns !== undefined
                         ? { maxModelTurns: this.options.maxModelTurns }
                         : {}),
                     ...(this.options.betas?.length ? { betas: this.options.betas } : {}),
@@ -3270,21 +3328,25 @@ export class ClaudeSessionService {
                     });
                 }
                 if (sessionMemory && finalLeafUuid) {
-                    const turnInputTokens = result.usage?.inputTokens ?? 0;
-                    const warn = (error) => this.options.eventSink?.({
-                        type: 'warning',
-                        message: `Session memory extraction failed: ${error instanceof Error ? error.message : String(error)}`,
-                    });
+                    const memorySnapshot = projectClaudeModelMessages(snapshot.entries);
+                    const providerVisibleMessages = [
+                        ...contextMessages,
+                        ...injectTurnContext(memorySnapshot),
+                    ];
+                    const currentContextTokens = budget
+                        ? budget.evaluate(providerVisibleMessages, definitions)
+                            .occupancyTokens
+                        : estimateModelRequestTokens(providerVisibleMessages, definitions);
                     try {
-                        await sessionMemory.observeDelta(turnInputTokens, currentTurnToolCalls, finalLeafUuid, projectClaudeModelMessages(snapshot.entries));
-                        // Normal turns schedule extraction without awaiting it; failures
-                        // surface as a warning while the sidecar stays retryable.
-                        sessionMemory.waitForIdle().catch(warn);
+                        await sessionMemory.observeContext(currentContextTokens, currentTurnToolCalls, finalLeafUuid, memorySnapshot);
                     }
                     catch (error) {
                         // A failed observation must not fail the user turn; the sidecar
                         // retains a retryable error for the next observation.
-                        warn(error);
+                        this.options.eventSink?.({
+                            type: 'warning',
+                            message: `Session memory observation failed: ${error instanceof Error ? error.message : String(error)}`,
+                        });
                     }
                 }
                 turnCompleted = true;
@@ -3402,7 +3464,7 @@ export class ClaudeSessionService {
             return agentName;
         return null;
     }
-    /** Conservative selective-preservation seam for manual compact: when the
+    /** Conservative selective-preservation seam for full compact: when the
      *  durable session memory watermark matches an active entry, summarize the
      *  last good memory artifact plus the post-watermark branch and retain a
      *  recent suffix. Returns null to fall back to the existing full-compaction
@@ -3412,6 +3474,7 @@ export class ClaudeSessionService {
         const controller = this.sessionMemoryController(sessionId);
         if (controller === null)
             return null;
+        await controller.waitForCompact();
         let watermark = null;
         let memorySummary = '';
         try {
@@ -3437,11 +3500,18 @@ export class ClaudeSessionService {
             return null;
         const compactedEntries = activeEntries.slice(watermarkIndex + 1, suffixStart);
         const preservedEntries = activeEntries.slice(suffixStart);
-        const selectedMessages = projectClaudeModelMessages(compactedEntries);
-        if (selectedMessages.length === 0)
+        const preservedMessages = projectClaudeModelMessages(preservedEntries);
+        if (projectClaudeModelMessages(compactedEntries).length === 0)
             return null;
         const memoryMessage = { role: 'user', content: memorySummary };
-        if (estimateModelRequestTokens([memoryMessage, ...selectedMessages]) >
+        if (estimateModelRequestTokens([
+            {
+                role: 'user',
+                content: formatClaudeCompactSummary(''),
+            },
+            ...preservedMessages,
+        ]) +
+            MEMORY_COMPACT_MAX_SUMMARY_TOKENS >
             MEMORY_COMPACT_MAX_PROJECTION_TOKENS) {
             return null;
         }
@@ -4045,7 +4115,9 @@ export class ClaudeSessionService {
             return false;
         if (this.options.sessionPersistence === false)
             return false;
-        return true;
+        if (this.options.sessionKind === 'bg')
+            return false;
+        return this.sessionMemoryProviderFactory() !== null;
     }
     sessionMemoryController(sessionId) {
         if (!this.sessionMemoryEnabled() || !isClaudeSessionId(sessionId)) {
@@ -4059,7 +4131,11 @@ export class ClaudeSessionService {
                     sessionId,
                     sidecarRoot: this.paths(sessionId).praxisRoot,
                 }),
-                extractor: (input) => this.extractSessionMemory(sessionId, input),
+                extractor: (input) => this.extractSessionMemory(input),
+                onExtractionError: (error) => this.options.eventSink?.({
+                    type: 'warning',
+                    message: `Session memory extraction failed: ${error instanceof Error ? error.message : String(error)}`,
+                }),
             });
             this.sessionMemoryControllers.set(sessionId, controller);
         }
@@ -4110,10 +4186,16 @@ export class ClaudeSessionService {
                 parts.push(`Tool result: ${message.content}`);
             }
         }
-        return this.boundSessionMemorySummary(parts.join('\n\n'));
-    }
-    async extractSessionMemory(sessionId, input) {
-        const provider = this.provider();
+        // The successful watermark names the newest message in this snapshot, so
+        // extraction must receive every message in full. Summary injection remains
+        // bounded separately; provider refusal leaves the old watermark retryable.
+        return parts.join('\n\n');
+    }
+    async extractSessionMemory(input) {
+        const provider = this.sessionMemoryProvider();
+        if (provider === null) {
+            throw new SessionMemoryStateError('Session memory requires an isolated provider factory');
+        }
         const messages = [
             { role: 'system', content: SESSION_MEMORY_EXTRACTION_PROMPT },
             ...(input.summary.trim().length === 0
@@ -4133,8 +4215,11 @@ export class ClaudeSessionService {
                     },
                 ]),
         ];
-        const metrics = await completeMeteredModelRequest(provider, { messages }, {
-            onMetrics: (recorded) => this.recordAuxiliaryMetrics(sessionId, recorded),
+        // Session memory is operational side work: it never contributes to the
+        // foreground result or the persisted session cost/usage tracker.
+        const metrics = await completeMeteredModelRequest(provider, {
+            messages,
+            signal: input.signal,
         });
         if (metrics.toolCalls.length > 0) {
             throw new SessionMemoryStateError('Session memory extraction must not call tools');
@@ -4145,6 +4230,24 @@ export class ClaudeSessionService {
         }
         return summary;
     }
+    sessionMemoryProvider() {
+        if (this.resolvedSessionMemoryProvider !== undefined) {
+            return this.resolvedSessionMemoryProvider;
+        }
+        const factory = this.sessionMemoryProviderFactory();
+        this.resolvedSessionMemoryProvider = factory?.() ?? null;
+        return this.resolvedSessionMemoryProvider;
+    }
+    sessionMemoryProviderFactory() {
+        if (this.options.sessionMemoryProviderFactory) {
+            return this.options.sessionMemoryProviderFactory;
+        }
+        const selectProvider = this.options.providerForMainModel ?? this.options.providerForModel;
+        const foregroundModel = this.options.provider?.model;
+        return foregroundModel && selectProvider
+            ? () => selectProvider(foregroundModel)
+            : null;
+    }
     toolCapabilities() {
         const taskNames = this.options.taskToolNames ?? [];
         const input = {

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

@@ -45,6 +45,7 @@ export declare class StructuredOutputRegistry implements ToolRegistry {
         value: unknown;
     } | undefined);
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy(call: ModelToolCall): import("../core/runtime.js").ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }

package/dist/application/subagent-service.js

@@ -11,6 +11,7 @@ import { createClaudeHookAttachmentEntries, translateProviderEvents, } from '../
 import { injectFirstUserMessageContext, } from '../core/context.js';
 import { ContextBudget } from '../core/context-budget.js';
 import { AgentRuntime, } from '../core/runtime.js';
+import { resolveToolSchedulingPolicy } from '../core/tool-scheduling-policy.js';
 import { BUILTIN_STATUSLINE_AGENT_PATH, } from '../extensions/claude-extensions.js';
 import { ClaudeHookToolCoordinator } from '../hooks/claude-hook-tools.js';
 import { ClaudeSidechainStore } from '../persistence/claude-sidechain-store.js';
@@ -26,6 +27,7 @@ const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
 const SIDECHAIN_DISCOVERY_MAX_DEPTH = 4;
 const structuredOnlyTools = {
     definitions: () => [],
+    schedulingPolicy: () => ({ concurrency: 'exclusive' }),
     prepare: async (call) => call,
     execute: async () => ({ content: '', isError: false }),
 };
@@ -68,6 +70,12 @@ export class StructuredOutputRegistry {
                 ]),
         ];
     }
+    schedulingPolicy(call) {
+        if (call.name === 'StructuredOutput') {
+            return { concurrency: 'exclusive' };
+        }
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     prepare(call, context) {
         if (call.name !== 'StructuredOutput')
             return this.base.prepare(call, context);
@@ -106,6 +114,12 @@ class RestrictedToolRegistry {
             .definitions()
             .filter((definition) => this.allowed.has(definition.name));
     }
+    schedulingPolicy(call) {
+        if (!this.allowed.has(call.name)) {
+            return { concurrency: 'exclusive' };
+        }
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     prepare(call, context) {
         if (!this.allowed.has(call.name))
             throw new Error(`Tool ${call.name} is unavailable to this agent`);
@@ -1353,7 +1367,9 @@ export class ClaudeSubagentExecutor {
         const runtime = new AgentRuntime(options.provider, emit, {
             tools: runtimeTools,
             permissions: runtimePermissions,
-            maxModelTurns: customAgent?.maxTurns ?? 16,
+            ...(customAgent?.maxTurns === undefined
+                ? {}
+                : { maxModelTurns: customAgent.maxTurns }),
             maxModelOutputBytes: this.options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
             maxToolCallsPerTurn: 32,
             maxToolInputBytes: 1024 * 1024,
@@ -1647,6 +1663,12 @@ class ClaudeSubagentToolRegistry {
             ...ordinary.slice(insertionIndex),
         ];
     }
+    schedulingPolicy(call) {
+        if (['Agent', 'SendMessage', 'TaskOutput', 'TaskStop'].includes(call.name)) {
+            return { concurrency: 'exclusive', cancelOnInterrupt: true };
+        }
+        return resolveToolSchedulingPolicy(this.base, call);
+    }
     async prepare(call, context) {
         if (call.name === 'Agent')
             return this.executor.prepare(call, this.depth);

package/dist/cli-runtime.d.ts

@@ -178,6 +178,10 @@ export interface CliDependencies extends InteractiveServiceFactory {
  * to the existing default behavior (undefined).
  */
 export declare function resolveRuntimeModel(explicitModel: string | undefined, environment: NodeJS.ProcessEnv, settings: PraxisRuntimeSettings | undefined): string | undefined;
+/** Builds the default CLI's isolated Session-memory adapter seam. Each
+ * invocation reconstructs the selected main-model provider stack instead of
+ * sharing foreground adapter-local cache and retry state. */
+export declare function createSessionMemoryProviderFactory(providerForMainModel: ((model: string) => ModelProvider) | undefined, model: string | undefined): (() => ModelProvider) | undefined;
 export declare function resolveInteractiveRuntimeSettingsLocation(dataPlane: DataPlane, environment?: NodeJS.ProcessEnv): {
     configRoot: string;
     statePath: string;

package/dist/cli-runtime.js

@@ -749,6 +749,14 @@ export function resolveRuntimeModel(explicitModel, environment, settings) {
         (envModel !== undefined && envModel.trim() !== '' ? envModel : undefined) ??
         settingsModel);
 }
+/** Builds the default CLI's isolated Session-memory adapter seam. Each
+ * invocation reconstructs the selected main-model provider stack instead of
+ * sharing foreground adapter-local cache and retry state. */
+export function createSessionMemoryProviderFactory(providerForMainModel, model) {
+    if (!providerForMainModel || !model)
+        return undefined;
+    return () => providerForMainModel(model);
+}
 export function resolveInteractiveRuntimeSettingsLocation(dataPlane, environment = process.env) {
     const configRoot = resolveDataPlaneRoot({ dataPlane, environment });
     return {
@@ -854,6 +862,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         projectIdentity: await resolveClaudeProjectIdentity({ cwd }),
         sidecarPath: resolveUnknownCostSidecarPath(dataPlane, configRoot),
     });
+    const sessionMemoryProviderFactory = createSessionMemoryProviderFactory(providerForMainModel, model);
     const options = {
         configRoot,
         dataPlane,
@@ -879,6 +888,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : { maxBudgetUsd: cli.maxBudgetUsd }),
         pricing: ModelPricingRegistry.fromEnvironment(runtimeEnvironment.PRAXIS_PRICING_JSON),
         collectMetrics: true,
+        ...(sessionMemoryProviderFactory ? { sessionMemoryProviderFactory } : {}),
         ...(sessionKind === undefined ? {} : { sessionKind }),
         workspace,
         ...(cli.worktreeRequested

package/dist/core/runtime.d.ts

@@ -322,8 +322,15 @@ export interface ToolExecutionContext {
     permissionPhase?: 'request' | 'execute';
     permissionApproved?: boolean;
 }
+export interface ToolSchedulingPolicy {
+    concurrency: 'concurrent' | 'exclusive';
+    cancelOnInterrupt?: boolean;
+    abortGroupOnError?: boolean;
+    startAfterAssistant?: boolean;
+}
 export interface ToolRegistry {
     definitions(): readonly ModelToolDefinition[];
+    schedulingPolicy?(call: ModelToolCall): ToolSchedulingPolicy;
     prepare(call: ModelToolCall, context: ToolExecutionContext): Promise<ModelToolCall>;
     execute(call: ModelToolCall, context: ToolExecutionContext): Promise<ToolExecutionResult>;
 }
@@ -514,6 +521,9 @@ export declare class AgentRuntime {
     recoverToolCalls(calls: readonly ModelToolCall[], request: AgentToolRecoveryRequest): Promise<ToolExecutionResult[]>;
     executeDirectToolCall(call: ModelToolCall, request: AgentToolRecoveryRequest): Promise<ToolExecutionResult>;
     private completeToolCall;
+    private executeScheduledToolCall;
+    private presentToolResult;
+    private persistToolCall;
     private executeTool;
     private requireRecoveryApproval;
     private cancel;