praxis-agent 0.35.0 → 0.37.0

package/dist/cli-runtime.d.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { type ForkResult, type ManualCompactResult, type ManualCompactSelection, type RewindPoint, type SessionForkCheckpoint, type SessionInspection, type SessionRunResult, type SessionSummary, type SideQuestionForkResult, type SideQuestionResult } from './application/session-service.js';
+import type { TeamLeadOperations } from './application/team-lead-operations.js';
 import type { ClaudeSessionCostSnapshot } from './application/session-cost-tracker.js';
 import { type AgentColorName, type AgentColorSelection } from './compatibility/claude/agent-color.js';
-import type { ClaudeDisplayTranscriptItem } from './compatibility/claude/projection.js';
+import type { TranscriptDisplayItem } from './application/transcript-projection.js';
 import { type DataPlane } from './persistence/data-plane.js';
 import { type ModelDocument, type ModelImage, type ModelProvider, type ModelToolCall, type PermissionApproval, type PermissionDecision, type ToolRegistry, type RuntimeEventSink } from './core/runtime.js';
 import type { InteractiveResumeOptions, InteractiveServiceFactory } from './cli/interactive.js';
@@ -28,6 +29,7 @@ export interface CliIO {
     readStdinLines?: () => AsyncIterable<string | Uint8Array>;
 }
 interface SessionCommands {
+    teamLeadOperations?: TeamLeadOperations;
     toolRegistry?: ToolRegistry;
     run(prompt: string, signal?: AbortSignal, sessionId?: string, name?: string, images?: readonly ModelImage[], documents?: readonly ModelDocument[]): Promise<SessionRunResult>;
     resume(sessionId: string, prompt: string, signal?: AbortSignal, name?: string, images?: readonly ModelImage[], documents?: readonly ModelDocument[]): Promise<SessionRunResult>;
@@ -60,7 +62,7 @@ interface SessionCommands {
     registerResumePath?(path: string): Promise<SessionSummary>;
     inspect(sessionId: string): Promise<SessionInspection>;
     export(sessionId: string): Promise<Buffer>;
-    transcript?(sessionId: string): Promise<ClaudeDisplayTranscriptItem[]>;
+    transcript?(sessionId: string): Promise<TranscriptDisplayItem[]>;
     costSnapshot?(sessionId: string): Promise<ClaudeSessionCostSnapshot>;
     compact?(sessionId: string, signal?: AbortSignal, selection?: ManualCompactSelection): Promise<ManualCompactResult>;
     rename?(sessionId: string, name: string): Promise<void>;

package/dist/cli-runtime.js

@@ -26,6 +26,7 @@ import { loadClaudeReleaseNotes } from './cli/tui/release-notes.js';
 import { canonicalClaudeCostModelName, formatCostSummary, } from './cli/tui/cost-summary.js';
 import { projectTuiHooks, } from './cli/tui/hook-settings.js';
 import { DEFAULT_CLI_CONTROLS, resolveCliControls } from './cli/controls.js';
+import { PRAXIS_TEAM_TOOLS, resolveClaudeToolCapabilities, } from './tools/claude-capabilities.js';
 import { applyRuntimeSettingDefaults, loadRuntimeSettings, runtimeSettingsSystemPrompt, } from './cli/tui/runtime-settings.js';
 import { createCliDebugSink } from './cli/debug.js';
 import { ClaudePermissionResolver, } from './permissions/claude-permission-resolver.js';
@@ -160,6 +161,7 @@ Usage:
   praxis attach <agent-id>
   praxis logs <agent-id>
   praxis stop <agent-id>
+  praxis team <create|resume|list|accept|stop> ...
   praxis mcp <list|get|add|add-json|remove|reset-project-choices|login|logout|serve> ...
   praxis auto-mode <config|defaults|critique>
   praxis plugin|plugins <details|list|install|uninstall|enable|disable|update|init|prune|tag|validate|marketplace> ...
@@ -738,6 +740,15 @@ Options:
   --json      Output a machine-readable result
   -h, --help  Show help
 `;
+const TEAM_HELP = `Usage: praxis team <command>
+
+Commands:
+  create <manifest.json> --lead-session-id <id> [--json]
+  resume <team-id> --lead-session-id <id> [--json]
+  list [--json]
+  accept <team-id> <task-id> --lead-session-id <id> [--generation <n>] [--decision accepted|rejected] [--json]
+  stop <team-id> --lead-session-id <id> [--drain-ms <ms>] [--json]
+`;
 export { parseContextEnvironment, parseProviderEnvironment };
 const consoleIO = {
     stdout: (message) => process.stdout.write(message),
@@ -788,6 +799,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const cwd = requestedCwd ?? process.cwd();
     const workspace = new WorkspaceContext(cwd);
     const dataPlane = controls.dataPlane ?? resolveDataPlane(runtimeEnvironment);
+    const experimentalNativeTranscriptWrites = /^(?:1|true|yes|on)$/iu.test((runtimeEnvironment.PRAXIS_EXPERIMENTAL_NATIVE_TRANSCRIPT_WRITES ?? '').trim());
     const configRoot = resolveDataPlaneRoot({
         dataPlane,
         ...(requestedConfigRoot === undefined ? {} : { root: requestedConfigRoot }),
@@ -812,6 +824,41 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ? {}
             : { permissionMode: interactivePermissionMode }),
     }, cwd);
+    if (experimentalNativeTranscriptWrites) {
+        const incompatible = [
+            ['dataPlane', dataPlane !== 'native'],
+            ['sessionPersistence', cli.sessionPersistence === false],
+            ['interactive', interactive],
+            ['simpleMode', !simpleMode],
+            ['sessionKind', sessionKind !== undefined],
+            ['name', cli.name !== undefined],
+            [
+                'worktree',
+                cli.worktreeRequested === true || cli.worktreeName !== undefined,
+            ],
+            ['addDirectories', cli.additionalDirectories.length > 0],
+            ['fileResources', cli.fileResources.length > 0],
+            ['settings', cli.additionalSettings !== undefined],
+            ['settingSources', cli.settingSources !== undefined],
+            ['pluginDirectories', cli.pluginDirectories.length > 0],
+            ['pluginUrls', cli.pluginUrls.length > 0],
+            ['agent', agent !== undefined || cli.inlineAgents.length > 0],
+            ['mcp', cli.mcpConfigs.length > 0 || cli.strictMcpConfig],
+            [
+                'checkpointing',
+                cli.rewindFiles !== undefined ||
+                    /^(?:1|true|yes|on)$/iu.test((runtimeEnvironment.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING ?? '').trim()),
+            ],
+            [
+                'teams',
+                /^(?:1|true|yes|on)$/iu.test((runtimeEnvironment.PRAXIS_ENABLE_TEAMS ?? '').trim()),
+            ],
+        ];
+        const active = incompatible.find(([, enabled]) => enabled);
+        if (active) {
+            throw new Error(`experimental native transcript writes incompatible with ${active[0]}`);
+        }
+    }
     const debug = cli.debug !== undefined || cli.debugFile !== undefined
         ? createCliDebugSink(eventSink, {
             cwd,
@@ -878,6 +925,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const options = {
         configRoot,
         dataPlane,
+        ...(experimentalNativeTranscriptWrites
+            ? { experimentalNativeTranscriptWrites: true }
+            : {}),
         cwd,
         claudeVersion,
         eventSink: runtimeEventSink,
@@ -901,10 +951,14 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : { maxBudgetUsd: cli.maxBudgetUsd }),
         pricing: ModelPricingRegistry.fromEnvironment(runtimeEnvironment.PRAXIS_PRICING_JSON),
         collectMetrics: true,
-        ...(sessionMemoryProviderFactory ? { sessionMemoryProviderFactory } : {}),
-        ...(sessionKind === undefined ? {} : { sessionKind }),
-        workspace,
-        ...(cli.worktreeRequested
+        ...(!experimentalNativeTranscriptWrites && sessionMemoryProviderFactory
+            ? { sessionMemoryProviderFactory }
+            : {}),
+        ...(!experimentalNativeTranscriptWrites && sessionKind !== undefined
+            ? { sessionKind }
+            : {}),
+        ...(!experimentalNativeTranscriptWrites ? { workspace } : {}),
+        ...(!experimentalNativeTranscriptWrites && cli.worktreeRequested
             ? {
                 initialWorktree: true,
                 ...(cli.worktreeName === undefined
@@ -912,7 +966,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                     : { initialWorktreeName: cli.worktreeName }),
             }
             : {}),
-        ...(cli.fileResources.length > 0
+        ...(!experimentalNativeTranscriptWrites && cli.fileResources.length > 0
             ? {
                 fileResources: cli.fileResources,
                 fileResourceConfig: {
@@ -1375,6 +1429,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             'ScheduleWakeup',
         ];
         const workflowToolNames = ['Workflow'];
+        const teamToolNames = PRAXIS_TEAM_TOOLS;
         const worktreeToolNames = ['EnterWorktree', 'ExitWorktree'];
         const interactiveToolNames = [
             'AskUserQuestion',
@@ -1403,6 +1458,18 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 cli.tools.includes('default') ||
                 cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
+        const teamEnabled = resolveClaudeToolCapabilities({
+            role: 'main',
+            interactive,
+            simpleMode,
+            env: runtimeEnvironment,
+        }).has('TeamCreate');
+        const selectedTeamTools = teamToolNames.filter((name) => teamEnabled &&
+            !simpleMode &&
+            (cli.tools === undefined ||
+                cli.tools.includes('default') ||
+                cli.tools.includes(name)) &&
+            !cli.disallowedTools.includes(name));
         const selectedWorktreeTools = worktreeToolNames.filter((name) => !simpleMode &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
@@ -1431,6 +1498,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             !taskToolNames.includes(name) &&
             !scheduledToolNames.includes(name) &&
             !workflowToolNames.includes(name) &&
+            !teamToolNames.includes(name) &&
             !worktreeToolNames.includes(name) &&
             !interactiveToolNames.includes(name) &&
             (!simpleMode || (name !== 'WebFetch' && name !== 'WebSearch')));
@@ -1484,6 +1552,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                         ...selectedTaskRuntimeTools,
                         ...selectedScheduledTools,
                         ...selectedWorkflowTools,
+                        ...selectedTeamTools,
                         ...selectedWorktreeTools,
                         ...selectedInteractiveTools,
                         ...(enableSubagents ? selectedAgentTools : []),
@@ -1518,6 +1587,50 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 : {}),
             ...(simpleMode ? { bare: true } : {}),
         });
+        const teamModules = teamEnabled
+            ? await Promise.all([
+                import('./application/team-capability.js'),
+                import('./application/team-agent-runtime.js'),
+                import('./application/team-lead-operations.js'),
+                import('./tools/team-lead-tools.js'),
+            ])
+            : undefined;
+        const teamCapability = teamModules
+            ? new teamModules[0].LocalTeamCapability({
+                nativeRoot: resolveDataPlaneRoot({
+                    dataPlane: 'native',
+                    environment: runtimeEnvironment,
+                }),
+                cwd: () => workspace.cwd(),
+                maxConcurrent: teamModules[0].DEFAULT_LOCAL_TEAM_CONCURRENCY,
+                baseTools: filteredTools,
+                permissions,
+                createRuntime: () => new teamModules[1].ClaudeTeamAgentRuntime({
+                    nativeRoot: resolveDataPlaneRoot({
+                        dataPlane: 'native',
+                        environment: runtimeEnvironment,
+                    }),
+                    configRoot,
+                    claudeVersion,
+                    provider: hostedToolProvider,
+                    ...(extensions ? { extensions } : {}),
+                    ...(permissionApprover
+                        ? { approveTool: permissionApprover }
+                        : {}),
+                    ...(hooks ? { hooks } : {}),
+                    ...(contextAssembler ? { contextAssembler } : {}),
+                    ...(providerForModel ? { providerForModel } : {}),
+                    permissionResolverForMode,
+                    eventSink: runtimeEventSink,
+                }),
+            })
+            : undefined;
+        const teamLeadOperations = teamCapability && teamModules
+            ? new teamModules[2].TeamLeadOperations(teamCapability)
+            : undefined;
+        const teamLeadToolRegistryFactory = teamModules
+            ? (base, operations, sessionId, names) => new teamModules[3].TeamLeadToolRegistry(base, operations, sessionId, names)
+            : undefined;
         const service = new ClaudeSessionService({
             ...options,
             provider: hostedToolProvider,
@@ -1525,7 +1638,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ...(providerForMainModel ? { providerForMainModel } : {}),
             tools: filteredTools,
             toolCapabilityEnvironment: runtimeEnvironment,
-            mcp: mcpTools,
+            ...(!experimentalNativeTranscriptWrites ? { mcp: mcpTools } : {}),
             permissions,
             permissionResolverForMode,
             permissionMode: cli.dangerouslySkipPermissions
@@ -1537,41 +1650,72 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 dataPlane,
                 updates,
             }),
-            extensions,
-            enableSubagents,
-            subagentToolNames: routedSubagentTools,
-            taskToolNames: selectedTaskRuntimeTools,
-            scheduledToolNames: selectedScheduledTools,
-            enableDynamicWakeups: interactive,
-            enableWorkflows: selectedWorkflowTools.length > 0,
+            ...(experimentalNativeTranscriptWrites
+                ? {}
+                : {
+                    extensions,
+                    enableSubagents,
+                    subagentToolNames: routedSubagentTools,
+                    taskToolNames: selectedTaskRuntimeTools,
+                    scheduledToolNames: selectedScheduledTools,
+                    teamToolNames: selectedTeamTools,
+                    enableDynamicWakeups: interactive,
+                    enableWorkflows: selectedWorkflowTools.length > 0,
+                }),
             emitToolUseSummaries,
-            enableWorktrees: cli.worktreeRequested || selectedWorktreeTools.length > 0,
-            worktreeToolNames: selectedWorktreeTools,
-            ...(runtimeSettings
-                ? { worktreeBaseRef: runtimeSettings.worktreeBaseRef }
+            ...(!experimentalNativeTranscriptWrites
+                ? {
+                    enableWorktrees: cli.worktreeRequested || selectedWorktreeTools.length > 0,
+                    worktreeToolNames: selectedWorktreeTools,
+                    ...(runtimeSettings
+                        ? { worktreeBaseRef: runtimeSettings.worktreeBaseRef }
+                        : {}),
+                    ...(interactiveTools ? { interactiveTools } : {}),
+                    ...(hooks ? { hooks } : {}),
+                    ...(selectedMainAgent ? { agent: selectedMainAgent } : {}),
+                    ...(memoryDirectory
+                        ? { projectMemoryDirectory: memoryDirectory }
+                        : {}),
+                    ...(projectMemoryRecall ? { projectMemoryRecall } : {}),
+                    ...(projectMemoryExtraction ? { projectMemoryExtraction } : {}),
+                }
                 : {}),
-            ...(interactiveTools ? { interactiveTools } : {}),
-            ...(hooks ? { hooks } : {}),
-            ...(selectedMainAgent ? { agent: selectedMainAgent } : {}),
-            ...(memoryDirectory ? { projectMemoryDirectory: memoryDirectory } : {}),
-            ...(projectMemoryRecall ? { projectMemoryRecall } : {}),
-            ...(projectMemoryExtraction ? { projectMemoryExtraction } : {}),
             contextAssembler,
-            conditionalRuleResolver: new ClaudeConditionalRuleResolver({
-                loadResources: loadContextResources,
-            }),
+            ...(!experimentalNativeTranscriptWrites
+                ? {
+                    conditionalRuleResolver: new ClaudeConditionalRuleResolver({
+                        loadResources: loadContextResources,
+                    }),
+                }
+                : {}),
             ...('contextReserveTokens' in context
                 ? { contextReserveTokens: context.contextReserveTokens }
                 : {}),
             ...(permissionApprover ? { approveTool: permissionApprover } : {}),
             ...(approveRecovery ? { approveRecovery } : {}),
-            fileCheckpointing: runtimeEnvironment.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING ===
-                'true' || runtimeSettings?.checkpoints === true,
+            ...(!experimentalNativeTranscriptWrites
+                ? {
+                    fileCheckpointing: runtimeEnvironment.CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING ===
+                        'true' || runtimeSettings?.checkpoints === true,
+                }
+                : {}),
             autoCompact: runtimeSettings?.autoCompact ?? true,
-            fileRewindRoots: [
-                ...cli.additionalDirectories,
-                ...(memoryDirectory ? [memoryDirectory] : []),
-            ],
+            ...(!experimentalNativeTranscriptWrites
+                ? {
+                    fileRewindRoots: [
+                        ...cli.additionalDirectories,
+                        ...(memoryDirectory ? [memoryDirectory] : []),
+                    ],
+                }
+                : {}),
+            ...(!experimentalNativeTranscriptWrites && teamLeadOperations
+                ? {
+                    teamLeadOperations,
+                    ...(teamLeadToolRegistryFactory
+                        ? { teamLeadToolRegistryFactory }
+                        : {}),
+                }
+                : {}),
         });
         const toolNames = [
             ...filteredTools.definitions().map((definition) => definition.name),
@@ -1584,6 +1728,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ...selectedWorktreeTools,
             ...selectedInteractiveTools,
             ...(enableSubagents ? selectedAgentTools : []),
+            ...selectedTeamTools,
         ];
         const runtimeInfo = {
             cwd: workspace.cwd(),
@@ -1619,6 +1764,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             : filteredTools;
         let pendingResumeSessionAt = cli.resumeSessionAt;
         return {
+            ...(teamLeadOperations ? { teamLeadOperations } : {}),
             toolRegistry,
             run: (prompt, signal, sessionId, name, images, documents) => service.run(prompt, signal, sessionId, name ?? cli.name, images, documents),
             resume: (sessionId, prompt, signal, name, images, documents) => {
@@ -4015,6 +4161,7 @@ function printCommandHelp(argv, io) {
         'auto-mode',
         'project',
         'import',
+        'team',
     ].includes(value));
     if (commandIndex < 0)
         return false;
@@ -4102,8 +4249,217 @@ function printCommandHelp(argv, io) {
         io.stdout(IMPORT_HELP);
         return true;
     }
+    if (command === 'team') {
+        if (!hasHelpFlag)
+            return false;
+        io.stdout(TEAM_HELP);
+        return true;
+    }
     return false;
 }
+function parseTeamCommand(args) {
+    if (args[0] !== 'team')
+        throw new Error('Invalid Team command');
+    const command = args[1];
+    if (!command || command === 'help')
+        throw new Error(TEAM_HELP.trim());
+    if (!['create', 'resume', 'list', 'accept', 'stop'].includes(command))
+        throw new Error(`Unsupported Team command: ${command}`);
+    const operands = [];
+    let json = false;
+    let leadSessionId;
+    let generation;
+    let decision = 'accepted';
+    let drainMs;
+    const seen = new Set();
+    const optionValue = (index, option) => {
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith('--'))
+            throw new Error(`${option} requires a value`);
+        if (seen.has(option))
+            throw new Error(`${option} may only be specified once`);
+        seen.add(option);
+        return value;
+    };
+    for (let index = 2; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--json') {
+            if (json)
+                throw new Error('--json may only be specified once');
+            json = true;
+        }
+        else if (value === '--lead-session-id') {
+            leadSessionId = optionValue(index, value);
+            index += 1;
+        }
+        else if (value === '--generation') {
+            const raw = optionValue(index, value);
+            if (!/^\d+$/.test(raw))
+                throw new Error('Invalid generation');
+            generation = Number(raw);
+            if (!Number.isSafeInteger(generation))
+                throw new Error('Invalid generation');
+            index += 1;
+        }
+        else if (value === '--decision') {
+            const raw = optionValue(index, value);
+            if (raw !== 'accepted' && raw !== 'rejected')
+                throw new Error('Invalid decision');
+            decision = raw;
+            index += 1;
+        }
+        else if (value === '--drain-ms') {
+            const raw = optionValue(index, value);
+            if (!/^\d+(?:\.\d+)?$/.test(raw))
+                throw new Error('Invalid drain-ms');
+            drainMs = Number(raw);
+            if (!Number.isFinite(drainMs) || drainMs < 0 || drainMs > 600000)
+                throw new Error('Invalid drain-ms');
+            index += 1;
+        }
+        else if (value.startsWith('-')) {
+            throw new Error(`Unknown Team option: ${value}`);
+        }
+        else
+            operands.push(value);
+    }
+    const requireLead = () => {
+        if (!leadSessionId)
+            throw new Error('--lead-session-id requires a value');
+        return leadSessionId;
+    };
+    const rejectOptions = (allowed) => {
+        for (const option of seen) {
+            if (!allowed.includes(option))
+                throw new Error(`${option} is not valid for team ${command}`);
+        }
+    };
+    if (command === 'create') {
+        rejectOptions(['--lead-session-id']);
+        if (operands.length !== 1)
+            throw new Error('create requires a manifest path');
+        return {
+            command,
+            manifest: operands[0],
+            leadSessionId: requireLead(),
+            json,
+        };
+    }
+    if (command === 'list') {
+        rejectOptions([]);
+        if (operands.length !== 0)
+            throw new Error('Invalid list options');
+        return { command, json };
+    }
+    if (command === 'resume') {
+        rejectOptions(['--lead-session-id']);
+        if (operands.length !== 1)
+            throw new Error('resume requires a team ID');
+        return {
+            command,
+            teamId: operands[0],
+            leadSessionId: requireLead(),
+            json,
+        };
+    }
+    if (command === 'accept') {
+        rejectOptions(['--lead-session-id', '--generation', '--decision']);
+        if (operands.length !== 2)
+            throw new Error('accept requires team ID and task ID');
+        return {
+            command,
+            teamId: operands[0],
+            taskId: operands[1],
+            leadSessionId: requireLead(),
+            ...(generation === undefined ? {} : { generation }),
+            decision,
+            json,
+        };
+    }
+    rejectOptions(['--lead-session-id', '--drain-ms']);
+    if (operands.length !== 1)
+        throw new Error('stop requires a team ID');
+    return {
+        command: 'stop',
+        teamId: operands[0],
+        leadSessionId: requireLead(),
+        ...(drainMs === undefined ? {} : { drainMs }),
+        json,
+    };
+}
+function teamEnabled(environment) {
+    return /^(1|true|yes|on)$/i.test((environment.PRAXIS_ENABLE_TEAMS ?? '').trim());
+}
+async function executeTeamCommand(args, io, dependencies, signal) {
+    const parsed = parseTeamCommand(args);
+    if (!teamEnabled(process.env))
+        throw new Error('Experimental Team capability is disabled; set PRAXIS_ENABLE_TEAMS=true');
+    const nativeControls = {
+        ...DEFAULT_CLI_CONTROLS,
+        dataPlane: 'native',
+    };
+    const service = await dependencies.createService({
+        eventSink: () => undefined,
+        requireProvider: parsed.command !== 'list',
+        exposeToolRegistry: true,
+        controls: nativeControls,
+        configRoot: resolveDataPlaneRoot({ dataPlane: 'native' }),
+        providerEnvironment: process.env,
+        ...(signal ? { signal } : {}),
+    });
+    try {
+        const operations = service.teamLeadOperations;
+        if (!operations)
+            throw new Error('Team lead operations are unavailable');
+        if (parsed.command === 'list') {
+            const teams = await operations.list();
+            if (parsed.json)
+                writeJson(io, { teams });
+            else
+                io.stdout(`${teams.map((team) => team.teamId).join('\n')}${teams.length ? '\n' : ''}`);
+            return 0;
+        }
+        let snapshot;
+        if (parsed.command === 'create') {
+            const raw = await readFile(parsed.manifest, 'utf8');
+            const value = JSON.parse(raw);
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                throw new Error('Team manifest must be an object');
+            const request = value;
+            snapshot = await operations.create(request, parsed.leadSessionId);
+            snapshot = await operations.detach(request.teamId, parsed.leadSessionId);
+        }
+        else if (parsed.command === 'resume') {
+            snapshot = await operations.resume(parsed.teamId, parsed.leadSessionId);
+            snapshot = await operations.detach(parsed.teamId, parsed.leadSessionId);
+        }
+        else if (parsed.command === 'accept') {
+            snapshot = await operations.accept({
+                teamId: parsed.teamId,
+                taskId: parsed.taskId,
+                ...(parsed.generation === undefined
+                    ? {}
+                    : { generation: parsed.generation }),
+                decision: parsed.decision,
+            }, parsed.leadSessionId);
+            snapshot = await operations.detach(parsed.teamId, parsed.leadSessionId);
+        }
+        else {
+            snapshot = await operations.stop({
+                teamId: parsed.teamId,
+                ...(parsed.drainMs === undefined ? {} : { drainMs: parsed.drainMs }),
+            }, parsed.leadSessionId);
+        }
+        if (parsed.json)
+            writeJson(io, { team: snapshot });
+        else
+            io.stdout(`${snapshot.teamId}\n`);
+        return 0;
+    }
+    finally {
+        await service.close?.();
+    }
+}
 function extractSpecialDataPlane(argv) {
     const args = [];
     let dataPlane;
@@ -4133,6 +4489,7 @@ function extractSpecialDataPlane(argv) {
 }
 function specialCommandIndex(argv) {
     const commands = new Set([
+        'team',
         'plugin',
         'plugins',
         'project',
@@ -4187,6 +4544,14 @@ async function execute(argv, io, dependencies, signal) {
         return dependencies.runInteractive(signal ? { signal } : {});
     }
     const commandIndex = specialCommandIndex(argv);
+    if (commandIndex >= 0 &&
+        argv[commandIndex] === 'team' &&
+        !argv.includes('--help') &&
+        !argv.includes('-h')) {
+        if (argv.some((value) => value === '--data-plane' || value.startsWith('--data-plane=')))
+            throw new Error('Team commands are native-only; --data-plane is not supported');
+        return executeTeamCommand(argv.slice(commandIndex), io, dependencies, signal);
+    }
     const specialPrefix = commandIndex > 0 &&
         (argv[commandIndex] === 'plugin' || argv[commandIndex] === 'plugins')
         ? parseCliInvocation([...argv.slice(0, commandIndex), '__probe__'])

package/dist/compatibility/claude/transcript-codec.js

@@ -477,6 +477,12 @@ export class ClaudeTranscriptCodec {
                 },
             };
         }
+        else if (event.kind === 'tool-execution-started') {
+            return {
+                ok: false,
+                issue: diagnostic('unsupported-event', 'Claude transcripts do not support native tool execution markers', 0, null, { eventKind: event.kind }),
+            };
+        }
         else
             try {
                 entry = {

package/dist/core/agent-orchestration.d.ts

@@ -0,0 +1,31 @@
+/** Provider- and persistence-independent lifecycle contract for one Agent. */
+export type LifecycleState = 'queued' | 'running' | 'waiting' | 'completed' | 'failed' | 'cancelling' | 'cancelled' | 'orphaned';
+export type LifecycleAcceptance = 'pending' | 'accepted' | 'rejected';
+export interface LifecycleOwner {
+    readonly token: string;
+    readonly pid: number;
+    readonly acquiredAt: string;
+}
+export interface AgentLifecycleSnapshot {
+    readonly generation: number;
+    readonly revision: number;
+    readonly state: LifecycleState;
+    readonly owner: LifecycleOwner | null;
+    readonly previousOwnerToken: string | null;
+    readonly terminalAt: string | null;
+    readonly acceptance: LifecycleAcceptance;
+}
+export declare const TERMINAL_LIFECYCLE_STATES: readonly ["completed", "failed", "cancelled", "orphaned"];
+export declare function isTerminalLifecycleState(state: LifecycleState): state is 'completed' | 'failed' | 'cancelled' | 'orphaned';
+/** The single invariant parser used by every lifecycle mutation and store. */
+export declare function parseAgentLifecycleSnapshot(value: unknown): AgentLifecycleSnapshot;
+export declare function createAgentLifecycle(owner: LifecycleOwner, generation?: number): AgentLifecycleSnapshot;
+export declare function transitionLifecycle(current: AgentLifecycleSnapshot, nextState: LifecycleState, ownerToken: string, terminalAt?: string): AgentLifecycleSnapshot;
+/** Rotate a queued execution owner during a planned parent-to-worker handoff. */
+export declare function transferLifecycleOwner(current: AgentLifecycleSnapshot, currentOwnerToken: string, nextOwner: LifecycleOwner): AgentLifecycleSnapshot;
+export declare function continueLifecycle(current: AgentLifecycleSnapshot, owner: LifecycleOwner): AgentLifecycleSnapshot;
+export declare function recoverLifecycle(current: AgentLifecycleSnapshot, owner: LifecycleOwner): AgentLifecycleSnapshot;
+/** Adapter-proven owner loss is intentionally separate from ordinary transitions. */
+export declare function markLifecycleOrphaned(current: AgentLifecycleSnapshot, ownerToken: string, terminalAt?: string): AgentLifecycleSnapshot;
+export declare function acceptLifecycle(current: AgentLifecycleSnapshot, generation?: number, acceptance?: Exclude<LifecycleAcceptance, 'pending'>): AgentLifecycleSnapshot;
+//# sourceMappingURL=agent-orchestration.d.ts.map