praxis-agent 0.55.0 → 0.55.2

package/README.md

@@ -347,7 +347,7 @@ normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run test:coverage` measures all production code under `src/**` with V8 and
 enforces global floors of 79% statements, 70% branches, 85% functions, and 81% lines,
 and rejects any production runtime module with zero covered statements (while allowing
-type-only modules). `npm run test:fixtures` executes the 70-behavior native contract; 62 behaviors
+type-only modules). `npm run test:fixtures` executes the 71-behavior native contract; 63 behaviors
 are qualified and 8 are explicitly excluded. `npm run verify:fixture-contracts`
 performs the structural check and is part of `npm run check`.
 `npm run test:core-completion` is retained as a compatibility alias for

package/dist/application/context-engine.js

@@ -1,5 +1,6 @@
 import { AgentRunCancelledError, } from '../core/runtime.js';
 import { contextRecoveryMadeProgress, isPromptTooLongError, } from '../core/context-budget.js';
+import { StaleContextGenerationError } from './context-preparation.js';
 function assertSignal(signal) {
     if (signal?.aborted)
         throw new AgentRunCancelledError();
@@ -95,7 +96,9 @@ export class ContextEngine {
             return { kind: 'retry', envelope: proposal.envelope };
         }
         catch (cause) {
-            if (signal?.aborted || cause instanceof AgentRunCancelledError)
+            if (signal?.aborted ||
+                cause instanceof AgentRunCancelledError ||
+                cause instanceof StaleContextGenerationError)
                 throw cause;
             return { kind: 'exhausted', error };
         }

package/dist/application/context-preparation.d.ts

@@ -0,0 +1,60 @@
+import { type ContextAssembler, type ContextAssemblyOptions } from '../core/context.js';
+import type { ModelMessage, ModelToolDefinition } from '../core/runtime.js';
+import type { ContextEnvelope } from './context-engine.js';
+export interface ContextPreparationProjection {
+    readonly generation: number;
+    readonly envelope: ContextEnvelope;
+    readonly stableSystemMessageCount: number;
+}
+export interface ContextPreparationSources {
+    readonly history: () => readonly ModelMessage[];
+    readonly memory: () => readonly ModelMessage[];
+    readonly activeTools: () => readonly ModelToolDefinition[];
+}
+export interface ContextPreparationProjectOptions {
+    readonly includeHistory?: boolean;
+    readonly includeMemory?: boolean;
+    readonly pendingMessages?: readonly ModelMessage[];
+}
+export interface ContextHistoryReplacement {
+    readonly generation: number;
+    readonly envelope: ContextEnvelope;
+    readonly stableSystemMessageCount: number;
+    commit<T>(replace: () => Promise<T>): Promise<{
+        generation: number;
+        value: T;
+    }>;
+}
+export declare class StaleContextGenerationError extends Error {
+    readonly expectedGeneration: number;
+    readonly actualGeneration: number;
+    constructor(expectedGeneration: number, actualGeneration: number);
+}
+export interface ContextPreparationOptions {
+    readonly assembler?: ContextAssembler;
+    readonly sources: ContextPreparationSources;
+    readonly agentMentions?: () => {
+        readonly prompt: string;
+        readonly messages: readonly string[];
+    };
+    readonly initialGeneration?: number;
+}
+/** Owns provider-visible context projection and guarded history replacement. */
+export declare class ContextPreparation {
+    private readonly assembler;
+    private readonly sources;
+    private readonly agentMentions;
+    private generation;
+    private prepared;
+    private replacementQueue;
+    constructor(options: ContextPreparationOptions);
+    refresh(options?: ContextAssemblyOptions): Promise<void>;
+    project(options?: ContextPreparationProjectOptions): ContextPreparationProjection;
+    proposeHistoryReplacement(input: {
+        readonly historyMessages: readonly ModelMessage[];
+        readonly pendingMessages?: readonly ModelMessage[];
+    }): ContextHistoryReplacement;
+    private projectWithMessages;
+    private decorate;
+}
+//# sourceMappingURL=context-preparation.d.ts.map

package/dist/application/context-preparation.js

