praxis-agent 0.34.0 → 0.36.0

package/dist/application/context-engine.js

@@ -0,0 +1,129 @@
+import { AgentRunCancelledError, } from '../core/runtime.js';
+import { contextRecoveryMadeProgress, isPromptTooLongError, } from '../core/context-budget.js';
+function assertSignal(signal) {
+    if (signal?.aborted)
+        throw new AgentRunCancelledError();
+}
+function validateEnvelope(envelope) {
+    if (!Array.isArray(envelope.messages) || !Array.isArray(envelope.tools)) {
+        throw new TypeError('Context envelope must contain messages and tools arrays');
+    }
+    if (envelope.outputTokens !== undefined &&
+        (!Number.isSafeInteger(envelope.outputTokens) || envelope.outputTokens < 0)) {
+        throw new TypeError('Context envelope outputTokens must be nonnegative');
+    }
+}
+/** Owns context measurement, bounded recovery, and the proposal/commit seam. */
+export class ContextEngine {
+    recoveryUsed = false;
+    budget;
+    memory;
+    autoCompact;
+    constructor(options = {}) {
+        this.budget = options.budget;
+        this.memory = options.memory ?? {};
+        this.autoCompact = options.autoCompact ?? true;
+    }
+    async prepare(port, signal) {
+        const current = port.current();
+        validateEnvelope(current);
+        if (!this.budget || !this.autoCompact)
+            return current;
+        const before = this.reportRequired(current);
+        if (!before.shouldCompact)
+            return current;
+        assertSignal(signal);
+        const irreducible = port.irreducible();
+        validateEnvelope(irreducible);
+        const irreducibleReport = this.reportRequired(irreducible);
+        this.budget.assertFits(irreducibleReport);
+        await this.memory.beforeCompact?.();
+        assertSignal(signal);
+        const proposal = await port.propose({
+            trigger: 'auto',
+            before,
+            irreducible: irreducibleReport,
+            ...(signal ? { signal } : {}),
+        });
+        assertSignal(signal);
+        validateEnvelope(proposal.envelope);
+        this.budget.assertFits(this.reportRequired(proposal.envelope));
+        await proposal.commit();
+        await this.memory.afterCompact?.();
+        return proposal.envelope;
+    }
+    async recover(error, port, signal) {
+        if (!isPromptTooLongError(error))
+            return { kind: 'not-applicable' };
+        if (this.recoveryUsed)
+            return { kind: 'exhausted', error };
+        // Recovery is a single turn-scoped opportunity, regardless of whether the
+        // proposal eventually proves usable. This prevents provider retry loops.
+        this.recoveryUsed = true;
+        assertSignal(signal);
+        if (!this.budget || !this.autoCompact) {
+            return { kind: 'exhausted', error };
+        }
+        try {
+            const current = port.current();
+            validateEnvelope(current);
+            const before = this.reportRequired(current, { promptTooLong: true });
+            const irreducible = port.irreducible();
+            validateEnvelope(irreducible);
+            const irreducibleReport = this.reportRequired(irreducible);
+            this.budget.assertFits(irreducibleReport);
+            await this.memory.beforeCompact?.();
+            assertSignal(signal);
+            const proposal = await port.propose({
+                trigger: 'reactive',
+                before,
+                irreducible: irreducibleReport,
+                ...(signal ? { signal } : {}),
+            });
+            assertSignal(signal);
+            validateEnvelope(proposal.envelope);
+            const after = this.reportRequired(proposal.envelope);
+            this.budget.assertFits(after);
+            if (!contextRecoveryMadeProgress({
+                beforeOccupancyTokens: before.occupancyTokens,
+                afterOccupancyTokens: after.occupancyTokens,
+            })) {
+                return { kind: 'exhausted', error };
+            }
+            await proposal.commit();
+            await this.memory.afterCompact?.();
+            return { kind: 'retry', envelope: proposal.envelope };
+        }
+        catch (cause) {
+            if (signal?.aborted || cause instanceof AgentRunCancelledError)
+                throw cause;
+            return { kind: 'exhausted', error };
+        }
+    }
+    observeUsage(usage, messages, tools) {
+        this.budget?.observeUsage(usage, messages, tools);
+    }
+    report(envelope, options = {}) {
+        validateEnvelope(envelope);
+        if (!this.budget) {
+            return undefined;
+        }
+        return this.budget.evaluate(envelope.messages, envelope.tools, {
+            ...(envelope.outputTokens === undefined
+                ? {}
+                : { outputTokens: envelope.outputTokens }),
+            ...options,
+        });
+    }
+    reportRequired(envelope, options = {}) {
+        if (!this.budget)
+            throw new Error('Context budget is unavailable');
+        return this.budget.evaluate(envelope.messages, envelope.tools, {
+            ...(envelope.outputTokens === undefined
+                ? {}
+                : { outputTokens: envelope.outputTokens }),
+            ...options,
+        });
+    }
+}
+//# sourceMappingURL=context-engine.js.map

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

