praxis-agent 0.36.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

@@ -27,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;
@@ -56,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>>;
@@ -104,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;
@@ -219,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);
@@ -345,8 +355,11 @@ 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;
@@ -365,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