praxis-agent 0.28.0 → 0.30.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

@@ -756,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;
@@ -996,6 +1006,7 @@ export class ClaudeSessionService {
         }
         const assembledContext = await this.options.contextAssembler?.assemble({
             cwd: this.activeCwd(),
+            lifecycleId: activeSessionId,
         });
         const messages = [
             ...(assembledContext?.systemMessages ?? []),
@@ -1106,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,
@@ -1410,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) {
@@ -1791,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) {
@@ -1799,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}`);
@@ -1810,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) {
@@ -2442,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,
@@ -2584,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',
@@ -2614,7 +2711,7 @@ export class ClaudeSessionService {
                                 },
                             ]
                             : []),
-                        ...(this.options.structuredOutputSchema
+                        ...(!hasPromptManifest && this.options.structuredOutputSchema
                             ? [
                                 {
                                     role: 'system',
@@ -2915,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',
@@ -3086,6 +3187,9 @@ export class ClaudeSessionService {
                         ...contextMessages,
                         ...injectTurnContext(projectClaudeModelMessages(snapshot.entries)),
                     ],
+                    ...(stableSystemMessageCount === undefined
+                        ? {}
+                        : { stableSystemMessageCount }),
                     cwd: this.activeCwd(),
                     toolResultDirectory,
                     observer,
@@ -3099,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)),
@@ -3213,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.js

@@ -1493,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,
                 ];

package/dist/application/top-level-agent-manager.js

@@ -30,6 +30,14 @@ const WORKER_RUNTIME_ENVIRONMENT = [
     'PRAXIS_MAX_OUTPUT_TOKENS',
     'PRAXIS_ANTHROPIC_VERSION',
     'PRAXIS_ANTHROPIC_WEB_SEARCH',
+    'PRAXIS_ANTHROPIC_PROMPT_CACHING',
+    'PRAXIS_ANTHROPIC_PROMPT_CACHE_TTL',
+    'DISABLE_PROMPT_CACHING',
+    'DISABLE_PROMPT_CACHING_HAIKU',
+    'DISABLE_PROMPT_CACHING_SONNET',
+    'DISABLE_PROMPT_CACHING_OPUS',
+    'ENABLE_PROMPT_CACHING_1H',
+    'FORCE_PROMPT_CACHING_5M',
     'PRAXIS_CONTEXT_WINDOW_TOKENS',
     'PRAXIS_CONTEXT_RESERVE_TOKENS',
     'PRAXIS_PRICING_JSON',

package/dist/cli-runtime.js

@@ -39,6 +39,7 @@ import { writeFileAtomically } from './platform/atomic-write.js';
 import { detectInstalledClaudeVersion } from './platform/claude-version.js';
 import { redactSensitiveText, sensitiveEnvironmentValues, } from './platform/sensitive-data.js';
 import { AnthropicCompatibleProvider } from './providers/anthropic-compatible.js';
+import { createAnthropicPromptCachePolicyResolver } from './providers/anthropic-prompt-cache.js';
 import { FallbackModelProvider } from './providers/fallback-provider.js';
 import { OpenAICompatibleProvider } from './providers/openai-compatible.js';
 import { parseContextEnvironment, parseProviderEnvironment, } from './providers/environment.js';
@@ -89,34 +90,37 @@ function fileResourceHeaders(environment, providerEnvironment, credential) {
             : {}),
     };
 }
-function createProviderForModel(apiKey, providerEnvironment, context, controls, explicitThinkingControls) {
+function createProviderForModel({ apiKey, environment, dataPlane, provider, context, controls, explicitThinkingControls, }) {
+    const resolvePromptCachePolicy = createAnthropicPromptCachePolicyResolver(environment, dataPlane);
     return (selectedModel) => {
         const providerOptions = {
             apiKey,
             model: selectedModel,
-            baseUrl: providerEnvironment.baseUrl,
+            baseUrl: provider.baseUrl,
             ...('contextWindowTokens' in context
                 ? { contextWindowTokens: context.contextWindowTokens }
                 : {}),
         };
-        return providerEnvironment.provider === 'anthropic'
+        return provider.provider === 'anthropic'
             ? new AnthropicCompatibleProvider({
                 ...providerOptions,
+                promptCaching: resolvePromptCachePolicy({
+                    baseUrl: provider.baseUrl,
+                    model: selectedModel,
+                }),
                 thinking: {
                     mode: controls.thinking ?? 'enabled',
                     ...(controls.maxThinkingTokens === undefined
                         ? {}
                         : { maxTokens: controls.maxThinkingTokens }),
                 },
-                ...('maxOutputTokens' in providerEnvironment
-                    ? { maxOutputTokens: providerEnvironment.maxOutputTokens }
-                    : {}),
-                ...('anthropicVersion' in providerEnvironment
-                    ? { anthropicVersion: providerEnvironment.anthropicVersion }
+                ...('maxOutputTokens' in provider
+                    ? { maxOutputTokens: provider.maxOutputTokens }
                     : {}),
-                ...('webSearch' in providerEnvironment
-                    ? { webSearch: providerEnvironment.webSearch }
+                ...('anthropicVersion' in provider
+                    ? { anthropicVersion: provider.anthropicVersion }
                     : {}),
+                ...('webSearch' in provider ? { webSearch: provider.webSearch } : {}),
             })
             : new OpenAICompatibleProvider({
                 ...providerOptions,
@@ -245,6 +249,8 @@ Provider environment:
   PRAXIS_PROVIDER=openai|anthropic, PRAXIS_API_KEY, PRAXIS_MODEL
   PRAXIS_BASE_URL, PRAXIS_MAX_OUTPUT_TOKENS, PRAXIS_ANTHROPIC_VERSION
   PRAXIS_ANTHROPIC_WEB_SEARCH=true|false
+  PRAXIS_ANTHROPIC_PROMPT_CACHING=true|false
+  PRAXIS_ANTHROPIC_PROMPT_CACHE_TTL=5m|1h
   PRAXIS_CONTEXT_WINDOW_TOKENS, PRAXIS_CONTEXT_RESERVE_TOKENS
 `;
 const AGENTS_HELP = `Usage: praxis agents [options]
@@ -802,12 +808,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,
@@ -843,7 +843,15 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         if (!providerEnvironment) {
             throw new Error('Provider environment is unavailable');
         }
-        providerForModel = createProviderForModel(apiKey, providerEnvironment, context, cli, controls);
+        providerForModel = createProviderForModel({
+            apiKey,
+            environment: runtimeEnvironment,
+            dataPlane,
+            provider: providerEnvironment,
+            context,
+            controls: cli,
+            explicitThinkingControls: controls,
+        });
         const createProvider = providerForModel;
         providerForMainModel = (primaryModel) => {
             const models = [primaryModel, ...(cli.fallbackModels ?? [])].filter((candidate, index, all) => all.indexOf(candidate) === index);
@@ -1175,6 +1183,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 +1228,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 +1384,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 +1467,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,
             }),
@@ -1674,7 +1719,16 @@ const createDefaultAutoModeCritic = async ({ model, dataPlane, configRoot, state
     if (!apiKey || !selectedModel) {
         throw new Error('PRAXIS_API_KEY and a model (--model or PRAXIS_MODEL) are required');
     }
-    return createProviderForModel(apiKey, parseProviderEnvironment(process.env), parseContextEnvironment(process.env), {}, {})(selectedModel);
+    const providerEnvironment = parseProviderEnvironment(process.env);
+    return createProviderForModel({
+        apiKey,
+        environment: process.env,
+        dataPlane: resolvedDataPlane,
+        provider: providerEnvironment,
+        context: parseContextEnvironment(process.env),
+        controls: {},
+        explicitThinkingControls: {},
+    })(selectedModel);
 };
 const defaultPluginEvalRuntimeFactory = {
     create: async (options) => {
@@ -1774,7 +1828,16 @@ const defaultPluginEvalJudge = {
         const apiKey = environment.PRAXIS_API_KEY;
         if (!apiKey)
             throw new Error('PRAXIS_API_KEY is required for paid eval graders');
-        const provider = createProviderForModel(apiKey, parseProviderEnvironment(environment), parseContextEnvironment(environment), {}, {})(model);
+        const providerEnvironment = parseProviderEnvironment(environment);
+        const provider = createProviderForModel({
+            apiKey,
+            environment,
+            dataPlane: resolveDataPlane(environment),
+            provider: providerEnvironment,
+            context: parseContextEnvironment(environment),
+            controls: {},
+            explicitThinkingControls: {},
+        })(model);
         const prompt = `You are an eval judge. Return only JSON matching {"passed":boolean,"explanation":string}.
 
 Criteria:

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