praxis-agent 0.20.4 → 0.20.7

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

@@ -493,28 +493,17 @@ export class BackgroundAgentManager {
     }
     formatNotification(task, notification) {
         const result = notification.result?.text ?? notification.error ?? '';
+        const status = notification.status === 'stopped' ? 'killed' : notification.status;
         const usage = notification.result
-            ? `<usage><subagent_tokens>${notification.result.usage.inputTokens + notification.result.usage.outputTokens}</subagent_tokens><tool_uses>${notification.result.toolUseCount}</tool_uses><duration_ms>${notification.result.durationMs}</duration_ms></usage>`
+            ? `<usage><total_tokens>${notification.result.usage.inputTokens + notification.result.usage.outputTokens}</total_tokens><tool_uses>${notification.result.toolUseCount}</tool_uses><duration_ms>${notification.result.durationMs}</duration_ms></usage>`
             : '';
         return [
             '<task-notification>',
             `<task-id>${task.spec.agentId}</task-id>`,
             `<tool-use-id>${escapeXml(notification.toolUseId)}</tool-use-id>`,
             `<output-file>${escapeXml(task.spec.outputFile)}</output-file>`,
-            `<status>${notification.status}</status>`,
+            `<status>${status}</status>`,
             `<summary>Agent &quot;${escapeXml(task.spec.description)}&quot; finished</summary>`,
-            '<note>A task-notification fires each time this agent stops with no live background children of its own. The user can send it another message and resume it, so the same task-id may notify more than once.</note>',
-            ...(notification.result?.isolationPath
-                ? [
-                    `<worktree-path>${escapeXml(notification.result.isolationPath)}</worktree-path>`,
-                    `<worktree-retained>${String(notification.result.isolationRetained)}</worktree-retained>`,
-                    ...(notification.result.isolationWarning
-                        ? [
-                            `<worktree-warning>${escapeXml(notification.result.isolationWarning)}</worktree-warning>`,
-                        ]
-                        : []),
-                ]
-                : []),
             `<result>${escapeXml(result)}</result>`,
             usage,
             '</task-notification>',

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

@@ -1,3 +1,4 @@
+import { type ReactElement } from 'react';
 import type { ModelToolCall, ModelUsage } from '../../core/runtime.js';
 import type { AgentColorName } from '../../compatibility/claude/agent-color.js';
 import type { TuiFileEntry, TuiMentionEntry } from './file-picker.js';
@@ -76,7 +77,7 @@ export declare function WelcomePanel({ display, width, }: {
 }): import("react").JSX.Element;
 export declare function MarkdownText({ text }: {
     text: string;
-}): import("react").JSX.Element;
+}): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
 export declare function Transcript({ items, activeText, activeThinking, thinkingExpanded, detailedTranscript, screenReader, }: {
     items: readonly TranscriptItem[];
     activeText: string;

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useEffect, useState } from 'react';
+import { cloneElement, useEffect, useState } from 'react';
 import { Box, Text, useStdout } from 'ink';
 import { composerEditorSegments } from './composer-editor.js';
 import { visiblePatchLines } from './git-diff.js';
@@ -61,35 +61,114 @@ export function WelcomePanel({ display, width, }) {
     const fill = Math.max(1, panelWidth - title.length - 6);
     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) }), '╮'] }), _jsx(Box, { borderStyle: "round", borderColor: palette.muted, borderTop: false, flexDirection: "column", width: panelWidth, paddingX: 1, children: _jsxs(Box, { flexDirection: wide ? 'row' : 'column', children: [_jsxs(Box, { alignItems: wide ? 'center' : undefined, flexDirection: "column", width: wide ? '50%' : '100%', children: [_jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Welcome back!" }), _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, { children: [display.model ?? 'provider default', display.effort ? (_jsxs(Text, { dimColor: true, children: [" \u00B7 ", display.effort, " effort"] })) : null] }), _jsx(Text, { dimColor: true, children: compactPath(display.cwd) })] }), _jsxs(Box, { flexDirection: "column", width: wide ? '50%' : '100%', marginTop: wide ? 0 : 1, children: [_jsx(Text, { bold: true, children: "Tips for getting started" }), _jsx(Text, { children: "Run /init to create a CLAUDE.md file with instructions for Claude" }), _jsx(Text, { dimColor: true, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }), _jsx(Text, { bold: true, children: "What's new" }), _jsx(Text, { children: 'Subagent forking is now on by default: a `subagent_type: "fork"` subagent inherits the full conversation and prompt cache, and non-teammate agent spawns in interactive sessions now run in the background by default' }), _jsx(Text, { children: 'Type `@` in the prompt to mention another Claude session by name; Claude then uses `SendMessage` to reach that session directly' }), _jsx(Text, { children: '`SendMessage` now delivers to a bare name that exactly matches one live session, instead of asking to confirm with a ref first' }), _jsx(Text, { dimColor: true, children: "/release-notes for more" })] })] }) })] }));
 }
-function InlineText({ text }) {
-    const palette = useTuiPalette();
-    const tokens = text.split(/(`[^`]+`|\*\*[^*]+\*\*|\[[^\]]+\]\([^)]+\))/u);
-    return (_jsx(Text, { children: tokens.map((token, index) => {
-            if (token.startsWith('`') && token.endsWith('`'))
-                return (_jsx(Text, { color: palette.info, children: token.slice(1, -1) }, index));
-            if (token.startsWith('**') && token.endsWith('**'))
-                return (_jsx(Text, { bold: true, children: token.slice(2, -2) }, index));
-            const link = /^\[([^\]]+)\]\(([^)]+)\)$/u.exec(token);
-            if (link)
-                return (_jsx(Text, { color: palette.link, underline: true, children: link[1] }, index));
-            return token;
+const INLINE_SEGMENT_CACHE_MAX = 4096;
+const inlineSegmentCache = new Map();
+function cachedInlineSegments(text) {
+    const cached = inlineSegmentCache.get(text);
+    if (cached)
+        return cached;
+    const segments = text
+        .split(/(`[^`]+`|\*\*[^*]+\*\*|\[[^\]]+\]\([^)]+\))/u)
+        .map((token) => {
+        if (token.startsWith('`') && token.endsWith('`'))
+            return { kind: 'code', text: token.slice(1, -1) };
+        if (token.startsWith('**') && token.endsWith('**'))
+            return { kind: 'bold', text: token.slice(2, -2) };
+        const link = /^\[([^\]]+)\]\(([^)]+)\)$/u.exec(token);
+        if (link) {
+            const linkText = link[1];
+            if (linkText !== undefined)
+                return { kind: 'link', text: linkText };
+        }
+        return { kind: 'plain', text: token };
+    });
+    inlineSegmentCache.set(text, segments);
+    if (inlineSegmentCache.size > INLINE_SEGMENT_CACHE_MAX) {
+        const oldest = inlineSegmentCache.keys().next().value;
+        if (oldest !== undefined)
+            inlineSegmentCache.delete(oldest);
+    }
+    return segments;
+}
+function inlineTextElement(text, palette) {
+    return (_jsx(Text, { children: cachedInlineSegments(text).map((segment, index) => {
+            if (segment.kind === 'code')
+                return (_jsx(Text, { color: palette.info, children: segment.text }, index));
+            if (segment.kind === 'bold')
+                return (_jsx(Text, { bold: true, children: segment.text }, index));
+            if (segment.kind === 'link')
+                return (_jsx(Text, { color: palette.link, underline: true, children: segment.text }, index));
+            return segment.text;
         }) }));
 }
-function MarkdownLine({ line }) {
-    const palette = useTuiPalette();
+const MARKDOWN_LINE_CACHE_MAX = 4096;
+const markdownLineCache = new Map();
+function cachedMarkdownLineShape(line) {
+    const cached = markdownLineCache.get(line);
+    if (cached)
+        return cached;
+    let shape;
     if (line.startsWith('### '))
-        return (_jsx(Text, { bold: true, children: _jsx(InlineText, { text: line.slice(4) }) }));
-    if (line.startsWith('## '))
-        return (_jsx(Text, { bold: true, color: palette.accent, children: _jsx(InlineText, { text: line.slice(3) }) }));
-    if (line.startsWith('# '))
-        return (_jsx(Text, { bold: true, color: palette.brand, children: _jsx(InlineText, { text: line.slice(2) }) }));
-    if (/^[-*] /u.test(line))
-        return (_jsxs(Text, { children: ['  • ', _jsx(InlineText, { text: line.slice(2) })] }));
-    if (/^\d+\. /u.test(line))
-        return (_jsxs(Text, { children: ['  ', _jsx(InlineText, { text: line })] }));
-    if (line.startsWith('> '))
-        return (_jsxs(Text, { dimColor: true, children: ['│ ', _jsx(InlineText, { text: line.slice(2) })] }));
-    return line ? _jsx(InlineText, { text: line }) : _jsx(Text, { children: " " });
+        shape = { role: 'h3', content: line.slice(4) };
+    else if (line.startsWith('## '))
+        shape = { role: 'h2', content: line.slice(3) };
+    else if (line.startsWith('# '))
+        shape = { role: 'h1', content: line.slice(2) };
+    else if (/^[-*] /u.test(line))
+        shape = { role: 'bullet', content: line.slice(2) };
+    else if (/^\d+\. /u.test(line))
+        shape = { role: 'ordered', content: line };
+    else if (line.startsWith('> '))
+        shape = { role: 'quote', content: line.slice(2) };
+    else if (line === '')
+        shape = { role: 'empty' };
+    else
+        shape = { role: 'plain', content: line };
+    markdownLineCache.set(line, shape);
+    if (markdownLineCache.size > MARKDOWN_LINE_CACHE_MAX) {
+        const oldest = markdownLineCache.keys().next().value;
+        if (oldest !== undefined)
+            markdownLineCache.delete(oldest);
+    }
+    return shape;
+}
+const ELEMENT_CACHE_KEY_SEPARATOR = String.fromCharCode(0);
+function markdownLineStyleSignature(palette) {
+    return [palette.accent, palette.brand, palette.info, palette.link].join(ELEMENT_CACHE_KEY_SEPARATOR);
+}
+const MARKDOWN_LINE_ELEMENT_CACHE_MAX = 4096;
+const markdownLineElementCache = new Map();
+function buildMarkdownLine(line, palette) {
+    const shape = cachedMarkdownLineShape(line);
+    if (shape.role === 'h3')
+        return _jsx(Text, { bold: true, children: inlineTextElement(shape.content, palette) });
+    if (shape.role === 'h2')
+        return (_jsx(Text, { bold: true, color: palette.accent, children: inlineTextElement(shape.content, palette) }));
+    if (shape.role === 'h1')
+        return (_jsx(Text, { bold: true, color: palette.brand, children: inlineTextElement(shape.content, palette) }));
+    if (shape.role === 'bullet')
+        return (_jsxs(Text, { children: ['  • ', inlineTextElement(shape.content, palette)] }));
+    if (shape.role === 'ordered')
+        return (_jsxs(Text, { children: ['  ', inlineTextElement(shape.content, palette)] }));
+    if (shape.role === 'quote')
+        return (_jsxs(Text, { dimColor: true, children: ['│ ', inlineTextElement(shape.content, palette)] }));
+    if (shape.role === 'plain')
+        return inlineTextElement(shape.content, palette);
+    return _jsx(Text, { children: " " });
+}
+function cachedMarkdownLineElement(line, palette) {
+    const key = [line, markdownLineStyleSignature(palette)].join(ELEMENT_CACHE_KEY_SEPARATOR);
+    const cached = markdownLineElementCache.get(key);
+    if (cached)
+        return cached;
+    const element = buildMarkdownLine(line, palette);
+    markdownLineElementCache.set(key, element);
+    if (markdownLineElementCache.size > MARKDOWN_LINE_ELEMENT_CACHE_MAX) {
+        const oldest = markdownLineElementCache.keys().next().value;
+        if (oldest !== undefined)
+            markdownLineElementCache.delete(oldest);
+    }
+    return element;
 }
 const CODE_KEYWORDS = new Set([
     'async',
@@ -112,25 +191,73 @@ const CODE_KEYWORDS = new Set([
     'var',
 ]);
 const CODE_TOKEN_PATTERN = /("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\b(?:async|await|class|const|else|export|false|from|function|if|import|let|new|null|return|true|undefined|var)\b|\b[A-Za-z_$][\w$]*(?=\s*\())/gu;
-function SyntaxCodeLine({ text, prefix = '', change, }) {
-    const palette = useTuiPalette();
+const SYNTAX_TOKEN_CACHE_MAX = 2048;
+const syntaxTokenCache = new Map();
+function cachedSyntaxTokens(text) {
+    const cached = syntaxTokenCache.get(text);
+    if (cached)
+        return cached;
+    const tokens = text.split(CODE_TOKEN_PATTERN).map((token) => ({
+        kind: token.startsWith('"') || token.startsWith("'")
+            ? 'string'
+            : CODE_KEYWORDS.has(token)
+                ? 'keyword'
+                : /^[A-Za-z_$][\w$]*$/u.test(token)
+                    ? 'identifier'
+                    : 'text',
+        token,
+    }));
+    syntaxTokenCache.set(text, tokens);
+    if (syntaxTokenCache.size > SYNTAX_TOKEN_CACHE_MAX) {
+        const oldest = syntaxTokenCache.keys().next().value;
+        if (oldest !== undefined)
+            syntaxTokenCache.delete(oldest);
+    }
+    return tokens;
+}
+function syntaxStyleSignature(palette) {
+    const syntax = palette.syntax;
+    return [
+        palette.syntaxHighlightingDisabled ? '1' : '0',
+        syntax.text,
+        syntax.keyword,
+        syntax.identifier,
+        syntax.string,
+        syntax.removedBackground ?? '',
+        syntax.addedBackground ?? '',
+    ].join(ELEMENT_CACHE_KEY_SEPARATOR);
+}
+const SYNTAX_LINE_ELEMENT_CACHE_MAX = 4096;
+const syntaxLineElementCache = new Map();
+function buildSyntaxCodeLine(text, prefix, change, palette) {
     if (palette.syntaxHighlightingDisabled) {
         return (_jsxs(Text, { children: [prefix, text || ' '] }));
     }
     const lineStyle = tuiSyntaxStyle(palette, 'text', change);
-    return (_jsxs(Text, { children: [prefix, _jsx(Text, { ...lineStyle, children: text.split(CODE_TOKEN_PATTERN).map((token, index) => {
-                    const kind = token.startsWith('"') || token.startsWith("'")
-                        ? 'string'
-                        : CODE_KEYWORDS.has(token)
-                            ? 'keyword'
-                            : /^[A-Za-z_$][\w$]*$/u.test(token)
-                                ? 'identifier'
-                                : 'text';
+    return (_jsxs(Text, { children: [prefix, _jsx(Text, { ...lineStyle, children: cachedSyntaxTokens(text).map(({ kind, token }, index) => {
                     if (kind === 'text')
                         return token;
                     return (_jsx(Text, { ...tuiSyntaxStyle(palette, kind), children: token }, index));
                 }) })] }));
 }
+function cachedSyntaxCodeLine(text, prefix, change, palette) {
+    const key = [text, prefix, change ?? '', syntaxStyleSignature(palette)].join(ELEMENT_CACHE_KEY_SEPARATOR);
+    const cached = syntaxLineElementCache.get(key);
+    if (cached)
+        return cached;
+    const element = buildSyntaxCodeLine(text, prefix, change, palette);
+    syntaxLineElementCache.set(key, element);
+    if (syntaxLineElementCache.size > SYNTAX_LINE_ELEMENT_CACHE_MAX) {
+        const oldest = syntaxLineElementCache.keys().next().value;
+        if (oldest !== undefined)
+            syntaxLineElementCache.delete(oldest);
+    }
+    return element;
+}
+function SyntaxCodeLine({ text, prefix = '', change, }) {
+    const palette = useTuiPalette();
+    return cachedSyntaxCodeLine(text, prefix, change, palette);
+}
 function ToolResultText({ text, prefix = '', }) {
     const palette = useTuiPalette();
     return (_jsx(Box, { flexDirection: "column", children: text.split('\n').map((line, index) => line.startsWith('+') && !line.startsWith('+++') ? (_jsx(SyntaxCodeLine, { prefix: index === 0 ? prefix : prefix ? '   ' : '', text: line, change: "added" }, index)) : line.startsWith('-') && !line.startsWith('---') ? (_jsx(SyntaxCodeLine, { prefix: index === 0 ? prefix : prefix ? '   ' : '', text: line, change: "removed" }, index)) : (_jsxs(Text, { ...(line.startsWith('@@')
@@ -205,17 +332,72 @@ function ContextUsageBlock({ usedTokens, contextWindowTokens, model, skills, mem
     const cells = Array.from({ length: 25 }, (_, index) => index < usedCells ? '⛁' : index >= 25 - bufferCells ? '⛝' : '⛶');
     return (_jsxs(Box, { flexDirection: "column", marginTop: 1, marginLeft: 2, children: [_jsx(Text, { bold: true, children: "Context Usage" }), _jsxs(Box, { children: [_jsx(Box, { flexDirection: "column", marginRight: 2, children: Array.from({ length: 5 }, (_, row) => (_jsx(Text, { children: cells.slice(row * 5, row * 5 + 5).join(' ') }, row))) }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { dimColor: true, children: [model ?? 'provider default', " \u00B7 ", compactTokens(usedTokens), "/", compactTokens(totalTokens), " tokens (", percent(usedTokens, totalTokens), ")"] }), _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, italic: true, children: "Estimated usage by category" }), _jsxs(Text, { children: ["\u26C1 Messages and other context: ", compactTokens(usedTokens), " tokens (", percent(usedTokens, totalTokens), ")"] }), _jsxs(Text, { children: ["\u26F6 Free space: ", compactTokens(Math.max(0, usable - usedTokens)), " (", percent(Math.max(0, usable - usedTokens), totalTokens), ")"] }), _jsxs(Text, { children: ["\u26DD Autocompact buffer: ", compactTokens(compactBuffer), " tokens (", percent(compactBuffer, totalTokens), ")"] })] })] }), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Memory files \u00B7 /memory" }), memoryFiles.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u2514 No memory files" })) : (memoryFiles.map((file, index) => (_jsxs(Text, { dimColor: true, children: [index === memoryFiles.length - 1 ? '└' : '├', " ", file.path, ":", ' ', file.tokens, " tokens"] }, file.path)))), _jsx(Text, { children: " " }), _jsx(Text, { bold: true, children: "Skills \u00B7 /skills" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Loaded" }), skills.length === 0 ? (_jsx(Text, { dimColor: true, children: "\u2514 No skills loaded" })) : (skills.map((skill, index) => (_jsxs(Text, { dimColor: true, children: [index === skills.length - 1 ? '└' : '├', " ", skill.name, ": ~", skill.tokens, " tokens"] }, skill.name))))] }));
 }
-export function MarkdownText({ text }) {
+const MARKDOWN_TEXT_CACHE_MAX = 2048;
+const markdownTextCache = new Map();
+function cachedMarkdownText(text) {
+    const cached = markdownTextCache.get(text);
+    if (cached)
+        return cached;
     const lines = text.split('\n');
+    const parsed = [];
     let code = false;
-    return (_jsx(Box, { flexDirection: "column", children: lines.map((line, index) => {
-            if (line.startsWith('```')) {
-                code = !code;
-                return (_jsx(Text, { dimColor: true, children: code ? `╭─ ${line.slice(3) || 'code'}` : '╰─' }, index));
-            }
-            return code ? (_jsx(SyntaxCodeLine, { prefix: "\u2502 ", text: line }, index)) : (_jsx(MarkdownLine, { line: line }, index));
+    for (const line of lines) {
+        if (line.startsWith('```')) {
+            code = !code;
+            parsed.push(code
+                ? { type: 'fence-open', label: line.slice(3) || 'code' }
+                : { type: 'fence-close' });
+            continue;
+        }
+        parsed.push(code ? { type: 'code', text: line } : { type: 'markdown', line });
+    }
+    markdownTextCache.set(text, parsed);
+    if (markdownTextCache.size > MARKDOWN_TEXT_CACHE_MAX) {
+        const oldest = markdownTextCache.keys().next().value;
+        if (oldest !== undefined)
+            markdownTextCache.delete(oldest);
+    }
+    return parsed;
+}
+function markdownTextStyleSignature(palette) {
+    return [
+        syntaxStyleSignature(palette),
+        markdownLineStyleSignature(palette),
+    ].join(ELEMENT_CACHE_KEY_SEPARATOR);
+}
+const MARKDOWN_TEXT_ELEMENT_CACHE_MAX = 4096;
+const markdownTextElementCache = new Map();
+function buildMarkdownText(text, palette) {
+    return (_jsx(Box, { flexDirection: "column", children: cachedMarkdownText(text).map((line, index) => {
+            if (line.type === 'fence-open')
+                return (_jsx(Text, { dimColor: true, children: `╭─ ${line.label}` }, index));
+            if (line.type === 'fence-close')
+                return (_jsx(Text, { dimColor: true, children: '╰─' }, index));
+            if (line.type === 'code')
+                return cloneElement(cachedSyntaxCodeLine(line.text, '│ ', undefined, palette), { key: index });
+            return cloneElement(cachedMarkdownLineElement(line.line, palette), {
+                key: index,
+            });
         }) }));
 }
+function cachedMarkdownTextElement(text, palette) {
+    const key = [text, markdownTextStyleSignature(palette)].join(ELEMENT_CACHE_KEY_SEPARATOR);
+    const cached = markdownTextElementCache.get(key);
+    if (cached)
+        return cached;
+    const element = buildMarkdownText(text, palette);
+    markdownTextElementCache.set(key, element);
+    if (markdownTextElementCache.size > MARKDOWN_TEXT_ELEMENT_CACHE_MAX) {
+        const oldest = markdownTextElementCache.keys().next().value;
+        if (oldest !== undefined)
+            markdownTextElementCache.delete(oldest);
+    }
+    return element;
+}
+export function MarkdownText({ text }) {
+    const palette = useTuiPalette();
+    return cachedMarkdownTextElement(text, palette);
+}
 export function Transcript({ items, activeText, activeThinking = '', thinkingExpanded = false, detailedTranscript = false, screenReader, }) {
     const palette = useTuiPalette();
     const detailed = thinkingExpanded || detailedTranscript;

package/dist/cli/tui/git-diff.js

@@ -28,7 +28,74 @@ export function visiblePatchLines(patch) {
         !isNewFileHeader(line) &&
         !line.startsWith('@@ '));
 }
+async function hasHead(cwd) {
+    try {
+        await execFileAsync('git', ['-C', cwd, 'rev-parse', '--verify', '--quiet', 'HEAD'], { encoding: 'utf8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function diffUnbornPath(cwd, path) {
+    try {
+        const result = await execFileAsync('git', [
+            '-C',
+            cwd,
+            'diff',
+            '--no-index',
+            '--no-ext-diff',
+            '--no-color',
+            '--unified=3',
+            '--',
+            '/dev/null',
+            path,
+        ], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+        return result.stdout;
+    }
+    catch (error) {
+        const execError = error;
+        // `git diff --no-index` exits with code 1 when the inputs differ.
+        if (execError.code === 1) {
+            return execError.stdout ?? '';
+        }
+        throw error;
+    }
+}
+async function loadUnbornDiff(cwd) {
+    const stagedResult = await execFileAsync('git', ['-C', cwd, 'diff', '--cached', '--name-only', '-z', '--'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+    const untrackedResult = await execFileAsync('git', ['-C', cwd, 'ls-files', '--others', '--exclude-standard', '-z'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+    const stagedPaths = stagedResult.stdout.split('\0').filter(Boolean);
+    const untrackedPaths = untrackedResult.stdout.split('\0').filter(Boolean);
+    const files = [];
+    for (const path of stagedPaths) {
+        const result = await execFileAsync('git', [
+            '-C',
+            cwd,
+            'diff',
+            '--cached',
+            '--no-ext-diff',
+            '--no-color',
+            '--unified=3',
+            '--',
+            path,
+        ], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+        files.push({ path, patch: result.stdout, ...changedLines(result.stdout) });
+    }
+    for (const path of untrackedPaths) {
+        const patch = await diffUnbornPath(cwd, path);
+        files.push({ path, patch, ...changedLines(patch) });
+    }
+    return {
+        files,
+        additions: files.reduce((total, file) => total + file.additions, 0),
+        deletions: files.reduce((total, file) => total + file.deletions, 0),
+    };
+}
 export async function loadGitDiff(cwd) {
+    if (!(await hasHead(cwd))) {
+        return loadUnbornDiff(cwd);
+    }
     const names = await execFileAsync('git', ['-C', cwd, 'diff', '--name-only', '-z', 'HEAD', '--'], { encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
     const paths = names.stdout.split('\0').filter(Boolean);
     const files = [];

package/dist/cli-runtime.d.ts

@@ -0,0 +1,172 @@
+#!/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 { 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 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';
+import type { TuiSlashCommand } from './cli/tui/slash-commands.js';
+import { type TuiHookConfiguration } from './cli/tui/hook-settings.js';
+import { type ClaudePermissionMode } from './permissions/claude-permission-resolver.js';
+import { type ClaudeMcpServerStatus, type ClaudeMcpToolInspection } from './mcp/claude-mcp-tools.js';
+import { authenticateMcpServer } from './mcp/claude-mcp-oauth.js';
+import { servePraxisMcpStdio } from './mcp/praxis-mcp-server.js';
+import { parseContextEnvironment, parseProviderEnvironment } from './providers/environment.js';
+import { type ClaudeInteractiveToolCallbacks } from './tools/claude-interactive-tools.js';
+import { type TopLevelAgentSummary } from './application/top-level-agent-manager.js';
+import { launchTmuxWorktree } from './platform/tmux-worktree.js';
+import { type CliControls, type CliRuntimeInfo, type CliElicitationRequest, type CliElicitationResult } from './cli/protocol.js';
+import { type PluginEvalDependencies } from './plugins/claude-plugin-eval.js';
+import { type SelfUpdateResult } from './maintenance/self-update.js';
+export { parseContextEnvironment, parseProviderEnvironment };
+export interface CliIO {
+    stdout(message: string | Uint8Array): void;
+    stderr(message: string): void;
+    isTTY?: boolean;
+    readStdinLines?: () => AsyncIterable<string | Uint8Array>;
+}
+interface SessionCommands {
+    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>;
+    runShell?(command: string, signal?: AbortSignal, sessionId?: string, name?: string): Promise<SessionRunResult>;
+    resumeShell?(sessionId: string, command: string, signal?: AbortSignal, name?: string): Promise<SessionRunResult>;
+    fork(sessionId: string, targetSessionId?: string, resumeSessionAt?: string): Promise<ForkResult>;
+    ensureFork?(sessionId: string, targetSessionId: string, checkpoint?: SessionForkCheckpoint): Promise<ForkResult>;
+    setPermissionMode?(sessionId: string, mode: ClaudePermissionMode): Promise<void>;
+    rewindFiles?(sessionId: string, userMessageId: string): Promise<void>;
+    rewindPoints?(sessionId: string): Promise<RewindPoint[]>;
+    changeCwd?(sessionId: string | undefined, cwd: string): Promise<string>;
+    recordCdUsage?(sessionId: string): Promise<void>;
+    approveRecentlyDenied?(sessionId: string, display: string): Promise<void>;
+    retryRecentlyDenied?(sessionId: string, display: string, signal?: AbortSignal): Promise<SessionRunResult>;
+    answerSideQuestion?(sessionId: string | undefined, question: string, signal?: AbortSignal, onDelta?: (delta: string) => void, permissionMode?: ClaudePermissionMode): Promise<SideQuestionResult>;
+    recordBtwUsage?(sessionId: string | undefined, permissionMode?: ClaudePermissionMode): Promise<string>;
+    recordColorUsage?(sessionId: string | undefined, selection: AgentColorSelection, display: string, permissionMode?: ClaudePermissionMode, options?: {
+        createSession?: boolean;
+    }): Promise<string>;
+    agentColor?(sessionId: string): Promise<AgentColorName | undefined>;
+    recordBackgroundUsage?(sessionId: string | undefined, permissionMode?: ClaudePermissionMode): Promise<string>;
+    recordBackgroundLaunch?(sessionId: string): Promise<SessionForkCheckpoint>;
+    forkSideQuestion?(sessionId: string, question: string, signal?: AbortSignal): Promise<SideQuestionForkResult>;
+    lifecycle?(trigger: 'init' | 'maintenance', options?: {
+        sessionStart?: boolean;
+        sessionId?: string;
+    }): Promise<void>;
+    sessions(): Promise<SessionSummary[]>;
+    inspect(sessionId: string): Promise<SessionInspection>;
+    export(sessionId: string): Promise<Buffer>;
+    transcript?(sessionId: string): Promise<ClaudeDisplayTranscriptItem[]>;
+    costSnapshot?(sessionId: string): Promise<ClaudeSessionCostSnapshot>;
+    compact?(sessionId: string, signal?: AbortSignal, selection?: ManualCompactSelection): Promise<ManualCompactResult>;
+    rename?(sessionId: string, name: string): Promise<void>;
+    sessionNameSuggestion?(sessionId: string, signal?: AbortSignal): Promise<string | null>;
+    nextScheduledPrompt?(signal?: AbortSignal): Promise<{
+        id: string;
+        prompt: string;
+    } | null>;
+    slashCommands?(): readonly TuiSlashCommand[];
+    hookConfiguration?(): Promise<TuiHookConfiguration>;
+    mcpInspect?(): Promise<readonly ClaudeMcpServerStatus[]>;
+    mcpReconnect?(name: string): Promise<void>;
+    mcpAuthenticate?(name: string): Promise<void>;
+    mcpReload?(): Promise<void>;
+    mcpTools?(name: string): Promise<readonly ClaudeMcpToolInspection[]>;
+    close?(): Promise<void>;
+    runtimeInfo?(): CliRuntimeInfo;
+    initialAgentPrompt?(): string | undefined;
+    agentDefinitions?(): readonly {
+        name: string;
+        description: string;
+    }[];
+    promptSuggestion?(sessionId: string, signal?: AbortSignal): Promise<string | null>;
+}
+interface TopLevelAgentCommands {
+    launch(options: {
+        prompt: string;
+        argv: string[];
+        resumeSessionId?: string;
+        cwd?: string;
+        deferInitialTurn?: boolean;
+        sourceSessionId?: string;
+        sourceCheckpoint?: SessionForkCheckpoint;
+        initialDetail?: string;
+    }): Promise<{
+        id: string;
+        sessionId: string;
+    }>;
+    list(options: {
+        cwd?: string;
+        all: boolean;
+    }): Promise<TopLevelAgentSummary[]>;
+    logs(id: string): Promise<string>;
+    stop(id: string): Promise<void>;
+    attach(id: string, input: AsyncIterable<string | Uint8Array>, output: (text: string) => void, signal?: AbortSignal): Promise<void>;
+}
+export interface CliDependencies extends InteractiveServiceFactory {
+    loadReleaseNotes?(configRoot: string): Promise<string>;
+    /** CLI entrypoint used when this runtime spawns child processes. */
+    cliPath?: string;
+    createService(options: {
+        eventSink: RuntimeEventSink;
+        requireProvider: boolean;
+        hooksOnly?: boolean;
+        approveRecovery?: (call: ModelToolCall) => boolean | Promise<boolean>;
+        approveTool?: (call: ModelToolCall, originalCall?: ModelToolCall, decision?: PermissionDecision) => PermissionApproval | Promise<PermissionApproval>;
+        agent?: string;
+        model?: string;
+        effort?: CliControls['effort'];
+        permissionMode?: ClaudePermissionMode;
+        isSessionActionApproved?: (call: ModelToolCall) => boolean;
+        controls?: CliControls;
+        interactive?: boolean;
+        sessionKind?: 'bg';
+        signal?: AbortSignal;
+        exposeToolRegistry?: boolean;
+        emitToolUseSummaries?: boolean;
+        cwd?: string;
+        sandboxOriginalCwd?: string;
+        configRoot?: string;
+        environment?: Readonly<Record<string, string>>;
+        providerEnvironment?: NodeJS.ProcessEnv;
+        onElicitation?: (request: CliElicitationRequest) => Promise<CliElicitationResult>;
+        askUser?: ClaudeInteractiveToolCallbacks['askUser'];
+        approvePlan?: ClaudeInteractiveToolCallbacks['approvePlan'];
+    }): Promise<SessionCommands>;
+    createAutoModeCritic?(options: {
+        model?: string;
+    }): Promise<ModelProvider>;
+    pluginEval?: PluginEvalDependencies;
+    runInteractive?(options: {
+        agent?: string;
+        controls?: CliControls;
+        initialPrompt?: string;
+        resume?: InteractiveResumeOptions & {
+            fromPr?: string | true;
+        };
+        signal?: AbortSignal;
+    }): Promise<number>;
+    runAgentsDashboard?(options: {
+        manager: TopLevelAgentCommands;
+        defaults: {
+            argv: readonly string[];
+            cwd?: string;
+        };
+        signal?: AbortSignal;
+    }): Promise<number>;
+    topLevelAgents?: TopLevelAgentCommands;
+    launchTmux?: typeof launchTmuxWorktree;
+    mcpAuthenticate?: typeof authenticateMcpServer;
+    mcpServe?: typeof servePraxisMcpStdio;
+    selfUpdate?: (options: {
+        operation: 'install' | 'update';
+        target?: string;
+        force?: boolean;
+    }) => Promise<SelfUpdateResult>;
+}
+export declare function createDefaultDependencies(entrypoint?: string): CliDependencies;
+export declare function createBackgroundWorkerRuntime(workerSink: RuntimeEventSink, dispatch: {
+    argv: string[];
+}, createService?: CliDependencies['createService']): Promise<Awaited<ReturnType<CliDependencies['createService']>>>;
+export declare function run(argv: readonly string[], io?: CliIO, dependencies?: CliDependencies, signal?: AbortSignal): Promise<number>;
+//# sourceMappingURL=cli-runtime.d.ts.map