praxis-agent 0.20.21 → 0.21.0

package/dist/application/subagent-service.js

@@ -1,6 +1,6 @@
 import { randomBytes, randomUUID } from 'node:crypto';
-import { mkdir, readFile, readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { lstat, mkdir, readFile, readdir } from 'node:fs/promises';
+import { join, relative } from 'node:path';
 import { Ajv2020 } from 'ajv/dist/2020.js';
 import { resolveClaudePaths } from '../compatibility/claude/paths.js';
 import { workflowAgentFiles } from '../compatibility/claude/workflow.js';
@@ -22,11 +22,24 @@ import { createWorkflowWorktree } from './workflow-worktree.js';
 const DEFAULT_MAX_DEPTH = 4;
 const DEFAULT_MAX_CALLS = 16;
 const DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+const SIDECHAIN_DISCOVERY_MAX_DEPTH = 4;
 const structuredOnlyTools = {
     definitions: () => [],
     prepare: async (call) => call,
     execute: async () => ({ content: '', isError: false }),
 };
+async function readSidechainMetadataName(metadataFile) {
+    try {
+        const value = JSON.parse(await readFile(metadataFile, 'utf8'));
+        if (!value || typeof value !== 'object')
+            return undefined;
+        const name = value.name;
+        return typeof name === 'string' ? name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export class StructuredOutputRegistry {
     base;
     schema;
@@ -134,7 +147,7 @@ function agentToolRuleName(rule) {
     const opening = rule.indexOf('(');
     return (opening < 0 ? rule : rule.slice(0, opening)).trim();
 }
-function enabledAgentToolNames(base, definition, background, additiveTools = new Set()) {
+function enabledAgentToolNames(base, definition, background, permissionMode, additiveTools = new Set()) {
     const requested = definition?.tools
         ? new Set(definition.tools.map(agentToolRuleName))
         : null;
@@ -150,8 +163,10 @@ function enabledAgentToolNames(base, definition, background, additiveTools = new
         .filter((name) => {
         if (additiveTools.has(name))
             return true;
-        if (AGENT_UNAVAILABLE_TOOLS.has(name))
+        if (AGENT_UNAVAILABLE_TOOLS.has(name) &&
+            !(name === 'ExitPlanMode' && permissionMode === 'plan')) {
             return false;
+        }
         if (background &&
             !name.startsWith('mcp__') &&
             !BACKGROUND_AGENT_TOOLS.has(name)) {
@@ -968,25 +983,28 @@ export class ClaudeSubagentExecutor {
             cwd: this.cwd(),
             sessionId,
         });
-        const agentId = await this.resolvePersistedAgentId(paths.projectRoot, sessionId, identifier);
-        if (!agentId)
+        const sidechainPaths = await this.resolvePersistedSidechain(paths.projectRoot, sessionId, identifier);
+        if (!sidechainPaths)
             return;
-        const sidechainPaths = resolveClaudeSidechainPaths(paths.projectRoot, sessionId, agentId);
+        const agentId = sidechainPaths.agentId;
         const sidechain = new ClaudeSidechainStore(sidechainPaths, join(paths.praxisRoot, 'locks', `${sessionId}-${agentId}.lock`), this.schema);
-        let metadata;
         let snapshot;
         try {
-            ;
-            [metadata, snapshot] = await Promise.all([
-                sidechain.metadata(),
-                sidechain.loadReadOnly(),
-            ]);
+            snapshot = await sidechain.loadReadOnly();
         }
         catch (error) {
             if (error.code === 'ENOENT')
                 return;
             throw error;
         }
+        let metadata = null;
+        try {
+            metadata = await sidechain.metadata();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
         const root = snapshot.entries[0];
         if (!root || root.type !== 'user') {
             throw new Error(`Background agent ${agentId} has no sidechain root`);
@@ -1003,15 +1021,20 @@ export class ClaudeSubagentExecutor {
             (lastAssistant.toolCalls?.length ?? 0) > 0) {
             throw new Error(`Background agent ${agentId} is not completed`);
         }
+        const agentType = metadata?.agentType ?? 'general-purpose';
+        const description = metadata?.description ?? 'Recovered Claude sidechain';
+        const toolUseId = metadata?.toolUseId ?? `recovered:${agentId}`;
+        const spawnDepth = metadata?.spawnDepth ?? 1;
+        const name = metadata?.name;
+        const permissionMode = metadata?.permissionMode;
+        const isolation = metadata?.isolation;
         const input = {
-            description: metadata.description,
+            description,
             prompt,
-            subagentType: metadata.agentType,
-            ...(metadata.name ? { name: metadata.name } : {}),
-            ...(metadata.permissionMode
-                ? { permissionMode: metadata.permissionMode }
-                : {}),
-            ...(metadata.isolation ? { isolation: metadata.isolation } : {}),
+            subagentType: agentType,
+            ...(name ? { name } : {}),
+            ...(permissionMode ? { permissionMode } : {}),
+            ...(isolation ? { isolation } : {}),
             runInBackground: true,
         };
         const provider = this.options.provider;
@@ -1024,9 +1047,9 @@ export class ClaudeSubagentExecutor {
                 input,
                 provider,
                 agentId,
-                spawnDepth: metadata.spawnDepth,
+                spawnDepth,
                 promptId: String(root.promptId ?? randomUUID()),
-                toolUseId: metadata.toolUseId,
+                toolUseId,
                 transcriptPath: sidechainPaths.transcriptFile,
                 toolResultDirectory: join(paths.projectRoot, sessionId, 'tool-results'),
                 ...(continuation ? { continuationMessage: message } : {}),
@@ -1036,11 +1059,11 @@ export class ClaudeSubagentExecutor {
         });
         this.background.registerCompleted({
             agentId,
-            ...(metadata.name ? { name: metadata.name } : {}),
-            agentType: metadata.agentType,
-            description: metadata.description,
+            ...(name ? { name } : {}),
+            agentType,
+            description,
             prompt,
-            toolUseId: metadata.toolUseId,
+            toolUseId,
             outputFile: sidechainPaths.transcriptFile,
             resolvedModel: provider.model ?? 'praxis/provider',
             run,
@@ -1051,37 +1074,110 @@ export class ClaudeSubagentExecutor {
             durationMs: 0,
         });
     }
-    async resolvePersistedAgentId(projectRoot, sessionId, identifier) {
-        if (/^a[0-9a-f]{16}$/u.test(identifier))
-            return identifier;
-        if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u.test(identifier))
+    async resolvePersistedSidechain(projectRoot, sessionId, identifier) {
+        const isAgentId = /^a[0-9a-f]{16}$/u.test(identifier);
+        const isName = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u.test(identifier);
+        if (!isAgentId && !isName)
             return null;
-        const directory = join(projectRoot, sessionId, 'subagents');
-        let names;
+        const candidates = await this.discoverSidechainCandidates(projectRoot, sessionId);
+        const matches = candidates.filter((candidate) => isAgentId
+            ? candidate.agentId === identifier
+            : candidate.name === identifier);
+        matches.sort((left, right) => (right.metadataModifiedAt ?? -Infinity) -
+            (left.metadataModifiedAt ?? -Infinity) ||
+            left.agentId.localeCompare(right.agentId) ||
+            left.paths.directory.localeCompare(right.paths.directory));
+        return matches[0]?.paths ?? null;
+    }
+    async discoverSidechainCandidates(projectRoot, sessionId) {
+        const rootDirectory = join(projectRoot, sessionId, 'subagents');
+        let rootStat;
         try {
-            names = await readdir(directory);
+            rootStat = await lstat(rootDirectory);
         }
         catch (error) {
             if (error.code === 'ENOENT')
-                return null;
+                return [];
             throw error;
         }
-        const matches = await Promise.all(names
-            .map((name) => /^agent-(a[0-9a-f]{16})\.meta\.json$/u.exec(name)?.[1])
-            .filter((agentId) => agentId !== undefined)
-            .map(async (agentId) => {
-            const sidechainPaths = resolveClaudeSidechainPaths(projectRoot, sessionId, agentId);
-            const sidechain = new ClaudeSidechainStore(sidechainPaths, join(this.options.configRoot, 'praxis', 'locks', `${sessionId}-${agentId}.lock`), this.schema);
-            const metadata = await sidechain.metadata();
-            if (metadata.name !== identifier)
-                return null;
-            const file = await stat(sidechainPaths.metadataFile);
-            return { agentId, modifiedAt: file.mtimeMs };
-        }));
-        return (matches
-            .filter((match) => match !== null)
-            .sort((left, right) => right.modifiedAt - left.modifiedAt ||
-            right.agentId.localeCompare(left.agentId))[0]?.agentId ?? null);
+        if (rootStat.isSymbolicLink() || !rootStat.isDirectory())
+            return [];
+        const candidates = [];
+        const walk = async (directory, depth) => {
+            if (depth > SIDECHAIN_DISCOVERY_MAX_DEPTH)
+                return;
+            let entries;
+            try {
+                entries = await readdir(directory, { withFileTypes: true });
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return;
+                throw error;
+            }
+            const byName = new Map(entries.map((entry) => [entry.name, entry]));
+            const subdirectory = relative(rootDirectory, directory).replaceAll('\\', '/');
+            await Promise.all(entries.map(async (entry) => {
+                if (entry.isSymbolicLink())
+                    return;
+                const entryPath = join(directory, entry.name);
+                if (entry.isDirectory()) {
+                    await walk(entryPath, depth + 1);
+                    return;
+                }
+                if (!entry.isFile())
+                    return;
+                const metadataMatch = /^agent-(a[0-9a-f]{16})\.meta\.json$/u.exec(entry.name);
+                if (metadataMatch) {
+                    const agentId = metadataMatch[1];
+                    if (agentId === undefined)
+                        return;
+                    const transcriptEntry = byName.get(`agent-${agentId}.jsonl`);
+                    if (!transcriptEntry ||
+                        transcriptEntry.isSymbolicLink() ||
+                        !transcriptEntry.isFile()) {
+                        return;
+                    }
+                    const paths = resolveClaudeSidechainPaths(projectRoot, sessionId, agentId, subdirectory === '' ? {} : { subdirectory });
+                    let metadataStat;
+                    try {
+                        metadataStat = await lstat(paths.metadataFile);
+                    }
+                    catch (error) {
+                        if (error.code === 'ENOENT')
+                            return;
+                        throw error;
+                    }
+                    if (metadataStat.isSymbolicLink() || !metadataStat.isFile())
+                        return;
+                    const name = await readSidechainMetadataName(paths.metadataFile);
+                    candidates.push({
+                        agentId,
+                        paths,
+                        metadataModifiedAt: metadataStat.mtimeMs,
+                        ...(name === undefined ? {} : { name }),
+                    });
+                    return;
+                }
+                const transcriptMatch = /^agent-(a[0-9a-f]{16})\.jsonl$/u.exec(entry.name);
+                if (!transcriptMatch)
+                    return;
+                const agentId = transcriptMatch[1];
+                if (agentId === undefined)
+                    return;
+                // A metadata companion (even an invalid one) is owned by the
+                // metadata branch; only a bare transcript without metadata is a
+                // legacy candidate.
+                if (byName.has(`agent-${agentId}.meta.json`))
+                    return;
+                candidates.push({
+                    agentId,
+                    paths: resolveClaudeSidechainPaths(projectRoot, sessionId, agentId, subdirectory === '' ? {} : { subdirectory }),
+                });
+            }));
+        };
+        await walk(rootDirectory, 0);
+        return candidates;
     }
     asyncLaunchResult(options) {
         return [
@@ -1181,7 +1277,7 @@ export class ClaudeSubagentExecutor {
             .definitions()
             .map(({ name }) => name)
             .filter((name) => !inheritedToolNames.has(name)));
-        const agentScopedTools = new RestrictedToolRegistry(agentToolBase, enabledAgentToolNames(agentToolBase, customAgent, options.input.runInBackground, additiveAgentToolNames));
+        const agentScopedTools = new RestrictedToolRegistry(agentToolBase, enabledAgentToolNames(agentToolBase, customAgent, options.input.runInBackground, options.input.permissionMode, additiveAgentToolNames));
         const builtInStatusLineAgent = customAgent?.path === BUILTIN_STATUSLINE_AGENT_PATH;
         const scopedTools = builtInStatusLineAgent
             ? new RestrictedToolRegistry(agentScopedTools, ['Read', 'Edit'])

package/dist/cli/interactive.js

@@ -11,7 +11,7 @@ import { permissionRuleValueToString } from '../permissions/permission-updates.j
 import { AgentRunCancelledError } from '../core/runtime.js';
 import { claudePermissionActionKey, claudePermissionRuleMatches, } from '../permissions/claude-permission-resolver.js';
 import { redactSensitiveText, sensitiveEnvironmentValues, } from '../platform/sensitive-data.js';
-import { CommandPalette, BtwPanel, Composer, DiffDashboard, DialogFrame, ExternalEditorWait, HelpMenu, HookDashboard, ListDashboard, MemoryDashboard, MentionPicker, ModelMenu, PermissionDashboard, SelectionMenu, SessionPicker, ThemePicker, CustomThemeEditor, Transcript, WelcomePanel, useTerminalRows, useTerminalWidth, } from './tui/claude-style.js';
+import { CommandPalette, BtwPanel, Composer, DiffDashboard, DialogFrame, ExternalEditorWait, HelpMenu, HookDashboard, ListDashboard, MemoryDashboard, MentionPicker, ModelMenu, PermissionDashboard, SelectionMenu, SessionPicker, ThemePicker, CustomThemeEditor, SessionIdentity, Transcript, WelcomePanel, useTerminalRows, useTerminalWidth, } from './tui/claude-style.js';
 import { loadTuiMemoryFiles, openTuiMemoryFolder, } from './tui/memory-files.js';
 import { loadClaudeReleaseNotes } from './tui/release-notes.js';
 import { createClaudeStatusLineInput, StatusLine } from './tui/status-line.js';
@@ -417,9 +417,21 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     const [history, setHistory] = useState([...initialHistory]);
     // Startup diagnostics are useful before the first prompt, but they are not
     // conversation history and must not suppress the new-session welcome panel.
-    const hasConversationHistory = history.some((item) => item.kind !== 'notice' &&
-        item.kind !== 'warning' &&
-        item.kind !== 'local-result');
+    // Only real user/assistant transcript entries start a conversation; every
+    // other kind (thinking, context, tool, shell, notices, results, and so on)
+    // is operational bookkeeping that must not hide the fresh-session welcome.
+    const isRealConversation = (item) => item.kind === 'user' || item.kind === 'assistant';
+    // The original loaded transcript decides whether the session was resumed,
+    // separately from the live history that grows while the session runs.
+    const resumedWithTranscript = initialHistory.some(isRealConversation);
+    const hasConversationHistory = history.some(isRealConversation);
+    // A session is resumed only when it was opened through `resume` and the
+    // original transcript already contained real conversation content. Supplying
+    // a session ID alone with an empty transcript keeps the session fresh, so the
+    // full welcome panel renders and the compact identity stays hidden until real
+    // conversation content appears.
+    const resumed = resume !== undefined && resumedWithTranscript;
+    const freshSession = !resumed && !hasConversationHistory;
     const sessionLoadRef = useRef(0);
     const [turnDiffs, setTurnDiffs] = useState([]);
     const turnNumberRef = useRef(0);
@@ -5635,7 +5647,7 @@ export function InteractiveApp({ factory, initialSessions, initialPrompt, initia
     });
     return (_jsx(TuiThemeProvider, { settings: themeSettings, children: _jsx(Box, { flexDirection: "column", ...(!fixedViewport
                 ? {}
-                : { height: rows, overflowY: 'hidden' }), children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && !hasConversationHistory && !sessionId ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width, showTips: runtimeSettings.tips })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, _jsx(Transcript, { items: history, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }), externalEditorRequest !== null ||
+                : { height: rows, overflowY: 'hidden' }), children: selectingSession ? (_jsx(SessionPicker, { sessions: filteredPickerChoices, selectedIndex: selectedIndex, screenReader: axScreenReader, query: sessionSearch })) : (_jsxs(_Fragment, { children: [!axScreenReader && freshSession ? (_jsx(WelcomePanel, { display: runtimeDisplay, width: width, showTips: runtimeSettings.tips })) : null, sessionId ? (_jsxs(Text, { dimColor: true, children: ["Session ", sessionId.slice(0, 8)] })) : null, !axScreenReader && !resumed && hasConversationHistory ? (_jsx(SessionIdentity, { display: runtimeDisplay, width: width })) : null, _jsx(Transcript, { items: history, activeText: activeText, activeThinking: activeThinking, thinkingExpanded: thinkingExpanded, detailedTranscript: thinkingExpanded || runtimeSettings.verbose, screenReader: axScreenReader }), externalEditorRequest !== null ||
                         keybindingsEditing ||
                         memoryEditorRequest !== null ? (_jsx(ExternalEditorWait, { screenReader: axScreenReader })) : permission ? (permission.kind === 'tool' && toolPermissionModel ? (_jsx(ToolPermissionDialog, { model: toolPermissionModel, selection: permissionSelection, feedbackMode: permissionFeedbackMode, feedback: input, ruleEditor: permissionRuleEditor, screenReader: axScreenReader })) : (_jsxs(DialogFrame, { title: `Retry interrupted ${permission.call.name}?`, screenReader: axScreenReader, children: [_jsx(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: _jsx(Text, { bold: true, children: describeTool(permission.call, sensitiveValues) }) }), _jsx(Text, { children: "Do you want to proceed?" }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 0, children: [selectionPrefix(permissionSelection === 0, axScreenReader), "1. Yes"] }), _jsxs(Text, { inverse: !axScreenReader && permissionSelection === 1, children: [selectionPrefix(permissionSelection === 1, axScreenReader), "2. No"] }), permissionFeedbackMode ? (_jsxs(Text, { children: ["\u203A", ' ', input ||
                                         (permissionSelection === 0

package/dist/cli/tui/claude-style.d.ts

@@ -77,6 +77,10 @@ export declare function WelcomePanel({ display, width, showTips, }: {
     width: number;
     showTips: boolean;
 }): import("react").JSX.Element | null;
+export declare function SessionIdentity({ display, width, }: {
+    display: TuiDisplayMetadata;
+    width: number;
+}): import("react").JSX.Element;
 export declare function MarkdownText({ text }: {
     text: string;
 }): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

package/dist/cli/tui/claude-style.js

@@ -125,6 +125,17 @@ export function WelcomePanel({ display, width, showTips, }) {
     const rightWidth = Math.max(12, panelWidth - leftWidth - 4);
     return (_jsxs(Box, { flexDirection: "column", width: panelWidth, children: [_jsxs(Text, { color: palette.muted, children: ['╭───', _jsx(Text, { color: palette.brand, bold: true, children: brand }), ` Code v${display.version} `, _jsx(Text, { dimColor: true, children: '─'.repeat(fill) }), '╮'] }), _jsxs(Box, { borderStyle: "round", borderColor: palette.muted, borderTop: false, flexDirection: wide ? 'row' : 'column', width: panelWidth, paddingX: 1, children: [_jsxs(Box, { alignItems: wide ? 'center' : undefined, flexDirection: "column", width: wide ? leftWidth : '100%', children: [_jsx(Text, { children: " " }), _jsxs(Text, { bold: true, children: ["Welcome to ", brand] }), _jsx(Text, { children: " " }), _jsx(Text, { color: palette.brand, bold: true, children: "\u2590\u259B\u2588\u2588\u2588\u259C\u258C" }), _jsx(Text, { color: palette.brand, children: "\u259D\u259C\u2588\u2588\u2588\u2588\u2588\u259B\u2598" }), _jsx(Text, { color: palette.brand, children: " \u2598\u2598 \u259D\u259D" }), _jsx(Text, { children: " " }), _jsxs(Text, { wrap: "truncate-end", children: [model, effort] }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cwd })] }), _jsxs(Box, { flexDirection: "column", width: wide ? rightWidth : '100%', marginTop: wide ? 0 : 1, children: [_jsx(Text, { bold: true, children: "Get started" }), _jsx(Text, { wrap: "truncate-end", children: "/init to create CLAUDE.md" }), _jsx(Text, { wrap: "truncate-end", children: "/config to open settings" }), _jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { bold: true, children: "Shared with Claude Code" }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: "Sessions \u00B7 memory \u00B7 skills" })] })] })] }));
 }
+// Compact identity header shown above the transcript once a fresh session has
+// conversation content. Keeps the same product/model/cwd facts as WelcomePanel
+// in a small fixed footprint, truncating every line to the supplied width.
+export function SessionIdentity({ display, width, }) {
+    const palette = useTuiPalette();
+    const identityWidth = Math.max(1, Math.floor(width));
+    const model = display.model ?? 'provider default';
+    const effort = display.effort ? ` · ${display.effort} effort` : '';
+    const cwd = compactPath(display.cwd);
+    return (_jsxs(Box, { flexDirection: "column", width: identityWidth, children: [_jsx(Text, { wrap: "truncate-end", children: _jsx(Text, { color: palette.brand, bold: true, children: `Praxis Code v${display.version}` }) }), _jsxs(Text, { wrap: "truncate-end", children: [model, effort] }), _jsx(Text, { dimColor: true, wrap: "truncate-end", children: cwd })] }));
+}
 const INLINE_SEGMENT_CACHE_MAX = 4096;
 const inlineSegmentCache = new Map();
 function cachedInlineSegments(text) {

package/dist/cli-runtime.js

@@ -720,7 +720,9 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const claudeStatePath = requestedConfigRoot || configuredRoot
         ? join(configRoot, '.claude.json')
         : resolve(homedir(), '.claude.json');
-    const runtimeSettings = controls.safeMode || controls.bare
+    const simpleMode = controls.bare ||
+        /^(?:1|true|yes|on)$/iu.test((runtimeEnvironment.CLAUDE_CODE_SIMPLE ?? '').trim());
+    const runtimeSettings = controls.safeMode || simpleMode
         ? undefined
         : await loadRuntimeSettings({ configRoot, statePath: claudeStatePath });
     const runtimeSettingsPrompt = runtimeSettingsSystemPrompt(runtimeSettings);
@@ -799,6 +801,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         eventSink: runtimeEventSink,
         sessionPersistence: cli.sessionPersistence,
         costStateStore,
+        simpleMode,
         explicitModel: interactiveModel !== undefined || controls.model !== undefined,
         explicitSystemPrompt: cli.systemPrompt !== undefined,
         agentInitialPromptHandledExternally: interactive,
@@ -843,7 +846,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             loadClaudeSettings({
                 configRoot,
                 cwd,
-                ...(cli.bare
+                ...(simpleMode
                     ? { settingSources: [] }
                     : cli.settingSources === undefined
                         ? {}
@@ -855,7 +858,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 pluginDirectories: cli.pluginDirectories,
                 pluginUrls: cli.pluginUrls,
                 strictPluginDirectories: cli.pluginDirectories.length + cli.pluginUrls.length > 0,
-                loadInstalled: !cli.safeMode && !cli.bare,
+                loadInstalled: !cli.safeMode && !simpleMode,
                 readOnlyHooks: true,
                 environment: runtimeEnvironment,
             }),
@@ -903,12 +906,12 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             complete: (request) => toolProvider.complete(request),
         }
         : toolProvider;
-    const automaticSettingSources = cli.safeMode || cli.bare ? [] : cli.settingSources;
+    const automaticSettingSources = cli.safeMode || simpleMode ? [] : cli.settingSources;
     const settings = [
         ...(await loadClaudeSettings({
             configRoot,
             cwd,
-            ...(cli.bare
+            ...(simpleMode
                 ? { settingSources: [] }
                 : cli.settingSources === undefined
                     ? {}
@@ -930,7 +933,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         pluginDirectories: cli.pluginDirectories,
         pluginUrls: cli.pluginUrls,
         strictPluginDirectories: cli.pluginDirectories.length + cli.pluginUrls.length > 0,
-        loadInstalled: !cli.safeMode && !cli.bare,
+        loadInstalled: !cli.safeMode && !simpleMode,
         environment: runtimeEnvironment,
     });
     for (const plugin of pluginResources.plugins) {
@@ -972,7 +975,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
     const extensions = new ClaudeExtensionCatalog(resources, {
         disableSlashCommands: cli.disableSlashCommands,
     });
-    const memoryDirectory = cli.safeMode || cli.bare
+    const memoryDirectory = cli.safeMode || simpleMode
         ? undefined
         : await resolveClaudeProjectMemoryDirectory({ configRoot, cwd });
     if (memoryDirectory)
@@ -1056,7 +1059,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         return filterDisabledMcpResources(candidates, await management.disabled());
     };
     const mcpTools = await ClaudeMcpToolRegistry.connect({
-        base: cli.bare
+        base: simpleMode
             ? localTools
             : new WebToolRegistry({
                 base: localTools,
@@ -1115,7 +1118,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
         const extensionTools = new ClaudeExtensionToolRegistry(mcpTools, extensions);
         const lspEnabled = interactive &&
             !cli.safeMode &&
-            !cli.bare &&
+            !simpleMode &&
             pluginResources.lsp.length > 0;
         lspTools = lspEnabled
             ? new ClaudeLspToolManager({
@@ -1159,24 +1162,24 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
         const selectedTaskTools = taskToolNames.filter((name) => cli.sessionPersistence &&
-            !cli.bare &&
+            !simpleMode &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
                 cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
-        const selectedScheduledTools = scheduledToolNames.filter((name) => !cli.bare &&
+        const selectedScheduledTools = scheduledToolNames.filter((name) => !simpleMode &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
                 cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
         const selectedWorkflowTools = workflowToolNames.filter((name) => (runtimeSettings?.workflows ?? true) &&
             cli.sessionPersistence &&
-            !cli.bare &&
+            !simpleMode &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
                 cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
-        const selectedWorktreeTools = worktreeToolNames.filter((name) => !cli.bare &&
+        const selectedWorktreeTools = worktreeToolNames.filter((name) => !simpleMode &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
                 cli.tools.includes(name)) &&
@@ -1187,7 +1190,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
                 cli.tools.includes(name)) &&
             !cli.disallowedTools.includes(name));
         const enableBackgroundBash = cli.sessionPersistence &&
-            !cli.bare &&
+            !simpleMode &&
             (cli.tools === undefined ||
                 cli.tools.includes('default') ||
                 cli.tools.includes('Bash')) &&
@@ -1206,17 +1209,17 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             !workflowToolNames.includes(name) &&
             !worktreeToolNames.includes(name) &&
             !interactiveToolNames.includes(name) &&
-            (!cli.bare || (name !== 'WebFetch' && name !== 'WebSearch')));
+            (!simpleMode || (name !== 'WebFetch' && name !== 'WebSearch')));
         const filteredTools = new FilteredToolRegistry(extensionAndLspTools, {
             ...(cli.tools === undefined
-                ? cli.bare
+                ? simpleMode
                     ? { tools: ['Bash', 'Edit', 'Read'] }
                     : {}
                 : { tools: selectedBaseTools ?? [] }),
             disallowedTools: cli.disallowedTools,
         });
-        const enableSubagents = !cli.bare && selectedAgentTools.length > 0;
-        const hooks = cli.safeMode || cli.bare
+        const enableSubagents = !simpleMode && selectedAgentTools.length > 0;
+        const hooks = cli.safeMode || simpleMode
             ? undefined
             : new ClaudeHookRunner({
                 settings,
@@ -1243,6 +1246,7 @@ const createDefaultService = async ({ eventSink, requireProvider, hooksOnly = fa
             ...(providerForModel ? { providerForModel } : {}),
             ...(providerForMainModel ? { providerForMainModel } : {}),
             tools: filteredTools,
+            toolCapabilityEnvironment: runtimeEnvironment,
             mcp: mcpTools,
             permissions,
             permissionResolverForMode,

package/dist/compatibility/claude/schema.d.ts

@@ -11,6 +11,13 @@ export interface ClaudeSchemaAdapter {
     serializeForSidechainAppend(entry: ClaudeTranscriptEntry): string;
     serializeForFork(entry: ClaudeTranscriptEntry): string;
 }
+/**
+ * Historical fixture/default provenance constant for the Claude Code
+ * transcript schema. It records the version Praxis fixtures and default
+ * translation paths were captured against; it is not an append gate. Any
+ * nonempty semver-like Claude Code version whose entry shape is structurally
+ * supported is writable through the append/sidechain/fork serializers.
+ */
 export declare const VERIFIED_CLAUDE_SCHEMA_VERSION = "2.1.208";
 export declare function isClaudeForkableEntryType(type: string): boolean;
 export declare function copyClaudeEntryWithSessionId(entry: ClaudeTranscriptEntry, sessionId: string): ClaudeTranscriptEntry;

package/dist/compatibility/claude/schema.js

@@ -1,5 +1,16 @@
 import { isAgentColorValue } from './agent-color.js';
+/**
+ * Historical fixture/default provenance constant for the Claude Code
+ * transcript schema. It records the version Praxis fixtures and default
+ * translation paths were captured against; it is not an append gate. Any
+ * nonempty semver-like Claude Code version whose entry shape is structurally
+ * supported is writable through the append/sidechain/fork serializers.
+ */
 export const VERIFIED_CLAUDE_SCHEMA_VERSION = '2.1.208';
+const CLAUDE_CODE_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+function isClaudeCodeVersion(version) {
+    return CLAUDE_CODE_VERSION_PATTERN.test(version);
+}
 const APPENDABLE_ENTRY_TYPES = new Set([
     'agent-color',
     'agent-name',
@@ -776,9 +787,8 @@ function validateAppendableEntry(entry) {
             throw new Error(`Claude transcript entry is missing ${field}`);
         }
     }
-    if (entry.version !== VERIFIED_CLAUDE_SCHEMA_VERSION) {
-        throw new Error(`Claude transcript append must target Claude Code ${VERIFIED_CLAUDE_SCHEMA_VERSION}`);
-    }
+    // version is producer provenance: it must be present and nonempty (enforced
+    // above) but is not compared against a single verified writer version.
     if (!('parentUuid' in entry) ||
         (entry.parentUuid !== null && !isNonEmptyString(entry.parentUuid))) {
         throw new Error('Claude transcript entry has invalid parentUuid');
@@ -837,9 +847,8 @@ function validateSidechainEntry(entry) {
             throw new Error(`Claude sidechain entry is missing ${field}`);
         }
     }
-    if (entry.version !== VERIFIED_CLAUDE_SCHEMA_VERSION) {
-        throw new Error(`Claude sidechain append must target Claude Code ${VERIFIED_CLAUDE_SCHEMA_VERSION}`);
-    }
+    // version is producer provenance: it must be present and nonempty (enforced
+    // above) but is not compared against a single verified writer version.
     if (!('parentUuid' in entry) ||
         (entry.parentUuid !== null && !isNonEmptyString(entry.parentUuid))) {
         throw new Error('Claude sidechain entry has invalid parentUuid');
@@ -971,9 +980,12 @@ function validateForkableEntry(entry) {
     else
         validateForkAssistantMessage(entry.message);
 }
-class ClaudeCode21208Adapter {
-    version = VERIFIED_CLAUDE_SCHEMA_VERSION;
+class ClaudeCodeWritableAdapter {
+    version;
     writeMode = 'read-write';
+    constructor(version) {
+        this.version = version;
+    }
     parse(line) {
         return parseEntry(line);
     }
@@ -1022,8 +1034,8 @@ class ReadOnlyClaudeAdapter {
     }
 }
 export function selectClaudeSchemaAdapter(version) {
-    if (version === VERIFIED_CLAUDE_SCHEMA_VERSION) {
-        return new ClaudeCode21208Adapter();
+    if (isClaudeCodeVersion(version)) {
+        return new ClaudeCodeWritableAdapter(version);
     }
     return new ReadOnlyClaudeAdapter(version);
 }

package/dist/compatibility/claude/sidechain.d.ts

@@ -7,6 +7,10 @@ export interface ClaudeSidechainPaths {
     transcriptFile: string;
     metadataFile: string;
 }
+export interface ClaudeSidechainPathOptions {
+    /** Bounded relative subdirectory under `<sessionId>/subagents` (e.g. `workflows/<runId>`). */
+    subdirectory?: string;
+}
 export interface ClaudeSidechainMetadata {
     agentType: string;
     description: string;
@@ -17,7 +21,7 @@ export interface ClaudeSidechainMetadata {
     isolation?: 'worktree';
 }
 export type ClaudeSidechainPermissionMode = 'acceptEdits' | 'auto' | 'bypassPermissions' | 'default' | 'dontAsk' | 'plan';
-export declare function resolveClaudeSidechainPaths(projectRoot: string, sessionId: string, agentId: string): ClaudeSidechainPaths;
+export declare function resolveClaudeSidechainPaths(projectRoot: string, sessionId: string, agentId: string, options?: ClaudeSidechainPathOptions): ClaudeSidechainPaths;
 export declare function createClaudeSidechainRoot(options: {
     sessionId: string;
     promptId: string;