@@ -0,0 +1,139 @@
+import { injectFirstUserMessageContext, projectContextSnapshot, } from '../core/context.js';
+import { assembleContextSnapshot } from '../core/prompt-composer.js';
+export class StaleContextGenerationError extends Error {
+    expectedGeneration;
+    actualGeneration;
+    constructor(expectedGeneration, actualGeneration) {
+        super(`Stale context generation: expected ${expectedGeneration}, actual ${actualGeneration}; prepare a new history replacement`);
+        this.name = 'StaleContextGenerationError';
+        this.expectedGeneration = expectedGeneration;
+        this.actualGeneration = actualGeneration;
+    }
+}
+function validateGeneration(generation) {
+    if (!Number.isSafeInteger(generation) || generation < 1) {
+        throw new TypeError('Context generation must be a positive safe integer');
+    }
+}
+function cloneTools(tools) {
+    return tools.map((tool) => ({ ...tool }));
+}
+/** Owns provider-visible context projection and guarded history replacement. */
+export class ContextPreparation {
+    assembler;
+    sources;
+    agentMentions;
+    generation;
+    prepared;
+    replacementQueue = Promise.resolve();
+    constructor(options) {
+        this.assembler = options.assembler;
+        this.sources = options.sources;
+        this.agentMentions = options.agentMentions;
+        this.generation = options.initialGeneration ?? 1;
+        validateGeneration(this.generation);
+    }
+    async refresh(options = {}) {
+        const snapshot = await assembleContextSnapshot(this.assembler, options);
+        const projection = projectContextSnapshot(snapshot);
+        const stableCount = projection.stableSystemSectionCount;
+        const prepared = {
+            stableSystemMessages: projection.systemMessages.slice(0, stableCount),
+            volatileSystemMessages: projection.systemMessages.slice(stableCount),
+            ...(projection.firstUserMessageContext === undefined
+                ? {}
+                : { firstUserMessageContext: projection.firstUserMessageContext }),
+            stableSystemMessageCount: stableCount,
+        };
+        this.prepared = prepared;
+    }
+    project(options = {}) {
+        return this.projectWithMessages((options.includeHistory ?? true) ? this.sources.history() : [], (options.includeMemory ?? true) ? this.sources.memory() : [], options.pendingMessages ?? []);
+    }
+    proposeHistoryReplacement(input) {
+        const baseGeneration = this.generation;
+        if (baseGeneration === Number.MAX_SAFE_INTEGER) {
+            throw new RangeError('Context generation cannot exceed Number.MAX_SAFE_INTEGER');
+        }
+        const generation = baseGeneration + 1;
+        const projection = this.projectWithMessages(input.historyMessages, [], input.pendingMessages ?? []);
+        let committed = false;
+        return {
+            generation,
+            envelope: projection.envelope,
+            stableSystemMessageCount: projection.stableSystemMessageCount,
+            commit: async (replace) => {
+                const operation = this.replacementQueue.then(async () => {
+                    if (this.generation !== baseGeneration) {
+                        throw new StaleContextGenerationError(baseGeneration, this.generation);
+                    }
+                    if (committed) {
+                        throw new StaleContextGenerationError(baseGeneration, this.generation);
+                    }
+                    const value = await replace();
+                    this.generation = generation;
+                    committed = true;
+                    return { generation, value };
+                });
+                this.replacementQueue = operation.then(() => undefined, () => undefined);
+                return operation;
+            },
+        };
+    }
+    projectWithMessages(historyMessages, memoryMessages, pendingMessages) {
+        const prepared = this.prepared;
+        if (!prepared) {
+            throw new Error('ContextPreparation must be refreshed before projecting');
+        }
+        const history = [...historyMessages];
+        const memory = [...memoryMessages];
+        const pending = [...pendingMessages];
+        const decoratedHistory = this.decorate([...history, ...memory, ...pending]);
+        const messages = [
+            ...prepared.stableSystemMessages,
+            ...prepared.volatileSystemMessages,
+            ...decoratedHistory,
+        ];
+        return {
+            generation: this.generation,
+            envelope: {
+                messages,
+                tools: cloneTools(this.sources.activeTools()),
+            },
+            stableSystemMessageCount: prepared.stableSystemMessageCount,
+        };
+    }
+    decorate(messages) {
+        const prepared = this.prepared;
+        if (!prepared) {
+            throw new Error('ContextPreparation must be refreshed before projecting');
+        }
+        const withFirstUserContext = injectFirstUserMessageContext(messages, prepared.firstUserMessageContext);
+        const mentionInput = this.agentMentions?.();
+        if (!mentionInput || mentionInput.messages.length === 0)
+            return withFirstUserContext;
+        let insertionIndex = withFirstUserContext.length;
+        let foundPrompt = false;
+        for (let index = withFirstUserContext.length - 1; index >= 0; index -= 1) {
+            const message = withFirstUserContext[index];
+            if (message?.role === 'user' &&
+                typeof message.content === 'string' &&
+                message.content.endsWith(mentionInput.prompt)) {
+                insertionIndex = index;
+                foundPrompt = true;
+                break;
+            }
+        }
+        if (!foundPrompt)
+            return withFirstUserContext;
+        return [
+            ...withFirstUserContext.slice(0, insertionIndex),
+            ...mentionInput.messages.map((content) => ({
+                role: 'user',
+                content,
+            })),
+            ...withFirstUserContext.slice(insertionIndex),
+        ];
+    }
+}
+//# sourceMappingURL=context-preparation.js.map

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

@@ -236,7 +236,7 @@ export declare class ClaudeSessionService {
     private readonly hookLifecycle;
     private readonly leadOperations;
     private readonly fileChangeWatcher;
-    private readonly activeTurnInputs;
+    private readonly turnCoordinator;
     private runtimeCwd;
     constructor(options: ClaudeSessionServiceOptions);
     nextScheduledPrompt(signal?: AbortSignal): Promise<ScheduledPrompt | null>;
@@ -374,13 +374,6 @@ export declare class ClaudeSessionService {
     private toolCapabilities;
     private capabilityToolNames;
     private teamRegistry;
-    private append;
-    /**
-     * Update the in-memory compatibility projection used by the turn pipeline.
-     * Authoritative native persistence is performed by NativeSessionTranscript;
-     * these entries are never written to the native event store.
-     */
-    private appendProjectionMany;
     private logicalTailUuid;
 }
 export {};