praxis-agent 0.27.0 → 0.29.0

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

@@ -208,6 +208,7 @@ export declare class ClaudeSessionService {
     private applyPermissionUpdates;
     close(): Promise<void>;
     transitionHookSession(sessionId: string, reason: Exclude<HookSessionEndReason, 'other'>): Promise<void>;
+    reloadContextResources(sessionId: string): void;
     createHostedToolRegistry(sessionId: string): ToolRegistry;
     run(prompt: string, signal?: AbortSignal, sessionId?: string, name?: string, images?: readonly ModelImage[], documents?: readonly ModelDocument[]): Promise<SessionRunResult>;
     runShell(command: string, signal?: AbortSignal, sessionId?: string, name?: string): Promise<SessionRunResult>;

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 }),
 };
@@ -754,6 +756,16 @@ export class ClaudeSessionService {
     }
     async transitionHookSession(sessionId, reason) {
         await this.hookLifecycle.transition(sessionId, reason);
+        this.options.contextAssembler?.invalidate?.({
+            lifecycleId: sessionId,
+            reason: reason === 'resume' ? 'restore' : 'clear',
+        });
+    }
+    reloadContextResources(sessionId) {
+        this.options.contextAssembler?.invalidate?.({
+            lifecycleId: sessionId,
+            reason: 'resource-reload',
+        });
     }
     createHostedToolRegistry(sessionId) {
         const baseTools = this.options.tools;
@@ -943,6 +955,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),
         };