@@ -2,7 +2,7 @@ import { type AgentColorName, type AgentColorSelection } from '../compatibility/
 import type { ClaudeConditionalRuleResolver } from '../compatibility/claude/context.js';
 import { type DataPlane } from '../persistence/data-plane.js';
 import { type ClaudeFileResource, type ClaudeFileResourceConfig } from '../compatibility/claude/file-resources.js';
-import { type ClaudeDisplayTranscriptItem } from '../compatibility/claude/projection.js';
+import type { TranscriptDisplayItem } from './transcript-projection.js';
 import { type ClaudeTranscriptEntry } from '../compatibility/claude/schema.js';
 import { type ClaudeSessionMetadata } from '../compatibility/claude/session-metadata.js';
 import { type ClaudeInterruptionClassification } from '../compatibility/claude/interruption.js';
@@ -15,6 +15,7 @@ import { type ContextAssembler } from '../core/context.js';
 import type { ClaudeExtensionCatalog } from '../extensions/claude-extensions.js';
 import type { ClaudeHookRunner } from '../hooks/claude-hooks.js';
 import { type TranscriptParseIssue } from '../persistence/claude-transcript-store.js';
+import type { TranscriptCodecDiagnostic } from '../core/transcript-codec.js';
 import type { ClaudeCostStateStore } from '../persistence/claude-cost-state-store.js';
 import { type AgentPermissionMode } from './subagent-service.js';
 import { type ScheduledPrompt } from './scheduled-prompt-manager.js';
@@ -138,14 +139,14 @@ export interface SessionSummary {
     lastPrompt: string | null;
     updatedAt: string;
     status: SessionStatus;
-    issue: TranscriptParseIssue | null;
+    issue: (TranscriptParseIssue | TranscriptCodecDiagnostic) | null;
     prNumber?: number;
     prUrl?: string;
     prRepository?: string;
 }
 export type SessionStatus = 'ready' | 'read-only' | 'corrupt';
 export interface SessionInspection extends SessionSummary {
-    claudeVersion: string;
+    claudeVersion?: string;
     writeMode: 'read-only' | 'read-write';
     entryCount: number;
     byteLength: number;
@@ -273,7 +274,7 @@ export declare class ClaudeSessionService {
     readEffectiveAgentColor(sessionId: string): Promise<AgentColorName | undefined>;
     export(sessionId: string): Promise<Buffer>;
     registerResumePath(requestedPath: string): Promise<SessionSummary>;
-    transcript(sessionId: string, resumeSessionAt?: string): Promise<ClaudeDisplayTranscriptItem[]>;
+    transcript(sessionId: string, resumeSessionAt?: string): Promise<TranscriptDisplayItem[]>;
     interruption(sessionId: string): Promise<ClaudeInterruptionClassification>;
     metadata(sessionId: string): Promise<ClaudeSessionMetadata>;
     rename(sessionId: string, name: string): Promise<void>;
@@ -345,12 +346,14 @@ export declare class ClaudeSessionService {
     private assertSessionPersistence;
     private assertWritable;
     private sessionStatus;
+    private nativeSessionStatus;
+    private claudeSessionSummary;
     private provider;
+    private assertNativeWriteTargetIsLegacy;
     model(): string | undefined;
     private providerForAgent;
     private resolveAgent;
     private mainAgentSystemPrompt;
-    private assembledSystemMessages;
     private contextBudget;
     private sessionMemoryEnabled;
     private sessionMemoryController;