praxis-agent 0.38.0 → 0.40.0

package/README.md

@@ -17,15 +17,10 @@ Anthropic/OpenAI-compatible model access. Praxis deliberately excludes
 accounts, organizations, billing, managed enterprise policy, remote control,
 IDE surfaces, and telemetry control planes.
 
-Claude Code 2.1.208 remains the architecture, design, and observable
-compatibility baseline for included and required single-user developer
-capabilities. Only entries classified `required` block developer-core
-closure; `deferred` entries are optional and demand-driven. Exclusions cover
-the existing enterprise, authentication, hosted, and client surfaces plus the
-explicitly classified subscription-bound integration, campaign, hidden
-maintainer diagnostic, and build-experimental commands. A similar Praxis
-surface is not a substitute for the corresponding Claude command or runtime
-contract.
+Claude Code 2.1.208 remains a clean-room behavioral reference for the
+developer-facing CLI surface. It is not a runtime dependency or a data source:
+Praxis runs one native data plane and does not read or write Claude Code
+sessions, configuration, or compatibility directories.
 
 ## Requirements
 
@@ -34,13 +29,12 @@ contract.
 - [`ripgrep`](https://github.com/BurntSushi/ripgrep) (`rg`) for the Grep tool
 - an API key and model ID for an Anthropic or OpenAI-compatible provider
 
-Praxis does not use Claude subscription authentication. Claude Code
-interoperability covers local sessions, configuration, permissions, memory,
-skills, hooks, agents, plugins, and MCP data.
+Praxis does not use Claude subscription authentication. Claude-shaped message,
+tool, and CLI protocol forms remain supported where they are part of the
+public surface, while all persisted state is Praxis-native.
 
-Claude Team compatibility is explicit and fail-closed: supported delete/send
-wire shapes route through native Team operations, while lossy or unsupported
-Team surfaces are rejected rather than silently simplified.
+Team operations are local-only and opt-in. Unsupported or lossy Team payloads
+are rejected rather than silently simplified.
 
 ## Install
 
@@ -89,14 +83,15 @@ praxis doctor
 
 See
 [Getting Started](https://github.com/Forest-Isle/Praxis/blob/main/docs/GETTING_STARTED.md)
-for provider setup, shared Claude state, permissions, updating, and
+for provider setup, shared Praxis state, permissions, updating, and
 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, plus a shared-command
+  surface with the reusable P-loop + spark Praxis mark and ANSI/no-color
+  fallbacks, 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,
@@ -111,12 +106,34 @@ 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,
   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,
   interactive `/doctor` diagnostics, per-session model/effort/permission controls,
   context/status/skill/task dashboards, prompt stash and continuation shortcuts,
   filterable `@` file and agent references, composer undo, `Ctrl+G` external
   editing, shared `/keybindings` creation/editing and supported-action remapping,
-  shared built-in and Claude-compatible custom `/theme` profiles with immediate
+  shared built-in and custom `/theme` profiles with immediate
   semantic recoloring, token editing/reset, deletion, and persisted syntax
   toggles across transcript code and diff views,
   shared runtime preferences for reduced motion, spinner tips, progress and
@@ -174,16 +191,12 @@ troubleshooting. Run `praxis --help` for the authoritative command surface.
   Lead Decision queue with provenance. Coordinator leads are restricted to
   orchestration, and custom Team agents receive no MCP capability. The native
   CLI also exposes `praxis team status`, `logs`, and `attach` in human or JSON
-  form; durable-local attach does not require tmux. The Claude Team adapter is
-  removable and currently limited to fixture-verified delete/send; Claude create
-  is decoded but rejected when the payload cannot represent native roster/task
-  claims,
-  shutdown, and plan-response shapes; native task, notification, context, and
-  Team resume/inbox seams are implemented, while their Claude-facing zero-skip
-  qualification remains explicitly separate.
-- **Claude-compatible ecosystem** — shared instructions with recursive `@`
+  form; durable-local attach does not require tmux. Native task, notification,
+  context, and Team resume/inbox seams are implemented with fail-closed
+  validation for unsupported payloads.
+- **Native resource ecosystem** — shared Praxis instructions with recursive `@`
   imports, memory, skills, commands, agents, hooks, settings, MCP servers,
-  plugins, and transcript data.
+  plugins, and append-only `praxis.transcript` JSONL sessions under `~/.praxis`.
 - **Provider-neutral models** — native Anthropic Messages and OpenAI-compatible
   streaming adapters with explicit capability checks and metering controls.
 
@@ -191,39 +204,6 @@ Detailed feature status and executable evidence live in the
 [parity matrix](https://github.com/Forest-Isle/Praxis/blob/main/docs/PARITY_MATRIX.md),
 not in this entry-point README.
 
-## Claude Code interoperability
-
-Praxis uses an independent local data plane by default:
-
-```text
-Praxis ─── ~/.praxis (or PRAXIS_HOME)
-```
-
-Use `praxis --data-plane claude` when you need the legacy shared Claude Code
-layout (`~/.claude` or `CLAUDE_CONFIG_DIR`). Praxis can resume Claude Code
-sessions in that mode, and Claude Code can resume compatible sessions written
-there. Every semver-like Claude Code producer version is
-structurally validated and is read/write compatible when its entry shape is
-supported; schema adapters are selected from transcript entry structure rather
-than an installed or fixed producer version, and malformed or unsupported
-shapes fail closed before any write. Each transcript record keeps its original
-producer version, so supported shapes may be mixed across versions in one
-session. Native fork creation is a separate restricted lossless copy path that
-preserves each existing source record's producer version, so it can copy
-specific black-box-verified foreign shapes such as the observed Claude Code
-2.1.233 records; unsupported record shapes and unverified versions still fail
-closed and remain read-only. Maintainers can prove mixed-version Claude JSONL interoperability with
-`npm run test:cross-version-session-compat`, `test:cross-version-fork-compat`,
-`test:cross-version-sidechain-compat`, `test:cross-version-compaction-compat`,
-and `test:cross-version-resume-at-compat`, covering linear resume, native fork,
-foreground sidechain, compaction, and `--resume-session-at` branch projection.
-Each requires `PRAXIS_CLAUDE_BINARY` (Claude Code 2.1.208) and
-`PRAXIS_CLAUDE_CROSS_VERSION_BINARY` (a different Claude Code version).
-
-See the
-[compatibility contract](https://github.com/Forest-Isle/Praxis/blob/main/docs/COMPATIBILITY.md)
-for exact shared data, version boundaries, exclusions, and verification gates.
-
 ## Documentation
 
 | Need                                       | Document                                                                                   |
@@ -268,15 +248,12 @@ npm ci
 npm run check
 ```
 
-`npm run build:native` compiles the implemented Praxis-owned core, provider,
-native transcript, and session profile without the Claude compatibility adapter.
+`npm run build:native` compiles the Praxis-owned core, provider, native
+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.
-Native transcript migration remains explicit and recoverable. The built-CLI
-smoke gate `npm run verify:native-migration-cli` exercises all-session dry-run,
-publication, text/JSON idempotence, rollback, and Claude-data-plane exclusion.
-The isolated active-stream regression proof is available through
-`npm run test:performance:active-stream`; the product p95 budget remains 50 ms.
+`npm run test:performance` runs the native projection scaling and regression
+budgets; the retained-render p95 budget remains 50 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/background-agent-manager.js

@@ -1,8 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { isTerminalLifecycleState, } from '../core/agent-orchestration.js';
-import { isClaudeAgentId } from '../compatibility/claude/sidechain.js';
 const MAX_TIMEOUT_MS = 600_000;
 const DEFAULT_CLOSE_DRAIN_MS = 5_000;
+const NATIVE_AGENT_ID_PATTERN = /^a[0-9a-f]{16}$/u;
+function isNativeAgentId(agentId) {
+    return NATIVE_AGENT_ID_PATTERN.test(agentId);
+}
 export class BackgroundAgentRunError extends Error {
     result;
     constructor(message, result, cause) {
@@ -37,7 +40,7 @@ function notificationWireStatus(status) {
     return null;
 }
 function assertAgentId(agentId) {
-    if (!isClaudeAgentId(agentId)) {
+    if (!isNativeAgentId(agentId)) {
         throw new Error(`Invalid background agent ID: ${agentId}`);
     }
 }
@@ -625,7 +628,7 @@ export class BackgroundAgentManager {
         return { task, created: true };
     }
     resolveOptional(identifier) {
-        if (isClaudeAgentId(identifier))
+        if (isNativeAgentId(identifier))
             return identifier;
         return this.names.get(identifier);
     }
@@ -669,7 +672,7 @@ export class BackgroundAgentManager {
     }
     resolveRequired(identifier) {
         const resolved = this.resolveOptional(identifier);
-        if (!isClaudeAgentId(identifier) &&
+        if (!isNativeAgentId(identifier) &&
             !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u.test(identifier)) {
             assertAgentId(identifier);
         }

package/dist/application/background-bash-manager.d.ts

@@ -32,8 +32,8 @@ export interface BackgroundBashToolResult {
         task?: Record<string, unknown>;
     };
 }
-export declare function claudeBackgroundTaskParent(cwd: string): string;
-export declare function claudeBackgroundTaskRoot(cwd: string, sessionId: string): string;
+export declare function nativeBackgroundTaskParent(cwd: string): string;
+export declare function nativeBackgroundTaskRoot(cwd: string, sessionId: string): string;
 export declare class BackgroundBashManager {
     private readonly options;
     private readonly tasks;

package/dist/application/background-bash-manager.js

@@ -1,16 +1,16 @@
 import { mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { sanitizeClaudeProjectPath } from '../compatibility/claude/paths.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
 import { writeFileAtomically } from '../platform/atomic-write.js';
 import { BoundedProcessRunner, } from '../platform/bounded-process-runner.js';
 import { commandShell, commandShellArguments, } from '../platform/command-shell.js';
 import { assertBackgroundBashTaskId, backgroundBashTaskIdFromStateFile, createBackgroundBashTaskId, } from './background-task-id.js';
-export function claudeBackgroundTaskParent(cwd) {
+export function nativeBackgroundTaskParent(cwd) {
     const uid = process.getuid?.() ?? 'unknown';
-    return resolve('/tmp', `claude-${uid}`, sanitizeClaudeProjectPath(resolve(cwd)));
+    return resolve('/tmp', `praxis-${uid}`, sanitizeProjectPath(resolve(cwd)));
 }
-export function claudeBackgroundTaskRoot(cwd, sessionId) {
-    return resolve(claudeBackgroundTaskParent(cwd), sessionId, 'tasks');
+export function nativeBackgroundTaskRoot(cwd, sessionId) {
+    return resolve(nativeBackgroundTaskParent(cwd), sessionId, 'tasks');
 }
 function parsePersistedTask(source, taskId, outputFile) {
     let value;
@@ -65,7 +65,7 @@ export class BackgroundBashManager {
             cwd: options.cwd,
             maxOutputBytes: options.maxOutputBytes ?? 128 * 1024,
         });
-        this.outputRoot = claudeBackgroundTaskRoot(options.cwd, options.sessionId);
+        this.outputRoot = nativeBackgroundTaskRoot(options.cwd, options.sessionId);
         this.sessionStateRoot = resolve(options.stateRoot, options.sessionId);
     }
     has(taskId) {

package/dist/application/claude-project-purge.js

@@ -1,9 +1,10 @@
 import { lstat, readFile, readdir, realpath, rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from 'node:path';
-import { isClaudeSessionId, sanitizeClaudeProjectPath, } from '../compatibility/claude/paths.js';
-import { resolveClaudeProjectIdentity } from '../compatibility/claude/shared-resources.js';
+import { isSessionId } from '../core/session.js';
 import { writeFileAtomically } from '../platform/atomic-write.js';
+import { resolveProjectIdentity } from '../platform/project-identity.js';
+import { sanitizeProjectPath } from '../platform/project-path-key.js';
 const MAX_ATOMIC_UPDATE_RETRIES = 8;
 function errorCode(error) {
     return error.code;
@@ -182,17 +183,17 @@ async function discoverSessionIds(projectRoot) {
     for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith('.jsonl')) {
             const sessionId = entry.name.slice(0, -'.jsonl'.length);
-            if (isClaudeSessionId(sessionId))
+            if (isSessionId(sessionId))
                 sessionIds.add(sessionId);
         }
-        if (entry.isDirectory() && isClaudeSessionId(entry.name)) {
+        if (entry.isDirectory() && isSessionId(entry.name)) {
             sessionIds.add(entry.name);
         }
     }
     return [...sessionIds].sort();
 }
-async function discoverProjectRoots(configRoot, targetPaths, dataPlane) {
-    const projectsRoot = join(configRoot, dataPlane === 'native' ? 'sessions' : 'projects');
+async function discoverProjectRoots(configRoot, targetPaths) {
+    const projectsRoot = join(configRoot, 'sessions');
     if (!(await pathExists(projectsRoot)))
         return [];
     await assertSafePurgePath(configRoot, projectsRoot);
@@ -206,8 +207,8 @@ async function discoverProjectRoots(configRoot, targetPaths, dataPlane) {
         }
         throw error;
     }
-    const targetKeys = targetPaths.map(sanitizeClaudeProjectPath);
-    const worktreeSegment = dataPlane === 'native' ? '--praxis-worktrees-' : '--claude-worktrees-';
+    const targetKeys = targetPaths.map(sanitizeProjectPath);
+    const worktreeSegment = '--praxis-worktrees-';
     return entries
         .filter((entry) => targetKeys.some((targetKey) => entry.name === targetKey ||
         entry.name.startsWith(`${targetKey}${worktreeSegment}`)))
@@ -231,32 +232,18 @@ async function addExistingPath(items, configRoot, item) {
     items.push(item);
 }
 export async function planClaudeProjectPurge(options) {
+    void options.dataPlane;
     if (options.all && options.path !== undefined) {
         throw new Error('Cannot specify both a path and --all');
     }
     const configuredRoot = options.configRoot ??
-        (process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude'));
+        (process.env.PRAXIS_HOME || join(homedir(), '.praxis'));
     const configRoot = await canonicalPath(configuredRoot);
-    const dataPlane = options.dataPlane ?? 'claude';
-    const homeDirectory = options.homeDirectory ?? homedir();
-    const legacyClaudeStatePath = resolve(homeDirectory, '.claude.json');
-    const legacyClaudeConfigRoot = await canonicalPath(resolve(homeDirectory, '.claude'));
-    const defaultStatePath = dataPlane === 'native'
-        ? join(configRoot, 'state.json')
-        : options.configRoot !== undefined ||
-            Boolean(process.env.CLAUDE_CONFIG_DIR)
-            ? join(configRoot, '.claude.json')
-            : legacyClaudeStatePath;
+    const defaultStatePath = join(configRoot, 'state.json');
     const statePath = resolve(options.statePath ?? defaultStatePath);
-    const usesLegacyDefaultClaudeState = dataPlane === 'claude' &&
-        !process.env.CLAUDE_CONFIG_DIR &&
-        configRoot === legacyClaudeConfigRoot &&
-        statePath === legacyClaudeStatePath;
     const canonicalStateParent = await canonicalPath(dirname(statePath));
-    if (!usesLegacyDefaultClaudeState) {
-        assertLexicallyContained(configRoot, join(canonicalStateParent, basename(statePath)));
-    }
-    await assertMutableRegularFile(statePath, usesLegacyDefaultClaudeState ? canonicalStateParent : configRoot);
+    assertLexicallyContained(configRoot, join(canonicalStateParent, basename(statePath)));
+    await assertMutableRegularFile(statePath, configRoot);
     const state = parseState(await readOptionalFile(statePath), statePath);
     const projects = stateProjects(state);
     const items = [];
@@ -264,30 +251,22 @@ export async function planClaudeProjectPurge(options) {
         const roots = [
             {
                 kind: 'project',
-                name: dataPlane === 'native' ? 'sessions' : 'projects',
-                description: dataPlane === 'native'
-                    ? 'all project transcripts'
-                    : 'all project transcripts and memory',
+                name: 'sessions',
+                description: 'all project transcripts',
+            },
+            {
+                kind: 'memory',
+                name: 'memory',
+                description: 'all project memory',
+            },
+            {
+                kind: 'scheduled',
+                name: 'scheduled',
+                description: 'all project scheduled prompts',
             },
-            ...(dataPlane === 'native'
-                ? [
-                    {
-                        kind: 'memory',
-                        name: 'memory',
-                        description: 'all project memory',
-                    },
-                    {
-                        kind: 'scheduled',
-                        name: 'scheduled',
-                        description: 'all project scheduled prompts',
-                    },
-                ]
-                : []),
             {
                 kind: 'memory',
-                name: dataPlane === 'native'
-                    ? join('state', 'project-memory')
-                    : join('praxis', 'project-memory'),
+                name: join('state', 'project-memory'),
                 description: 'all private Project-memory operational state',
             },
             {
@@ -330,9 +309,6 @@ export async function planClaudeProjectPurge(options) {
             mode: 'all',
             configRoot,
             statePath,
-            ...(usesLegacyDefaultClaudeState
-                ? { allowStateOutsideConfigRoot: true }
-                : {}),
             projectRootPaths: [],
             sessionIds: [],
             items,
@@ -341,10 +317,8 @@ export async function planClaudeProjectPurge(options) {
     const requestedPath = resolve(options.path ?? options.cwd);
     const targetPath = await canonicalPath(requestedPath);
     const targetPaths = [...new Set([requestedPath, targetPath])];
-    const projectIdentity = await resolveClaudeProjectIdentity({
-        cwd: targetPath,
-    });
-    const projectRootPaths = await discoverProjectRoots(configRoot, targetPaths, dataPlane);
+    const projectIdentity = await resolveProjectIdentity(targetPath);
+    const projectRootPaths = await discoverProjectRoots(configRoot, targetPaths);
     const sessionIdSet = new Set();
     for (const projectRoot of projectRootPaths) {
         await assertSafePurgePath(configRoot, projectRoot);
@@ -359,26 +333,17 @@ export async function planClaudeProjectPurge(options) {
         await addExistingPath(items, configRoot, removePathItem('file-history', join(configRoot, 'file-history', sessionId), `file edit history for session ${sessionId}`));
     }
     const projectKeys = new Set([
-        ...targetPaths.map(sanitizeClaudeProjectPath),
+        ...targetPaths.map(sanitizeProjectPath),
         ...projectRootPaths.map((path) => basename(path)),
-        sanitizeClaudeProjectPath(projectIdentity),
+        sanitizeProjectPath(projectIdentity),
     ]);
-    if (dataPlane === 'native') {
-        for (const projectKey of projectKeys) {
-            await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'memory', projectKey), `memory for project ${projectKey}`));
-            await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'state', 'project-memory', projectKey), `private Project-memory state for project ${projectKey}`));
-            await addExistingPath(items, configRoot, removePathItem('scheduled', join(configRoot, 'scheduled', `${projectKey}.json`), `scheduled prompts for project ${projectKey}`));
-        }
-    }
-    else {
-        for (const projectKey of projectKeys) {
-            await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'praxis', 'project-memory', projectKey), `private Project-memory state for project ${projectKey}`));
-        }
+    for (const projectKey of projectKeys) {
+        await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'memory', projectKey), `memory for project ${projectKey}`));
+        await addExistingPath(items, configRoot, removePathItem('memory', join(configRoot, 'state', 'project-memory', projectKey), `private Project-memory state for project ${projectKey}`));
+        await addExistingPath(items, configRoot, removePathItem('scheduled', join(configRoot, 'scheduled', `${projectKey}.json`), `scheduled prompts for project ${projectKey}`));
     }
     for (const projectRoot of projectRootPaths) {
-        await addExistingPath(items, configRoot, removePathItem('project', projectRoot, dataPlane === 'native'
-            ? 'project transcripts'
-            : 'project transcripts and memory'));
+        await addExistingPath(items, configRoot, removePathItem('project', projectRoot, 'project transcripts'));
     }
     const historyPath = join(configRoot, 'history.jsonl');
     const historyExists = await pathExists(historyPath);
@@ -420,9 +385,6 @@ export async function planClaudeProjectPurge(options) {
         mode: 'project',
         configRoot,
         statePath,
-        ...(usesLegacyDefaultClaudeState
-            ? { allowStateOutsideConfigRoot: true }
-            : {}),
         targetPath,
         projectIdentity,
         projectRootPaths,

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

@@ -1,6 +1,10 @@
 import type { ModelMessage, ModelToolCall, ToolExecutionResult } from '../core/runtime.js';
-import type { TranscriptMessagesEvent } from '../core/transcript-event.js';
-import type { NativeTranscriptStore } from '../persistence/native-transcript-store.js';
+import type { TranscriptEvent, TranscriptMessagesEvent } from '../core/transcript-event.js';
+import type { NativeTranscriptLease, NativeTranscriptLeaseResult } from '../persistence/native-transcript-store.js';
+/** Minimal transcript-store contract required by the native session facade. */
+export interface NativeSessionTranscriptStore {
+    withLease<T>(operation: (lease: NativeTranscriptLease) => Promise<T>): Promise<NativeTranscriptLeaseResult<T>>;
+}
 export type NativeTranscriptActivation = {
     readonly kind: 'start';
 } | {
@@ -19,6 +23,11 @@ export interface NativeCompactionAppend {
     readonly postTokens: number;
     readonly durationMs: number;
     readonly preservedMessages?: readonly ModelMessage[];
+    /** Optional parent in the active branch when compacting a selected range. */
+    readonly logicalParentId?: string;
+    readonly direction?: 'from' | 'up_to';
+    readonly messagesSummarized?: number;
+    readonly preservePrefix?: boolean;
 }
 export type NativeInterruption = {
     readonly kind: 'complete' | 'none';
@@ -35,6 +44,8 @@ export type NativeInterruption = {
     readonly callIds: readonly string[];
 };
 export interface NativeSessionTranscriptLease {
+    /** Events on the currently selected active branch, in parent order. */
+    activeEvents(): TranscriptEvent[];
     activeMessages(): ModelMessage[];
     interruption(): NativeInterruption;
     beginToolExecution(callId: string): Promise<void>;
@@ -56,7 +67,7 @@ export interface NativeForkOptions {
 }
 export interface NativeSessionTranscriptOptions {
     readonly sessionId: string;
-    readonly store: NativeTranscriptStore;
+    readonly store: NativeSessionTranscriptStore;
     readonly createId?: () => string;
     readonly now?: () => string;
 }

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

@@ -83,6 +83,14 @@ export class NativeSessionTranscript {
             const initial = prepared;
             const currentId = selectedId ?? initial.records.at(-1)?.event.id ?? null;
             const records = [...initial.records];
+            const usedIds = new Set(records.map((record) => record.event.id));
+            const createUniqueId = () => {
+                let id = this.createId();
+                while (usedIds.has(id))
+                    id = this.createId();
+                usedIds.add(id);
+                return id;
+            };
             let tail = currentId === null
                 ? initial.tail
                 : { ...initial.tail, branchParentId: currentId };
@@ -94,6 +102,7 @@ export class NativeSessionTranscript {
                 return result;
             };
             const lease = {
+                activeEvents: () => activeEvents(records.map((record) => record.event), activeId ?? undefined).slice(),
                 activeMessages: () => projectActiveMessages(records.map((record) => record.event), activeId ?? undefined).slice(),
                 interruption: () => {
                     const events = activeEvents(records.map((record) => record.event), activeId ?? undefined);
@@ -166,7 +175,7 @@ export class NativeSessionTranscript {
                         throw new Error(`Native tool call already claimed: ${callId}`);
                     const event = {
                         kind: 'tool-execution-started',
-                        id: this.createId(),
+                        id: createUniqueId(),
                         parentId: activeId,
                         sessionId: this.sessionId,
                         timestamp: this.now(),
@@ -196,7 +205,7 @@ export class NativeSessionTranscript {
                         throw new Error(`Native tool call is already resolved: ${callId}`);
                     const event = {
                         kind: 'messages',
-                        id: this.createId(),
+                        id: createUniqueId(),
                         parentId: activeId,
                         sessionId: this.sessionId,
                         timestamp: this.now(),
@@ -232,7 +241,7 @@ export class NativeSessionTranscript {
                         throw new Error('native transcript cannot append empty messages');
                     const event = {
                         kind: 'messages',
-                        id: this.createId(),
+                        id: createUniqueId(),
                         parentId: activeId,
                         sessionId: this.sessionId,
                         timestamp: this.now(),
@@ -266,19 +275,28 @@ export class NativeSessionTranscript {
                     const events = records.map((record) => record.event);
                     if (unresolvedActiveToolCallIds(projectActiveMessages(events, activeId)).length > 0)
                         throw new Error('Cannot compact a native transcript with unresolved tool calls');
-                    const boundaryId = this.createId();
-                    const summaryId = this.createId();
+                    const boundaryId = createUniqueId();
+                    const summaryId = createUniqueId();
                     const boundary = {
                         kind: 'context-boundary',
                         id: boundaryId,
                         parentId: null,
                         sessionId: this.sessionId,
                         timestamp: this.now(),
-                        logicalParentId: activeId,
+                        logicalParentId: input.logicalParentId ?? activeId,
                         trigger: input.trigger,
                         preTokens: input.preTokens,
                         postTokens: input.postTokens,
                         durationMs: input.durationMs,
+                        ...(input.direction === undefined
+                            ? {}
+                            : { direction: input.direction }),
+                        ...(input.messagesSummarized === undefined
+                            ? {}
+                            : { messagesSummarized: input.messagesSummarized }),
+                        ...(input.preservePrefix === undefined
+                            ? {}
+                            : { preservePrefix: input.preservePrefix }),
                     };
                     const summary = {
                         kind: 'context-summary',
@@ -294,9 +312,12 @@ export class NativeSessionTranscript {
                         if (message.role !== 'assistant')
                             continue;
                         for (const call of message.toolCalls ?? [])
-                            replayToolCallIds.set(call.id, this.createId());
+                            replayToolCallIds.set(call.id, createUniqueId());
                     }
-                    const replaySuffix = suffix.map((message) => {
+                    const replaySuffix = suffix
+                        .filter((message) => message.role !== 'tool' ||
+                        replayToolCallIds.has(message.toolCallId))
+                        .map((message) => {
                         if (message.role === 'assistant')
                             return {
                                 ...message,
@@ -320,7 +341,7 @@ export class NativeSessionTranscript {
                     const suffixEvent = replaySuffix.length
                         ? {
                             kind: 'messages',
-                            id: this.createId(),
+                            id: createUniqueId(),
                             parentId: summaryId,
                             sessionId: this.sessionId,
                             timestamp: this.now(),

package/dist/application/scheduled-prompt-manager.d.ts

@@ -1,4 +1,4 @@
-import { type ClaudeScheduledTask } from '../persistence/claude-scheduled-task-store.js';
+import { type NativeScheduledTask } from '../persistence/native-scheduled-task-store.js';
 export declare const MAX_JOBS = 50;
 export declare class ScheduledJobLimitError extends Error {
     readonly maxJobs: number;
@@ -24,7 +24,7 @@ export interface ScheduledPrompt {
     id: string;
     prompt: string;
 }
-export interface ListedScheduledPrompt extends ClaudeScheduledTask {
+export interface ListedScheduledPrompt extends NativeScheduledTask {
     durable: boolean;
 }
 export interface DynamicWakeupResult {

package/dist/application/scheduled-prompt-manager.js

@@ -2,7 +2,7 @@ import { execFile } from 'node:child_process';
 import { randomBytes } from 'node:crypto';
 import { promisify } from 'node:util';
 import { CronExpressionParser } from 'cron-parser';
-import { ClaudeScheduledTaskLimitError, ClaudeScheduledTaskStore, } from '../persistence/claude-scheduled-task-store.js';
+import { NativeScheduledTaskLimitError, NativeScheduledTaskStore, } from '../persistence/native-scheduled-task-store.js';
 const execFileAsync = promisify(execFile);
 const RECURRING_LIFETIME_MS = 7 * 24 * 60 * 60 * 1_000;
 const MIN_DYNAMIC_WAKEUP_SECONDS = 60;
@@ -111,7 +111,7 @@ export class ScheduledPromptManager {
     initialization;
     closed = false;
     constructor(options) {
-        this.store = new ClaudeScheduledTaskStore({
+        this.store = new NativeScheduledTaskStore({
             filePath: options.filePath,
             lockFile: options.lockFile,
         });
@@ -145,7 +145,7 @@ export class ScheduledPromptManager {
                 task = await this.store.create(base, { maxJobs: MAX_JOBS });
             }
             catch (error) {
-                if (error instanceof ClaudeScheduledTaskLimitError) {
+                if (error instanceof NativeScheduledTaskLimitError) {
                     throw new ScheduledJobLimitError(MAX_JOBS);
                 }
                 throw error;