@@ -993,6 +1006,7 @@ export class ClaudeSessionService {
         }
         const assembledContext = await this.options.contextAssembler?.assemble({
             cwd: this.activeCwd(),
+            lifecycleId: activeSessionId,
         });
         const messages = [
             ...(assembledContext?.systemMessages ?? []),
@@ -1103,13 +1117,18 @@ export class ClaudeSessionService {
         const agent = this.resolveAgent(agentName);
         const provider = this.providerForAgent(agent);
         this.activeProvider = provider;
+        const agentSystem = await this.mainAgentSystemPrompt(agent);
         const assembledContext = await this.options.contextAssembler?.assemble({
             cwd: this.activeCwd(),
+            lifecycleId: sessionId,
+            ...(agentSystem ? { mode: 'agent', baseSystemPrompt: agentSystem } : {}),
         });
-        const agentSystem = await this.mainAgentSystemPrompt(agent);
-        const assembledSystemMessages = this.assembledSystemMessages(agent, assembledContext?.systemMessages ?? []);
+        const hasPromptManifest = assembledContext?.promptSections !== undefined;
+        const assembledSystemMessages = hasPromptManifest
+            ? (assembledContext?.systemMessages ?? [])
+            : this.assembledSystemMessages(agent, assembledContext?.systemMessages ?? []);
         const contextMessages = [
-            ...(agentSystem
+            ...(!hasPromptManifest && agentSystem
                 ? [{ role: 'system', content: agentSystem }]
                 : []),
             ...assembledSystemMessages,
@@ -1407,12 +1426,22 @@ export class ClaudeSessionService {
             this.sessionCwds.set(sessionId, cwd);
             this.runtimeCwd = cwd;
             this.options.workspace?.setCwd(cwd);
+            this.options.contextAssembler?.invalidate?.({
+                lifecycleId: sessionId,
+                reason: 'cwd',
+            });
             return cwd;
         }
         this.runtimeCwd = cwd;
         this.options.workspace?.setCwd(cwd);
         if (sessionId)
             this.sessionCwds.set(sessionId, cwd);
+        if (sessionId) {
+            this.options.contextAssembler?.invalidate?.({
+                lifecycleId: sessionId,
+                reason: 'cwd',
+            });
+        }
         return cwd;
     }
     async recordCdUsage(sessionId) {
@@ -1788,6 +1817,10 @@ export class ClaudeSessionService {
         if (result.status === 'conflict') {
             throw new Error('Generated Claude fork session already exists');
         }
+        this.options.contextAssembler?.invalidate?.({
+            lifecycleId: sessionId,
+            reason: 'fork',
+        });
         return { sessionId, parentSessionId };
     }
     async ensureFork(parentSessionId, sessionId, checkpoint) {
@@ -1796,8 +1829,13 @@ export class ClaudeSessionService {
         const expected = await this.nativeForkEntries(parentSessionId, sessionId, checkpoint?.resumeSessionAt, checkpoint?.entryCount);
         const target = this.store(sessionId);
         const created = await target.create(expected);
-        if (created.status === 'created')
+        if (created.status === 'created') {
+            this.options.contextAssembler?.invalidate?.({
+                lifecycleId: sessionId,
+                reason: 'fork',
+            });
             return { sessionId, parentSessionId };
+        }
         const existing = await target.withLease((lease) => lease.load());
         if (existing.status === 'conflict') {
             throw new Error(`Claude transcript fork conflict: ${existing.reason}`);
@@ -1807,6 +1845,10 @@ export class ClaudeSessionService {
                 JSON.stringify(entry))) {
             throw new Error('Claude handoff target is not the expected native fork');
         }
+        this.options.contextAssembler?.invalidate?.({
+            lifecycleId: sessionId,
+            reason: 'fork',
+        });
         return { sessionId, parentSessionId };
     }
     async nativeForkEntries(parentSessionId, sessionId, resumeSessionAt, sourceEntryCount) {
@@ -2316,6 +2358,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'
@@ -2435,6 +2481,10 @@ export class ClaudeSessionService {
                     currentTurnToolCalls += 1;
                     const transition = this.worktreeManager?.consumeTransition(call.id);
                     if (transition) {
+                        this.options.contextAssembler?.invalidate?.({
+                            lifecycleId: sessionId,
+                            reason: 'worktree',
+                        });
                         const stateEntry = {
                             type: 'worktree-state',
                             worktreeSession: transition.state,
@@ -2577,29 +2627,83 @@ export class ClaudeSessionService {
                 let planModeMessage;
                 let sessionMemoryMessage = null;
                 let contextMessages = [];
+                let stableSystemMessageCount;
                 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 = [
+                    const additionalSections = [
+                        ...(planModeMessage
+                            ? [
+                                {
+                                    id: 'plan-mode',
+                                    placement: 'system',
+                                    stability: 'volatile',
+                                    content: planModeMessage,
+                                },
+                            ]
+                            : []),
+                        ...(sessionMemoryMessage
+                            ? [
+                                {
+                                    id: 'session-memory',
+                                    placement: 'system',
+                                    stability: 'volatile',
+                                    content: sessionMemoryMessage,
+                                },
+                            ]
+                            : []),
+                        ...(this.options.brief
+                            ? [
+                                {
+                                    id: 'brief-output',
+                                    placement: 'system',
+                                    stability: 'volatile',
+                                    content: CLAUDE_USER_MESSAGE_PROMPT,
+                                },
+                            ]
+                            : []),
+                        ...(this.options.structuredOutputSchema
+                            ? [
+                                {
+                                    id: 'structured-output',
+                                    placement: 'system',
+                                    stability: 'volatile',
+                                    content: 'You MUST call StructuredOutput exactly once at the end with a value matching the requested JSON Schema.',
+                                },
+                            ]
+                            : []),
+                    ];
+                    assembledContext = await this.options.contextAssembler?.assemble({
+                        cwd: this.activeCwd(),
+                        lifecycleId: sessionId,
                         ...(agentSystem
+                            ? { mode: 'agent', baseSystemPrompt: agentSystem }
+                            : {}),
+                        additionalSections,
+                    });
+                    const hasPromptManifest = assembledContext?.promptSections !== undefined;
+                    stableSystemMessageCount = hasPromptManifest
+                        ? assembledContext?.stableSystemSectionCount
+                        : undefined;
+                    const assembledSystemMessages = hasPromptManifest
+                        ? (assembledContext?.systemMessages ?? [])
+                        : this.assembledSystemMessages(agent, assembledContext?.systemMessages ?? []);
+                    contextMessages = [
+                        ...(!hasPromptManifest && agentSystem
                             ? [{ role: 'system', content: agentSystem }]
                             : []),
                         ...assembledSystemMessages,
-                        ...(planModeMessage
+                        ...(!hasPromptManifest && planModeMessage
                             ? [{ role: 'system', content: planModeMessage }]
                             : []),
-                        ...(sessionMemoryMessage
+                        ...(!hasPromptManifest && sessionMemoryMessage
                             ? [{ role: 'system', content: sessionMemoryMessage }]
                             : []),
-                        ...(this.options.brief
+                        ...(!hasPromptManifest && this.options.brief
                             ? [
                                 {
                                     role: 'system',
@@ -2607,7 +2711,7 @@ export class ClaudeSessionService {
                                 },
                             ]
                             : []),
-                        ...(this.options.structuredOutputSchema
+                        ...(!hasPromptManifest && this.options.structuredOutputSchema
                             ? [
                                 {
                                     role: 'system',
@@ -2908,6 +3012,10 @@ export class ClaudeSessionService {
                         if (outcome)
                             await recordHookOutcome(outcome);
                     }
+                    this.options.contextAssembler?.invalidate?.({
+                        lifecycleId: sessionId,
+                        reason: 'compact',
+                    });
                     await refreshRuntimeContext();
                     this.options.eventSink?.({
                         type: 'compact-boundary',
@@ -3079,11 +3187,14 @@ export class ClaudeSessionService {
                         ...contextMessages,
                         ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
                     ],
+                    ...(stableSystemMessageCount === undefined
+                        ? {}
+                        : { stableSystemMessageCount }),
                     cwd: this.activeCwd(),
                     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 } : {}),
@@ -3092,6 +3203,12 @@ export class ClaudeSessionService {
                         : {}),
                     reloadMessages: async () => {
                         await compactIfNeeded([], currentTurnUserMessages ?? []);
+                        if (stableSystemMessageCount === undefined) {
+                            delete runtimeRequest.stableSystemMessageCount;
+                        }
+                        else {
+                            runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
+                        }
                         return [
                             ...contextMessages,
                             ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
@@ -3206,6 +3323,12 @@ export class ClaudeSessionService {
                         ...contextMessages,
                         ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
                     ];
+                    if (stableSystemMessageCount === undefined) {
+                        delete runtimeRequest.stableSystemMessageCount;
+                    }
+                    else {
+                        runtimeRequest.stableSystemMessageCount = stableSystemMessageCount;
+                    }
                     try {
                         result = await attemptMainTurn();
                     }

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,
@@ -1477,10 +1493,16 @@ export class ClaudeSubagentExecutor {
             const assembleMessages = async () => {
                 const assembledContext = await this.options.contextAssembler?.assemble({
                     cwd,
+                    lifecycleId: options.agentId,
+                    mode: 'subagent',
+                    baseSystemPrompt: system,
                 });
+                const composedSubagentPolicy = assembledContext?.promptSections?.some((section) => section.id === 'subagent-policy');
                 const messages = [
                     ...(assembledContext?.systemMessages ?? []),
-                    { role: 'system', content: system },
+                    ...(composedSubagentPolicy
+                        ? []
+                        : [{ role: 'system', content: system }]),
                     ...injectFirstUserMessageContext(projectClaudeModelMessages(snapshot.entries), assembledContext?.firstUserMessageContext),
                     ...preloadedSkills,
                 ];
@@ -1647,6 +1669,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.js

@@ -802,12 +802,6 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ? {}
             : { permissionMode: interactivePermissionMode }),
     }, cwd);
-    const effectiveAppendSystemPrompt = [
-        runtimeSettingsPrompt,
-        cli.appendSystemPrompt,
-    ]
-        .filter((value) => value !== undefined)
-        .join('\n');
     const debug = cli.debug !== undefined || cli.debugFile !== undefined
         ? createCliDebugSink(eventSink, {
             cwd,
@@ -1175,6 +1169,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         });
         return filterDisabledMcpResources(candidates, await management.disabled());
     };
+    let contextAssembler;
     const mcpTools = await ClaudeMcpToolRegistry.connect({
         base: simpleMode
             ? localTools
@@ -1219,6 +1214,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         configRoot,
         onWarning: (message) => runtimeEventSink({ type: 'warning', message }),
         onPromptsChanged: (prompts) => extensions.setMcpPrompts(prompts),
+        onInstructionsChanged: () => contextAssembler?.invalidate({ reason: 'tool-pool' }),
         authenticateServer: async (name) => {
             const record = await new ClaudeMcpManagement({
                 dataPlane,
@@ -1374,6 +1370,54 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 },
             })
             : undefined;
+        contextAssembler = new ClaudeContextAssembler({
+            loadResources: loadContextResources,
+            loadDynamicContext: (runtimeCwd = workspace.cwd()) => loadClaudeDynamicContext({
+                cwd: runtimeCwd,
+                ...(memoryDirectory ? { memoryDirectory } : {}),
+            }),
+            loadMcpInstructions: async () => mcpTools.instructions(),
+            loadSessionGuidance: async () => {
+                const toolNames = [
+                    ...new Set([
+                        ...filteredTools.definitions().map((definition) => definition.name),
+                        ...selectedTaskRuntimeTools,
+                        ...selectedScheduledTools,
+                        ...selectedWorkflowTools,
+                        ...selectedWorktreeTools,
+                        ...selectedInteractiveTools,
+                        ...(enableSubagents ? selectedAgentTools : []),
+                    ]),
+                ].sort();
+                const skillNames = extensions
+                    .modelInvocableSkills()
+                    .map((skill) => skill.name)
+                    .sort();
+                if (toolNames.length === 0 &&
+                    skillNames.length === 0 &&
+                    runtimeSettingsPrompt === undefined)
+                    return undefined;
+                return [
+                    '# Session capabilities',
+                    ...(toolNames.length > 0
+                        ? [`Enabled tools: ${toolNames.join(', ')}`]
+                        : []),
+                    ...(skillNames.length > 0
+                        ? [`Model-invocable skills: ${skillNames.join(', ')}`]
+                        : []),
+                    'Use a capability only when it directly helps complete the request, and follow its declared input contract.',
+                    ...(runtimeSettingsPrompt ? ['', runtimeSettingsPrompt] : []),
+                ].join('\n');
+            },
+            excludeDynamicSystemPromptSections: cli.excludeDynamicSystemPromptSections,
+            ...(cli.systemPrompt === undefined
+                ? {}
+                : { systemPrompt: cli.systemPrompt }),
+            ...(cli.appendSystemPrompt
+                ? { appendSystemPrompt: cli.appendSystemPrompt }
+                : {}),
+            ...(simpleMode ? { bare: true } : {}),
+        });
         const service = new ClaudeSessionService({
             ...options,
             provider: hostedToolProvider,
@@ -1409,20 +1453,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ...(interactiveTools ? { interactiveTools } : {}),
             ...(hooks ? { hooks } : {}),
             ...(selectedMainAgent ? { agent: selectedMainAgent } : {}),
-            contextAssembler: new ClaudeContextAssembler({
-                loadResources: loadContextResources,
-                loadDynamicContext: (runtimeCwd = workspace.cwd()) => loadClaudeDynamicContext({
-                    cwd: runtimeCwd,
-                    ...(memoryDirectory ? { memoryDirectory } : {}),
-                }),
-                excludeDynamicSystemPromptSections: cli.excludeDynamicSystemPromptSections,
-                ...(cli.systemPrompt === undefined
-                    ? {}
-                    : { systemPrompt: cli.systemPrompt }),
-                ...(effectiveAppendSystemPrompt
-                    ? { appendSystemPrompt: effectiveAppendSystemPrompt }
-                    : {}),
-            }),
+            contextAssembler,
             conditionalRuleResolver: new ClaudeConditionalRuleResolver({
                 loadResources: loadContextResources,
             }),

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

@@ -1,12 +1,20 @@
-import type { AssembledContext, ContextAssembler } from '../../core/context.js';
+import type { AssembledContext, ContextAssembler, ContextAssemblyOptions, ContextInvalidationOptions } from '../../core/context.js';
 import { type ClaudeDynamicContextSections } from './dynamic-context.js';
 import type { ClaudeContextResources, ClaudeConditionalRule } from './shared-resources.js';
 export interface ClaudeContextAssemblerOptions {
     loadResources(cwd?: string): Promise<ClaudeContextResources>;
     loadDynamicContext?(cwd?: string): Promise<ClaudeDynamicContextSections>;
+    loadMcpInstructions?(): Promise<readonly ClaudeMcpInstruction[]>;
+    loadSessionGuidance?(): Promise<string | undefined>;
     excludeDynamicSystemPromptSections?: boolean;
     systemPrompt?: string;
     appendSystemPrompt?: string;
+    bare?: boolean;
+    now?(): Date;
+}
+export interface ClaudeMcpInstruction {
+    server: string;
+    instructions: string;
 }
 export type ClaudeConditionalRuleResolverOptions = ClaudeContextAssemblerOptions;
 export declare class ClaudeConditionalRuleResolver {
@@ -16,9 +24,16 @@ export declare class ClaudeConditionalRuleResolver {
 }
 export declare class ClaudeContextAssembler implements ContextAssembler {
     private readonly options;
+    private readonly composer;
+    private readonly snapshots;
     constructor(options: ClaudeContextAssemblerOptions);
-    assemble(options?: {
-        cwd?: string;
-    }): Promise<AssembledContext>;
+    assemble(options?: ContextAssemblyOptions): Promise<AssembledContext>;
+    invalidate(options: ContextInvalidationOptions): void;
+    private snapshot;
+    private loadResources;
+    private loadDynamicContext;
+    private loadMcpInstructions;
+    private loadSessionGuidance;
+    private currentDate;
 }
 //# sourceMappingURL=context.d.ts.map