praxis-agent 0.35.0 → 0.37.0

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

@@ -0,0 +1,156 @@
+import { mkdir, open, readFile, rm } from 'node:fs/promises';
+import { basename, isAbsolute, resolve } from 'node:path';
+import { NativeSessionTranscript, } from './native-session-transcript.js';
+import { NativeTranscriptStore } from '../persistence/native-transcript-store.js';
+const permissionModes = new Set([
+    'acceptEdits',
+    'auto',
+    'bypassPermissions',
+    'default',
+    'dontAsk',
+    'plan',
+]);
+const requiredKeys = [
+    'agentType',
+    'description',
+    'toolUseId',
+    'spawnDepth',
+    'cwd',
+    'promptId',
+];
+const optionalKeys = [
+    'name',
+    'permissionMode',
+    'isolation',
+    'parentAgentId',
+    'worktreePath',
+];
+function nonBlank(value) {
+    return (typeof value === 'string' &&
+        value.trim().length > 0 &&
+        !value.includes('\0'));
+}
+function assertPaths(paths) {
+    for (const value of [
+        paths.sessionId,
+        paths.agentId,
+        paths.directory,
+        paths.transcriptFile,
+        paths.metadataFile,
+    ]) {
+        if (!nonBlank(value))
+            throw new Error('native sidechain paths are invalid');
+    }
+    if (!isAbsolute(paths.directory) ||
+        !isAbsolute(paths.transcriptFile) ||
+        !isAbsolute(paths.metadataFile))
+        throw new Error('native sidechain paths must be absolute');
+    const directory = resolve(paths.directory);
+    if (resolve(paths.transcriptFile) !==
+        resolve(directory, `agent-${paths.agentId}.jsonl`) ||
+        resolve(paths.metadataFile) !==
+            resolve(directory, `agent-${paths.agentId}.meta.json`) ||
+        basename(paths.transcriptFile) !== `agent-${paths.agentId}.jsonl` ||
+        basename(paths.metadataFile) !== `agent-${paths.agentId}.meta.json`)
+        throw new Error('native sidechain paths do not match agent identity');
+    if (paths.lockFile !== undefined &&
+        (!nonBlank(paths.lockFile) || !isAbsolute(paths.lockFile)))
+        throw new Error('native sidechain lock path is invalid');
+}
+function validateMetadata(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('native sidechain metadata must be an object');
+    const record = value;
+    if (Object.keys(record).some((key) => !requiredKeys.includes(key) && !optionalKeys.includes(key)))
+        throw new Error('native sidechain metadata contains unknown fields');
+    if (requiredKeys.some((key) => !(key in record)))
+        throw new Error('native sidechain metadata is invalid');
+    if (![record.agentType, record.description, record.toolUseId].every(nonBlank))
+        throw new Error('native sidechain metadata is invalid');
+    if (!Number.isSafeInteger(record.spawnDepth) ||
+        Number(record.spawnDepth) <= 0)
+        throw new Error('native sidechain metadata is invalid');
+    if (!nonBlank(record.cwd) || !isAbsolute(record.cwd))
+        throw new Error('native sidechain metadata cwd is invalid');
+    if (!nonBlank(record.promptId))
+        throw new Error('native sidechain metadata promptId is invalid');
+    if (record.name !== undefined && !nonBlank(record.name))
+        throw new Error('native sidechain metadata name is invalid');
+    if (record.permissionMode !== undefined &&
+        (typeof record.permissionMode !== 'string' ||
+            !permissionModes.has(record.permissionMode)))
+        throw new Error('native sidechain metadata permissionMode is invalid');
+    if (record.isolation !== undefined && record.isolation !== 'worktree')
+        throw new Error('native sidechain metadata isolation is invalid');
+    if (record.parentAgentId !== undefined &&
+        (typeof record.parentAgentId !== 'string' ||
+            !/^a[0-9a-f]{16}$/u.test(record.parentAgentId)))
+        throw new Error('native sidechain metadata parentAgentId is invalid');
+    if (record.worktreePath !== undefined &&
+        (!nonBlank(record.worktreePath) || !isAbsolute(record.worktreePath)))
+        throw new Error('native sidechain metadata worktreePath is invalid');
+    return {
+        ...record,
+        spawnDepth: Number(record.spawnDepth),
+    };
+}
+export class NativeSidechainTranscript {
+    paths;
+    transcript;
+    store;
+    constructor(paths) {
+        this.paths = paths;
+        assertPaths(paths);
+        this.store = new NativeTranscriptStore({
+            transcriptFile: paths.transcriptFile,
+            lockFile: paths.lockFile ?? `${paths.transcriptFile}.lock`,
+        });
+        this.transcript = new NativeSessionTranscript({
+            sessionId: paths.sessionId,
+            store: this.store,
+        });
+    }
+    async create(prompt, metadata) {
+        if (!nonBlank(prompt))
+            throw new Error('native sidechain prompt must not be blank');
+        const checked = validateMetadata(metadata);
+        await mkdir(this.paths.directory, { recursive: true });
+        let created = false;
+        try {
+            const handle = await open(this.paths.metadataFile, 'wx');
+            created = true;
+            try {
+                await handle.writeFile(`${JSON.stringify(checked)}\n`);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await this.transcript.withLease({ kind: 'start' }, async (lease) => {
+                await lease.appendMessages({
+                    messages: [{ role: 'user', content: prompt }],
+                });
+            });
+        }
+        catch (error) {
+            if (created)
+                await rm(this.paths.metadataFile, { force: true });
+            throw error;
+        }
+    }
+    withLease(operation) {
+        return this.transcript.withLease({ kind: 'resume' }, operation);
+    }
+    async loadReadOnly() {
+        const snapshot = await this.store.loadReadOnly();
+        if (snapshot.issue)
+            throw new Error(`Invalid native sidechain transcript: ${snapshot.issue.message}`);
+        if (snapshot.records.some((record) => record.event.sessionId !== this.paths.sessionId))
+            throw new Error('native sidechain transcript sessionId does not match paths');
+        return snapshot;
+    }
+    async metadata() {
+        return validateMetadata(JSON.parse(await readFile(this.paths.metadataFile, 'utf8')));
+    }
+}
+//# sourceMappingURL=native-sidechain-transcript.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';
@@ -26,10 +27,14 @@ import { type ClaudeToolRole } from '../tools/claude-capabilities.js';
 import type { ClaudeInteractiveToolManager } from '../tools/claude-interactive-tools.js';
 import type { ClaudePermissionMode } from '../permissions/claude-permission-resolver.js';
 import type { ClaudeMcpRuntime, ClaudeMcpServerStatus, ClaudeMcpToolInspection } from '../mcp/claude-mcp-tools.js';
+import type { TeamLeadOperations } from './team-lead-operations.js';
+type TeamLeadToolRegistryFactory = (base: ToolRegistry, operations: TeamLeadOperations, sessionId: string, enabledTools: readonly string[]) => ToolRegistry;
 export interface ClaudeSessionServiceOptions {
     configRoot: string;
     /** `claude` preserves the legacy shared layout; the CLI selects `native` by default. */
     dataPlane?: DataPlane;
+    /** Experimental canonical native transcript writes. */
+    experimentalNativeTranscriptWrites?: boolean;
     cwd: string;
     claudeVersion: string;
     provider?: ModelProvider;
@@ -55,6 +60,7 @@ export interface ClaudeSessionServiceOptions {
     subagentToolNames?: readonly string[];
     taskToolNames?: readonly string[];
     scheduledToolNames?: readonly string[];
+    teamToolNames?: readonly string[];
     /** Runtime gates for Claude capability-driven tool exposure. */
     toolRole?: ClaudeToolRole;
     toolCapabilityEnvironment?: Readonly<Record<string, string | undefined>>;
@@ -103,6 +109,10 @@ export interface ClaudeSessionServiceOptions {
     interactiveTools?: ClaudeInteractiveToolManager;
     mcp?: ClaudeMcpRuntime;
     costStateStore?: Pick<ClaudeCostStateStore, 'load' | 'save'>;
+    /** Shared internal Team lead operations port. */
+    teamLeadOperations?: TeamLeadOperations;
+    /** Lazily supplied Team tool wrapper, so disabled runs do not load Team code. */
+    teamLeadToolRegistryFactory?: TeamLeadToolRegistryFactory;
 }
 export interface SessionRunResult {
     sessionId: string;
@@ -138,14 +148,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;
@@ -218,6 +228,7 @@ export declare class ClaudeSessionService {
     private readonly sessionMemoryControllers;
     private resolvedSessionMemoryProvider;
     private readonly hookLifecycle;
+    private readonly leadOperations;
     private readonly fileChangeWatcher;
     private runtimeCwd;
     constructor(options: ClaudeSessionServiceOptions);
@@ -273,7 +284,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>;
@@ -344,8 +355,14 @@ export declare class ClaudeSessionService {
     private rememberDurableMetadata;
     private assertSessionPersistence;
     private assertWritable;
+    private assertTurnWritable;
     private sessionStatus;
+    private nativeSessionStatus;
+    private nativeTranscriptWritesEnabled;
+    private assertNativeTranscriptOptions;
+    private claudeSessionSummary;
     private provider;
+    private assertNativeWriteTargetIsLegacy;
     model(): string | undefined;
     private providerForAgent;
     private resolveAgent;
@@ -361,7 +378,9 @@ export declare class ClaudeSessionService {
     private sessionMemoryProviderFactory;
     private toolCapabilities;
     private capabilityToolNames;
+    private teamRegistry;
     private append;
     private logicalTailUuid;
 }
+export {};
 //# sourceMappingURL=session-service.d.ts.map