praxis-agent 0.34.0 → 0.35.0

package/dist/cli/tui/tui-view-model.d.ts

@@ -1,4 +1,5 @@
-import type { TranscriptItem } from './claude-style.js';
+import type { TranscriptItem } from './transcript-presentation.js';
+import { type TranscriptPresentationEntry } from './transcript-presentation.js';
 export type TuiRendererMode = 'default' | 'fullscreen';
 /**
  * Inputs for the pure TUI view projection. `history` is the live transcript
@@ -15,9 +16,12 @@ export interface TuiViewInput {
     rows: number | undefined;
     width: number;
     scrollOffset: number;
+    detailedTranscript: boolean;
 }
 export interface TuiViewModel {
-    projectedHistory: readonly TranscriptItem[];
+    transcriptEntries: readonly TranscriptPresentationEntry[];
+    transcriptPageRows: number;
+    maxTranscriptScrollOffset: number;
     resumed: boolean;
     freshSession: boolean;
     hasConversationHistory: boolean;

package/dist/cli/tui/tui-view-model.js

@@ -1,4 +1,5 @@
-import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, projectTranscriptTail, projectTranscriptWindow, } from './transcript-viewport.js';
+import { projectTranscriptPresentation, } from './transcript-presentation.js';
+import { FULLSCREEN_TRANSCRIPT_RESERVED_ROWS, projectTranscriptPresentationTail, projectTranscriptPresentationWindow, transcriptPresentationLineCount, } from './transcript-viewport.js';
 /**
  * Pure, deterministic TUI projection. It classifies the session identity
  * (fresh/resumed/started) and projects the rendered transcript exactly as the
@@ -27,12 +28,28 @@ export function projectTuiView(input) {
     // viewport, leaving the composer/status chrome intact and keeping the active
     // stream visible. Classic and screen-reader modes always render the full
     // history exactly as before.
-    const projectedHistory = input.fixedViewport && !input.screenReader
+    const mode = input.screenReader
+        ? 'screen-reader'
+        : input.detailedTranscript
+            ? 'audit'
+            : 'normal';
+    const fullEntries = projectTranscriptPresentation(input.history, mode);
+    const transcriptPageRows = Math.max(2, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS);
+    const maxTranscriptScrollOffset = Math.max(0, transcriptPresentationLineCount(fullEntries, input.width, mode) -
+        transcriptPageRows);
+    const transcriptEntries = input.fixedViewport && !input.screenReader
         ? input.scrollOffset > 0
-            ? projectTranscriptWindow(input.history, Math.max(1, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), input.width, input.scrollOffset)
-            : projectTranscriptTail(input.history, Math.max(1, (input.rows ?? 0) - FULLSCREEN_TRANSCRIPT_RESERVED_ROWS), input.width)
-        : input.history;
-    return { projectedHistory, resumed, freshSession, hasConversationHistory };
+            ? projectTranscriptPresentationWindow(fullEntries, transcriptPageRows, input.width, input.scrollOffset, mode)
+            : projectTranscriptPresentationTail(fullEntries, transcriptPageRows, input.width, mode)
+        : fullEntries;
+    return {
+        transcriptEntries,
+        transcriptPageRows,
+        maxTranscriptScrollOffset,
+        resumed,
+        freshSession,
+        hasConversationHistory,
+    };
 }
 /**
  * Resolves the renderer for an interactive session. Fullscreen is the default

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

@@ -1,4 +1,4 @@
-import type { AssembledContext, ContextAssembler, ContextAssemblyOptions, ContextInvalidationOptions } from '../../core/context.js';
+import type { ContextAssembler, ContextAssemblyOptions, ContextSnapshot, ContextInvalidationOptions } from '../../core/context.js';
 import { type ClaudeDynamicContextSections } from './dynamic-context.js';
 import type { ClaudeContextResources, ClaudeConditionalRule, ClaudeTextResource } from './shared-resources.js';
 export interface ClaudeContextAssemblerOptions {
@@ -32,7 +32,7 @@ export declare class ClaudeContextAssembler implements ContextAssembler {
     private readonly composer;
     private readonly snapshots;
     constructor(options: ClaudeContextAssemblerOptions);
-    assemble(options?: ContextAssemblyOptions): Promise<AssembledContext>;
+    assemble(options?: ContextAssemblyOptions): Promise<ContextSnapshot>;
     invalidate(options: ContextInvalidationOptions): void;
     private snapshot;
     private loadResources;

package/dist/compatibility/claude/context.js

@@ -135,12 +135,6 @@ ${sections.join('\n\n')}`,
                 });
             }
         }
-        for (const section of options.additionalSections ?? []) {
-            const target = section.stability === 'volatile' || section.placement === 'first-user'
-                ? tailSections
-                : sessionSections;
-            target.push(section);
-        }
         const composition = this.composer.compose({
             mode,
             ...(options.baseSystemPrompt !== undefined
@@ -153,15 +147,9 @@ ${sections.join('\n\n')}`,
                 : {}),
             sessionSections,
             tailSections,
+            ...(options.turn === undefined ? {} : { turn: options.turn }),
         });
-        return {
-            systemMessages: composition.systemMessages,
-            promptSections: composition.sections,
-            stableSystemSectionCount: composition.stableSystemSectionCount,
-            ...(composition.firstUserMessageContext
-                ? { firstUserMessageContext: composition.firstUserMessageContext }
-                : {}),
-        };
+        return composition;
     }
     invalidate(options) {
         for (const [key, snapshot] of this.snapshots) {

package/dist/compatibility/claude/data-plane-adapter.d.ts

@@ -0,0 +1,9 @@
+import type { DataPlaneAdapter, DataPlaneAdapterOptions, DataPlanePaths, DataPlaneRootOptions, ScheduledTaskFileOptions } from '../../persistence/data-plane-adapter.js';
+export declare class ClaudeDataPlaneAdapter implements DataPlaneAdapter {
+    readonly dataPlane: "claude";
+    resolveRoot(options: DataPlaneRootOptions): string;
+    resolvePaths(options: DataPlaneAdapterOptions): DataPlanePaths;
+    resolveScheduledTaskFile(options: ScheduledTaskFileOptions): string;
+}
+export declare const claudeDataPlaneAdapter: ClaudeDataPlaneAdapter;
+//# sourceMappingURL=data-plane-adapter.d.ts.map

package/dist/compatibility/claude/data-plane-adapter.js

@@ -0,0 +1,44 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { isSessionId } from '../../core/session.js';
+import { resolveClaudePaths, resolveClaudeScheduledTaskFile, sanitizeClaudeProjectPath, } from './paths.js';
+export class ClaudeDataPlaneAdapter {
+    dataPlane = 'claude';
+    resolveRoot(options) {
+        const environment = options.environment ?? process.env;
+        if (options.root?.trim())
+            return resolve(options.root);
+        const configuredRoot = environment.CLAUDE_CONFIG_DIR;
+        return resolve(configuredRoot?.trim()
+            ? configuredRoot
+            : resolve(options.homeDirectory ?? homedir(), '.claude'));
+    }
+    resolvePaths(options) {
+        if (!isSessionId(options.sessionId)) {
+            throw new Error(`Invalid session ID: ${options.sessionId}`);
+        }
+        const root = this.resolveRoot(options);
+        const paths = resolveClaudePaths({
+            cwd: options.cwd,
+            sessionId: options.sessionId,
+            configDir: root,
+        });
+        const projectKey = sanitizeClaudeProjectPath(options.cwd);
+        const stateRoot = paths.praxisRoot;
+        return {
+            dataPlane: 'claude',
+            root: paths.configRoot,
+            projectRoot: paths.projectRoot,
+            sessionFile: paths.sessionFile,
+            taskRoot: paths.taskRoot,
+            stateRoot,
+            praxisRoot: stateRoot,
+            memoryRoot: resolve(root, 'projects', projectKey, 'memory'),
+        };
+    }
+    resolveScheduledTaskFile(options) {
+        return resolveClaudeScheduledTaskFile(options.cwd);
+    }
+}
+export const claudeDataPlaneAdapter = new ClaudeDataPlaneAdapter();
+//# sourceMappingURL=data-plane-adapter.js.map

package/dist/compatibility/claude/paths.js

@@ -1,12 +1,12 @@
 import { lstat, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { extname, resolve } from 'node:path';
+import { isSessionId } from '../../core/session.js';
 import { sanitizeProjectPath } from '../../platform/project-path-key.js';
 import { getDataOwnership } from './ownership.js';
 const MAX_SANITIZED_LENGTH = 200;
-const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export function isClaudeSessionId(value) {
-    return SESSION_ID_PATTERN.test(value);
+    return isSessionId(value);
 }
 export function sanitizeClaudeProjectPath(path) {
     return sanitizeProjectPath(path);

package/dist/compatibility/claude/shared-resources.d.ts

@@ -1,41 +1,10 @@
-export type ClaudeResourceScope = 'local' | 'project' | 'user';
-export interface ClaudeTextResource {
-    path: string;
-    scope: ClaudeResourceScope;
-    content: string;
-    importedFrom?: string;
-    importRoot?: string;
-}
-export interface ClaudeJsonResource {
-    path: string;
-    scope: ClaudeResourceScope;
-    value: unknown;
-    plugin?: true;
-    pluginName?: string;
-    pluginSource?: string;
-    environment?: Readonly<Record<string, string>>;
-    sensitiveValues?: readonly string[];
-}
-export interface ClaudeContextResources {
-    instructions: ClaudeTextResource[];
-    conditionalRules: ClaudeConditionalRule[];
-    memoryIndex: ClaudeTextResource | null;
-}
-export interface ClaudeConditionalRule extends ClaudeTextResource {
-    baseDirectory: string;
-    content: string;
-    globs: string[];
-    rawContent: string;
-}
-export interface ClaudeSharedResources {
-    instructions: ClaudeTextResource[];
-    memory: ClaudeTextResource[];
-    skills: ClaudeTextResource[];
-    commands: ClaudeTextResource[];
-    agents: ClaudeTextResource[];
-    settings: ClaudeJsonResource[];
-    mcp: ClaudeJsonResource[];
-}
+import type { ConditionalRule, ContextResources, JsonResource, ResourceScope, SharedResources, TextResource } from '../../core/resources.js';
+export type ClaudeResourceScope = ResourceScope;
+export type ClaudeTextResource = TextResource;
+export type ClaudeJsonResource = JsonResource;
+export type ClaudeContextResources = ContextResources;
+export type ClaudeConditionalRule = ConditionalRule;
+export type ClaudeSharedResources = SharedResources;
 export interface LoadClaudeSharedResourcesOptions {
     configRoot: string;
     cwd: string;

package/dist/compatibility/claude/transcript-codec.d.ts

@@ -0,0 +1,21 @@
+import { type TranscriptEvent } from '../../core/transcript-event.js';
+import { type OpaquePreservationToken, type TranscriptCodec, type TranscriptDocumentResult, type TranscriptEncodeResult, type TranscriptLineResult } from '../../core/transcript-codec.js';
+export interface ClaudeTranscriptCodecOptions {
+    version: string;
+    cwd: string;
+    gitBranch?: string | null;
+    entrypoint?: string;
+}
+export declare class ClaudeTranscriptCodec implements TranscriptCodec {
+    private readonly options;
+    readonly id = "claude";
+    readonly version: string;
+    readonly writeMode: 'read-only' | 'read-write';
+    private readonly adapter;
+    constructor(options: ClaudeTranscriptCodecOptions);
+    decodeLine(line: string, lineNumber?: number, byteOffset?: number): TranscriptLineResult;
+    encodeLine(event: TranscriptEvent, preservation?: OpaquePreservationToken): TranscriptEncodeResult;
+    decodeDocument(source: string | Uint8Array): TranscriptDocumentResult;
+}
+export declare function createClaudeTranscriptCodec(options: ClaudeTranscriptCodecOptions): ClaudeTranscriptCodec;
+//# sourceMappingURL=transcript-codec.d.ts.map