praxis-agent 0.42.1 → 0.43.1

package/README.md

@@ -45,6 +45,7 @@ praxis --version
 
 Release tarballs, SBOMs, SHA-256 checksums, and build attestations are attached
 to every [GitHub release](https://github.com/Forest-Isle/Praxis/releases).
+Use `praxis update` for transactional self-updates; see [Getting Started](https://github.com/Forest-Isle/Praxis/blob/main/docs/GETTING_STARTED.md) for recovery and verification details.
 
 ## Quick start
 
@@ -88,10 +89,13 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
 
 ## What Praxis provides
 
-- **Local agent runtime** — Claude-style responsive TUI with a fixed fullscreen
-  viewport, non-shrinking composer/status area, and complete bounded welcome
-  surface with the reusable P-loop + spark Praxis mark and ANSI/no-color
-  fallbacks, plus a shared-command
+- **Local agent runtime** — C+ Quiet Operator responsive TUI with a linear
+  `you>`/`praxis>` conversation, compact stable tool rows, responsive density,
+  terminal-native background, and a minimal composer/status row. Interactive
+  surfaces share the same presentation across terminals, with English
+  permission/configuration choices and a taught `❯` / Up/Down / Enter / Esc
+  interaction grammar, plus a
+  shared-command
   slash palette, tabbed help and shortcut surfaces, searchable resume picker,
   restored active-branch conversation history, streaming and expandable
   thinking, grouped multi-file reads, globally expandable tool results,
@@ -106,26 +110,8 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   skills/hooks flow, provider-free per-session `/color` prompt-bar styling,
   `/mcp`, `/memory` shared instruction and auto-memory
   access, and live extension-reload controls,
-  plus a framework-free runtime kernel that atomically publishes streaming
-  frames and keeps status/busy transitions deterministic, with a unified
-  framework-free TuiStore that retains runtime and composer state together,
-  with a shared semantic transcript Row IR for renderer-neutral layout and
-  stable incremental updates,
-  backed by the authoritative grapheme/Markdown viewport layout so narrow and
-  Unicode-heavy transcripts wrap consistently across renderers,
-  and an independent ANSI fullscreen frame renderer with alternate-screen
-  lifecycle, synchronized output, and dirty-row diffing,
-  opt-in TTY wiring with automatic Ink fallback on renderer failure,
-  with complex overlays and dialogs intentionally remaining on the mature Ink
-  surface until their semantic ANSI projections are complete,
-  while welcome and identity intros also remain on Ink for a complete first
-  frame,
-  and a pure FocusStack that centralizes overlay/dialog precedence and Esc
-  cancellation routing,
-  plus a generation-aware effect runner that drops stale asynchronous results
-  and aborts cleanly on replacement or unmount,
-  with ANSI fullscreen text styles derived from the active semantic theme and
-  automatic no-color/screen-reader suppression,
+  plus automatic fallback when a terminal renderer fails, screen-reader
+  support, and no-color output,
   cursor/history composer, provider-free `/cost` usage and pricing summaries,
   with a hermetic PTY smoke covering real `runInteractive` ANSI entry,
   resize-safe lifecycle, and Ctrl-C restoration,
@@ -204,6 +190,9 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
 - **Provider-neutral models** — native Anthropic Messages and OpenAI-compatible
   streaming adapters with explicit capability checks, metering controls, and
   a bounded absolute deadline for every provider attempt.
+- **Transactional self-update** — `praxis update` verifies the package before
+  installing it, rejects concurrent updates, and can roll back after an
+  interruption or crash.
 
 Detailed feature status and executable evidence live in the
 [parity matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md),
@@ -211,17 +200,17 @@ not in this entry-point README.
 
 ## Documentation
 
-| Need                                       | Document                                                                                   |
-| ------------------------------------------ | ------------------------------------------------------------------------------------------ |
-| Install and run the first session          | [Getting Started](https://github.com/Forest-Isle/Praxis/blob/main/docs/GETTING_STARTED.md) |
-| Common commands and environment variables  | [CLI Reference](https://github.com/Forest-Isle/Praxis/blob/main/docs/CLI_REFERENCE.md)     |
-| Find all user and maintainer documentation | [Documentation Index](https://github.com/Forest-Isle/Praxis/blob/main/docs/README.md)      |
-| Understand module and data-flow boundaries | [Architecture](https://github.com/Forest-Isle/Praxis/blob/main/docs/ARCHITECTURE.md)       |
-| Review security assumptions                | [Threat Model](https://github.com/Forest-Isle/Praxis/blob/main/docs/THREAT_MODEL.md)       |
-| Check Claude Code parity                   | [Parity Matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md)     |
-| Review interactive TUI design and evidence | [TUI Parity](https://github.com/Forest-Isle/Praxis/blob/main/docs/TUI_PARITY.md)           |
-| Build, test, and contribute                | [Contributing](https://github.com/Forest-Isle/Praxis/blob/main/CONTRIBUTING.md)            |
-| Verify release and supply-chain controls   | [Release Contract](https://github.com/Forest-Isle/Praxis/blob/main/docs/RELEASE.md)        |
+| Need                                       | Document                                                                                         |
+| ------------------------------------------ | ------------------------------------------------------------------------------------------------ |
+| Install and run the first session          | [Getting Started](https://github.com/Forest-Isle/Praxis/blob/main/docs/GETTING_STARTED.md)       |
+| Common commands and environment variables  | [CLI Reference](https://github.com/Forest-Isle/Praxis/blob/main/docs/CLI_REFERENCE.md)           |
+| Find all user and maintainer documentation | [Documentation Index](https://github.com/Forest-Isle/Praxis/blob/main/docs/README.md)            |
+| Understand module and data-flow boundaries | [Architecture](https://github.com/Forest-Isle/Praxis/blob/main/docs/ARCHITECTURE.md)             |
+| Review security assumptions                | [Threat Model](https://github.com/Forest-Isle/Praxis/blob/main/docs/THREAT_MODEL.md)             |
+| Check Claude Code parity                   | [Parity Matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md)           |
+| Review interactive TUI design and evidence | [Quiet Operator Spec](https://github.com/Forest-Isle/Praxis/blob/main/docs/TUI_REDESIGN_SPEC.md) |
+| Build, test, and contribute                | [Contributing](https://github.com/Forest-Isle/Praxis/blob/main/CONTRIBUTING.md)                  |
+| Verify release and supply-chain controls   | [Release Contract](https://github.com/Forest-Isle/Praxis/blob/main/docs/RELEASE.md)              |
 
 ## Project boundary
 
@@ -257,8 +246,10 @@ npm run check
 transcript, and session profile.
 `npm run test:native:deletion` adds an emitted-output deletion gate. These are
 implemented profile checks, not qualification of the full native package.
-`npm run test:performance` runs the native projection scaling and regression
-budgets; the retained-render p95 budget remains 50 ms.
+`npm run test:performance` enforces TUI projection scaling, doubling ratios
+`<=3.25`, the absolute 120k median budget of `<1000 ms`, and deterministic
+injected regression protection, plus Quiet Operator input echo `<50 ms` and
+normal/low-capability full-frame p95 budgets of `<16.7/<33 ms`.
 `npm run check` also enforces the corresponding source dependency direction.
 `npm run test:core-completion` runs the 56-story #402 audit and reports
 implemented, qualified, blocked, deferred, and out-of-scope states separately;

package/dist/application/native-session-projection.d.ts

@@ -0,0 +1,4 @@
+import type { TranscriptEvent } from '../core/transcript-event.js';
+import type { NativeTranscriptEntry } from '../native/schema.js';
+export declare function projectNativeSessionEntries(events: readonly TranscriptEvent[]): NativeTranscriptEntry[];
+//# sourceMappingURL=native-session-projection.d.ts.map

package/dist/application/native-session-projection.js

@@ -0,0 +1,135 @@
+export function projectNativeSessionEntries(events) {
+    const entries = [];
+    for (const event of events) {
+        if (event.kind === 'context-boundary') {
+            entries.push({
+                type: 'system',
+                uuid: event.id,
+                parentUuid: event.parentId,
+                subtype: 'compact_boundary',
+                logicalParentUuid: event.logicalParentId,
+                compactMetadata: {
+                    trigger: event.trigger,
+                    preTokens: event.preTokens,
+                    postTokens: event.postTokens,
+                    durationMs: event.durationMs,
+                },
+            });
+            continue;
+        }
+        if (event.kind === 'context-summary') {
+            entries.push({
+                type: 'user',
+                uuid: event.id,
+                parentUuid: event.parentId,
+                isCompactSummary: true,
+                message: { role: 'user', content: event.summary },
+            });
+            continue;
+        }
+        if (event.kind !== 'messages')
+            continue;
+        let parentUuid = event.parentId;
+        event.messages.forEach((message, index) => {
+            const uuid = index === event.messages.length - 1 ? event.id : `${event.id}:${index}`;
+            if (message.role === 'user' && typeof message.content === 'string') {
+                const agentMatch = message.content.match(/^<praxis-agent-setting>([^<]+)<\/praxis-agent-setting>$/u);
+                if (agentMatch?.[1]) {
+                    entries.push({
+                        type: 'agent-setting',
+                        agentSetting: agentMatch[1],
+                        uuid,
+                        parentUuid,
+                        sessionId: event.sessionId,
+                    });
+                    parentUuid = uuid;
+                    return;
+                }
+                const nameMatch = message.content.match(/^<praxis-session-name>([^<]+)<\/praxis-session-name>$/u);
+                if (nameMatch?.[1]) {
+                    entries.push({
+                        type: 'custom-title',
+                        customTitle: nameMatch[1],
+                        uuid,
+                        parentUuid,
+                        sessionId: event.sessionId,
+                    });
+                    parentUuid = uuid;
+                    return;
+                }
+                const match = message.content.match(/^<praxis-file-history>([\s\S]*)<\/praxis-file-history>$/u);
+                if (match?.[1]) {
+                    try {
+                        const operational = JSON.parse(match[1]);
+                        if (operational &&
+                            typeof operational === 'object' &&
+                            typeof operational.type === 'string' &&
+                            (operational.type === 'file-history-snapshot' ||
+                                operational.type === 'file-history-delta')) {
+                            entries.push({
+                                ...operational,
+                                uuid,
+                                parentUuid,
+                                sessionId: event.sessionId,
+                            });
+                            parentUuid = uuid;
+                            return;
+                        }
+                    }
+                    catch {
+                        // Keep malformed operational markers visible as ordinary native user messages.
+                    }
+                }
+            }
+            if (message.role === 'tool') {
+                entries.push({
+                    type: 'user',
+                    uuid,
+                    parentUuid,
+                    message: {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'tool_result',
+                                tool_use_id: message.toolCallId,
+                                content: message.content,
+                                is_error: message.isError,
+                            },
+                        ],
+                    },
+                });
+                parentUuid = uuid;
+                return;
+            }
+            if (message.role === 'assistant') {
+                const content = [];
+                if (message.content)
+                    content.push({ type: 'text', text: message.content });
+                for (const call of message.toolCalls ?? [])
+                    content.push({
+                        type: 'tool_use',
+                        id: call.id,
+                        name: call.name,
+                        input: call.input,
+                    });
+                entries.push({
+                    type: 'assistant',
+                    uuid,
+                    parentUuid,
+                    message: { role: 'assistant', content },
+                });
+                parentUuid = uuid;
+                return;
+            }
+            entries.push({
+                type: message.role,
+                uuid,
+                parentUuid,
+                message: { role: message.role, content: message.content },
+            });
+            parentUuid = uuid;
+        });
+    }
+    return entries;
+}
+//# sourceMappingURL=native-session-projection.js.map

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

@@ -299,7 +299,6 @@ export declare class ClaudeSessionService {
     compact(sessionId: string, signal?: AbortSignal, selection?: ManualCompactSelection): Promise<ManualCompactResult>;
     fork(parentSessionId: string, sessionId?: string, resumeSessionAt?: string): Promise<ForkResult>;
     ensureFork(parentSessionId: string, sessionId: string, checkpoint?: SessionForkCheckpoint): Promise<ForkResult>;
-    private nativeForkEntries;
     rewindFiles(sessionId: string, userMessageId: string): Promise<void>;
     rewindPoints(sessionId: string): Promise<RewindPoint[]>;
     setPermissionMode(sessionId: string, permissionMode: ClaudePermissionMode): Promise<void>;

package/dist/application/session-service.js

@@ -8,10 +8,10 @@ import { formatClaudeCompactSummary } from '../native/compaction.js';
 import { isClaudeAgentId } from '../native/sidechain.js';
 import { assertNativeDataPlane, resolveDataPlanePaths, resolveScheduledTaskFile, } from '../persistence/data-plane.js';
 import { downloadClaudeFileResources, } from '../native/file-resources.js';
-import { createClaudeNativeFork } from '../native/fork.js';
 import { selectClaudeActiveTranscript } from '../native/history.js';
 import { ClaudeFileHistory } from '../native/file-history.js';
 import { getClaudeAgentSetting, projectClaudeModelMessages, } from '../native/projection.js';
+import { projectNativeSessionEntries } from './native-session-projection.js';
 import { classifyClaudeInterruption, } from '../native/interruption.js';
 import { findUnresolvedClaudeToolCalls, getClaudeContentBlocks, } from '../native/tool-links.js';
 import { createClaudeAgentSettingEntry, createClaudeHookAttachmentEntries, createClaudeLastPromptEntry, createClaudeRuleAttachmentEntry, translateProviderEvents, } from '../native/translation.js';
@@ -21,146 +21,6 @@ import { BackgroundTaskRuntime, } from './background-task-runtime.js';
 import { backgroundAgentNotificationMarkers, } from './background-agent-manager.js';
 import { usageCostUsd } from '../core/usage.js';
 import { isSessionId } from '../core/session.js';
-/** Project authoritative native events for legacy-only session helpers. */
-function projectNativeEvents(events) {
-    const entries = [];
-    for (const event of events) {
-        if (event.kind === 'context-boundary') {
-            entries.push({
-                type: 'system',
-                uuid: event.id,
-                parentUuid: event.parentId,
-                subtype: 'compact_boundary',
-                logicalParentUuid: event.logicalParentId,
-                compactMetadata: {
-                    trigger: event.trigger,
-                    preTokens: event.preTokens,
-                    postTokens: event.postTokens,
-                    durationMs: event.durationMs,
-                },
-            });
-            continue;
-        }
-        if (event.kind === 'context-summary') {
-            entries.push({
-                type: 'user',
-                uuid: event.id,
-                parentUuid: event.parentId,
-                isCompactSummary: true,
-                message: { role: 'user', content: event.summary },
-            });
-            continue;
-        }
-        if (event.kind !== 'messages')
-            continue;
-        let parentUuid = event.parentId;
-        event.messages.forEach((message, index) => {
-            // Native event parent links target the event ID. Assign that ID to the
-            // final projected message so the next event and memory watermark attach
-            // to the visible tail of this event; intermediate messages get stable
-            // derived IDs within the event.
-            const uuid = index === event.messages.length - 1 ? event.id : `${event.id}:${index}`;
-            if (message.role === 'user' && typeof message.content === 'string') {
-                const agentMatch = message.content.match(/^<praxis-agent-setting>([^<]+)<\/praxis-agent-setting>$/u);
-                if (agentMatch?.[1]) {
-                    entries.push({
-                        type: 'agent-setting',
-                        agentSetting: agentMatch[1],
-                        uuid,
-                        parentUuid,
-                        sessionId: event.sessionId,
-                    });
-                    parentUuid = uuid;
-                    return;
-                }
-                const nameMatch = message.content.match(/^<praxis-session-name>([^<]+)<\/praxis-session-name>$/u);
-                if (nameMatch?.[1]) {
-                    entries.push({
-                        type: 'custom-title',
-                        customTitle: nameMatch[1],
-                        uuid,
-                        parentUuid,
-                        sessionId: event.sessionId,
-                    });
-                    parentUuid = uuid;
-                    return;
-                }
-                const match = message.content.match(/^<praxis-file-history>([\s\S]*)<\/praxis-file-history>$/u);
-                if (match?.[1]) {
-                    try {
-                        const operational = JSON.parse(match[1]);
-                        if (operational &&
-                            typeof operational === 'object' &&
-                            typeof operational.type === 'string' &&
-                            (operational.type === 'file-history-snapshot' ||
-                                operational.type === 'file-history-delta')) {
-                            entries.push({
-                                ...operational,
-                                uuid,
-                                parentUuid,
-                                sessionId: event.sessionId,
-                            });
-                            parentUuid = uuid;
-                            return;
-                        }
-                    }
-                    catch {
-                        // Keep malformed operational markers visible as ordinary native
-                        // user messages; the authoritative transcript remains valid.
-                    }
-                }
-            }
-            if (message.role === 'tool') {
-                entries.push({
-                    type: 'user',
-                    uuid,
-                    parentUuid,
-                    message: {
-                        role: 'user',
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: message.toolCallId,
-                                content: message.content,
-                                is_error: message.isError,
-                            },
-                        ],
-                    },
-                });
-                parentUuid = uuid;
-                return;
-            }
-            if (message.role === 'assistant') {
-                const content = [];
-                if (message.content)
-                    content.push({ type: 'text', text: message.content });
-                for (const call of message.toolCalls ?? [])
-                    content.push({
-                        type: 'tool_use',
-                        id: call.id,
-                        name: call.name,
-                        input: call.input,
-                    });
-                entries.push({
-                    type: 'assistant',
-                    uuid,
-                    parentUuid,
-                    message: { role: 'assistant', content },
-                });
-                parentUuid = uuid;
-                return;
-            }
-            entries.push({
-                type: message.role,
-                uuid,
-                parentUuid,
-                message: { role: message.role, content: message.content },
-            });
-            parentUuid = uuid;
-        });
-    }
-    return entries;
-}
 import { ContextBudget, estimateModelRequestTokens, isPromptTooLongError, } from '../core/context-budget.js';
 import { ContextEngine } from './context-engine.js';
 import { TurnMemoryCoordinator } from './turn-memory-coordinator.js';
@@ -1935,7 +1795,7 @@ export class ClaudeSessionService {
                 const sourceStore = this.store(sessionId);
                 const relocated = await sourceStore.withLease(async (lease) => {
                     const snapshot = await lease.load();
-                    if (snapshot.entries.length === 0) {
+                    if (snapshot.records.length === 0) {
                         throw new Error(`Claude session not found: ${sessionId}`);
                     }
                     await mkdir(targetPaths.projectRoot, { recursive: true });
@@ -2112,7 +1972,7 @@ export class ClaudeSessionService {
                         : branchEvents[targetIndex - 1])?.id;
                 }
                 else {
-                    memorySelection = await this.selectMemoryPreservedCompact(sessionId, projectNativeEvents(branchEvents));
+                    memorySelection = await this.selectMemoryPreservedCompact(sessionId, projectNativeSessionEntries(branchEvents));
                     if (memorySelection) {
                         messages = [
                             memorySelection.memoryMessage,
@@ -2311,35 +2171,13 @@ export class ClaudeSessionService {
             return { sessionId, parentSessionId };
         }
     }
-    async nativeForkEntries(parentSessionId, sessionId, resumeSessionAt, sourceEntryCount) {
-        const sourceResult = await this.store(parentSessionId).withLease((lease) => lease.load());
-        if (sourceResult.status === 'conflict') {
-            throw new Error(`Claude transcript fork conflict: ${sourceResult.reason}`);
-        }
-        const source = sourceResult.value;
-        if (source.entries.length === 0) {
-            throw new Error(`Claude session not found: ${parentSessionId}`);
-        }
-        if (sourceEntryCount !== undefined &&
-            (sourceEntryCount <= 0 || sourceEntryCount > source.entries.length)) {
-            throw new Error('Claude handoff source checkpoint is no longer available');
-        }
-        return createClaudeNativeFork({
-            source: sourceEntryCount === undefined
-                ? source.entries
-                : source.entries.slice(0, sourceEntryCount),
-            sourceSessionId: parentSessionId,
-            sessionId,
-            ...(resumeSessionAt === undefined ? {} : { resumeSessionAt }),
-        });
-    }
     async rewindFiles(sessionId, userMessageId) {
         const transcript = new NativeSessionTranscript({
             sessionId,
             store: this.store(sessionId),
         });
         await transcript.withLease({ kind: 'resume' }, async (lease) => {
-            const projected = projectNativeEvents(lease.activeEvents()).filter((entry) => entry.type === 'file-history-snapshot' ||
+            const projected = projectNativeSessionEntries(lease.activeEvents()).filter((entry) => entry.type === 'file-history-snapshot' ||
                 entry.type === 'file-history-delta');
             if (projected.length === 0)
                 throw new Error(`Native session has no file history: ${sessionId}`);
@@ -2641,7 +2479,7 @@ export class ClaudeSessionService {
             const runUnderLease = async (lease, nativeLease) => {
                 const loadedSnapshot = await lease.load();
                 let snapshot = {
-                    entries: projectNativeEvents(nativeLease.activeEvents()),
+                    entries: projectNativeSessionEntries(nativeLease.activeEvents()),
                     tail: loadedSnapshot.tail,
                 };
                 const activeTurnMessages = () => {
@@ -2649,7 +2487,7 @@ export class ClaudeSessionService {
                     // after each append so memory/compaction sees the live branch.
                     snapshot = {
                         ...snapshot,
-                        entries: projectNativeEvents(nativeLease.activeEvents()),
+                        entries: projectNativeSessionEntries(nativeLease.activeEvents()),
                     };
                     return nativeLease.activeMessages();
                 };
@@ -3654,7 +3492,7 @@ export class ClaudeSessionService {
                                 }
                             }
                             const memorySelection = sessionMemory
-                                ? await this.selectMemoryPreservedCompact(sessionId, projectNativeEvents(activeNativeLease.activeEvents()))
+                                ? await this.selectMemoryPreservedCompact(sessionId, projectNativeSessionEntries(activeNativeLease.activeEvents()))
                                 : null;
                             if (memorySelection) {
                                 compactableMessages = [
@@ -4350,7 +4188,8 @@ export class ClaudeSessionService {
                     }
                     const memorySnapshot = activeTurnMessages();
                     const nativeMemoryMessageId = nativeLease
-                        ? projectNativeEvents(nativeLease.activeEvents()).at(-1)?.uuid
+                        ? projectNativeSessionEntries(nativeLease.activeEvents()).at(-1)
+                            ?.uuid
                         : undefined;
                     const providerVisibleMessages = [
                         ...contextMessages,